Ubutnu Facile - Manuale Hacker 2016

TRUCCHI E SEGRETI DA GURU DI LINUX

MANUALE HACKER

ass=”text” data-text=”/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group up_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always alloc one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize < OUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)_ page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nou _partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] group_info->sma Installa!= Kali ) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_inf Linux nel dvd che ups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGRO trovi all’interno BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info In collaborazione=con ks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks nblocks; /n a set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; ks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->bl n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n / kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n f (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups e = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nbl group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = tsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0 p_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n / page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n / groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < grou blocks; i++) /n /n echo(‘Hello World’);”> ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n a set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; ks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->bl n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n / kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n f (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups e = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nbl group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = tsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0 p_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n / page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n / groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < grou blocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info up_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always alloc one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize < OUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)_ page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nou _partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->sma ) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> ngroups = tsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0 p_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n / page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n / groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < grou blocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info up_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always alloc one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize < HACKERA TUO TELEFONO= group_info->small_block; MODIFICA /n IL ROUTER WIFI NELi++) CUORE DEL SISTEMA OUPS_SMALL) /n IL group_info->blocks[0] else { /n for (i = 0; i < nblocks; { /n gid_t *b; /n b = (void *)_ page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nou _partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->sma ) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_inf ups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGRO BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info ks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n a set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; ks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->bl n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n / kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n f (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

MANUALE HACKER

ATTACCO A WINDOWS

Il sistema Microsoft è un pericoloso colabrodo digitale: buttalo e crea il tuo PC a prova di bomba con Linux!

ANONIMO

Naviga subito in completa sicurezza al riparo da occhi indiscreti

Con l’open source sei libero dal controllo di governi spioni e multinazionali furbe!

Installa il terminale sul tuo dispositivo mobile e trasforma lo smartphone in un vero e proprio computer

Riconfigura il tuo router per trasformarlo nel tuo server privato e scopri come proteggerlo da ogni tipo di attacco

linux BATTE tutti

Metti le mani sul kernel: come i guru del coding fanno fare a Linux quello che vogliono...

É in edicola nux Programmare Li

i Con Linux iT S e i m m a r g o Creare Pr D

MASTER LINUX

agli autori Di

Programmare con Linux diventa facile e veloce con i nostri consigli e i tutorial passo-passo Le tecniche di base Le tecniche evolute Creare un videogioco Programmare con la tua Raspberry PI I segreti dei database Clonare un sito Web per modificarlo

Internet Python

ione moderna Programmazpre più usato su

Python è sem para subito le basi! computer e mobile: im

Crea il tuo sitogrammare il tuo primo sito Ecco come pro TML al database Web professionale, dall’H

26/08/2016 17:58 rammazione3 1

COP_001_LXPSP16_prog

PRENOTA LA TUA COPIA SU

min_lnx_pro_master_207x285.indd 1

www.sprea.it/masterlinux 09/09/16 11:41

n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n ks[0] != group_info->small_block) { /n /n int i; /n /n for 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATONIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n(i =struct group_info ze + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n we /* always Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblock S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure allocate at = gidsetsize; /n group_info->nblocks = nblocks;*), /nGFP_USER); atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, 1);group_info->blocks[i] /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} oup_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < MIC_INIT(2) }; group_info nblocks = _BLOCK - 1) / * Make sure we direct block cks ? : 1; /n *group_info) + gid_t *), /n return oups = gidsetcks = nblocks; >usage, 1); /n _SMALL) /n p_info->small_ 0; i < nblocks; = (void n if (!b) al_alloc; /n } /n } /n ut_undo_par= 0) { /n /n group_infon /n LL; /n /n} /n ; /n /n /n / n if (group_ i < group_infoct group_info t gidsetsize){ gidsetsize + s allocate at

È arrivata l’ora di ribellarsi!

Le multinazionali dell’hardware e del software vogliono sempre limitare quello che gli utenti possono fare con i loro programmi, i loro computer, i loro smartphone. Noi invece vogliamo usarli esattamente come vogliamo noi: d’altro canto non siamo noi quelli che hanno pagato per programmi e dispositivi? Per questo motivo abbiamo messo insieme questo manuale dedicato a tutti i ribelli informatici, a chi vuole mettere alla prova i limiti dell’hardware e modificare i programmi come preferisce. Vedremo quindi come verificare la sicurezza informatica dei computer, come modificare un router o uno smartphone e molto altro ancora, il tutto mentre mettiamo al sicuro la nostra preziosa privacy!

info) /n nblocks; /n group_in+) { /n goto out_ oup_info; /n /n ng)group_in/n /nEXPORT_ ) /n /n{ /n /n (i = 0; i < C_INIT(2) }; /n fo; /n int NGROUPS_ er */ /n zeof(gid_t *), = gidsetsize; /n gidsetsize nblocks = nblocks; /n atomic_set(&group_info0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_

manuale hacker

1

free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n rn NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n= {if.usage (group_info->block ngroups one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km cks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; /n NULL; gid_t b = (void *)__get_free_page(GFP_USER); /n /ni++) {return /n*b; /n /ngroup_info->ngroups = gidsetsize; /n group_info->nblo

Manuale Hacker

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n

Basi e Hacking Entrare in Linux.......................................................................................4 Fuggire da Windows 10................................................................ 12 200 trucchi da esperti................................................................... 22 Dossier Hacker.................................................................................... 30 BitLocker................................................................................................. 38 Chromebook: costruirsene uno................................................ 42 Modificare un router wireless.................................................... 44

Sicurezza

Sicurezza servizi: rischi e soluzioni......................................... 48 Sicurezza: tool e soluzioni............................................................ 56 Usare il firewall perimetrale........................................................ 64 Semplificate i vostri firewall........................................................ 73 Chi protegge i tuoi dati?................................................................ 76 Privacy totale: distro blindate.................................................... 80 ZuluCrypt: drive cifrati.................................................................... 86 Eliminazione sicura dei dati......................................................... 88 Protezione totale per i dischi..................................................... 92

2

manuale hacker

n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n ks[0] != group_info->small_block) { /n /n int i; /n /n for 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATONIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n(i =struct group_info ze + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n we /* always Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblock S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure allocate at = gidsetsize; /n group_info->nblocks = nblocks;*), /nGFP_USER); atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, 1);group_info->blocks[i] /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Mobile

Android: tutti i segreti della shell............................................. 94 Segreti della shell in Android parte 2...............................100 Un server sullo smartphone....................................................108

Database Basi del sistema: il kernel Linux............................................112 Accesso casuale..............................................................................116 Coding: inotify & getopts...........................................................120 Gestire il sistema: i processi.....................................................124

Sistema

Monitoring: guida pratica.........................................................................128 Fuga dall’interfaccia.....................................................................................132 Systemd.................................................................................................................136 Strumenti di rete in Linux........................................................................140

manuale hacker

3

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Entrare in Linux

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo Per iniziare, possiamo elencare i vari NGROUPS_SMALL) NGROUPS_ /n group_info->blocks[0] SMALL) /n group_info->blocks[0] = group_info->small_block; = group_info->sm /n e free_page(GFP_USER); = (void /n free_page(GFP_USER); if (!b) /n goto /nout_undo_partial_alloc; if (!b) /n goto /n o aspetti positivi di una distro Linux.*)__get_ undo_partial_alloc: /n /n while /n /nout_undo_partial_alloc: (--i >= 0) {la /ndistro /n più free_page((unsigned /n /n while (--i >= long)grou 0) { /n In primo luogo, tranne raregroup_info; eccezioni /n Probabilmente conosciuta. /n /n group_info); /nEXPORT_SYMBOL(groups_alloc); /n /n return NULL; /n /n} /n /n /nvoid /n /n /nEXPORT_SYMBOL(grou groups_free(struct group dedicate al mondo aziendale, sono Il suo punto di/n forza è/n l’usabilità. Nei suoi block) if (group_in{ /n /n int i; /n /n fo->blocks[0] for (i = 0; i != < group_info->nblocks; group_info->small_block) i++) /n { /n /n/n echo(‘in gratuite e Open Source. Potete quindi dieci anni di storia, Ubuntu ha perfezionato l’utilizzo .usage p> nblocks vogliono i=propri programmi sul Pinguino. gidsetsize; (!group_info) return importare NULL; /n /n nblocks; group_info->ngroups /n atomic_set(&group_info->usag = gidsetsize; /n gro group_info->small_block; (gidsetsize /n else /n { /n group_info->blocks[0] for (i = 0; i < nblocks; = i++) group_info->sma { /n gid_ disposizione tramite i Software Center blocks[i] /n =ifb; (!b) /n /n } /n }goto /n ro sono migliaia e potete installarli con un free_page((unsigned group_info; long)group_info->blocks[i]); /n /nout_undo_partial_alloc: /n il/n /n/n /n while kfree(group_info (--i >= 0) { /n solo click del mouse. A differenza dei /n Fedora è conosciuta per suo}/n spirito nvoid groups_free(struct group_info); /n /n group_info return NULL; *group_info) /n /n} /n /n/n /n{ /n/n /nEXPORT_SYMBOL(grou /n if (group_info->bloc sistemi operativi proprietari, Linux è di adattamento e la capacità di adeguarsi fo->nblocks; if (group_in- i++) /n /n/nstruct fo->blocks[0] group_info != init_groups group_info->small_block) = { .usage = ATOMIC_INIT(2) { /n /n i molto più flessibile. Modificate le = { .usage nuove tecnologie. anni,=questa *group_info; groups /n int =a ATOMIC_INIT(2) nblocks; /n int};i;Nel /n /n corso /nstruct /n /n degli nblocks group_info (gidsetsize *groups_alloc(int + NGROUPS gids applicazioni distro è riuscita trovare un sapiente equilibrio least one=indirect nblocks (gidsetsize block + NGROUPS_PER_BLOCK pointer */a/n nblocks =- nblocks 1) / NGROUPS_PER_BLOCK; ? : 1; /n tragroup_info =/nkm predefinite, nuove e stabilità generale. Infatti, è per /n nblocks return ? : 1; /n NULL; group_info /n /nfunzionalità group_info->ngroups = kmalloc(sizeof(*group_info) = gidsetsize; + nblocks*sizeof(gid_t /n group_info->nblo * NGROUPS_SMALL) = gidsetsize; /n che group_info->blocks[0] nblocks; /n = group_info->small_block; atomic_set(&group_info->usa /n e e impostate un /n group_info->nblocks questo si tratta di=una delle soluzioni più free_page(GFP_USER); group_info->small_block; /n/n else ifattivisti (!b) { /n/n delfor (i =goto 0;Linux. i =group_info->blocks[i] 0) { /n /n free_page((unsigned = b; /n } /nlong)grou } /n r se quello /n /n /nEXPORT_SYMBOL(groups_alloc); free_page((unsigned long)group_info->blocks[i]); /n /n /n /nvoid groups_free(struct /n /n } /n /n kfree(g group di default non block) /n /n /n { /n /nvoid /n int i; /n /n groups_free(struct for (i = 0; i < group_info->nblocks; group_info *group_info) i++)/n/n/n{ /n/nstruc /n /n vi soddisfa. Anche fino a i++) ora si/npossono contare solo *groups_alloc(int (i = 0; i < group_ gidsetsize){ info->nblocks; /nsestruct group_info /n/nstruct *group_info; group_info /n int init_groups nblocks; /= Infine,non si deve dimenticare l’enorme quattro distingue finindirect dagli PER_BLOCK; /n struct group_ /n /* Makeinfo sure*group_info; weversioni, always Mageia allocate /n intsiat nblocks; least one /n int i; /nblock /n /npointe nblo nblocks*sizeof(gid_t Make sure we always *), allocate GFP_USER); leastflessibilità. /n oneifindirect (!group_info) blockdipointer /n return */ /n NULL; nblocks /n = /nn quantità di distribuzioni presenti. Basta anni ‘90 per at la sua Si tratta un prodotto mic_set(&group_info->usage, GFP_USER); /n ifcreato (!group_info) 1);vibrante /n /n return if (gidsetsize NULL; /n ngroups /n = dare un’occhiata a DistroWatch da una comunità, supportato da nblocks; ge, /n i++) /n (gidsetsize gid_t blocks[0] consiglio = b;/n *b; /n }b /n= (void } /n *)__get_free_page(GFP_USER); return group_info; /n /n /nout_undo_partial_alloc: /n if (!b) /n /n /n goto wh grado di scegliere la migliore in base alle di collaboratori eletti. La distro è famosa per i suoi /n /n kfree(group_info); group_info; /n /n /nout_undo_partial_alloc: /n /n return NULL; /n /n /n} while /n /n (--i/n>= /nEXPORT_SYMBOL( 0) { /n /n free_p vostre esigenze. Tra questereturn strumenti facile utilizzo e per il suo impianto /nnonif (group_info->blocks[0] NULL; /n /n} /n /n /ndi /nEXPORT_SYMBOL(groups_alloc); != group_info->small_block) { /n /n/n /nint /ni;/nvoid /n /n gro mancano quelle che consentono di dare personalizzabile. group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblock una marcia in più ai vecchi PC.

Linux Entrare in

Siete incuriositi dal Pinguino, ma non vi sentite pronti ad affrontare un territorio apparentemente sconosciuto? Niente paura! Vi guidiamo noi in questo fantastico mondo

S

correndo la storia di Linux, possiamo dire che non c’è momento migliore di adesso per entrare a far parte della schiera dei suoi utenti. Il Pinguino è diventato facile da installare e usare e dispone di desktop usabili e flessibili. In più, la maggior parte delle distro famose ha recentemente ricevuto una serie di aggiornamenti che le rendono ancora più stabili. Se non avete mai avuto modo di

“Linux è facile da installare, ma soprattutto è gratis e Open Source” mettere mano a Linux è quindi venuto il momento per rompere il ghiaccio. Per l’occasione, noi di Linux Pro abbiamo pensato di mettervi a disposizione una guida completa che permette di prendere subito confidenza con le procedure di installazione e configurazione più comuni.

4

manuale hacker PASSA A LINUX!

Ubuntu

Fedora

Mageia

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < lgroup_info->nblocks; i++)di/n /n/nstruct group_info init_groups =isolando {. sicurezza, i dati necessari da quelli non indispensabili. processo d’installazione una distro Linux n struct group_info *group_info; /n ma intnon nblocks; /n int i; /n /n /n nblocks = la funzione di cui stiamo parlando è necessario Per abilitare è piuttosto elaborato, per questo complesso. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? fornire una passphrase che verrà poi utilizzata per sbloccare I passaggi da affrontare sono diversi a seconda del SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = i file criptati. sistema che utilizzate. Tuttavia, grazie all’installer ge, 1); /n /n if (gidsetsize blocks[0] = Un altro passo importante nella procedura d’installazione è la creazione di un utente root. Nella maggior verrete guidati da una procedura semplice _t *b; /n grafico, b = (void *)__get_free_page(GFP_USER); /n if (!b) /n delle e intuitiva che/nout_undo_partial_alloc: rende tutto più immediato. return group_info; /n /n /n In /nsostanza, while (--i >= parte 0) { /n /n distro, questo passaggio è parte integrante o); /n /n return NULL; /n /nè/n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nper / la generazione di un utente normale. del processo l’installazione di /n} Linux molto simile a quella di qualsiasi cks[0] != group_info->small_block) /n /n differenze: int i; /n /n for (i = 0; Quest’ultimo, i < group_in-al contrario del root, non dispone dei permessi altro software, sia pure con{alcune truct group_info init_groups =del { .usage ATOMIC_INIT(2) }; /n /nstructper group_info modificare il sistema. Partizionamento disco. =Rispetto ai comuni programmi, /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ per installare una distro Linux è necessario creare una Dual boot. Durante l’installazione di Linux, un software con er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + partizione dedicata sul disco /n fisso.group_info->nblocks Se avete in programma= nblocks; cui/n è importante prendere confidenza è il bootloader. Si tratta group_info->ngroups = gidsetsize; atodi equipaggiare=ilgroup_info->small_block; PC con il solo Pinguino, questo di (i un=piccolo group_info->blocks[0] /npassaggio else { /n for 0; i < programma che informa il PC riguardo a dove non/n rappresentagoto un problema. Se però volete usare trovare i vari sistemi operativi installati su disco. Come /n if (!b) out_undo_partial_alloc; /nWindows group_info->blocks[i] hile (--i >= 0) { /n /n long)group_info->blocks[i]); /n /n la} maggior parte delle distro utilizza Grub 2. e Linux insiemefree_page((unsigned è importante approfondire ulteriormente bootloader, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info /n /n{anche /n quando si installa Linux su un computer l’argomento. Molte distro dispongono di una funzione che *group_info) In generale, for (i = 0; consente i < group_info->nblocks; i++) /n/nstruct group_info init_groups = { . 8, non dovrebbero verificarsi problemi. Infatti, di partizionare l’hard disk/ndel tutto automaticamente. con Windows n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = Ciò non toglie che sia comunque possibile creare partizioni basta che nel BIOS/UEFI sia abilitata la voce Secure Boot. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? propria scelta tramite lo strumento Gestione Le ultime SER); /n ifa(!group_info) /n return NULL; /n /n Disco. group_info->ngroups = versioni delle distro più famose, come Ubuntu Il vantaggio di un partizionamento manuale risiede nella e Fedora, un bootloader compatibile con UEFI ge, 1); /n /n if (gidsetsize blocks[0]installano = di scegliere quanto spazio dedicare a Linux. che funzionerà perfettamente senza alcun intervento da parte _t *b; /n possibilità b = (void *)__get_free_page(GFP_USER); /n Durante if (!b) /n return group_info; /n /nricordiamo /nout_undo_partial_alloc: /npartizioni, /n while (--i >= vostra. 0) { /nTuttavia, /n la procedura, sempre di creare due la più è importante prendere in considerazione anche o); /n /n return /n /n}12/nGB /ndi/n /nEXPORT_SYMBOL(groups_alloc); /n /n /n grandeNULL; con almeno spazio disponibile e formattata la possibilità di/avere qualche problema, causato soprattutto cks[0] != group_info->small_block) { /n /ninvece,int i; /n /n come for (i = 0; dalle i < group_incon il filesystem Ext4. La seconda, funzionerà diverse configurazioni con cui i produttori gestiscono UEFI. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info partizione di Swap. Questa avrà la funzione di estendere la Quando per esempio non si riesce a scegliere il sistema S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at quantità di RAM fisica installata nel computer. avete un /n ifoperativo e Windows si avvia automaticamente, la soluzione malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),Se GFP_USER); (!group_info) computer poca memoria (uno o due GB), vi consigliamo miglioreusage, 1); /n /n if (gidsetsize di/n creare partizione dii++) Swap volte più estesa rispetto gid_t le funzioni base else mall_block; { /n for (ielse = una 0;{ i/n < nblocks; for (i = 0; {i due < /nnblocks; gid_t i++) *b; { /n /n b = (void *b; /n *)__get_ b del firmware UEFI/BIOS. out_undo_partial_alloc; group_info->blocks[i] = b;Per /ngroup_info->blocks[i] } /nnon} hanno /n return =group_info; b; in /nquesto } /n /n /n }Provare /n /nout_ return alla quantità di/n RAM. i PC che problemi prima di installare. Ogni distro mainstream, n up_info->blocks[i]); /n free_page((unsigned /n /n } /n long)group_info->blocks[i]); /nSwap kfree(group_info); /nalla /n /n RAM. /n return } /nNULL; /n kfree(/n /n} /ne Fedora, permette di prendere confidenza senso, basterà creare uno di dimensioni uguali tra cui Ubuntu p_info ups_alloc); *group_info) /nSicurezza /n /n /n /nvoid /n{ groups_free(struct /nDurante if (group_info->blocks[0] group_info *group_info) != group_info->small_ /n /n /n tramite un ambiente Live. In questo modo, con/n{ il sistema dei/n dati. il processo d’installazione, molte ‘Hello nt i; /nWorld’);”> /n for (i = 0; ngroups *), GFP_USER);=/n if ge, oup_info->nblocks 1); /n /n if (gidsetsize = nblocks; usage, /n group_info->blocks[0] 1); /n /n if = all_block; _t *b; /n /n else b = (void { /n *)__get_free_page(GFP_USER); for (i = 0; i < nblocks; i++) { /n /n gid_t if (!b)*b; /n/n b= return out_undo_partial_alloc; group_info; /n /n /n /nout_undo_partial_alloc: group_info->blocks[i] /n /n= b;while /n (--i} >= /n 0)} /n { /n /n return /n o); /n /n /n free_page((unsigned return NULL; /n /n} /n long)group_info->blocks[i]); /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n } /n /n /n kfree(/n /n / ups_alloc); cks[0] != group_info->small_block) /n /n /n /nvoid groups_free(struct { /n /n group_info int i; /n /n *group_info) for (i = 0; /n i < /n{ group_in/n /n int ) }; i;/n/n/nstruct /n for group_info (i = 0; i nblocks; gidsetsize){ i++) /n /n/nstruct /n struct group_info init_ S_PER_BLOCK setsize){ /n struct - 1) / NGROUPS_PER_BLOCK; group_info *group_info; /n /n int /* nblocks; Make sure /nweint always i; /n /n allocate /n at malloc(sizeof(*group_info) /* Make sure we always allocate + nblocks*sizeof(gid_t at least one indirect *), GFP_USER); block pointer /n */if/n (!group_info) nblocks = *), ocks GFP_USER); = nblocks; /n if atomic_set(&group_info->usage, (!group_info) /n return NULL; 1);/n /n/n /n group_info->ngroups if (gidsetsize blocks[i] /n b = (void *)__get_free_page(GFP_USER); = b; /n } /n } /n return /n group_info; if (!b) /n /n /n /nout_ return up_info->blocks[i]); group_info; /n/n /n/n /nout_undo_partial_alloc: } /n /n kfree(group_info); /n /n/n while /n return (--i >=NULL; 0) { /n/n/n/n} /n p_info group_info); *group_info) /n /n /n return /n{ /n NULL; /n if/n(group_info->blocks[0] /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); != group_info->small_ ct if group_info (group_info->blocks[0] init_groups =!= { .usage group_info->small_block) = ATOMIC_INIT(2) };{ /n /nstruct /n intgroup_info i; /n /n for /n = { .usage int i; /n= /n ATOMIC_INIT(2) /n nblocks = }; (gidsetsize /n /nstruct + NGROUPS_PER_BLOCK group_info *groups_alloc(int - 1) / gidsetsize){ NGROUPS_ er ocks */ = /n(gidsetsize nblocks =+ nblocks NGROUPS_PER_BLOCK ? : 1; /n group_info - 1) /=NGROUPS_PER_BLOCK; kmalloc(sizeof(*group_info) /n +/* 1 2 nblocks group_info->ngroups ? : 1; /n group_info = gidsetsize; = kmalloc(sizeof(*group_info) /n group_info->nblocks + nblocks*sizeof(gid_t = nblocks; /n ato- *), di partizionare il disco,=è nblocks; necessario Si apre = group_info->blocks[0] gidsetsize;Prima /n group_info->nblocks = group_info->small_block; /n /natomic_set(&group_info->usaelse { /n la finestra for (i =Riduci 0; i < volume che restringere lo spazio a disposizione di mostra la dimensione totale del disco group_info->small_block; /n if (!b) /n /n gotoelse out_undo_partial_alloc; { /n for (i = 0; i blocks[i] i++) { /n gid_t Windows, da un margine per una la/n quantità disponibile per o hile out_undo_partial_alloc; (--i >= 0) { /n /n cosìfree_page((unsigned /n creare group_info->blocks[i] long)group_info->blocks[i]); =eb; } /ndi spazio } /n /nreturn } nuova partizione. Usate lo strumento/n /n group_info la riduzione. Per creare page((unsigned (groups_alloc); /n long)group_info->blocks[i]); /n /n /nvoid groups_free(struct } /n /n kfree(group_info); *group_info) /n /n{ /nuna /n /n nuova disco, quindi fatei++) click/n destro sulla specificate le!= dimensioni in oups_free(struct for (i = 0; Gestione i < group_info->nblocks; group_info *group_info) /n /n /n{ echo(‘Hello /n /n ifpartizione, (group_info->blocks[0] World’);”> partizione principale (di solito C:). A questo MB, quindi fate click sul pulsante Riduci ks; i++) /n /n echo(‘Hello World’);”> punto scegliete l’opzione Riduci volume. per dare inizio alla procedura.

Spazio a Linux: ridimensionare una partizione di Windows

Ridurre Windows

Creare una partizione

3

Usare la partizione

Una volta completata la procedura, vedrete una nuova partizione indicata come non allocata. Adesso sarà possibile puntare l’installazione della distro Linux direttamente su questo spazio. Ripetete il processo per creare una partizione di Swap. manuale hacker

5

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Entrare in Linux

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n na delle differenze maggiori che gli/nutenti funziona più o meno come la barra Start di Windows. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n provenienti da altri sistemi operativi Qui compaiono le icone delle applicazioni più utilizzate che (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su proprietari spesso rilevano è la mancanza di vi permettono di avere un accesso diretto ai vari programmi. : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US coerenza tra i vari layout delle distro Linux. I desktop Naturalmente è possibile modificare e il contenuto gidsetsize; /n group_info->nblocks = nblocks; /nl’ordine atomic_set(&group_info->usag di default di Ubuntu, Fedora e Mageia, pergroup_info->small_block; esempio, si del Launcher, da{adattarsi alle prima /n così else /n for (i vostre = 0; i blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n qualsiasi } /n /n kfree(group_info parla di desktop predefinito perché ogni distribuzione casella di ricerca che vi permette di trovare group_info *group_info) /n /n{ /n if (group_info->bloc ne usa uno specifico, ma niente impediscenvoid di groups_free(struct riferimento alle chiavi inserite, sia contenuto nel/n PC sia fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1);poi /na/n if (gidsetsize blocks[0] != Utilizzando group_info->small_block) { /n delle applicazioni. HUD, infatti, si evita la /n fatica int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n di trovare le opzioni più nidificate all’interno dei menu (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su di gestione. Per accedere a HUD è sufficiente premere il tasto *), GFP_US Ubuntu utilizza il desktop Unity. La componente: 1; più /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t Alt all’interno di qualsiasi applicazione, quindi utilizzare la importante di questo ambiente è il Launcher verticale che gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag casella di ricerca simile a quella Dash. Sebbene group_info->small_block; /n else { /n forpresente (i = 0; i nella < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n in partegroup_info->blocks[i] = b; /n } /n } /n r Unity si dimostri un desktop piuttosto versatile, free_page((unsigned long)group_info->blocks[i]); /n /n lo } /n /n kfree(group_info è possibile personalizzarlo a piacere. Tramite strumento nvoid groups_free(struct group_info *group_info) /npossibile /n{ /n /n if (group_info->bloc Impostazioni di Sistema, infatti, sarà gestire gli fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) aspetti più specifici dell’ambiente. Sarà poi possibile gestire *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS i propri quelli=inerenti a Facebook, least one indirect blockaccount pointeronline, */ /n come nblocks nblocks ? : 1; /n group_info = km Google o Flickr, quindi fare in modo che interagiscano /n return NULL; /n /n group_info->ngroups = gidsetsize; /n con group_info->nblo le applicazioni preinstallate nel sistema. NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e Chi utilizza free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n Gnome, per undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou personalizzare /n /n /nEXPORT_SYMBOL(groups_alloc); /npiù /npopolari. /n /nvoid group Gnome è un altro dei desktop Lagroups_free(struct versione 3 a dovere block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ contiene più o meno gli stessi elementi che l’ambiente, .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n contraddistinguono Unity, se vengono messi (gidsetsize + NGROUPS_PER_BLOCK - 1)anche / NGROUPS_PER_BLOCK; /n /* Make su deve sfruttare a disposizione in modo diverso. In primo luogo, il desktop : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Gnome Tweak è meno ricco di elementi grafici. Per/nmostrare la panoramica gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag Tool group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; ancora. Usando diversi programmi di /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Una delle specialità di Linux è far least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km terze parti sarà poi possibile bloccare gli resuscitare vecchi PC che altrimenti non /n i podcast, return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo annunci dei siti Web, sfruttare sarebbero più in grado di stare al passo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e telefonare via Internet, masterizzare con i sistemi operativi più recenti. free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n Le distro progettate per essere installate CD/DVD e molto altro ancora. undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou su computer obsoleti sono parecchie La distribuzione è disponibile con diverse /n /ndi/nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group specifiche, tra cui la possibilità ma la nostra preferita è Puppy Linux. block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc recuperare driver aggiuntivi per i vecchi La distribuzione ha il pregio di utilizzare *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / uno dei windows manager tra i più leggeri modem dial-up. Tra le distro leggere, PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe comunque, ci sono anche delle derivate in circolazione: JWM. Anche se non è tra nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n di Ubuntu come Tahrpup che è basato i più belli da vedere, è veloce e pratico. mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n

Differenze tra distro I primi passi con Linux

U

Unity... nella diversità

Distinguersi con Gnome

Date nuova vita a un vecchio PC

la produttività, multimediali e molto altro

6

manuale hacker

comunque applicazioni più limitate.

reperibile sui forum e online

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Activity. Utilizzandola è possibile creare diverse attività delle applicazioni è necessario fare click sull’angolo p_info *group_info) /n /n{ /ninstallate /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info diversificate per contesto e applicazioni, ognuna con il proprio superiore destro=del desktop. Avrete quindi a disposizione /n int i; /nun /nLauncher /n nblocks = a(gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_ di programmi. Per esempio, è possibile creare una simile quello disponibile in Unity. Nel centro, - 1) insieme er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Activity Social interamente basata su software utili alla invece, è presente un’anteprima di tutte le finestre aperte. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atocomunicazione, come client di messaggistica instantanea, A destra troverete il selettore delle aree di lavoro che mostra group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < collegamento a Facebook o Twitter e via dicendo. Molte distro l’aspetto corrente. Nella parte superiore /n if (!b) /n della scrivania goto out_undo_partial_alloc; /n group_info->blocks[i] basate è presente casella di ricerca che consente di trovare hile (--i >= 0) { /n /n unafree_page((unsigned long)group_info->blocks[i]); /n su /n KDE } offrono un’Activity di default chiamata (groups_alloc); /n /n /nfile /nvoid groups_free(struct group_info *group_info) /n /n{ /n Desktop Activity. È comunque possibile recuperare diverse applicazioni, e documenti archiviati nel computer, nonché for (i = 0; interrogare i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups ={. activity predefinite direttamente da Internet, quindi installarle vari servizi online. Gnome include un’applicazione n struct group_info *group_info; /n int nblocks; /ncheint i; /n /n /n nblocks = senza difficoltà. KDE dispone poi di diverse interfacce che per la gestione unificata degli account online consente ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? permettono di offrire al meglio le funzioni del desktop. Potete di accedere a servizi come Google Docs e Flickr. Fedora, SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = contare su=opzioni specifiche per gli schermi standard, ma per esempio, una volta installata, vi chiederà di configurare ge, 1); /n /n if (gidsetsize blocks[0] anche per display più piccoli come quelli dei netbook o dei profili.*)__get_free_page(GFP_USER); Il desktop Gnome si distingue anche _t *b; /n i relativi b = (void /n per la if (!b) /n Per passare dall’una all’altra, è sufficiente fare presenza/n di/n varie applicazioni personalizzate/n che return group_info; /nout_undo_partial_alloc: /npossono while (--i >= portatili. 0) { /n /n o); /n /n return NULL;informazioni /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /n / destro del mouse sulla scrivania, quindi click /n con/n il tasto recuperare da/n vari servizi online. Gnome cks[0] != group_info->small_block) /n /n di recuperare int i; /n /n i < group_inla voce Impostazioni desktop predefinito. Contacts, per esempio, è in{ grado i vostrifor (i = 0; selezionare truct group_info init_groups = {Web .usage = ATOMIC_INIT(2) /n /nstructNella group_info finestra che si apre, basta selezionare la scheda contatti da varie fonti come Gmail. Allo stesso }; modo, /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Visualizza e scegliere una delle diverse voci presenti nel Gnome Documents riesce a interfacciarsi alla perfezione er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + menu. non dimenticare poi la Folder View che consente con Google Docs. Un ulteriore aspetto che differenzia group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n Da atodi (i inserire file e cartelle. KDE, infine, può essere Gnome dai principali concorrenti è la peculiarità group_info->blocks[0] = group_info->small_block; /n delle elseopzioni. { /n for = 0; i dovunque < Qui,/n per esempio, nonout_undo_partial_alloc; troverete alcun pulsante per /n if (!b) goto /n group_info->blocks[i] hile (--i >= 0) { /n /n lefree_page((unsigned /n /n } minimizzare applicazioni. Quando silong)group_info->blocks[i]); vuole passare (groups_alloc); /n /nfinestra, /n /nvoid groups_free(struct group_info a un’altra sarà sufficiente usare la funzione *group_info) /n /n{ /n for (i = 0; Activity i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . e selezionare un programma da aprire o già n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = attivo. Uno degli aspetti più importanti di Gnome è però la ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? flessibilità. /n Infatti, return questoNULL; desktop particolarmente SER); /n ifsua (!group_info) /nè/n group_info->ngroups = amato dagli smanettoni che possono rimuovere o ge, 1); /n /n if (gidsetsize blocks[0] = ulteriormente personalizzato tramite le Impostazioni con un solo click del mouse. _t *b; /n aggiungere b = (voidfunzionalità *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /n /ndi while (--i >= di 0)sistema. { /n /n Tuttavia, prima di procedere all’organizzazione Gnome,/n infatti, supporta una quantità enorme o); /n /n return NULL;Basta /n /n} /n /n /nal/nEXPORT_SYMBOL(groups_alloc); /n /ndel /n desktop, / personale vi consigliamo di prendere confidenza estensioni. accedere sito Gnome Extensions cks[0] != group_info->small_block) { /n /n Quiint i; /n /n plug-in for (i = 0; con i < group_ingli strumenti disponibili. Le vostre capacità di interagire (http://extensions.gnome.org). troverete ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info per tutti i gusti e per ogni necessità. Alcuni dei componenti con l’ambiente cresceranno mano a mano che lo utilizzate. S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at aggiuntivi sono + poi progettati per permettere un malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) passaggio più agevole agli utenti che provengono ocks = nblocks; /n atomic_set(&group_info->usage, 1); /ndal /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n possono /n /nout_ essere usati con la stessa flessibilità. Uno di questi up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n è Cinnamon, incluso nella distro Linux Mint, ma non p_info *group_info) /n /n{ /naltri /n due if (group_info->blocks[0] != group_info->small_ A differenza degli desktop di cui abbiamo parlato fino dobbiamo dimenticare altre piattaforme estremamente ‘Hello World’);”> ngroups = con la massima semplicità. Basta installarli e sceglierli=durante la procedura di log-in al sistema. Fedora, da usare e pratico /n da gestire. KDE ge, 1); /n /n estremamente if (gidsetsizeversatile blocks[0] _t *b; /n puòbessere = (void *)__get_free_page(GFP_USER); per esempio, in passato ha utilizzato Gnome come desktop considerato il desktop per eccellenza /n di Linux, if (!b) /n return group_info; /noffrire /n /nout_undo_partial_alloc: /n quantità while (--i >= di 0)default, { /n /nscegliendo poi KDE per le versioni successive. capace di il massimo della flessibilità /n e una o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / è possibile utilizzare Mageia con Gnome, Allo stesso modo, enorme di opzioni per le personalizzazioni. Una delle cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_innonostante sfrutti KDE come impostazione predefinita. caratteristiche più utili di KDE viene fornita dalla funzione ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ Aggiungendolo al sistema, sarà Oltre al /n desktop di ogni up_info->blocks[i]); /n }predefinito /n /n kfree(group_info); /n /n return NULL; /n /n} /n possibile!=installare il desktop dal distro,/n è possibile altri. p_info *group_info) /n{ /n /ninstallarne if (group_info->blocks[0] group_info->small_ Software Center. Per passare da un esempio è=Cinnamon ct group_infoUn init_groups { .usage =che ATOMIC_INIT(2) }; /n /nstruct group_info ambiente all’altro, basta selezionarlo di sfruttare un ambiente /n int i; /n /nconsente /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) durante la procedura di log-in.+ flessibile e ben disegnato. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /ncredenziali, atoQuando inserite le vostre È disponibile nei repo ufficiali group_info->blocks[0] group_info->small_block; /n sufficiente else { /n fare for (i =sull’icona 0; i < sarà click di Fedora e = Mageia ed è possibile /n if (!b)installarlo /n goto out_undo_partial_alloc; /n ai desktop group_info->blocks[i] relativa e optare per quello tramite i rispettivi gestori hile (--i >= 0) {pacchetti. /n /n free_page((unsigned /n modo, /n } che si preferisce. In questo Su Ubuntu, invece, può long)group_info->blocks[i]); (groups_alloc); /n /nrecuperato /n /nvoidaggiungendo groups_free(struct group_info *group_info) /n /n{ /n potrete provare diversi ambienti con essere il for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”> la massima semplicità e senza PPA: ppa:gwendal-lebihanTramite il gestore pacchetti della vostra distro

“Ubuntu, Fedora e Mageia sono disponibili in diverse edizioni e con vari ambienti desktop”

Ancora più scelta

La versatilità di KDE

Scegliere il desktop

dev/cinnamon-stable.

rischiare di fare alcun tipo di danno.

è possibile installare diversi ambienti desktop

manuale hacker

7

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Entrare in Linux

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n differenza di Windows, una distro Linux usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n dubbio più dotata di software predefiniti. (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Anziché trovare un singolo editor di testo : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US o un’applicazione per la grafica, di solito vengono gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag messe a disposizioni intere suite per l’ufficio e per group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ l’elaborazione digitale. Tutto questo, naturalmente, goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info è in aggiunta alle varie applicazioni di default, come nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc il programma per la posta elettronica, il browser fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /nSoftware /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n sia grafiche che vi consentiranno di installare, rimuovere di gestione dei pacchetti. È possibile utilizzare questo usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n o aggiornare qualsiasi software in modo semplice e veloce. strumento sia per l’aggiornamento sia per la manipolazione (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su I singoli programmi sono raggruppati all’interno: 1; di /n pacchetti dei=repo su Ubuntu. Questo, infatti, elenca tutti i repository in *), GFP_US group_info kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t che includono anche diverse informazioni, tra cui l’elenco quattro schede. Per impostazione predefinita, i quattro repo gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag delle dipendenze necessarie a far funzionare una specifica ufficiali sono abilitati scheda Software per Ubuntu. group_info->small_block; /ngiàelse { /nnellafor (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r applicazione. Il sistema di gestione pacchetti, inoltre, si basa Il repository principale comprende il supporto software free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info su un database conosciuto con il nome di repository, così ufficiale, mentre il repo Restricted comprende i programmi group_info *group_info) /n /n{ /n /n if (group_info->bloc da tenere traccia di tutti i pacchetti disponibili. nvoid groups_free(struct che non sono disponibili con una licenza completamente fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) gratuita. I due repository Universe e Multiverse, invece, *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS dispongono rispettivamente dei software gestiti dalla least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km comunità quelli non liberi. A differenza di Ubuntu, Il mondo dei pacchetti Linux è sostanzialmente/n diviso return in due: NULL; /n /n e da group_info->ngroups = gidsetsize; /n group_info->nblo Fedora il sistema di gestione pacchetti RPM. La distro RPM e Deb. Si tratta di file binari precompilati, progettati NGROUPS_SMALL) /n utilizza group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); if (!b) /n goto out_undo_partial_alloc; /n archivia /n i repo in /etc/yum.repos.d, mentre quello per semplificare il processo d’installazione. Il primo è stato undo_partial_alloc: /n /n èwhile (--i >=fedora.repo. 0) { /n /n Mageia free_page((unsigned long)grou principale rinominato utilizza creato da Red Hat Linux e viene utilizzato con distro come /ncon /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid group il pacchetto urpmi, un wrapper di sistema pergroups_free(struct la gestione Fedora e Mageia. Il secondo, invece, è disponibile block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ dei pacchetti RPM. La distro ha tre repo principali: il Core i sistema basati su Debian come Ubuntu o Linux Mint. Tutte .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n contiene i pacchetti Open il Non-Free quelli closedle varie distro, inoltre, mettono a disposizione una serie di (gidsetsize + NGROUPS_PER_BLOCK - 1)Source, / NGROUPS_PER_BLOCK; /n /* Make su source e il Tainted quelli che in alcuni sono soggetti strumenti grafici utili a consentire agli utenti l’installazione, la : 1; /n group_info = kmalloc(sizeof(*group_info) + paesi nblocks*sizeof(gid_t *), GFP_US a restrizioni a causa delle leggi territoriali. Ognuno di questi rimozione e l’aggiornamento delle applicazioni.gidsetsize; Tuttavia, per/n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag /n else { /n sotto-repository. for (i = 0; i < nblocks; i++) { /n gid_ repo è suddiviso in quattro Il Release utilizzarli al meglio, è opportuno avere una certagroup_info->small_block; familiarità out_undo_partial_alloc; /n stabili, group_info->blocks[i] = b;stati /n } /n } /n r include i pacchetti l’Update quelli che sono con la struttura e i repository delle distribuzioni.goto Ubuntu free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km Download e Documenti./n Verificate poi NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo La vostra distro disporrà sicuramente di return che uno strumento utile a creare backup con dove i client di posta elettronica NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e utilizzate archiviano le vostre email, gli cui è importante prendere confidenza. free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n allegati e le rubriche. Considerate che Ubuntu, per esempio, sfrutta Déjà Dup, undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou mantenere i dati salvati su un programma progettato per essere /nun’altra /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block)sempre { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc partizione potrebbe non essere utilizzato anche dai principianti. Questo, *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / la scelta migliore. Infatti, si deve tener inoltre, è disponibile anche per Fedora PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe conto della possibilità che non sia e Mageia. Tuttavia, non importa quale nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n possibile avviare quella data porzione strumento di backup si utilizzi, quanto mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n inutile. Infatti, le directory predefinite dispone di una buona ADSL, prendete Déjà Dup è una semplice applicazione che permette

Gestione dei software

Personalizzate le vostre distro con applicazioni di vario genere

A

L’ABC della gestione pacchetti

L’importanza dei backup

per il salvataggio dei file sono spesso

8

manuale hacker

in considerazione i vari servizi Cloud.

di creare backup in modo semplice e veloce

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n aggiornati e il Backport quelli che != group_info->small_ p_info *group_info) /n dopo /n{ /nil rilascio /n if (group_info->blocks[0] ct group_info init_groups = { .usage ATOMIC_INIT(2) }; /n /nstruct group_info contengono nuove versioni=derivate dal repository /n int i; /nCauldron. /n /n nblocks (gidsetsize NGROUPS_PER_BLOCK - 1) / NGROUPS_ C’è poi=anche il repo+Testing che contiene er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + software utile per scopi di prova. Per configurare i vari group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atorepository, è necessario accedere al Centro di controllo group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < di Mageia, quindi selezionare Gestione Software /n if (!b) /n goto out_undo_partial_alloc; /n -> group_info->blocks[i] Configura per installazione e aggiornamento. Per hile (--i >= 0) { /n /n fonti free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /ni repository /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n installare ufficiali, basta fare click su Aggiorna for (i = 0; fonti, i < group_info->nblocks; i++) /nSelezionali /n/nstructtutti group_info quindi premere il pulsante e poi init_groups = { . n struct group_info /n farà int nblocks; /nunaint i; /ndi/n /n nblocks = Aggiorna.*group_info; Questa opzione comparire serie ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? repo che basterà selezionare per aggiungere alla distro. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n Tutte le principali distribuzioni desktop includono uno (--i >= 0) { /n /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while o); /n /n return NULL;grafico /n /n}per /n la /ngestione /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / strumento dei pacchetti e Software cks[0] != group_info->small_block) { /n /n int i; /n /n foruna (i = 0; i < group_inCenter di Ubuntu è uno dei migliori. Basta selezionare truct group_info init_groups = quindi { .usage = ATOMIC_INIT(2) }; /n /nstructegroup_info aggiungere software da queste fonti. I repo esterni, per categoria specifica, cercare tra i vari programmi /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ esempio, in Ubuntu sono conosciuti come Personal presenti. Volendo, è possibile utilizzare anche la funzione di er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Package Archive o PPA. È possibile aggiungere un repo ricerca che permette di trovare immediatamente group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoPPA l’applicazione=desiderata (se presente). Una/nvolta reperito group_info->blocks[0] group_info->small_block; else { /n for (i =per 0; la i blocks[i] hile (--i >= 0) { /n /n quindi free_page((unsigned long)group_info->blocks[i]); /n /n esatto } l’indirizzo del PPA in questione. Di solito, lo troviamo Compare la scheda del software che specifica la (groups_alloc); /n /nle/n /nvoid groups_free(struct group_info *group_info) /n /n{ elencato sul /n sito PPA Launchpad e avrà un forma simile versione, peculiarità principali e permette di installarlo for (i = 0; premendo i < group_info->nblocks; i++)Una /n /n/nstruct group_info init_groups {. a questa:=ppa:esempio-ppa/esempio. Una volta trovato il pulsante Installa. volta completato il n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = l’indirizzo, sempre da Software & Aggiornamenti, passate processo di download e installazione, il programma verrà ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? alla scheda Altro software e fate click sul pulsante al Launchpad così daNULL; essere/nrichiamato SER); /n ifaggiunto (!group_info) /n return /n group_info->ngroups = Aggiungi. Inserite la fonte e premete Aggiungi sorgente. velocemente. Fedora, invece, utilizza lo strumento grafico ge, 1); /n /n if (gidsetsize blocks[0] = In modo simile a Ubuntu Software/n Center, if (!b) /n _t *b; /n PackageKit. b = (void *)__get_free_page(GFP_USER); return group_info; /n /nout_undo_partial_alloc: /n while (--i >= 0) { /n /n oltre alla/n presenza di una casella di ricerca,/nanche questo o); /n /n return /n /n} /n di /nsoftware /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / elencaNULL; varie categorie tra cui è possibile cks[0] != group_info->small_block) { /n /n int i; desiderato, /n /n for (i = 0; i < group_inscegliere. Dopo aver trovato il programma ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info basterà un semplice click del mouse per installarlo S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at automaticamente e senza complicazioni.*), LoGFP_USER); strumento /n if (!group_info) malloc(sizeof(*group_info) + nblocks*sizeof(gid_t grafico la gestione dei pacchetti di Mageia1);è /n Drakrpm. ocks = nblocks; /nperatomic_set(&group_info->usage, /n if (gidsetsize blocks[i] = b;funzionale /n } /ne permette } /n return group_info; /n Allo /n /nout_ Fedora, ma è molto l’installazione stesso modo, anche Mageia può sfruttare una serie up_info->blocks[i]); /n in /nmodo } /nsemplice /n kfree(group_info); /n /nfiltrare return NULL; /n /n} dei software e veloce. È possibile di software di/n terze parti per cui è necessario il proprio URL. p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != solo group_info->small_ l’elenco delle applicazioni disponibili per visualizzare Una volta recuperato, accedete allo strumento Software ‘Hello World’);”> Configure media sources for install and n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = subìto aggiornamenti e altro ancora. I gruppi di software update, quindi? fate click su Add. Non vi resta che ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks visualizzati/nnella barra non aggiungere l’indirizzo del repo specificando il protocollo SER); /n ifsono (!group_info) returnlaterale NULL; e/nnaturalmente /n group_info->ngroups = la casellablocks[0] = Anche Fedora dispone di repository esterni, _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n ma il più popolare è RPMFusion. Questo è ulteriormente return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= suddiviso 0) { /n /nin altri due repo indipendenti che ospitano o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nLibero /n / e non. È possibile installarli entrambi Software La grande comunità Open Source è artefice di molti dei cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indirettamente dal browser, seguendo le istruzioni disponibili pacchetti elencati nei repo ufficiali. Quasi ogni distro ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info su www.rpmfusion.org/configuration. dispone di un meccanismo per/ninstallare S_PER_BLOCK - 1) /quindi NGROUPS_PER_BLOCK; /* Make sure we always allocate at

Gestori grafici

La maggior parte delle distro dispone di strumenti grafici per l’installazione, la rimozione e l’aggiornamento dei software

“Rispetto a Windows, Linux dispone di molte più applicazioni preinstallate”

Repo di terze parti

malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n il != filegroup_info->small_ necessario, fate doppio click per Tutti i /n software come Chrome, p_info *group_info) /n{ /n di /nGoogle, if (group_info->blocks[0] installarlo il gestore pacchetti. e molti =altri possono essere installati }; /n ct group_infoEarth init_groups { .usage = ATOMIC_INIT(2) /nstructtramite group_info Una volta -fatta operazione, problemi=in Linux. Tuttavia, a causa /n int i; /n /nsenza /n nblocks (gidsetsize + NGROUPS_PER_BLOCK 1) / questa NGROUPS_ i software di Google saranno disponibili della =loro licenza, nei =repo er */ /n nblocks nblocks ? : non 1; /nli troverete group_info kmalloc(sizeof(*group_info) + all’interno della /n distro. Un altro popolare ufficiali. Leggendo questo avrete group_info->ngroups = gidsetsize; /narticolo, group_info->nblocks = nblocks; atogroup_info->blocks[0] group_info->small_block; /n else { /n proprietario for (i = 0; è i blocks[i] può attivare i rispettivi repo tramite algoto volo.out_undo_partial_alloc; La pagina di download /n Ubuntu hile (--i >= 0) {messa /n /n a disposizione free_page((unsigned long)group_info->blocks[i]); /n /ne aggiornamenti } la funzione Software da Google dispone (groups_alloc); /n versioni /n /n /nvoid groups_free(struct group_info *group_info) /n{facendo, /n -> Altri software. /n Così sarà delle dei propri software per Linux for (i = 0; i nblocks; /n /n echo(‘Hello World’);”> possibile installare Skype direttamente a 32-bit sia a 64-bit.i++) I pacchetti sono

Come installare i software di Google

sia in Deb sia in RPM. Una volta scaricato

dal Software Center. Mageia, invece, offre

il pacchetto Skype all’interno del proprio repo Non-free. Se avete attivato questo repository, basterà solo cercare get-skype e scaricare l’applicazione dal proprio sito. Volendo, è comunque possibile accedere alla pagina di download di Skype e scaricare la versione per Linux, disponibile sia in versione Deb sia RPM. A questo punto, per installarlo, basterà fare doppio click sul pacchetto e il gestore penserà a tutto il resto.

manuale hacker

9

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Entrare in Linux

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n a maggior parte delle distro Linux desktop sono usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n in grado di gestire qualsiasi contenuto. Alcuni, (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su in particolare audio e video, vengono però : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US distribuiti in formati chiusi. Le distribuzioni non gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag possono quindi riprodurli con gli strumentigroup_info->small_block; predefiniti /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ e hanno bisogno di installare componenti aggiuntivi. goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Ubuntu permette di includere determinati strumenti utili nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc a riprodurre specifici file già durante il processo i++) /n /n echo(‘Hello World’);”> nblocks; distro, *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / dovrete utilizzare il gestore pacchetti, aggiungendo il PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe componente ubuntu-restricted-extra, il quale comprende nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n diversi codec proprietari tra i più popolari. Su Fedora, mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n su In alternativa, è != possibile estrarre quest’ultimo componente usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n yum install gstreamer{1,}-{plugin-crystalhd,ffmpeg,pluginsaggiuntivo da Chrome e importarlo in Chromium, la fork Open (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su {good,ugly,bad{,-free,-nonfree,-freeworld,-extras}{-extras}}} Source del browser di Google. Chi utilizza Ubuntu, invece, può *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t ffmpeg libmpg123 lame-libs installare Flash per Firefox così: gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag Se invece utilizzate Mageia, i codec necessari per la sudo apt-get group_info->small_block; /n install else flashplugin-installer { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /nChromium, group_info->blocks[i] = b; /n } /n } /n r riproduzione multimediale li avrete nel repository Tainted. Se state usando è invece possibile utilizzare free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Assicuratevi quindi di averlo abilitato. Una volta fatto, lanciate il plug-in Flash Pepper tramite il pacchetto nvoid groups_free(struct group_info *group_info) /ndi/n{ /n /nsono if (group_info->bloc l’applicazione di benvenuto dal menu Strumenti, quindi pepperflashplugin-nonfree. Gli utenti Fedora, invece fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) accedete alla scheda Applicazioni. Da qui sarà poi possibile in grado di sfruttare il rispettivo repo direttamente dal sito *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS installare i pacchetti più utili, tra cui i codec. Web di Adobe. Se*/ state versione least one indirect block pointer /n eseguendo nblocks =una nblocks ? :a1;64-bit, /n group_info = km il comando il seguente: /n return NULL; /n /n ègroup_info->ngroups = gidsetsize; /n group_info->nblo yum/n-y install http://linuxdownload.adobe.com/adobe-release/ NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n adobe-release-x86_64-1.0-1.noarch.rpm Nonostante il formato Open Source WebM sia sempre più undo_partial_alloc: /n /n while (--i >=la0) { /n adatta /n free_page((unsigned long)grou Potete anche importare chiave per il repo con: utilizzato, molti siti Web richiedono ancora plug-in del calibro L’applicazione /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-adobe-linux di Adobe Flash per lanciare lo streaming di contenuti Benvenuto block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ prima di installare il plug-in con: multimediali. Ottenere Flash per Linux non è facile. Infatti, in Mageia .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n yum -y install flash-plugin è uno strumento Adobe ha dismesso lo sviluppo di questo componente (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su In Mageia, invece, è sufficiente abilitare il repository Nonfree *), GFP_US aggiuntivo prima disponibile per Firefox. L’unico :modo eccezionale 1; /n per group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t per iniziare che include il plug-in Flash, quindi installarlo dalla scheda utilizzare Flash è quindi servirsi del browser Chrome che gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag a configurare group_info->small_block; /n presente else { /n for (i = 0;dii < nblocks; i++) { /n gid_ Applicazioni nello strumento benvenuto. include Pepper, un plug-in basato su quello di Adobe. goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r la distro free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc La maggior parte delle distribuzioni viene fornita con un fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) numero multimediali *group_info; /n discreto int nblocks; /ndi applicazioni int i; /n /n /n nblockspreinstallate. = (gidsetsize + NGROUPS Leblock più popolari sono Rhythmbox trovate come least one indirect pointer */ /n nblocksche = nblocks ? : 1; /n group_info = km programma predefinito nelle distribuzioni basate su/n Gnome /n return NULL; /n /n group_info->ngroups = gidsetsize; group_info->nblo NGROUPS_SMALL) /nsupportato group_info->blocks[0] group_info->small_block; /n e (viene anche da Ubuntu) e=Amarok per KDE. free_page(GFP_USER); /ni player possono if (!b) /nlavorare interfacciandosi goto out_undo_partial_alloc; /n Entrambi a Internet undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou e riprodurre podcast e radio online. Se poi si desidera puntare /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group su applicazioni più attraenti, procuratevi Banshee block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc e Clementine. i player video, su Gnome *groups_alloc(int gidsetsize){ Per /n quanto structriguarda group_info *group_info; /n int nblocks; / Totem (adesso chiamato semplicemente Video). PER_BLOCK; /n trovate /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); if (!group_info) return NULL; /n /n Se invece desiderate un/n programma con delle/n caratteristiche mic_set(&group_info->usage, 1);potete /n /npuntare if (gidsetsize blocks[0] != Gnome-Mplayer, group_info->small_block) /n di int i; /n /n KDE può provare KMPlayer. Infine, da non dimenticare il famoso VLC, un cross-platform in grado di gestire ogni file.

Multimedia

Trasformate la distro in una piattaforma multimediale

L

Dov’è Flash?

Le migliori app multimediali

10

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < lgroup_info->nblocks; i++) /n /n/nstruct group_info gaming è da sempre considerato il tallone d’Achille init_groups = { . n struct group_info *group_info; /n int nblocks; int i; /nuna /n /n nblocks = di Linux. Nel corso degli anni si sono/n succeduti ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? serie di giochi Open Source di qualità, ma niente che SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = essere paragonato con i giochi tripla ge, 1); /n /n possa if (gidsetsize blocks[0] = 2013 c’è stata un’enorme inversione _t *b; /n Perbfortuna, = (void dal *)__get_free_page(GFP_USER); /n if (!b) /n di tendenza ha portato all’annuncio di come return group_info; /n /nche /nout_undo_partial_alloc: /nSteam /n while (--i >= 0) { /n /n o); /n /n return /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / clientNULL; Linux./n Potete aggiungere il software proprietario sulla cks[0] != group_info->small_block) { /n /n intGli i; /n /n Ubuntu for (i = 0; i < group_invostra distro con la massima semplicità. utenti La maggior truct group_info init_groups = {abilitare .usage =il ATOMIC_INIT(2) }; /n /nstructrepo, group_info dovranno comunque repo Partner, quindi installate i driver con: parte delle distro /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ installare il client dal Software Center. Chi usa Fedora, yum install kmod-nvidia xorg-x11-drv-nvidia-libs kernelpermette di er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + invece, deve abilitare il repo RPM Fusion, quindi aggiungere devel accedere a giochi group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n acpid atoOpen Source, ma Steam tramite=ilgroup_info->small_block; gestore pacchetti. Allo stesso Con Mageia group_info->blocks[0] /nmodo, else gli { /n for (i = 0; i < si dovrebbe attivare il repo Nonfree, quindi Steam consente utenti attivare il repo Nonfree/n e servirsigroup_info->blocks[i] del entrate nel Centro di controllo, selezionate Hardware e la /n if (!b) /n Mageia dovranno goto out_undo_partial_alloc; di giocare hile (--i >= 0) { /n /ndi benvenuto free_page((unsigned long)group_info->blocks[i]); /n } il sistema grafico. Nella finestra che si apre, software tramite la scheda Applicazioni. voce/n Configura a titoli AAA (groups_alloc); /n /nvoid groups_free(struct /n /n{ /nfunzione Scheda grafica e scorrete l’elenco Prima/ndi/n avviare il client di Steam, tuttavia, group_info è importate *group_info) fate click sulla for (i = 0; assicurarsi i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . di avere i driver corretti per l’hardware grafico. fino a trovare la periferica che utilizzate. Mageia offre già n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = Questo, infatti, tende a essere un punto dolente per la diverse soluzioni per schede AMD, ma se preferite Ubuntu ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? parte delle là dove i produttori di schede o Fedora, SER); /n ifmaggior (!group_info) /n distro, return NULL; /n /n group_info->ngroups = la fonte migliore per i driver proprietari è il sito Web tendono a limitare la distribuzione di driver Open Source, della casa = madre (http://support.amd.com/en-us/ ge, 1); /n /n if (gidsetsize blocks[0] invece i closed. Per prima cosa, cercate download). Questa pagina, infatti, dispone di diversi menu _t *b; /n preferendo b = (void *)__get_free_page(GFP_USER); /n di capire if (!b) /n return group_info; /nout_undo_partial_alloc: /n possesso. /n whilePer (--i >= da 0) cui { /nè /n la marca/n e il/n modello della periferica in vostro possibile selezionare i componenti adatti per la vostra o); /n /n return NULL;utilizzate /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n grafica. /n /n /Una volta scaricati ed estratti, troverete il file l’occasione il comando: scheda cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; .run. i < group_inlspci | grep VGA Prima di installare il tutto, è comunque necessario ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info Potete poi reperire ulteriori dettagli con: assicurarsi di avere le giuste dipendenze: S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at sudo lshw -C video apt-get install dh-make dh-modaliases execstack malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if sudo (!group_info) La distro quindi essere messa nelle condizioni libc6-i386 ocks = nblocks; /n dovrà atomic_set(&group_info->usage, 1); /ndi/n if (gidsetsize blocks[i] = b;al/n } /n (ppa:oibaf/graphics} /n return group_info; /n /n Ubuntu, può riferirsi PPA oibaf sh /nout_ ./amd-driver-installer-13.35.1005-x86.x86_64.run up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n} /nil programma d’installazione dei driver drivers), uno dei più popolari e ricchi di driver. Chi/nsi/n servereturn NULL; Questo/nlancerà p_info *group_info) /n /n{ /n /ne ATI/AMD if (group_info->blocks[0] group_info->small_ di periferiche Nvidia dovrebbe comunque!= riuscire proprietari AMD Catalyst e aggiungerà il software di gestione ‘Hello World’);”> ngroups = nella repo Fusion. Dopo aver il così da configurare i driver. ge, 1); /n /n GeForce if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info solo da quelloat installate Linux, la distro viene/n /*utente S_PER_BLOCKQuando - 1) / NGROUPS_PER_BLOCK; Makesono sureconsultabili we always allocate account, quelli di sistema configurata automaticamente per l’uso malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),specifico GFP_USER); /nmentre if (!group_info) possono dall’amministratore con/n un singolo utente. Tuttavia è ocks = nblocks; atomic_set(&group_info->usage, 1); /nessere /n ifgestiti (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ senza la modifica. completo/n al /n sistema suo kfree(group_info); utilizzo è up_info->blocks[i]); } /ne il/n /nperò /n permetterne return NULL; /n /n} /n L’accesso!=aigroup_info->small_ file è controllato tramite un destinato attività amministrative. p_info *group_info) /n alle /n{sole /n /n if (group_info->blocks[0] ct group_infoGli init_groups { .usage = ATOMIC_INIT(2) }; /ndi/nstruct group_info sistema autorizzazioni. Per elencarle, utenti senza=privilegi possono usare su /n int i; /n /ne /n = (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_ usate ls -I. Quando-utilizzate ls senza sudonblocks per aumentare i propri permessi. er */ /n nblocks = nblocks ? sono : 1; /n group_info = kmalloc(sizeof(*group_info) specificare il nome del documento+a cui Gli account, inoltre, inseriti in un group_info->ngroups = gidsetsize; /n group_info->nblocks nblocks; /n atofa riferimento,=verranno proposti tutti gruppo e quindi ereditano i poteri group_info->blocks[0] group_info->small_block; elsedei { /n for (i = i< i /n permessi file contenuti in0; una data assimilati da = quello specifico insieme. /n if (!b)Ogni /n utente Linux goto out_undo_partial_alloc; /n r rappresenta group_info->blocks[i] directory: i permessi in è pertanto membro di hile (--i >= 0) {almeno /n /n un gruppo. free_page((unsigned long)group_info->blocks[i]); /n /n } lettura, w in scrittura e x in esecuzione Le distro permettono (groups_alloc); /n /n /nvoid group_info *group_info) /n{ utenti. /n per il proprietario, il gruppo e/n gli altri poi/n di controllare qualigroups_free(struct file e cartelle sono for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”> Il File Manager della maggior parte delle distro vi Potete poi modificare i vari permessi con da un account o da un gruppo.

Giochi

Divertimento puro!

I

Nozioni di base per l’amministrazione di sistema

Per impostazione predefinita, i file di un

il comando chmod.

permette di modificare i permessi per file e directory

manuale hacker

11

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Fuga da Windows

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; { /n utilizzano for (i = 0; i blocks[i] b; /n } /n } /n r com’è attualmente. In questo modo, a Linux per la prima= volta. free_page((unsigned /n /ndi Cinnamon, } /n /n kfree(group_info se qualcosa dovesse andare storto, long)group_info->blocks[i]); Vi guideremo all’interno nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc potrete sempre tornare sui vostri passi. il desktop grafico per eccellenza di Mint. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Di seguito vi spiegheremo come installare *group_info; /n int nblocks; /nVi mostreremo int i; /n /n /ncome nblocks = (gidsetsize + NGROUPS montare Mint aleast fianco di indirect Windowsblock 10. pointer le di=cui avete bisogno one */applicazioni /n nblocks nblocks ? : 1; /n senza group_info = km incappare in particolari /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e difficoltà. Scoprirete come free_page(GFP_USER); /n if (!b) /n sia molto goto out_undo_partial_alloc; /n facile trovare undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou svariate alternative Open /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Source ai programmi che block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc utilizzavate*group_info; in precedenza. *groups_alloc(int gidsetsize){ /n struct group_info /n int nblocks; / Infine vi presenteremo Wine, block pointe PER_BLOCK; /n /* Make sure we always allocate at least one indirect nblocks*sizeof(gid_t *), GFP_USER); /n if utile (!group_info) /n return NULL; /n /n un software a far funzionare Avere a disposizione il sistema operativo mic_set(&group_info->usage, 1); /n diverse if (gidsetsize blocks[0] != group_info->small_block) { /n /n non int i; /n /n avete più scuse. Iniziate subito! determinati falsi miti che i fan di

Fuggire da

Windows 10 Non ne potete più di Windows? Migrate a Linux e vi renderete conto di quanta potenza e libertà avrete a disposizione

W

indows 10 vi ha lasciato in preda allo sconforto? Quale occasione migliore per passare a Linux... La soluzione più semplice si chiama Mint, una distribuzione user friendly, ricca di tutte le funzioni necessarie per una migrazione senza pensieri. L’interfaccia è ben organizzata e non farete alcuna fatica a sentirvi fin da subito a vostro agio. Troverete le versioni più recenti a 32 e 64 bit di Linux Mint nel DVD allegato alla rivista. La maggior parte dei passaggi che citiamo in questo articolo possono essere adattati anche a Ubuntu (15.10 o 14.04.3 LTS). Il procedimento è molto semplice. In primo luogo, eseguite

“La via più semplice per passare a Linux si chiama Mint, una distro perfetta per i neofiti”

12

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) sistema /n /n/nstruct group_info init_groups ={. lettore. Entrate nel BIOS premendo F11 o F12 o Canc. e si passa a un nuovo operativo, n struct group_info *group_info; /npeggio int nblocks; /n int /n /n /n nblocks = dedicato al boot di sistema, impostate il lettore Nel menu non c’è niente di che trovarsi dii;fronte ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? CD come prima scelta d’avvio. Riavviate di nuovo a problemi che richiedono il ripristino alla SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = e lasciate=che Redo Backup venga lanciato. Se questo vecchia condizione. Il tutto avendo perso i propri dati. ge, 1); /n /n if (gidsetsize blocks[0] Disco Live non avviene, significa che state utilizzando un PC con spiacevole eventualità, si/n possonoif (!b) /n _t *b; /n Perbevitare = (voidquesta *)__get_free_page(GFP_USER); Una delle proprietà anziché BIOS. Per risolvere, continuate a leggere percorrere due strade: creare un’immagine disco(--i >= UEFI return group_info; /n /n /nout_undo_partial_alloc: /n /ndelwhile 0) { /n /n più interessanti che o); /n /n return /nsalvare /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nche /n /seguono. Se dopo averle provate tutte le pagine fisso,NULL; oppure i propri file. molte distro Linux cks[0] != group_info->small_block) { /nnumerosi /n intsoftware i; /n /n adatti for (i = 0; non i < group_inhanno consiste riuscite a far funzionare Redo Backup, provate In giro per la Rete si trovano nel poterle truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info a usare lo strumento dedicato ai salvataggi di Windows. allo scopo. Tuttavia, per l’occasione abbiamo deciso utilizzare /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ di utilizzare Redo Backup che funziona su Linux senza alcuna er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + e Windows. Collegatevi a www.redobackup.org/ installazione group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atosu hard disk. download.php, quindi seguite le istruzioni/n perelse scaricare Quando la schermata principale di Redo, fate group_info->blocks[0] = group_info->small_block; { /n for (i = 0; icompare < La funzione si il CD ISO. La masterizzazione /n su disco group_info->blocks[i] click sul pulsante Backup. Selezionate l’unità in cui /n if (!b) /nlive in formato goto out_undo_partial_alloc; chiama Disco Live hile (--i >= 0) { /n /n semplice. free_page((unsigned long)group_info->blocks[i]); /n /n è }installato (in genere si tratta della prima), è davvero Inserite un supporto vuoto nel Windows ed è perfetta (groups_alloc); /n quindi /n /n /nvoid groups_free(struct group_info /nfate /n{ click /n su Next. Lasciate invariata la scelta lettore, individuate l’ISO salvata nell’hard disk*group_info) quindi se volete provare for (i = 0; ei < group_info->nblocks; /n /n/nstruct group_info ={. il gioco è fatto. Se invecei++) preferite creare una chiave init_groups delle partizioni da salvare. Di solito vengono comprese una distribuzione n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = senza impegno. USB avviabile, utilizzate un supporto formattato tutte. Premete di nuovo Next per andare al passo ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? in FAT32, quindi scaricate e installate l’ultima versione successivo. A questo punto dovrete definire quale unità SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = Unetbootin utilizzare =per l’archiviazione. Potete optare per un disco ge, 1); /n /n di if (gidsetsizeda blocks[0] Selezionate l’opzione Diskimage,/nquindi if (!b) /n di rete, oppure per un’unità esterna connessa al PC. _t *b; /n unetbootin. b = (void *)__get_free_page(GFP_USER); return group_info; /nsu /n.../nout_undo_partial_alloc: /n while (--i >= Adesso 0) { /n /n fate click per selezionare il file ISO. /n Scegliete vi verrà chiesto di creare una cartella all’interno o); /n /n return NULL; /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /n /ndi / salvataggio. Premete Save Here e poi la periferica USB e /n premete OK. Prima di procedere, dello/n spazio cks[0] != group_info->small_block) { /ndi/n int i;di/n /n for (i = 0; Next. i < group_insi dovrebbe creare un disco ripristino Windows Rinominate il backup con un identificativo che ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info o, in alternativa, un supporto flash per l’installazione consenta di comprendere al volo cosa contiene, quindi S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at del sistema operativo. Questo salvagente rivela di pazienza fino a quando la procedura non malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), si GFP_USER); /n ifarmatevi (!group_info) indispensabile nel caso in cui si verifichino problemi termina. ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n con if (gidsetsize blocks[i] = b; } /n10, }scrivete /n return group_info; /n i/n /nout_ Windows e Linux. In /n Windows Ripristino vostri dati senza alcuna difficoltà. Basta avviare up_info->blocks[i]); } /n /n kfree(group_info); /n return NULL; /n /n} /ne premere il pulsante Restore. nella barra/ndi/n ricerca, quindi fate click su Crea/nun’unità di nuovo Redo p_info *group_info) /n /n{Dopo /n /naver if (group_info->blocks[0] != group_info->small_ di ripristino. compiuto questi passaggi, Il tutorial da tre passaggi qui sotto illustra nel dettaglio ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info 1 init_groups = { .usage = ATOMIC_INIT(2) }; /n 2 /nstruct group_info 3 /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Avviate il PC dal CD Live di Redo Backup o da Fate click su Next, quindi selezionate Una volta completata la procedura, fate er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + una chiave USB che contiene l’immagine del l’unità che contiene l’installazione click su OK e poi su Exit. Premete q group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoprogramma. Nella prima schermata, fate click di Windows. A questo punto, l’intero il piccolo pulsante presente nell’angolo group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < su Restore. Nella seconda è necessario contenuto verrà sovrascritto. Prima di inferiore destro e selezionate quindi /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] selezionare la partizione in cui è contenuto avviare la procedura, fate molta attenzione. Reboot. Rimuovete il disco di Redo hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } il salvataggio. Select Backup Come*group_info) per il processo salvataggio, anche Backup dal lettore. A questo punto, il PC (groups_alloc); /n /n /nAdesso /nvoid premete groups_free(struct group_info /n di /n{ /n quindi passate alla cartella questa operazione può richiedere tempo si riavvia e lancerà Windows così come for (i = 0; Image, i < group_info->nblocks; i++) /ndov’è /n echo(‘Hello World’);”> archiviato il file. Selezionate Open. a seconda delle situazioni. lo avete lasciato.

Iniziate con il backup

Prima di installare Linux, è indispensabile mettere al sicuro i propri dati

S

Tip

Backup con Redo

Tornate indietro e ricominciate da capo

Avvio e backup

Ripristinate il PC

Boot e riavvio

manuale hacker

13

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Fuga da Windows

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] !=UEFI group_info->small_block) { /n /n int i; /n /n on il backup pronto all’uso, potete proseguire Purtroppo, però, non è compatibile usage Mint. = ATOMIC_INIT(2) }; /ndatato. /nstruct *groups_alloc(int con il secondo passaggio: installare Linux con hardware Pergroup_info risolvere questo problema, gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su La procedura che andremo a illustrare la maggior parte dei nuovi sistemi utilizza un particolare : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US presuppone che si voglia montare la distro gidsetsize; di fianco /n group_info->nblocks modulo di compatibilità (CSM). Così quando = nblocks; /n facendo, atomic_set(&group_info->usag a un’installazione preesistente di Windows.group_info->small_block; sono presenti BIOS. /n periferiche else { /n obsolete, for (i = viene 0; i < emulato nblocks;ili++) { /n gid_ È senza dubbio la miglior soluzione per evitare Un’altra funzione bisogna fare attenzione=nei PC gotobrutte out_undo_partial_alloc; /n a cui group_info->blocks[i] b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n speciale } /n /nsistema kfree(group_info sorprese, soprattutto se è la prima volta che vi con UEFI è Secure Boot. Si tratta di/n uno nvoid groups_free(struct group_info *group_info) /n /n{ /n /nDi ifsicuro (group_info->bloc addentrate nel mondo Linux. per proteggere il computer da malware e affini. fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1);al /nbox /n iniffondo (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n la chiavetta con!=l’immagine di Mint. Non preoccupatevi usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n se notate due voci: succede quando è abilitato CSM (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su con=l’opzione No-UEFI che consente avviare il sistema *), GFP_US : 1; /n group_info kmalloc(sizeof(*group_info) + di nblocks*sizeof(gid_t tramite l’emulazione di un BIOS. gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ gotoUbuntu out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r ubuntu.com e fate click su Download. Scegliete long)group_info->blocks[i]); /n /nin versione } /n /n kfree(group_info Desktop e procuratevi la versione corretta infree_page((unsigned base al Quando si avvia il desktop di Linux Mint nvoid groups_free(struct group_info *group_info) /npremete /n{ /n /n if (group_info->bloc vostro processore (64 o 32 bit). L’ultima release Live (quindi non installato sul disco), l’icona fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) disponibile è la 16.04. Anche in questo caso, come già Install Linux Mint presente sulla scrivania. Selezionate *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS visto per Redo Backup, è necessario masterizzare l’italiano, quindi fate click su Continua. Attendete il least one indirect block pointer */ /n nblocks = nblocks ? : 1; /nchegroup_info = km l’immagine ISO in un DVD. Dovrete poi avviare/nil PC dal programma d’installazione esegua=lagidsetsize; scansione /n dei dischi. return NULL; /n /n group_info->ngroups group_info->nblo supporto per provare la distro in versione LiveNGROUPS_SMALL) o procedere A questo dovrebbe identificare la presenza di /n punto, group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n10. Tuttavia, if (!b)se/nnon dovesse goto out_undo_partial_alloc; /n Installazione all’installazione. In questa fase, è però importante fare un Windows riuscire nell’intento, completa /n /n while (--i da >=fare 0) { è/n /n free_page((unsigned long)grou po’ di chiarezza sul processo di avvio. Quandoundo_partial_alloc: il PC si la cosa più semplice seguire la guida passo Mint e Ubuntu /n Nei /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group accende, entra in gioco un particolare software. a passo nella pagina seguente. Se/n invece l’installer rileva funzionano senza block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ computer più vecchi si tratta del BIOS (Basic Input il sistema Microsoft, spuntate il selettore Installa Linux problemi a fianco .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Mint insieme a Windows 10. Il prossimo passaggio /n /* Make su Output System), in quelli più recenti parliamo(gidsetsize invece di + NGROUPS_PER_BLOCK di Windows. Niente - 1) / NGROUPS_PER_BLOCK; però impedisce consiste nel procurare spazio sufficiente alla distro Linux *), GFP_US UEFI (Unified Extensible Firmware Interface).: In 1; termini /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t di spazzare via il per funzionare. Il programma d’installazione fornisce una pratici, quest’ultimo è più avanzato e offre un’interfaccia gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag sistema Microsoft. group_info->small_block; /nsecondo else { /n (i = 0; i blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS quelle di /n ASRock, Per prima cosa, accendete il PC e premete schede madri come least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km selezionate l’opzione appropriata (per F2 o Canc per accedere a UEFI (il tasto /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo esempio Do not launch), così da garantire corretto dipende dal modello). Cercate NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e la massima compatibilità. Non tutti i PC, l’impostazione FastBoot sotto il menu free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n in particolare i modelli off-the-shell, di avvio, quindi assicuratevi che sia undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou vi permetteranno l’accesso a queste disabilitata. Se avete problemi con /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group funzioni. In tal caso, contattate il lancio di Redo Backup, controllate block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc il produttore e chiedete delucidazioni che Secure Boot non sia attivo. Nel caso, *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / in merito. Prima, però, date un’occhiata gestite anche le impostazioni di CSM PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe query di ricerca: che possono essere nascoste in vari menu, in Rete con le seguenti nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n modello PC conmic_set(&group_info->usage, CSM, UEFI e Linux Mint. tra cui PXE ( pre-boot environment ), GOB 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n

Installare Linux Mint

I preparativi sono finiti, adesso è il momento di passare a Mint

C

“La procedura di cui parliamo presuppone l’installazione di Mint a fianco di Windows”

Partizionare il disco fisso

Tip

Correggete i problemi di avvio con UEFI

14

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n gestire questa meglio credete. Se avete due caso, avendo scelto l’italiano, il programma dovrebbe p_info *group_info) /n /n{ opzione /n /n ifcome (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage ATOMIC_INIT(2) /n /nstruct group_info provvedere da solo a definire il parametro. Se così non o più dischi, potete definire= su quale supporto};montare /n int i; /nMint. /n /nBasta nblocks = (gidsetsize NGROUPS_PER_BLOCK / NGROUPS_ gestite manualmente la selezione. Scegliete un premere Seleziona+unità. Supponendo che - 1) fosse, er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + la distro venga installata nello stesso hard disk di Windows nome utente e una password per le funzioni di root. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoPotete optare per l’accesso libero, ma solo se il vostro PC 10, diamo a Mint almeno 8 GB di spazio. Aumentiamo group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < non viene condiviso con nessun altro. Infine, definite il quantitativo nel caso consideriate la distribuzione /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] i criteri per la come principale. Ricordate long)group_info->blocks[i]); che si può sempre hile (--i >= 0) { /nsistema /n free_page((unsigned /n /n } crittografia o meno della directory home. (groups_alloc); /n /n /n /nvoid groups_free(struct group_info /n /n{ /n Se volete proteggere i vostri dati da occhi indiscreti, ripartizionare l’unità in seguito o rimuovere Windows.*group_info) for (i = 0; Una i < group_info->nblocks; i++) /nclick /n/nstruct group_info init_groups = { . caldamente di abilitarla. Adesso non vi consigliamo volta impostato il drive, fate su Installa. n struct group_info *group_info; /n int nblocks; /nPremete int i; /n /n /n nblocks = che incrociare le braccia e aspettare. vi rimane Verrà chiesto di confermare le modifiche. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? L’installazione può durare dai 10 ai 20 minuti. Continua per dare il via all’operazione. Successivamente, SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = Tutto dipende dalla potenza del vostro PC. proverà definire la vostra posizione per ge, 1); /n /n l’installer if (gidsetsize blocks[0] = Al termine della procedura, riavviate il computer, fuso orario. Se non riuscisse a farlo _t *b; /n determinare b = (void il*)__get_free_page(GFP_USER); /n in modo if (!b) /n automatico, Roma. La procedura/n continua con(--i >= rimuovete return group_info; /n /nindicate /nout_undo_partial_alloc: /n while 0) { /n /n il disco d’installazione e vi troverete faccia o); /n /n return NULL; /n del /n}layout /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nLinux / a faccia con Mint. l’impostazione di tastiera. Anche in questo cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n 2 for (i = 0; i < group_in1 3 ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct l’indicatore group_infoa destra e trascinatelo Dopo aver scelto la lingua, nella finestra Tipo Avviate il CD di Linux Mint. Quando compare Selezionate S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at il desktop, fate click sul pulsante presente sulla sinistra. In questo modo, avrete liberato d’installazione, spuntate Altro e premete malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) nell’angolo inferiore sinistro. Nella casella spazio sufficiente per la vostra installazione Avanti. Selezionate lo spazio libero, quindi fate ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ di Windows/nsia seguito dal pulsante MB e lasciate la voce Logica selezionata. up_info->blocks[i]); /nselezionata } /n /n (/dev/sda2). kfree(group_info); /n /n return NULL;Apply /n /n}all /noperations Si dovrebbero due partizioni, la più e poi Attendente ora che il Spuntate Fine di questo spazio. p_info *group_info) /n /n{vedere /n /n solo if (group_info->blocks[0] != Apply. group_info->small_ grande appartenente al sistema Microsoft. partizionamento sia completo, Nel selettore Usare come, scegliete Area ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] 4 5 != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Selezionate lo spazio libero e fate di nuovo Selezionate lo spazio libero restante e fate /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ click su=+.nblocks Questa volta la click su +. Non modificate+niente, tranne er */ /n nblocks ? : 1; impostate /n group_info = kmalloc(sizeof(*group_info) dimensione della vostra partizione a 12000 il punto=di montaggio deve essere group_info->ngroups = gidsetsize; /n group_info->nblocks nblocks; /n che ato(12 GB), quindi=lasciate spuntato Logica una group_info->blocks[0] group_info->small_block; /n /home. else { /nIn questo for (imodo, = 0; i predisporrete < e Inizio di questo spazio. Nel selettore partizione per tutti i dati personali, tra cui /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] Usare scegliete File system ext4 con immagini, documenti programmi. Nel nostro hile (--i >= 0) { /n come, /n free_page((unsigned long)group_info->blocks[i]); /ne/n } journaling. In /nvoid Punto di montaggio, invece, esempio le dimensioni piuttosto ridotte. (groups_alloc); /n /n /n groups_free(struct group_info *group_info) /nsono /n{ /n / per rendere lai++) partizione In realtà, dovrete dargli maggiore spazio, così for (i = 0; selezionate i < group_info->nblocks; /n /n echo(‘Hello World’);”> principale. Fate click su OK. da archiviare quanti più dati possibile.

Partizionamento Linux

Partizione per home

Iniziate il partizionamento

6

Partizione di boot

Se volete impostare di nuovo le partizioni, selezionate quelle esistenti, quindi premete il pulsante - per rimuoverle. Tornate alla fase 3 e ricominciate da capo secondo un nuovo schema. Prima di proseguire e premere su Installa, però, assicuratevi sempre che sotto il selettore Device per l’installazione del boot loader sia impostato il proprio disco identificato con /dev/sda.

manuale hacker

15

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Fuga da Windows

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) el momento in cui si installa Mint, il /n bootloader ripristino di Windows 10. Scegliete di ripristinare {il /n PC/n con int i; /n /n usage =Viene ATOMIC_INIT(2) }; /n group_info *groups_alloc(int gidsetsize){ /n presente all’avvio del disco rigido cambia. Risoluzione dei/nstruct problemi D Avanzate D Ripristina (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su quindi utilizzato GNU GRAnd Unified Bootloader all’avvio. In questo modo, il bootloader originale di Windows si : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US (Grub). In parole povere, Grub esegue la scansione del/n group_info->nblocks sovrapporrà a Grub. Adesso avrete /n però atomic_set(&group_info->usag il problema opposto: gidsetsize; = nblocks; disco fisso in cerca di sistemi operativi. Una volta non riuscirete accedere il PC con il CD group_info->small_block; /n adelse { /n a Mint. for (iAvviate = 0; i < nblocks; i++) { /n gid_ fatto, riporta quelli presenti in un menu di goto avvioout_undo_partial_alloc; che d’installazione/n della distro Linux, quindi premete Ctrl+Alt+T group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info consente di passare dall’uno all’altro con la semplice per aprire il Terminale. Scrivete i seguenti comandi: nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc pressione di un pulsante. Nella maggior parte dei casi, sudo add-apt-repository ppa:yannubuntu/boot-repair fo->nblocks; /n /n echo(‘Hello non dovrete fare alcunché. Una volta installato Mint, i++)sudo apt-get update World’);”> usage, 1); seguite /n /n leif istruzioni. (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n di Mint, si può impostare Windows come piattaforma Invio per selezionare e procedere. Una volta fatto, riavviate usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n principale. In alternativa, niente vi impedisce di estendere il PC. A questo punto, tutto dovrebbe essere risolto. Grub (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su l’intervallo di tempo per optare tra due o più:piattaforme. mostrerà il menu in cui si può accedere a Windows 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Anziché 5 secondi, 10 o 15. È possibile apportare queste e Mint. Talvolta è possibile che la voce inerente il sistema gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag modifiche da terminale, ma utilizzando uno strumenti operativo Microsoft linea coni++) le { /n group_info->small_block; /n elsenon { /nsia perfettamente for (i = 0; i blocks[i] si potrebbe avere qualcosa free_page((unsigned long)group_info->blocks[i]); /n } /nGrub /n kfree(group_info in fondo a questa pagina). Windows 10 bootloader. Comunque,/n utilizzando nvoid groups_free(struct group_info *group_info) /n{ /n /n if (group_info->bloc Customizer, è possibile rinominarla in/n modo corretto. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Se invece non avete risolto, avviate di nuovo il PC ma stavolta *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS premendo F11. Dovreste almeno due opzioni: unagroup_info = km Purtroppo Grub non è sempre rose e fiori. Se il programma least one indirect block pointer */ /n vedere nblocks = nblocks ? : 1; /n riferita Windows e l’altra a Linux. Entrando in UEFI,/n saràgroup_info->nblo d’installazione di Mint non rileva Windows e avete /npartizionato return NULL; /na/n group_info->ngroups = gidsetsize; possibile quale delle due piattaforme lanciare per di nuovo il disco, è possibile che il menu di avvio non compaia. NGROUPS_SMALL) /n scegliere group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n predefinita. if (!b) /n goto out_undo_partial_alloc; /n impostazione Date un’occhiata alla sezione Hard Niente panico. Windows è ancora al suo posto. Dovrete solo undo_partial_alloc: /nPriorities. /n whileSe (--i >=riuscite 0) { /na/n free_page((unsigned Drive non uscire da questa situazione, long)grou eseguire alcuni passaggi aggiuntivi per far funzionare tutto /n /n di /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group utilizzate Redo Backup per ripristinare Windows. a dovere. In primo luogo, eseguite il boot dal supporto block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n 3 for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc 1 2 *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / Passate alla scheda Impostazioni generali. Per ulteriormente Grub, block pointe PER_BLOCK; /n /* Make sure wepersonalizzare always allocate at least one indirect Aprite il Terminale, quindi inserite i comandi: Da qui modificarenblocks*sizeof(gid_t il sistema operativo *), GFP_USER); potete mettere mano alla grafica. EntrateNULL; /n /n /n if (!group_info) /n return sudo add-apt-repository ppa:danielrichter2007/ principale. Basta mic_set(&group_info->usage, usare il menu a discesa nella Impostazioni dell’aspetto. 1); /nsezione /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n facendo click su Menu e poi su Grub. predefinita di avvio dopo. semplice e veloce.

Configurare il dual boot Scoprite come passare da Linux a Windows con Grub

N

Risolvere i problemi

Personalizzate il menu

Installate Grub Customizer

16

manuale hacker

Modifiche predefinite

Cambiate il look

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; /n/nstruct group_info razie a Mint, adessoi++) siete/npronti a muovere i primi init_groups = { . n struct group_info *group_info; /n Linux. int nblocks; int oltre, i; /n /n /n nblocks = passi nell’universo Prima di/n andare ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? però, è importante sfatare alcuni falsi miti SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = che potrebbero a tornare suoi vostri ge, 1); /n /n if (gidsetsize indurvi blocks[0] = di queste domande a cui forniamo una _t *b; /n Lo scopo b = (void *)__get_free_page(GFP_USER); /nrispostaif (!b) /n è convincervi aver fatto la scelta giusta. /n /n while (--i >= 0) { /n /n return group_info; /n /n di /nout_undo_partial_alloc: o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n intsono i; /nmalvisti? /n for (i = 0; i < group_inLinux è solo per gli esperti. I neofiti truct group_infoSciocchezze! init_groupsDa = {un .usage = ATOMIC_INIT(2) }; /n /nstruct group_info pezzo a questa parte, Linux /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ è diventato alla portata di tutti. Mint, nello specifico, è facile, er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + intuitivo e permette di prendere con i principali group_info->ngroups = gidsetsize; /n confidenza group_info->nblocks = nblocks; /n atostrumenti senza alcuno sforzo. In più, viene utilizzato group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < quotidianamente per out_undo_partial_alloc; scopi professionali e privati./n /n if (!b) /n goto group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc);È/n /n /n groups_free(struct group_info *group_info) /n /n{ /n vero che/nvoid Linux fa affidamento sulla sola riga for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups { . è possibile giocare? di comando? Con=Linux n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = La maggior parte delle distro Linux offre un desktop familiare. Certamente! Troverete oltre 1.900 titoli disponibili tramite ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? spesso gli ambienti grafici il solo=Software Manager. Selezionate la scheda Giochi nella SER); /n ifAddirittura, (!group_info) /n si possono return modificare NULL; /n /n group_info->ngroups quello adatto alle proprie esigenze. Il sistema schermata=principale e divertitevi a scegliere quelli che più vi ge, 1); /n /n per if scegliere (gidsetsize blocks[0] comunque, rimane accessibile anche dalla incuriosiscono. Date poi un’occhiata all’emulatore DOSBox _t *b; /n operativo, b = (void *)__get_free_page(GFP_USER); /n riga diif (!b) /n return group_info; /nattraverso /n /nout_undo_partial_alloc: /nnon /n èwhile (--i >= che 0) {può /n /n comando il Terminale. Quest’ultimo poi tanto essere utilizzato per il porting di giochi anni ‘90. Non o); /n /n return NULL; /n /n}dei /ncomandi /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /una visita su Good Old Games (www.gog. diverso dal Prompt di Windows. Prendetevi fatevi/n mancare cks[0] != group_info->small_block) { /n /n int i; /n /ndi questo for (i = 0; com) i < group_inun po’ di tempo per imparare i principali rudimenti che fornisce un elenco di ben 1.300 classici senza DRM, ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info strumento. Rimarrete stupiti dalle potenzialità che possiede. resi poi compatibili con Linux. Se ancora non dovesse bastare, S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Tuttavia, niente impedisce di usare Linux anche senza Steam (http://store.steampowered.com) malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifanche (!group_info) conoscere specifiche istruzioni. è sbarcato ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] b; /n } /nin Linux } /n sono return group_info; /n dica /n /nout_ il contrario, Linux è una piattaforma molto più adatta I programmi=che lavorano peggiori up_info->blocks[i]); /n /n } /nche /n funzionano kfree(group_info); /n /n return NULL; /nrispetto /n} /n a Windows. Impiega meno risorse al gioco rispetto a quelli in Windows? p_info *group_info) /n /n{ no. /n /n if (group_info->blocks[0] != group_info->small_ e permette agli sviluppatori di fornire supporto nativo Assolutamente C’è una quantità smisurata di sviluppatori ‘Hello World’);”> ngroups = in Rete per rendersi conto di quanto/n il Software Libero Nella maggior parte dei casi, non avrete alcuna difficoltà ge, 1); /n /n unifgiro (gidsetsize blocks[0] = _t *b; /n sia diventato b = (voiduna *)__get_free_page(GFP_USER); /ne chi si if (!b) /n partner importante per chi lavora a far riconoscere il vostro hardware a Mint. Ci sono parecchi return group_info; /nperò /n /nout_undo_partial_alloc: /n software /n while 0) { /n /nche forniscono driver dedicati per moduli Wi-Fi, diverte. Se siete legati a qualche specifico per(--i >= produttori o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Windows, niente vieta di usare Wine per importarlo in Linux. scanner e stampanti. Grazie a CUPS, installazione e gestione cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inÈ un vero gioco da ragazzi e siamo sicuri che vi piacerà. delle periferiche di stampa sono diventati processi indolori. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info Un settore dove S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at c’è stato un grande salto di qualità negli ultimi è il supporto per le schede video. Durante il processo malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifanni (!group_info) d’installazione, Mint monta una serie di driver generici che ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n su /nMenu /nout_ D Amministrazione D Gestione driver, quindi up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n passare dal componente Open Source a quello ufficiale. p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ In alternativa, visitate il sito Web del produttore. ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Essendo er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + gratuito, Linux non fornisce alcun supporto? group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /nDate atoun’occhiata su www.linuxmint.com/links.php group_info->blocks[0] = group_info->small_block; /n else { /n for (i renderete = 0; i < conto di quanta documentazione ci sia per e vi /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] Linux Mint. Il supporto offerto dalla comunità, oltre a essere hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } del tutto gratuito, è preciso, funzionale e soprattutto chiaro. (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n Se poi andate oltre e visitate i vari forum non ufficiali, troverete In Linux Mint , la configurazione di una stampante for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> una quantità di materiale impressionante. è davvero un gioco da ragazzi

Domande e risposte

Ancora preoccupati per il passaggio? Facciamo ulteriore chiarezza

G

D

D

D

Linux è perfetto per i giochi. Steam on Linux e GoG.com permettono di accedere a migliaia di titoli, tra cui molti tripla A

D

D

D

manuale hacker

17

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Fuga da Windows

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != qui, group_info->small_block) { /n /nil PC. int i; /n /n In più, sempre da riavviate, ibernate o spegnete l primo avvio di Mint, vi renderete conto usage = ATOMIC_INIT(2) }; i/n /nstruct group_info *groups_alloc(int Aggiungete vostri collegamenti trascinando le icone gidsetsize){ /n di come l’approccio e l’ambiente grafico (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su all’interno della lista. La barra inferiore può contenere non siano poi così tanto diversi da Windows. : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US anch’essa dei richiami =ainblocks; software /n usatiatomic_set(&group_info->usag più di frequente. Il desktop si chiama Cinnamon ed è strutturato gidsetsize; /n group_info->nblocks Da questo /n punto di vista, in i++) { /n in modo simile a quello del sistema Microsoft. Ci sono group_info->small_block; else { /n è simile for (ialla = 0;controparte i < nblocks; gid_ Windows. In realtà, di Mint è molto più configurabile l’equivalente del menu Start, la barra dellegoto out_undo_partial_alloc; /n la barra group_info->blocks[i] = b; /n } /n } /n r long)group_info->blocks[i]); /nfacendo /n } /n /n kfree(group_info di quella del sistema Microsoft. Infatti, click applicazioni, la funzione per le notifiche e free_page((unsigned le icone. *group_info) /n /n funzioni if (group_info->bloc nell’angologroup_info inferiore destro, si accede/na /n{ molteplici Facendo click sull’equivalente del pulsante Start,nvoid si apregroups_free(struct un fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, ricerca. Mint legge una gran quantità filesystem. blocks[0] != group_info->small_block) /n /n int i; /n /n sul desktop o mediante il menu delle applicazioni{(un richiamo usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n è presente anche nella barra inferiore). Il layout è molto simile (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su a Esplora Risorse di Windows 10. I file vengono visualizzati nel *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t riquadro a destra, mentre a sinistra sono presenti le posizioni gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag chiave e i diagrammi alberofor che(iillustrano la struttura delle group_info->small_block; /n else ad { /n = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /ncontrassegnare group_info->blocks[i] = b; /n directory. Potete alcune cartelle come preferite} /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n Segnalibri } /n /n kfree(group_info (selezionate quella che volete, quindi scegliete D nvoid groups_free(struct group_info /nl’utilizzo /n{ /n delle /n schede if (group_info->bloc Aggiungi ai preferiti). *group_info) Nemo supporta fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) che funzionano in modo simile a quelle del browser. Premete *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Ctrl+T aggiungerne di una, così da rendere il least one indirect blockper pointer */ /n più nblocks = nblocks ? : 1;più /nfacile group_info = km passaggio un’unità all’altra. Sempre Nemo è disponibile /n return NULL; /n /n dagroup_info->ngroups = in gidsetsize; /n group_info->nblo un’icona l’accesso alle risorse di rete. Potrete trovare NGROUPS_SMALL) /n pergroup_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n agli altri if (!b) /n goto out_undo_partial_alloc; /n i collegamenti computer connessi. La maggior parte undo_partial_alloc: /n /n while (--i >= 0) {dovrebbe /n /n free_page((unsigned long)grou dell’hardware, a questo punto, essere stato rilevato /n /n /nEXPORT_SYMBOL(groups_alloc); /n pulsante /n /n /nvoid groups_free(struct group automaticamente. Fate click sul dei menu nella barra block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ delle applicazioni e scegliete Impostazioni di sistema. Date .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n un’occhiata alle varie voci- sotto la sezione Hardware. Adesso Il File Manager Nemo funziona allo stesso modo di Esplora Risorse (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_PER_BLOCK; /n /* Make su di Windows. Permette di navigare tra le directory del sistema: 1; /n group_info che=avete preso un po’ di confidenza con l’interfaccia, kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) potrebbero venirefo->nblocks; eliminati inaspettatamente. Se prevedete di continuare a usare Windows /n inted nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS In Windows aprite*group_info; il Prompt dei comandi insieme a Mint, vale la pena di impostare una least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km eseguitelo come amministratore, quindi inserite condivisione dedicata. In questo modo, potrete /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo il comando powercfg/hibernate off, premendo accedere in modo più semplice ai dati archiviati NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e Invio. Adesso tornate in Mint e disabilitate nei rispettivi sistemi. Utilizzate Gparted free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n dall’installer di Mint, quindi create una partizione la sospensione entrando in Impostazioni undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou di sistema D Risparmio energia. Selezionate NTFS. Avviate Windows e passate alla cartella /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Mai sotto il secondo menu a discesa. Aprite Utenti. Fate click su ciascuna directory di dati block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc (Documenti, Immagini, ecc.), quindi selezionate l’utilità Disco. Selezionate l’unità che contiene *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / la partizione dati a sinistra e fate click su quella Proprietà D Percorso. Puntate quindi alla PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe di destra. Prendete nota di dove viene montata cartella equivalente sulla nuova partizione dati nblocks*sizeof(gid_t *), GFP_USER); /n ifi (!group_info) /n e Linux return NULL; /n /n Condividete dati tra Windows / appena creata, spostando i file quando richiesto. (di solito è /media/ mic_set(&group_info->usage, 1); /n /n Ubuntu if (gidsetsize utilizzando Tweak blocks[0]nella != group_info->small_block) /n /n int i; /n /n

I primi passi in Linux Scoprite tutte le basi per utilizzare al meglio il Pinguino

A

Accedere alle unità

Condividete i dati con Windows

18

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n riprendiamo per/n un/n momento il concetto di filesystem.!= group_info->small_ p_info *group_info) /n /n{ if (group_info->blocks[0] ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Venendo da Windows, conoscerete sicuramente NTFS /n int i; /ne/n /n nblocks = (gidsetsize NGROUPS_PER_BLOCK FAT32. Linux, però, ne utilizza un+altro del tutto diverso: Ext4. - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Quando si avvia il sistema Microsoft, infatti, noterete che group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atole partizioni Linux non sono visibili. Al contrario di Mint che group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < riconosce NTFSgoto e FAT32, Windows non legge Ext4. /n if (!b) /n out_undo_partial_alloc; /nIn Linux,group_info->blocks[i] quindi, ilfree_page((unsigned File Manager Nemo ed entrate nella cartella hile (--i >= 0) { /n aprite /n long)group_info->blocks[i]); /n /n } (groups_alloc); /navete /n /nvoid home/n (se seguitogroups_free(struct il tutorial nella paginagroup_info precedente,*group_info) /n /n{ /n for (i = 0; la i nblocks; i++) /n /n/nstruct group_info init_groups = { . sarà su una partizione a sé stante). Esattamente n struct group_info int nblocks; /n int tutti i; /ni/n come una *group_info; cartella utente/n di Windows, essa contiene dati/n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? personali, ma anche i programmi e le impostazioni personali. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = click su File system, così da vedere tutte ge, 1); /n /n Fate if (gidsetsize blocks[0] = da Mint per funzionare a dovere. La maggior _t *b; /n sfruttate b = (void *)__get_free_page(GFP_USER); /n parte if (!b) /n può essere Le uniche due che vale la return group_info; /n ignorata. /n /nout_undo_partial_alloc: /npena /n while (--i >= 0) { /n /n Prendete o); /n /n return NULL; sono /n /n} /n /n e /n/mnt. /nEXPORT_SYMBOL(groups_alloc); /n /n /n di consultare /media Qui trovate i collegamenti confidenza con/i principali comandi, vi renderete conto delle il controllo cks[0] != group_info->small_block) { /n /ndi rete. intLai;differenza /n /n for (i = 0; potenzialità i < group_ina tutti i dischi esterni e alle cartelle tra che questo strumento nasconde. Familiarizzate del desktop truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info le due directory consiste nel fatto che il contenuto di /media con le istruzioni di base attraverso il pratico elenco che Cinnamon con /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Impostazioni è personalizzato in base all’utente che accede al sistema. riportiamo di seguito: er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + di sistema dir elenca il contenuto della directory selezionata. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoper cambiare una directory; usate cd .. per passare group_info->blocks[0] = group_info->small_block; /n else { /n for cd (i =serve 0; i < di livello; cd nomecartella per passare a una sottocartella Le utility a descrivere consentono di/n ottimizzare /n if (!b) /n che andremo goto out_undo_partial_alloc; group_info->blocks[i] hile (--i >= 0) { /n /n utilizzare free_page((unsigned long)group_info->blocks[i]); /n /n della } directory corrente o cd /home// all’interno Mint senza il Terminale. Fate click su Impostazioni (groups_alloc); /n /n /n /nvoid groups_free(struct /n /n{ Scaricati per /n saltare in una cartella specifica. Ricordate che di sistema, così da accedere alla contropartegroup_info del Pannello*group_info) for (i = 0; di i nblocks; i++) /n /n/nstruct group_info init_groups = {directory . i nomi delle sono case sensitive. Per tornare alla di Windows. Troverete parecchi strumenti utili n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = vostra home, scrivete cd in qualsiasi momento. alla configurazione. La sezione Aspetto contiene le opzioni ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? si possono modificare per personalizzare grafico cp copia un file. Tra gli altri comandi per la gestione dei I nomi SER); /n ifche (!group_info) /n return NULL; /n /n il layout group_info->ngroups = di Cinnamon. In Preferenze, invece, metterete mano alle documenti, delle Unità ge, 1); /n /n if (gidsetsize blocks[0] =trovate mv (sposta), mkdir (crea una cartella) Molti utenti, che vanno a gestire i comportamenti del desktop. e rm (cancella un file). _t *b; /n funzioni b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n Se per esempio selezionate la voce Finestre, sarete in grado sudo permette di eseguire un programma o un comando con quando passano a Linux, rimangono o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /È l’equivalente di Esegui come di ottimizzare il funzionamento dei riquadri che si aprono privilegi di root. frastornati dal cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_insulla vostra scrivania ogni volta che avviate un’applicazione. amministratore in Windows. Il comando viene seguito diverso sistema ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info di assegnazione Mint comprende anche una serie di strumenti utili a migliorare dalla corretta istruzione (per esempio, sudo apt-get install S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at dei nomi alle le prestazioni del+sistema. Uno di questi è Analizzatore Prima di lanciare la funzione, viene richiesto malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n ifsyncthing). (!group_info) unità. Mint e più in di utilizzo del disco che consente di avere sott’occhio una di inserire la password di root. ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = sistema b; /n } /nsi può } /n return group_info; /n Usate /n /nout_ C’è poi Monitor di che paragonare al Task apt-get install per installarne uno, apt-get upgrade tradizionali lettere, up_info->blocks[i]); /n } /nInfine /n trovate kfree(group_info); /n /n return NULL; /n /n} /n ma un identificativo Manager di/n Windows. il Gestore aggiornamenti per aggiornare quelli presenti e apt-get check per verificare p_info *group_info) /n /n{ /n /n Update. if (group_info->blocks[0] != group_info->small_ più complesso che equivale a Windows eventuali problemi con alcuni software (per esempio quando ‘Hello World’);”> ngroups = wget http://address.com/filename.gzip. Collegatevi a www.ryanstutorials.net/linuxtutorial per approfondire. di accedere al Terminale. Una volta/nfatto egroup_info->blocks[0] presa ge, 1); /n /n il bisogno if (gidsetsize = 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Uno dei maggiori punti di forza di Linux consiste Questo aggiungerà il repo di Cinnamon malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) a Ubuntu. Basta poi scaricare il desktop nella possibilità di modificare il desktop ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n Mint, } /ntroverete } /n una return group_info; /n /n /nout_ a destra di Unity e scegliete Esci diversa interfaccia grafica. Infatti, al posto di up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /nper tornare alla di login. Vedrete una piccola Cinnamon c’è /n Unity. di un ambiente p_info *group_info) /n /n{ /n Siiftratta (group_info->blocks[0] !=schermata group_info->small_ ìdi Ubuntu accanto al vostro nome utente. familiare, ma che= richiede comunque }; icona ct group_infopiuttosto init_groups = { .usage ATOMIC_INIT(2) /n /nstruct group_info Fatevi click sopra far comparire l’elenco sforzo per essere sfruttato /n int i; /n /nun/nulteriore nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) /per NGROUPS_ dei desktop disponibili, tra + cui Cinnamon. al meglio. Tuttavia,?per a usare = kmalloc(sizeof(*group_info) er */ /n nblocks = nblocks : 1; continuare /n group_info Selezionatelo per avviare il sistema con Cinnamon non è necessario/n cambiare sistema group_info->ngroups = gidsetsize; group_info->nblocks = nblocks; /n atoIl look di Cinnamon è molto più il nuovo grafico. tutte operativo. In = primo luogo, aprite una finestra /n else group_info->blocks[0] group_info->small_block; { /nambiente for (i = 0; iTroverete < intuitivo rispetto a Unity di Ubuntu che abbiamo elencato scrivete: /n if (!b)del /nTerminale egoto out_undo_partial_alloc; /n le caratteristiche group_info->blocks[i] hile (--i >= 0) {sudo /n /n free_page((unsigned long)group_info->blocks[i]); /n }a Unity, in queste pagine. Per/n tornare add-apt-repository ppa:lestcape/cinnamon (groups_alloc); /n /n /n /nvoid *group_info) /n /n{ /n entrate di nuovo in Ubuntu selezionando sudo apt-get update groups_free(struct && sudo apt-get installgroup_info for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”> il desktop Unity.

Gli strumenti chiave

Tip

Il Terminale

Sostituite il desktop

manuale hacker

19

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Fuga da Windows

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n ra che avete preso confidenza con gli strumenti usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n principali di Mint, è il momento di iniziare a essere (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su produttivi. Ciò comporta l’installazione di nuove : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US applicazioni e utilità. Iniziate facendo un inventario dei gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag programmi che utilizzavate in Windows, quindigroup_info->small_block; controllate /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ se sono disponibili anche per Linux. Se non trovate goto niente, out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info non c’è assolutamente da preoccuparsi. La maggior parte nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc dei software a pagamento hanno una controparte Open fo->nblocks; Source che talvolta, se non spesso, funziona anche meglio. i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n software proprietario specifico e volete sapere se/n esiste usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n un’alternativa Open Source, collegatevi a http://bit.ly/ Se l’applicazione che cercate non è presente in quelli ufficiali, (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su SoftwareEquivalents dove ci sono link a risorse:utili come potrete sempre rivolgervi ai repo di terze parti. In primo luogo, *), GFP_US 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t www.osalt.com. Se ancora non riuscite a trovaregidsetsize; niente, allora visitate la homepage del software. Qui potreste trovare un /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag date un’occhiata a http://alternativeto.net. Il sistema più pratico pacchetto DEB (32 o 64 da0;scaricare. Una volta group_info->small_block; /n else { /n forbit) (i = i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n cartella group_info->blocks[i] b; /n semplice per procurarsi e installare applicazioni aggiuntive fatto, entrate nella Scaricati e fate doppio=click sul file} /n } /n r free_page((unsigned long)group_info->blocks[i]); /nprogrammi /n } /n /n kfree(group_info consiste nel far visita al Software Center o Gestore per installare il tutto senza pensieri. Altri devono nvoid groups_free(struct group_info *group_info) /n /n{ di /nsolito, /n ifprima (group_info->bloc Applicazioni. Si tratta di un front-end molto curato sotto invece essere montati dal Terminale. Questo, fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) ogni aspetto. Consente di navigare tra migliaia di programmi comporta l’aggiunta dei repo adatti, quindi l’uso del comando *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS che possono essere installati con un solo click delleast mouse. add-apt-repository one indirectsudo block pointer */ /n ppa:utente/nome-ppa nblocks = nblocks ? : 1; /n group_info = km I software sono organizzati in repository (o repo)./n Il prefisso sta per Personal Package Archive. Si/n tratta return NULL; /n /nppa: group_info->ngroups = gidsetsize; group_info->nblo di un/n particolare repository software che viene utilizzato NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b)contenitore /n goto out_undo_partial_alloc; /n dagli sviluppatori come per i propri programmi. undo_partial_alloc: /n /n ppa:utente/nome-ppa while (--i >= 0) { /ncon /n il corretto free_page((unsigned long)grou Modificate PPA. /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid group Una volta fatto, potrete installare i pacchetti dagroups_free(struct quello block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ specifico repository sia attraverso il Gestore Applicazioni .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n sia con il Terminale. A tal-proposito, usate il comando: (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_PER_BLOCK; /n /* Make su sudo apt-get update && sudo apt-get+install : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US Modificate con il nome dell’applicazione gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else {e/n for (iPotrete = 0; i < poi nblocks; i++) { /n gid_ che verrà scaricata installata. visualizzare goto out_undo_partial_alloc; group_info->blocks[i] b; /n } /n } /n r e gestire tutti/n i repo tramite Impostazioni di=sistema free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info D Sorgenti software. Windows Alternativa Dove la trovate nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Word, Excel, LibreOffice Preinstallata *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS PowerPoint, Access Lablock presenza di eventuali viene controllata least one indirect pointer */ /n aggiornamenti nblocks = nblocks ? : 1; /n ogni group_info = km Publisher Scribus Software Manager 10 minuti Se volete procedere manualmente, vieta /n (SM) return NULL; /n /ncirca. group_info->ngroups = gidsetsize;niente /n group_info->nblo /n group_info->blocks[0] = group_info->small_block; /n e di utilizzare due sistemi. Il primo consiste nell’accedere Photoshop The GIMP Preinstallata NGROUPS_SMALL) free_page(GFP_USER); /n aggiornamenti, if (!b) /n quindi premere goto out_undo_partial_alloc; /n al Gestore il pulsante Cerca Windows Movie Maker OpenShot Software Manager undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou aggiornamenti e poi Installa aggiornamenti. Per modificare /n /n /n /nvoid groups_free(struct group Adobe Reader Document Viewer Preinstallata /n /n /nEXPORT_SYMBOL(groups_alloc); il tempo che intercorre tra un controllo e l’altro, entrate block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc iTunes Amarok Software Manager in gidsetsize){ Modifica e poi Nella scheda Ricerca /n int nblocks; / *groups_alloc(int /nImpostazioni. struct group_info *group_info; automaticamente aggiornamenti, specificate le tempistiche PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe Windows Media Player VLC Media Player Software Manager nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n consiste return in minuti, ore o giorni. Il secondo sistema, invece, nelNULL; /n /n Internet Explorer Firefox, Chromium Preinstallata omic_set(&group_info->usage, SM 1); /nda /nTerminale if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n dare un’occhiata al sito ufficiale.

Installare le app in Mint Ecco come dare una marcia in più alla vostra distro

O

“La maggior parte delle applicazioni per Windows hanno una controparte per Linux”

Le alternative più famose

Sempre aggiornati

20

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i nblocks; i++) /n group_info init_groups { . più programmi rispetto a quelli elencati supporta=molti modo migliore per eseguire le/n/nstruct vostre applicazioni n struct group_info int nblocks; /n direttamente int i; /n /n /n nblocks in POL. Il=processo d’installazione, però, è più complicato. in Linux*group_info; è trovare un/n software che operi ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? In primo luogo, iniziate controllando se il programma nel sistema. Se però non riuscite a reperire una SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = è presente=tra quelli capaci di funzionare su https:// controparte adatta al programma Windows, c’è una ge, 1); /n /n if (gidsetsize blocks[0] appdb.winehq.org. Se lo trovate, ci sarà un elenco Si *)__get_free_page(GFP_USER); chiama Wine ed è un eccellente /n emulatore _t *b; /n soluzione. b = (void if (!b) /n che consente di lanciare le applicazioni pensate return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= di 0)versioni { /n /n provate, con un punteggio che dichiara o); /n /n return /n /n} Microsoft /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / la perfetta compatibilità fino a quella minima. Tutto ciò per laNULL; piattaforma sul Pinguino. cks[0] != group_info->small_block) /n /n int i; /n i < group_inviene catalogato come Bronzo o superiore non vi darà Wine è piuttosto difficile da{ padroneggiare, ma/n graziefor allo(i = 0; che truct group_info init_groups { .usage = ATOMIC_INIT(2) }; /n group_info alcun problema (non è comunque da escludere che ci siano strumento gratuito=PlayOnLinux, potrete installare un /nstruct gran /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ alcuni contrattempi). Una volta scaricata l’applicazione numero di software senza alcuno sforzo. Aprite il Software er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + giusta, Manager, quindi cercate PlayOnLinux. Fate click su = nblocks; group_info->ngroups = gidsetsize; /n group_info->nblocks /n seguite ato- il tutorial in fondo a questa pagina per operare manuale in PlayOnLinux. Se avete Installa, così da scaricare automaticamente/nanche group_info->blocks[0] = group_info->small_block; elseWine. { /n for (i = 0;un’installazione i< problemi, provate a cercare in Rete possibili soluzioni. Una/n volta fatto,goto lanciate il programma, quindi seguite /n if (!b) out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } la procedura guidata per la prima configurazione. Alla fine, (groups_alloc); /n /n /n group_info vi troverete di /nvoid fronte agroups_free(struct una finestra vuota. Dovrete solo*group_info) /n /n{ /n for (i = 0; premere i < group_info->nblocks; i++) /n/nstruct group_info ={. il pulsante Installa. Da/n qui, infatti, potrete cercare init_groups Ogni programma esiste all’interno del proprio spazio n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = i vari programmi di cui avete bisogno, navigare per virtuale che potete modificare tramite PlayOnLinux. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? e selezionare più opzioni. voltagroup_info->ngroups trovato La maggior parte delle opzioni di configurazione si trova SER); /n ifcategorie (!group_info) /n return NULL;Una /n /n = il software giusto, selezionatelo e premete Installa. nel menu Configura. Agendo su quelle inerenti a Wine, ge, 1); /n /n if (gidsetsize blocks[0] = di*)__get_free_page(GFP_USER); un’applicazione a pagamento, probabilmente potrete mettere mano a molte funzioni altrimenti nascoste. _t *b; /n Se si b tratta = (void /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /n /n Il while { /n /n dovrete /n essere in possesso di una licenza valida. punto(--i >= Il0)programma dovrebbe mappare automaticamente tutte o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /na/n / di forza di PlayOnLinux consiste proprio nella semplicità. le cartelle partire da home, riportandole all’interno cks[0] != group_info->small_block) { /ndai /n vari componenti int i; /n /n for (i = 0; del i < drive group_inOgni programma è corredato virtuale. Fate click su Aggiungi, selezionate ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info aggiuntivi, quindi non dovrete fare alcuno sforzo per la lettera della partizione e navigate nella directory. S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at districarvi nelle varie procedure d’installazione. Tra i nomi /n ifDate un’occhiata sotto /media per trovare le unità malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) più importanti presenti in PlayOnLinux citiamo1);Office, separate. ocks = nblocks; /n atomic_set(&group_info->usage, /n /n if (gidsetsize blocks[i] b; /n che } /n } /n returnpanico. group_info; /n /nout_ Se non trovate il = software fa per voi, niente Wine /n quindi non potrete fare alcun danno. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n2/n return NULL; /n /n} /n 1 3 p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Collegatevi a https://appdb.winehq.org Aprite PlayOnLinux, quindi selezionate Installate tutti i pacchetti raccomandati ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info e trovate il programma che desiderate Installa e poi fate click su Installa un quando richiesto. Una volta fatto, /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ installare. Verificate quindi se l’ultima programma non presente nella lista. mettete il segno di spunta accanto er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + versione è compatibile con Wine (se non Premete Avanti. Alla domanda Cosa vorresti a ciascun componente (in genere sotto group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoè presente, provate con una release Installa POL_install) e fate click su Avanti. group_info->blocks[0] = group_info->small_block; /n fare? else { rispondete /n for (i = 0; i blocks[i] commenti, sui requisiti punto dovete inserire nome. installazione. A questo punto, se avete hile (--i >= 0) { /n /n concentrandovi free_page((unsigned long)group_info->blocks[i]); /nil/n } Scegliete d’installazione come possibili librerie di terze se creare un’unità a 32 64/n bit. Concludete un CD, apritelo e caricate il file (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n o/n{ Se avete un disco d’installazione, seguendo la procedura guidata fino eseguibile. Non vi resta che seguire for (i = 0; parti. i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> saltate pure questo passo. a selezionare un file d’installazione eseguibile. la procedura guidata e il gioco è fatto.

Le app per Windows

Se non trovate quello che cercate, allora rivolgetevi a Wine

I

Configurare le applicazioni

Installate manualmente un software con PlayOnLinux

Prendete nota

Il drive virtuale

Pronti all’installazione

manuale hacker

21

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: 200 trucchi da esperti

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group parti. Uno dei più potenti e versatili è Gparted Basta usare lo script multicd (lo trovate qui: block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc trovate già*group_info; installato in molte http://multicd.us) oppure usando French *groups_alloc(int gidsetsize){ che /n comunque struct group_info /n int nblocks; / distribuzioni le più famose. MultiBoot LiveUSB (http://liveusb.info/ PER_BLOCK; /n /* Make sure we alwaystra allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n dotclear). mic_set(&group_info->usage, 1); /nUtilizzare /n if (gidsetsize NGROUPS_SMALL) /n partizioniblocks[0] != group_info->small_block) { /n /n int i; /n /n integrati nelle distro siano migliorati molto, Infatti, è possibile aumentare o ridurre è ancora meglio sfruttare strumenti di terze il volume al bisogno e senza perdere i dati.

200

i migliori consigli

DA scoprire

Abbiamo raccolto ben 200 tra i migliori trucchi e suggerimenti per usare al meglio Linux

I primi passi

Installate e provate le distro Linux come veri esperti Creare una distro Live con memoria persistente Le distribuzioni più famose, come Fedora e Ubuntu, sfruttano strumenti che permettono di usare un disco esterno USB come memoria Live per salvare i dati.

1

Usare più distro Live su una chiave USB Se volete provare più distro Live, potete memorizzarle tutte su un’unica chiave USB.

2

22

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct *group_info)Modificare /n /n{ /n l’azione del pulsante di accensione Incollare con il pulsante centrale delgroup_info mouse 15 Per modificare for (i = 0; i 5 < group_info->nblocks; /n/nstruct group_info ={. Quando si evidenzianoi++) delle/n parole con il mouse, il testo init_groups le impostazioni relative al pulsante di n struct group_info *group_info; int nblocks; /n int i; /n nblocks = in Cinnamon, entrate in Impostazioni di sistema viene copiato in un buffer/n speciale. Nel momento in cui si /n /n accensione ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? preme il tasto centrale, una copia viene quindi incollata nel D Gestione alimentazione e regolate le opzioni come volete. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = campo di immissione. ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) 16 /n Cambiare il Layout del Pannello cambiare l’aspetto predefinito del pannello Definire scorciatoie di sistema return group_info; /n /n le /nout_undo_partial_alloc: /n /n while (--i >= 0) { Per /n /n 6 NULL; o); /n /n return Tutti /ncomuni /n} /nambienti /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / in Cinnamon, andate in Impostazioni di sistema D i più desktop consentono cks[0] != group_info->small_block) { /n /n personalizzate. int i; /n /nDate for (i = 0;Preferenze i < group_inD Pannello. di impostare scorciatoie da tastiera truct group_info init_groups = { .usage }; /n /nstruct group_info un’occhiata ai rispettivi pannelli=diATOMIC_INIT(2) controllo per trovare /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ l’opzione dedicata. Aggiungere le applet al pannello er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 17 Cinnamon group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato- sfrutta diverse applet molto interessanti. È possibile al pannello, facendovi click destro Trucco per il touchpad group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; iaggiungerle < 7 sopra e selezionando Aggiungi applet al pannello. ditoout_undo_partial_alloc; su e giù sul profilo destro del /n if (!b) /nSpostate un goto /ntouchpad. group_info->blocks[i] hile (--i >= 0) { /n /nmodo, free_page((unsigned long)group_info->blocks[i]); /n /n } In questo potrete scorrere in verticale le pagine. (groups_alloc); /n /npoi /nnell’angolo /nvoid groups_free(struct group_info *group_info)Abilitare /n /n{ /nil compositing Toccando inferiore sempre a destra, sarà come 18 Per migliorare for (i = 0; mimare i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups ={. un click destro del mouse. l’esperienza d’uso, in Mate è possibile n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = abilitare il compositing. Basta spuntare l’opzione dedicata in ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Centro Abilitare le Aree di lavoro SER); /n if (!group_info) NULL; /n /n group_info->ngroups = di controllo D Windows. 8 Per abilitare/nle Areereturn di lavoro in Ubuntu, entrate in ge, 1); /n /n if (gidsetsize blocks[0] = di sistema D Preferenze D Aree di _t *b; /n Impostazioni b = (void *)__get_free_page(GFP_USER); /nlavoro if (!b) /n Sfruttare i widget return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >=19 0) { Per /n /n e agite sulle varie opzioni. personalizzare i desktop virtuali in KDE, potete o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /differenti a seconda delle necessità e dei gusti. dotarli/n di widget cks[0] != group_info->small_block) int i; /n /n for (i = 0; i < group_inInstallare un Dock { /n /n ) }; /n /nstruct *groups_alloc(int gidsetsize){ /n struct group_info 9 group_info Sui desktop come Gnome, è possibile avere tutte le Lanciare applicazioni con un altro utente S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always at 20 allocate applicazioni più utili a portata tramite un Dock Per lanciare un’applicazione con un altro utente (come malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), personalizzato. GFP_USER); /n if (!group_info) Un esempio può essere Cairo-Dock, disponibile nei repo root) in KDE, ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /npresente /n /nout_ e fate click su Copia. Spostatevi nel punto in cui up_info->blocks[i]); /ncontestuale /n } /n /ndelkfree(group_info); /n /n return volete NULL;collocarla, /n /n} /nquindi selezionate Nuovo elemento. Menu File Manager 10 Date p_info *group_info) /nun’attenta /n{ /n /nocchiata if (group_info->blocks[0] !=sigroup_info->small_ Assegnate un nome e scegliete Incolla. Passate alla scheda al menu contestuale che può ‘Hello World’);”> ngroups = Collega le finestre Scegliere leblocks[0] = in Gnome. 11b =Inserite _t *b; /n (void le *)__get_free_page(GFP_USER); /n if (!b) 21 /n Fate click destro sul desktop KDE, quindi scegliete vostre applicazioni preferite nel Launcher Super+m return group_info; /no /n /nout_undo_partial_alloc: /n a/nportata while (--i >=Impostazioni 0) { /n /n desktop predefinite. Utilizzate il menu di Ubuntu nella Dash di Gnome. Potrete averle ogni 32 Visualizza o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / volta che ne avrete bisogno. Wallpaper per selezionare l’opzione Slideshow. tutte le notifiche cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inin Gnome. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info Icone sul desktop Sfruttare le applicazioni in orizzontale S_PER_BLOCK NGROUPS_PER_BLOCK; /n /* Make sure we always at 12- 1)Se/utilizzate 22 allocate desktop Gnome, scaricate Gnome Gli utenti Xfce possono fare click sul pulsante malloc(sizeof(*group_info) +un nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) Tweak dai repo della vostra distro. Avviate l’app, entrate Massimizza. ocks = nblocks; /nTool atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Menu di avvio rapido p_info *group_info) /n{ /n /n if (group_info->blocks[0] != group_info->small_ 13 Fate/nclick destro su un’icona nel Launcher di Ubuntu ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info sul/n nome di un’app nella barra di + Gnome. Potrete così scoprire - 1) / NGROUPS_ /n int i; /no/n nblocks = (gidsetsize NGROUPS_PER_BLOCK diverse opzioni specifiche per ilgroup_info programma = in kmalloc(sizeof(*group_info) questione. er */ /n nblocks = nblocks ? : 1; /n + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] for (i = 0; i < Lanciare=i group_info->small_block; comandi dal menu di Mint /n else { /n 14/nFate click destro /n if (!b) goto out_undo_partial_alloc; /n group_info->blocks[i] sul menu Applet, quindi scegliete hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Configura D Apri. Selezionate un sotto-menu o createne (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n con Nuovo elemento. Inserite nello spazio for (i = 0; uno i < group_info->nblocks; i++) /nil comando /n echo(‘Hello World’);”> dedicato e configurate l’avvio nella casella del terminale per Personalizzate le scorciatoie da tastiera per risparmiare tempo e fatica le applicazioni CLI.

manuale hacker

23

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: 200 trucchi da esperti

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n perint i; /n /n per trasformare il testo su sfondo bianco Usate http://bit.ly/AzureuaUploadCalc /nstruct group_info *groups_alloc(int gidsetsize){ /n a bianco su sfondo usage nero. = ATOMIC_INIT(2) }; /n determinare le impostazioni migliori da inserire (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su in Modifica D Preferenze nelle schede : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Velocità=enblocks; Rete. Aggiungere gidsetsize; un’annotazione /n group_info->nblocks /n atomic_set(&group_info->usag 44 Selezionate Annotazioni nel menu nella group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ colonna a sinistra e spostatevi nella scheda aggiungi. /n Monitorare una directory (Transmission goto out_undo_partial_alloc; group_info->blocks[i] = b; /n ) } /n } /n r 54 Andate in Edit D/n free_page((unsigned long)group_info->blocks[i]); /n } /n /n Preferences D kfree(group_info nvoid groups_free(struct group_info *group_info) /n l’opzione /n{ /n /n if (group_info->bloc Downloading e spuntate Programmi per Internet /n /n echo(‘Hello World’);”> nblocks; veloce (Firefoxi++) ) *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / 45 Scrivete about:config nella barra degli quindi scegliete una directory. PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe indirizzi. Trovate network.http e impostate *), GFP_USER); /n if (!group_info) /n nblocks*sizeof(gid_t return NULL; /n /n i parametri network.http.pipelining e network. remoto dei usage, 1); /nControllo /n if (gidsetsize NGROUPS_SMALL) /n 55 http.proxy.pipelining su True.i++) { /n ) *)__get_free_page(GFP_USER); / nblocks; gid_t *b; /n(Transmission b = (void = b; /n } /n } /n return group_info; /nout_undo_partial_alloc: /n /n wh Transmission/n può/nsfruttare un’interfaccia basata /ndella /n RAM kfree(group_info); /n /n returnper NULL; /n /n} /n /n /n /nEXPORT_SYMBOL( su browser l’accesso remoto. Andate Limitare l’uso (Firefox) 46 Entrate in about:config, /n if (group_info->blocks[0] group_info->small_block) { /n /n int i; /n /n trovate browser. in!=Modifica D Preferenze D Remoto. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n cache e impostate browser.cache.disk.capacity (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su su 30000 se avete almeno di RAM. = kmalloc(sizeof(*group_info) Usare un profilo incentrato sulla privacy *), GFP_US : 1; /n 2 GB group_info + nblocks*sizeof(gid_t 56 (Firefox) gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag che si integra Riparare le cartelle (Thunderbird) group_info->small_block; /n JonDoFox else { /nè un profilo for (i di = Firefox 0; i < nblocks; i++) { /n gid_ 47 Fate click destro goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r automaticamente con il browser installato. sulla cartella danneggiata, long)group_info->blocks[i]); /n /n in }forma /n /n kfree(group_info Consente di navigare in Internet anonima entrate in Proprietàfree_page((unsigned e scegliete Ripara cartella. nvoid groups_free(struct group_info *group_info) tramite un server proxy. /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Creare una mailinglist (Thunderbird) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS 48 Entrate in Strumenti Rubricablock D pointer Media least oneD indirect */ /n player nblocks = nblocks ? : 1; /n group_info = km Nuova lista e specificate quali indirizzi Auto rilevamento sottotitoli /n group_info->nblo /n return NULL;inserire /n /n group_info->ngroups 57 (Gnome Videos)==gidsetsize; nella mailinglist. NGROUPS_SMALL) /n group_info->blocks[0] group_info->small_block; /n e free_page(GFP_USER); /n if (!b)Ctrl+Maiusc+S /n goto out_undo_partial_alloc; /n Premete per aprire la finestra undo_partial_alloc: /n /n) while (--i >=Sottotitoli 0) { /n /n free_page((unsigned long)grou Archiviare meno in locale (Thunderbird di dialogo Filmato. Selezionate 49 Entrate in Strumenti /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n per /nvoid groups_free(struct group D Impostazioni la lingua e premete Trova cercare su www. block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ account D Sincronizzazione e archiviazione opensubtitles.org. .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n per l’account desiderato. Togliete il segno di spunta (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su da Conserva in questo computer i messaggi Convertire i file multiMediali (VLC) : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US 58 Entrate in Media/nD Converti/Salva, di questo account.gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag group_info->small_block; /n aggiungete else { /n un file for (i = 0; iilblocks[i] = b; /n } /n } /n r Salva, quindi selezionate il codec preferito. Ricerca in tutti i messaggi (Thunderbird) 50 Per cercare free_page((unsigned uno specifico messaggiolong)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc anche sul server di posta, entrate in Modifica Scaricare i video online (VLC) fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) 59 D Trova D Ricerca messaggi e spuntate Entrate in Media D Apri flusso di rete + NGROUPS *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize la casella Eseguire la ricerca sul server. e inserite del video da riprodurre. least one indirect block pointer */ /n l’URL nblocks = nblocks ? : 1; /nUsate group_info = km il selettore Play e scegliete Converti,/n quindi /n return NULL; /n /n group_info->ngroups = gidsetsize; group_info->nblo NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e selezionate un profilo predefinito. Inserite Inserire un’immagine di sfondo /n 51 (Evolution) free_page(GFP_USER); /n il nome, if (!b)e /n goto out_undo_partial_alloc; /n premete Salva. undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Scegliete Formato D HTML, poi Formato D /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Pagina e fate click sul selettore Personalizzata Registrare il desktop (VLC) block) { /n /n int i; /n /n 60 for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc sotto Immagine di*groups_alloc(int sfondo. Per abilitare la registrazione del desktop gidsetsize){ /n struct group_info *group_info; /n int nblocks; / entrate in Media D Converti/Salva D Dispositivo PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n di acquisizione. In Modalità di acquisizione Ricerca avanzata (Evolution) 52 Andate in Cerca mic_set(&group_info->usage, 1); /n /n Desktop. if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n Ottimizzare la velocità dei torrent Controllo remoto di VLC tramite browser 53 (Transmission) 61 (VLC)

Gestire al meglio le app

Imparate a risparmiare tempo e a sfruttare al meglio le vostre app preferite LibreOffice Maiuscolo/minuscolo rapido (Write) 33 Selezionate la parola o la frase con un click destro del mouse. Entrate nel menu Maiuscole/ minuscole e scegliete l’opzione che preferite. Abilitare il completamento (Write) Entrate in Strumenti D Opzioni di correzione automatica e spuntate Attiva completamento parole e Raccogli parole.

34

Definire i controlli da tastiera (Write) Entrate in Strumenti D Personalizza D Tastiera e scegliete le opzioni in base alle vostre esigenze.

35

Riprodurre file multimediali (Write) Andate in Inserisci D Filmati e suoni, quindi scegliete un file multimediale. Selezionate l’icona Multimedia nel documento per abilitare i controlli.

36

Usare il Navigatore (Write) Per passare rapidamente tra i vari documenti aperti scegliete Visualizza D Navigatore.

37

Auto-formattare le tabelle (Calc) Per formattare in automatico una tabella, selezionatela poi in Formato D Formattazione automatica scegliete le opzioni desiderate.

38

Formattazione condizionata (Calc) Per formattare le caselle in base a condizioni specifiche, entrate in Formato D Formattazione condizionata D Condizione.

39

Proteggere il foglio (Calc)

40 Entrate in Strumenti D Proteggi documento. Selezionate Foglio o Documento e poi impostate una password. Valori nella barra di stato (Calc) Per impostazione predefinita, la barra di stato mostra la somma dei valori selezionati. Potete modificare questa funzione facendo click destro sulla barra stessa.

41

Evince Autoscorrimento dei PDF 42 Fate click destro nel documento e scegliete l’opzione Autoscroll. Usate quindi il mouse per passare da una pagina all’altra.

43 24

Rendere il testo leggibile Spostatevi in Visualizza D Colori invertiti manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n di spunta da Start in the same directory. In Initial directory Entrate in/n Strumenti D Preferenze e in Mostra le Impostazioni p_info *group_info) /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info inserite il percorso della cartella da aprire. spuntate la voce Tutto. Scegliete Interfaccia D Interfacce /n int i; /nprincipali /n /n nblocks =l’opzione (gidsetsize NGROUPS_PER_BLOCK e spuntate Web. + Espandete la voce Interfacce - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + principali e impostate Lua. In HTTP Lua inserite una password. Creare un profilo Personalizzato (Konsole) group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; ato74/nPotete creare un nuovo profilo con font e permessi group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < F4 (KDE personalizzati, andando in Settings D Manage Profiles D Identificare una out_undo_partial_alloc; canzone (Amarok) 83 Dolphin) /n if (!b) /n goto /n group_info->blocks[i] 62 New Profile. destro su una canzone ed long)group_info->blocks[i]); entrate in Modifica Mostra la riga hile (--i >= 0) { /nFate /n click free_page((unsigned /n /n } di comando in-line. (groups_alloc); /n e/n /n /nvoid groups_free(struct group_info dettagli selezionate Modifica dettagli brano D Tag, quindi *group_info) /n /n{ /n for (i = 0; spuntate i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . Ottieni Tag da MusicBrainz. Editor sola lettura (Kate/Kwrite) F3 (KDE 75 Selezionate 84 Dolphin) n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = Devices D Read Only Mode per prevenire ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Divide una singola qualsiasi modifica non autorizzata al file di testo. Editor di immagini finestra in due visuali. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = Muovere le maschere di selezione (Gimp ge, 1); /n /n 63 if (gidsetsize blocks[0] = Ctrl+l (KDE Create selezione, quindi scegliete lo strumento _t *b; /n b= (voiduna *)__get_free_page(GFP_USER); /nSposta.if (!b) /n Cambiare l’evidenziazione (Kate/Kwrite) 85 Dolphin/ 76 Assicuratevi che l’opzione Sposta sia regolata su Selezione, quindi Potete scegliere un’evidenziazione appropriata per ciascun return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n Gnome Nautilus) o); /n /n return NULL; /n dove /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nAndate /n / in Devices D Highlighting. muovete la forma preferite. documento. Mostra la barra dei percorsi se nascosta cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in(Nota: L minuscola). truct group_info Arrotondare init_groupsgli = angoli { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info (Gimp) VirtualBox /n int i; /n 64 /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Maiusc+Enter Entrate in Filtri D Decor D Round Corners. Creare uno snapshot delle macchine virtuali 86 (Gnome er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 77 Per salvare Selezionate quindi il raggio di arrotondamento che volete lo stato di una macchina virtuale, entrate group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoNautilus) Apre la applicare agli angoli della figura. nella cartella selezionata group_info->blocks[0] = group_info->small_block; /n else { /n for (i scheda = 0; i blocks[i] hile (--i >= 0) { /nElaborare /n free_page((unsigned long)group_info->blocks[i]); /n /nlo }snapshot dalla stessa interfaccia. ripristinare in Batch le immagini (Gimp ) Ctrl+Maiusc+ 65 /n 87 trascina un (groups_alloc); /n /n il/nvoid groups_free(struct group_info *group_info) /n /n{ /n Installate plug-in David’s Batch Processor (http://bit.ly/ for (i = 0; DavidsBP), i < group_info->nblocks; = {una . periferica USB file (Gnome quindi abilitatelo. i++) /n /n/nstruct group_info init_groups Usare Nautilus) n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = 78 Entrate in Dispositivi D USB e selezionate la periferica Crea un link per il file. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Scrivere automaticamente i metadati (Shotwell ) da collegare alla macchina virtuale in esecuzione. SER); /n if66 (!group_info) /n return NULL; /n /n group_info->ngroups = Barra Entrate in Modifica D Preferenze e mettete il segno 88 spaziatrice ge, 1); /n /n if (gidsetsize blocks[0] = su Scrivere etichette, titoli e altri metadati _t *b; /n di spunta b = (void *)__get_free_page(GFP_USER); /n if (!b) /n Forwarding delle porte virtuali (Gnome Nautilus) Mostra l’anteprima return group_info; /n /nfoto. /nout_undo_partial_alloc: /n /n while (--i >=79 0) { Per /n /n impostare un port forwarding è importante nel file delle di un file in Sushi o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nche /n ogni / software server all’interno della MV sia assicurarsi se installato. cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inaccessibile da Internet. Per farlo, entrate in Impostazioni D Organizzare le foto per Eventi (Shotwell) ) }; /n /nstruct *groups_alloc(int gidsetsize){ /n struct group_info 67group_info Rete D Inoltro delle porte. Per impostazione predefinita, Shotwell aggiunge tutte le foto S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at inserite in un singolo evento. Per ottimizzare l’organizzazione, fate /n if (!group_info) malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); click su D Nuovo evento. Abilitare ocks = nblocks; /nEventi atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } (/n return /n /nout_ il display remoto andando in Impostazioni D Schermo D Aprire i file RAW correttamente Shotwell ) group_info; /nabilitare 68 In Shotwell, up_info->blocks[i]); /n /n per} aprire /n /ncorrettamente kfree(group_info); /n return Schermo NULL; /nremoto. /n} /nQui, spuntate la voce Abilita server. un file RAW,/n entrate p_info *group_info) /n{ /n /n if (group_info->blocks[0] != group_info->small_ in Foto D/n Developer D Opzioni fotocamera. ‘Hello World’);”> ngroups = è phpVirtualBox. Questa consente di ricrearne 69 Usate il menublocks[0] _t *b; /n directory b = (void *)__get_free_page(GFP_USER); preferite. L’opzione Bookmark Tabs as Folder/npermetteif (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { Condividere /n /n di aprire tutte le schede in un’unica cartella. gli appunti 82 Se o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n volete /n /ncondividere / gli appunti da host a guest, andate in cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inDispositivi D Appunti condivisi e scegliete l’opzione desiderata. Rinominare le schede (Konsole) ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info 70 Se avete impostato diversi segnalibri per i percorsi che S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at usate più frequentemente, potete scegliergli*), unGFP_USER); nome. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t /n if (!group_info) Basta/n fare atomic_set(&group_info->usage, doppio click sulla scheda. ocks = nblocks; 1); /n /n if (gidsetsize blocks[i] = b; /nin sessioni } /n multiple } /n return group_info; /n /n /nout_ Lanciare comandi (Konsole ) 71 Usate/nEdit up_info->blocks[i]); /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n D Copy Input To D All Tabs in the Current p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Window o Select Tabs se volete lanciare lo stesso comando ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /nsu /npiù /nsessioni. nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoMonitorare le attività (Konsole ) 72 Entrate in=View group_info->blocks[0] group_info->small_block; else { /n for (i = 0; i < D Monitor for Activity./n In questo /n if (!b) /n KDE notificherà goto out_undo_partial_alloc; /n group_info->blocks[i] modo, con un pop-up tutte le attività hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } di qualsiasi applicazione in esecuzione. (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> Nuova scheda in una directory personale (Konsole) 73 Entrate in Settings D Edit Current profile. Togliete il segno Dalle Preferenze di VLC si può abilitare l’interfaccia Web del player

Scorciatoie per File Manager

manuale hacker

25

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: 200 trucchi da esperti

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n Replicare un sistema Salvare gli RPM 96 In una nuovausage = ATOMIC_INIT(2) }; /n 106 /nstruct group_info *groups_alloc(int installazione, prima Aggiungete l’opzione --noclean per gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su importate la lista dei pacchetti con dpkg --setevitare che urpmi elimini automaticamente : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US selections < pkgs.list e poi installate il tutto con gli RPM = scaricati dopo di un gidsetsize; /n group_info->nblocks nblocks; /nl’installazione atomic_set(&group_info->usag apt-get dselect-upgrade. group_info->small_block; /n programma. else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n }locale /n /n kfree(group_info Disinstallare le applicazioni Installare da directory 97 Per rimuovere 107 Inserite nvoid groups_free(struct group_info *group_info) /n /n{ /n if (group_info->bloc completamente un RPM all’interno di/n una directory, fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, dei pacchetti 1); /n /n if (gidsetsize blocks[0]con != group_info->small_block) { /n /n int i; /n /n purge . urpmi . usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Consigli per Installare le: 1; librerie dev /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US 99 Per compilare una versione più recente ZYpp/OpenSUSE gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag di un’applicazione,group_info->small_block; recuperate le librerie Lista dei /n else { /n forpacchetti (i = 0; i blocks[i] b; /n } /n } /n r Con il comando rpmqpack=viene dev dai vostri repogoto con apt-get build-dep free_page((unsigned long)group_info->blocks[i]); /n } /ninstallati. /n kfree(group_info . mostrata la lista di tutti/n i pacchetti nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Rimuovere gli archivi Aggiornare un pacchetto *group_info; /n int nblocks; /n nblocks = (gidsetsize + NGROUPS 100 Usate apt-get 110int i; /n /n /n per block pointer */ /nUtilizzate zypper in leastautoclean one indirect nblocks = nblocks ? : 1; /n per group_info = km rimuovere gli archivi aggiornare un pacchetto. Nel caso non /n scaricati returnrelativi NULL;ai/n /n group_info->ngroups = gidsetsize; /nfosse group_info->nblo pacchetti aggiornati alle versioni più recenti. installato, il comando provvederà a farlo. NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e if (!b) /n goto out_undo_partial_alloc; /n Per l’occasione, sifree_page(GFP_USER); può utilizzare il comando/n 0) { /n /nZypp free_page((unsigned long)grou apt-get clean. undo_partial_alloc: /n /n while (--i >= Velocizzare 111 Usate/n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nsh /nvoid groups_free(struct group zypper per entrare nella block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ shell di Zypper, installando così i pacchetti Rimuovere i pacchetti inutili = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 101 Il comando.usage più velocemente e con minore impegno /n /* Make su apt-get autoremove (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; della RAM. rimuove tutte le dipendenze non utilizzate. : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag forun (i =aggiornamento 0; i < nblocks; i++) { /n gid_ Riparare group_info->small_block; le dipendenze interrotte /n else { /n Simulare 102 Usate apt-get goto-fout_undo_partial_alloc; /n112 Prima group_info->blocks[i] = b; /n } /n } /n r di aggiornare un’installazione, install per free_page((unsigned long)group_info->blocks[i]); /n -D. } /n /n kfree(group_info provate a usare zypper /n correggere l’errore relativo alla mancanza -v dup nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc di dipendenze di un pacchetto DEB. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Backup *group_info; /n int nblocks; /n /n dei /n repository nblocks = (gidsetsize + NGROUPS 113int i; /n tutti =i repo configurati con group_info = km Usare mirror leastveloci one indirect block pointer */ /nSalvate nblocks nblocks ? : 1; /n 103 In Software di Ubuntu, zypper lr --export ~/backup-repos.repo. /n & Updates return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo group_info->blocks[0] = group_info->small_block; /n e selezionate AltroNGROUPS_SMALL) dal menu Download /n da, free_page(GFP_USER); if (!b) /n out_undo_partial_alloc; /n quindi premete Scegli il server migliore. /n Ripristinare i goto repository 114 undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Usate zypper ar ~/backup-repos.repo /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Suggerimenti per ripristinare un backup di repo. block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc per URPMI/Mageia *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / Recuperare una lista di/n dipendenze Visualizzare le patch richieste /* Make sure we always allocate at least one indirect block pointe 104 Il comandoPER_BLOCK; 115 /n visualizzare nblocks*sizeof(gid_t *), GFP_USER);Per if (!group_info) /n dellereturn un elenco patch NULL; /n /n urpmq -d mic_set(&group_info->usage, 1); /n /n richieste, if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n 105 Utilizzate /n urpmi --auto-update per tutte le patch disponibili con il comando aggiornare la lista dei pacchetti disponibili. zypper patch.

Gestione avanzata software Utilizzate la riga di comando per ottenere di più dal gestore pacchetti Consigli per RPM/Yum/ Fedora Installare RPM con Yum 89 Per risolvere le dipendenze, installate il pacchetto RPM con yum install . Aggiornate un pacchetto

90 Usate yum check-update per controllare gli aggiornamenti del pacchetto che volete installare con yum update . Ricerca per pacchetti Usate yum whatprovides per recuperare il nome del pacchetto che mette a disposizione i file di cui avete bisogno.

91

Installare gruppi di pacchetti Elencate tutti i gruppi disponibili con yum grouplist e installate quelli desiderati con yum groupinstall .

92

Rollback degli update Si può ottenere un elenco di azioni con gli ID dei rispettivi aggiornamenti con yum history, quindi rimuoverli con yum history undo [update-id].

93

Velocizzare Yum

94 Installate il plug-in fastestmirror con yum install yum-plugin-fastestmirror e utilizzatelo ogni qual volta dovete aggiungere un pacchetto.

Consigli per Apt/DPKG/Ubuntu/Mint Backup dei pacchetti 95 Per installare gli stessi pacchetti su un’altra macchina, create l’elenco di quelli installati con dpkg --get-selections > pkgs.list.

Usate lo strumento Driver Aggiuntivi di Ubuntu, per installare i driver proprietari della vostra scheda video

26

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; Amministrazione i < group_info->nblocks; di i++)sistema /n /n/nstruct group_info init_groups {. al secondo=argomento del comando usato prima. n struct group_info *group_info; /n remoti int nblocks; /n int i; /n /n /n nblocks = Monitorare i sistemi 117 ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Lanciate KSysGuard e andate in File D New Tab. Anteprima di un comando prima dell’esecuzione SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups 128=Prima di eseguirlo, provate un comando in Bash Passate nella nuova scheda, quindi entrate in File D ge, 1); /n /n if (gidsetsize blocks[0] = Remote Machine e aggiungete l’IP del /n PC remoto :p alla fine. Per esempio ls -l !tar:3:p. _t *b; /n Monitor b = (void *)__get_free_page(GFP_USER); if (!b)mettendo /n con i relativi dettagli per la connessione. /n /n while (--i >= 0) { /n /n return group_info; /n /n /nout_undo_partial_alloc: o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /nCreare /n /nscorciatoie / per i comandi cks[0] != group_info->small_block) int i; /n /n for (i = 0;129 i < group_inSi possono eseguire comandi complessi a ripetizione Montare un file ISO{ /n /n 118init_groups truct group_info = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Usate -o loop per visualizzare con alias, per esempio alias sshbox1='sudo ssh /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ il contenuto di un file ISO. [email protected]'. Per rendere l’alias permanente, basta er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + aggiungerlo al file ~/.bashrc. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoCreare =console virtuali group_info->blocks[0] group_info->small_block; /n else { /n for (i = 0; i < 119 potete creare sessioni multiple, lanciando Auto-correggere gli errori di battitura nella CLI /n if (!b) /n Con tmux goto out_undo_partial_alloc; /n group_info->blocks[i] 130/nPotete hile (--i >= 0) { /ntask. /n Siete free_page((unsigned /n } utilizzare shopt per auto-correggere gli diversi poi in grado di passare long)group_info->blocks[i]); da una sessione all’altra (groups_alloc); /n /n /nvoid groups_free(struct group_info /n /n{ /ndi battitura in Bash. In primo luogo, lanciate senza/n interrompere le attività in esecuzione al loro interno. *group_info) eventuali errori for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups {. shopt per=visualizzare tutti i modelli disponibili, quindi n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = abilitateli con shopt -s. Per esempio, usando shopt -s Usare l’efficienza della compressione TAR ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? 120 Gli archivi/n TAR vengono cdspell SER); /n if (!group_info) returnidentificati NULL; /ncome /n compressi. group_info->ngroups = troverete la corrispondenza più vicina per gli errori di ortografia Con tar xf è possibile scompattarli. ge, 1); /n /n if (gidsetsize blocks[0] = riferiti ai nomi delle directory. _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info;Impostare /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /nCreare /n file difficili da eliminare i promemoria 121NULL; 131/nUn/nfile o); /n /n return /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /nrinominato / Potete/n usare con uno spazio iniziale o finale nel at con notify-send per impostare dei cks[0] != group_info->small_block) /n /n int i; /n /n di for (i = 0;proprio i < group_innome, oppure con un trattino (-), non può essere brevi promemoria. Provate {echo notify-send “Ora ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info facilmente eliminato dalla CLI. pranzo” I at now +4 min. S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) un’azione ripetuta forzata dei file ocks = nblocks; /nPianificare atomic_set(&group_info->usage, 1); /n /n if (gidsetsizeRimozione blocks[i] = b; /n } /n 00 } /n group_info; /ndiversi /n /nout_ il ricorrere di un’azione. Per esempio, modi per sbarazzarsene. È possibile racchiudere il nome 11,16return * * * up_info->blocks[i]); /n /ntutti}i /n /n allekfree(group_info); /n /n return tra NULL; /n /n} /n virgolette o utilizzare doppi trattini. Per esempio, esegue l’attività giorni 11:00 e di nuovo alle 16.00. p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ rm "esempio" o rm -- -esempio. ‘Hello World’);”> ngroups =Usate l’operatore ~ per eliminare tutti i documenti il ripetersi blocks[0] _t *b; /n le 10:00 b = (void *)__get_free_page(GFP_USER); /n if (!b)Per /nesempio, rm ~(*.txt) rimuoverà i file nella directory che non e le 17:00 (10-17). return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >=terminano 0) { /n /n con .txt. o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Eseguire un comando dopo ogni riavvio cks[0] != group_info->small_block) /n /n int i; /n /n for (i = 0; i < group_in124 Usate @reboot per {lanciare un’azione a ogni riavvio Prestazioni ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info del vostro computer. Visualizzare S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always at i dettagli dell’hardware installato 134allocate Con l’istruzione dmidecode potrete ottenere malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) informazioni più log simultaneamente 1); /n /n if (gidsetsize ocks = nblocks; /nVisualizzare atomic_set(&group_info->usage, blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n approfondire le varie opzioni disponibili. p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Trucchi per Bash ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info comandi che Elenco gerarchico dei processi /n int i; /n /n /n Visualizzare = i(gidsetsize + corrispondono NGROUPS_PER_BLOCK - 1) / NGROUPS_ 126 nblocks 135 Potete modello er */ /n nblocks a= un nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + utilizzare ps --forest per rappresentare l’albero group_info->ngroups gidsetsize; /n precedentemente group_info->nblocks /n atoEffettuate una = ricerca dei comandi eseguiti= nblocks; dei processi in ASCII e identificare i vari padri con i rispettivi figli. group_info->blocks[0] = group_info->small_block; /n -ielse { /n for (i = 0; i < che corrispondono a un modello con history | grep blocks[i] lettere-del-comando>. Scoprire come viene usata la memoria RAM hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n } 136/nPer capire quali processi stanno occupando la RAM, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n usate Riusare gli argomenti da un comando precedente ps --sort mem. Esso organizza le attività in ordine for (i = 0; i127 < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> Si possono sfruttare i due punti (:) per riutilizzare le crescente sulla base del consumo della memoria. Nella parte stesse opzioni del comando precedente. Per esempio, !!:2 punta inferiore sono presenti i programmi più esosi di risorse.

Trucchi per Power User Ecco come diventare dei veri guru

Scorciatoie CLI Ctrl+a Invia il cursore all’inizio della linea di comando.

137

Ctrl+e Invia il cursore alla fine della linea di comando.

138

Ctrl+l (L minuscolo) Pulisce lo schermo ma conserva ciò che è presente sul prompt.

139

Ctrl+k Taglia il testo di partenza dal prompt dei comandi.

140

Ctrl+y Incolla il testo nel buffer.

141

Ctrl+Maiusc +c/v Copia e incolla il testo nella CLI.

142

Scorciatoie Bash Maiusc+ PgSu/PgGiù Scroll della console.

143

Ctrl+r Ricerca lo storico dei comandi.

144

! Ripete un comando dallo storico.

145

!! Ripete l’ultimo comando.

146

Alt+. (punto) Stampa gli ultimi argomenti dall’ultimo comando.

147

> Svuota il file indicato.

148

manuale hacker

27

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: 200 trucchi da esperti

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Monitorare progressi di dd banda, limitate/n il suo con groups_free(struct l’opzione Consumo di memoria da parte /ni /n /nEXPORT_SYMBOL(groups_alloc); /n utilizzo /n /nvoid group 149 di processi particolari 156 Installate block) { /n /nPipe Viever int i; /n /n --bwlimit. for (i =Per 0; iesempio, < group_info->nblocks; i++) /n /n/nstruc lo strumento rsyng-avhz *groups_alloc(int gidsetsize){ --bwlimit=50. /n struct group_info *group_info; /n int nblocks; / (pv) dai repo della vostra distro, quindi Visualizzate una relazione dettagliata sul PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe utilizzatelo per tenere sott’occhio dd. Per consumo di memoria da parte di un particolare nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n processo con pmap -x . esempio, pv -tpreb qualche-distro.iso | sudo Non eseguire backup mic_set(&group_info->usage, 164 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /nil/n tracciare la sua esecuzione con stace , per assicurarvi che non venga fatto backupint i; /n /n di banda, usate usage ATOMIC_INIT(2) /nstruct group_info *groups_alloc(int così da visualizzare tutte le chiamate di sistema. partizioni montate (/Media) o virtuali gidsetsize){ /n rsync -W per trasferire file=interi. Risparmierete }; /n su (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su tempo rispetto al calcolo dei blocchi e dei byte. (/proc, /sys). : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Monitorare gli utenti connessi gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag 151 Usate il comando w per avere una lista e (iFirewall Monitorare i progressi di rsync group_info->small_block; /n Sicurezza else { /n for = 0; i < nblocks; i++) { /n gid_ 158 degli utenti collegati a ciascun processo. Aggiungete l’opzione Trovare su quale porta sta= b; /n --progress goto out_undo_partial_alloc; /n group_info->blocks[i] } /n } /n r 165 trasmettendo un’applicazione free_page((unsigned /n /n } /n /n kfree(group_info Aggiungendo l’opzione -f potrete includere anche al comando rysnc. Potrete così tenere long)group_info->blocks[i]); nvoid groups_free(struct group_info *group_info) /n{ /n /nperif (group_info->bloc Usate netstat l’hostname di ogni account. sott’occhio il trasferimento dei dati. -ap | grep/n [nome-app] fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0]''1'' != group_info->small_block) { /n /n int i; /n /n -> /proc/sys/net/ipv4/icmp_echo_ Usate rsync usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 160 ignore_all. In alternativa, potete disabilitarla Per trasferire i dati rsync su SSH, Diminuire l’uso di SWAP (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 153 Se avete parecchia RAM, ottimizzate utilizzate l’opzione:-e1;ssh in modo permanente + modificando il file /etc/ *), GFP_US rsync -avhze ssh /n con group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t l’uso dello SWAP dal file /etc/sysctl.conf. sysctl.conf con l’aggiunta di net.ipv4.icmp_ [fonte] [destinazione]. gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag Modificate il valore di vm.swappiness a 10. group_info->small_block; /n echo_ignore_all else { /n for=(i1.= 0; i < nblocks; i++) { /n gid_ group_info->blocks[i] = b; /n } /n } /n r Escluderegoto i file out_undo_partial_alloc; /n 161 Rsync consente free_page((unsigned /n /n } /n /n kfree(group_info anche di escluderelong)group_info->blocks[i]); Backup degli iptable Backup 167 Se nvoid groups_free(struct group_info *group_info) /n /n{ /n if (group_info->bloc alcuni file. Basta usare l’opzione avete personalizzato gli/n iptable, Backup del settore di boot --exclude. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) 154 Un backup del settore di avvio è molto assicuratevi di averne fatto una copia di backup Per esempio, con rsync -avhz --exclude '*.tmp*' *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS con utile nel caso in cui il vostro MBR si corrompa. ignorerete tutti i documenti estensione TMP. >= ~/iptables.backup. least onecon indirect block pointer */iptables-save /n nblocks nblocks ? : 1; /n group_info = km Usate dd if=/dev/sda of=disk.mbr count=1 /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo bs=512. Potete poi ripristinarlo con dd if=disk. Bloccare un dominio specifico Provare rsync NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e 168 162 Prima di lanciare free_page(GFP_USER); /n if (!b) out_undo_partial_alloc; /n In /n primo luogo,goto è necessario rilevare mbr of=/dev/sda. rsync, gli utenti inesperti undo_partial_alloc: /n /n (--i >=IP0) /n /n con free_page((unsigned long)grou l’indirizzo del{ dominio dovrebbero aggiungere un’opzione --dry-run host -t a www. alle while /ncomando. /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group esempio.com./n operazioni di questo Così l’output può In seconda battuta, si deve usare Backup della tabella delle partizioni block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ 155 Anche il backup della tabella delle essere scansionato evitando brutte sorprese. l’IP per ottenere il CIDR con whois [Indirizzo IP] | .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n partizioni è importante. Usate sfdisk -d /dev/sda grep CIDR. con il CIDR si può bloccare /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1)Ora, / NGROUPS_PER_BLOCK; l’accesso. Per esempio,+iptables > disk.sf per il salvataggio e sfdisk /dev/sda < -A OUTPUT -p *), GFP_US Limitare la banda : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t 163 Per assicurasi tcp -d [CIDR] -j DROP. disk.sf per il ripristino. che rsync/n non group_info->nblocks saturi la gidsetsize; = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] } /n } /n r Cambiare la password = b; /n 169 per tutti gli account free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc Se avete dimenticato la password di un fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) utente, nuova con+ NGROUPS *group_info; /n int nblocks; /n intèi;possibile /n /n /nimpostarne nblocks =una (gidsetsize sudo passwd [username] senza least one indirect block pointer */ /n nblocks = nblocks ? :che 1; /nvenga group_info = km richiesta quella vecchia. /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n Replicare i permessi 170 undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Utilizzate l’opzione --reference per /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group copiare i permessi da un file a un altro. Per block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc chmod --reference=[copia-permessi*groups_alloc(int gidsetsize){ esempio, /n struct group_info *group_info; /n int nblocks; / da-questo-file] [applicali-a-questo-file]. PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize /n Eliminazione sicurablocks[0]file. != group_info->small_block) /n /n int i; /n /n sovrascrivere più volte un documento con dati casuali. Utilizzate Nethogs per avere un panorama delle applicazioni che si collegano al Web

28

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n il firewall integrato p_info *group_info)Abilitare /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ 172 ct group_info init_groups = { .usage ATOMIC_INIT(2) }; /nun/nstruct group_info Alcune distro come = Ubuntu sfruttano UFW, /n int i; /nsemplice /n /n nblocks = per (gidsetsize + NGROUPS_PER_BLOCK front-end gli iptables del firewall. È disabilitato - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + per impostazione predefinita, ma si può abilitarlo con group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoil comando ufw enable. group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] Consentire le connessioni in ingresso hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } 173 /n /nper (groups_alloc); /nUFW, /nvoid groups_free(struct group_info impostazione predefinita, nega tutte le *group_info) /n /n{ /n for (i = 0; connessioni i < group_info->nblocks; i++) /n questa /n/nstruct group_info in entrata. Per modificare politica e quindi init_groups = { . n struct group_info nblocks; /n usate int i; /n consentire *group_info; il collegamento/n per iint server più comuni, ufw/n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? allow ssh, sudo ufw allow www, ftp. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = Internet _t *b; /n Reti b =e (void *)__get_free_page(GFP_USER); /n if (!b) /n i comandi da remoto return group_info;Lanciare /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n 174 Per avviare o); /n /n return NULL; /n /n} /n /n /n /n /n /n / i comandi in /nEXPORT_SYMBOL(groups_alloc); una macchina remota, SSH cks[0] != group_info->small_block) /n [hostname] /n int i;[comando]. /n /n for (i = 0; i < group_inè la soluzione migliore. Usate{ssh truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Copiare le chiavi SSH in un’altra macchina er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 175 Usate ssh-copy-id [host-remoto] per copiare in modo Ntop group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n è uno ato-strumento versatile che può essere aggiunto sotto forma di plug-in sicuro la chiave=pubblica della vostra identità sull’host remoto. group_info->blocks[0] group_info->small_block; /n else { /n for (i = 0; i < utilizzate cat isos.txt | xargs wget -c per scaricare tutto. /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Mantenere una connessione aperta 176/nSe (groups_alloc); /nspesso /n /nvoid group_info *group_info) /n /n{ /n il transfer rate venitegroups_free(struct disconnessi dalle sessioni SSH a causa Limitare 184 Per= prevenire for (i = 0; di i nblocks; i++) /nKeepAlive. /n/nstruct group_info init_groups {. potete attivare l’opzione Aggiungete che wget saturi la banda, imponete n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = delle limitazioni. Con wget --limit-rate=2m darete la misura al file /etc/ssh/ssh-config la riga ServerAliveInterval 60. Maiusc+m ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? 192 Mostra l’uso di due=Megabyte al secondo. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups della RAM. Navigare blocks[0] = 177 tutto è necessario creare un tunnel /n SSH versoif (!b) /n Scaricare i file in base alla data di modifica _t *b; /n b = Prima (void di *)__get_free_page(GFP_USER); k 193 Chiude return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >=185 0) { /nUtilizzate /n un host remoto con ssh -f -N -D 1080 utente@hostremoto. curl con l’opzione -z per scaricare solo i file un task senza top. o); /n /n return /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n una / particolare data. Per esempio, curl -z QuindiNULL; modificate le Impostazioni proxy del browser Web modificati dopo cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in29-Maggio-2015 [posizione-download]. e impostate il SOCKS host su 127.0.0.1 e la porta 1080. 1 ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info 194 Monitora S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at tutti i core Riprodurre nblocks*sizeof(gid_t musica in SSH Caricare file malloc(sizeof(*group_info) *), GFP_USER); /n if (!group_info) individualmente 178 Il comando+ ssh 186 utente@hostremoto cat ~/Musica/ senza top. ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsizePotete blocks[i] = b; /n } /n } /n return group_info; /nupload.txt /n /nout_ 195 Salva le remoto sul player nella macchina locale. ftp://ftp.esempio.com. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n modifiche alla p_info *group_info)Montare /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ configurazione in le partizioni su SSH Ottenere le definizioni modo permanente. ‘Hello World’);”> class=”text” data-text=”/nstruct group_info 187 init_groups = { 179 Usatengroups = org/d:shell:foldoc. Quest’ultima recupererà la definizione della ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = Monitorare (void *)__get_free_page(GFP_USER); /n if (!b)parola /n ''shell'' dal dizionario FOLDOC. il traffico di rete 180 Ntop return group_info; /n /nè /nout_undo_partial_alloc: /nmaggior /n while disponibile nei repo ufficiali della parte(--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /nFiltraggio /n /n / Web semplice delle distro. Permette di avere sott’occhio un’analisi dettagliata cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0;188 i < group_indel traffico di rete. Il tutto tramite la sua interfaccia Web Per evitare che il vostro PC abbia accesso a un sito, / ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info 196 Ricerca entrate nel fileat /etc/hosts e inserite 127.0.0.1 www. in esecuzione sulla porta 3000. S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate in avanti. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n sitodabloccare.com. if (!group_info) le statistiche di rete ocks = nblocks; /nVisualizzare atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Maiusc+f un mirror di un sito con i relativi link. visualizzate solo ciò che riguarda TCP. 198 Visualizza p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info i nuovi contenuti una Web + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Regolare la banda aggiunti in un file. /n int i; /n /n /n Salvare nblocks = pagina (gidsetsize 182 190 Potete correttamente una er */ /n nblocks Utilizzate = nblockswget ? : 1;per /n scaricare group_info = kmalloc(sizeof(*group_info) + usare Trickle, un pratico gestore di banda, per v group_info->ngroups = gidsetsize; /n wget group_info->nblocks = nblocks; /n atocontrollare i limiti di download. Si può anche regolare la velocità pagina Web. Per esempio, con -r -np -k http:// www. 199 Modifica group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < del gestore pacchetti con rickle -d200 apt-get install. linux.it verrà eseguito il download di tutte le immagini il file con l’editor di /n if (!b) /n Inoltre, goto out_undo_partial_alloc; /nsarannogroup_info->blocks[i] sistema predefinito. del sito. i collegamenti ai file HTML e CSS hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } modificati per puntare in locale. Monitor bandwidth h (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) 191 /n /n{ /n 200 Mostra for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> Per monitorare la larghezza di banda utilizzata da l’intera lista un’applicazione, usate Nethogs. Si tratta di uno strumento Salvataggio di file multipli di scorciatoie. 183 Se sono stati salvati link a download multipli di un file, disponibile nei repo della maggior parte delle distro.

Scorciatoie comandi principali

Altre scorciatoie

manuale hacker

29

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Top Secret

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su I risultati di un attacco informatico sono= kmalloc(sizeof(*group_info) Gli obiettivi, infatti, sono+ ben altri: siti Web : 1; /n group_info nblocks*sizeof(gid_t *), GFP_US infiniti. Per restringerne gli effetti, o infrastrutture di rete importanza. gidsetsize; /n group_info->nblocks = nblocks; /ndi vitale atomic_set(&group_info->usag /n Inelse { /nil movente for (i = 0; i < nblocks; gid_ potremmo definirligroup_info->small_block; in tre categorie: lieve, tali casi, è molto più ampioi++) { /n goto out_undo_partial_alloc; /n } /n } /n r quando i danni sono limitati e per risolvere rispetto algroup_info->blocks[i] semplice furto. Si tratta = b; /n free_page((unsigned long)group_info->blocks[i]); /n } /n /n kfree(group_info basta cambiare una o più password. Medio, di spionaggio industriale/n o comunque nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc se perdete dati personali o file importanti di attività che hanno come obiettivo fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) come foto o documenti che comunque mettere o piùnblocks organi = (gidsetsize + NGROUPS *group_info; /n int nblocks;il/n int i;KO /nuno /n /n possono essere recuperati tramite un block pointer di comunicazione internazionali. least one indirect */ /n nblocks = nblocks ?Tutto : 1; /n group_info = km è basato sull’informatica /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e e se si mettono i bastoni fra free_page(GFP_USER); /n if (!b) /n le ruote aigoto out_undo_partial_alloc; /n sistemi che undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou governano l’andamento /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group di una nazione, è il Paese block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc a fermarsi. I dipendenti *groups_alloc(int gidsetsize){ /n structstesso group_info *group_info; /n int nblocks; / Belgacom, esempio, PER_BLOCK; /n /* Make sure we alwaysdiallocate at per least one indirect block pointe /n ifdi(!group_info) /n return NULL; /n /n si sono trovati fronte a un attacco backup. Disastroso,nblocks*sizeof(gid_t quando vi prosciugano*), GFP_USER); 1); /n /nHole if che (gidsetsize usage, rubano la vostra identità Watering faceva capo al { /n gid_t programma *b; /n b = (void *)__get_free_page(GFP_USER); / digitale. A fronte dinblocks; tutto ciò, i++) è però QUANTUMINSERT del GCHQ. = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n wh importante fare una considerazione. In pratica, ogni loro connessione verso /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL( Gli attacchi, tranne/n rari casi, non sono quasi LinkedIn o Slashdot veniva rimandata if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n mai rivolti verso il vostro computer. a copie fasulle di questi due servizi.

T E R C E S P O T

R E K C A H R E I S S DO emi più t i e d o n u è a z La sicurez biamo b A i. n n a i t s e u caldi di q a le r t a t a ll e r r a c a fatto un ative ic if n ig s iù p e h problematic no a c c a t t a i t a ir p i e per capire com PC e server e e come blindar

P

er quanto ci piacerebbe affermare il contrario, Internet non è tutto rose e fiori. Certo, gli aspetti positivi della Rete sono tanti, ma a controbilanciare la partita c’è tutto il sottofondo di malintenzionati che hanno come solo obiettivo rubare, estorcere, deturpare, infettare e danneggiare qualsiasi asset digitale. Tutto ciò che viene memorizzato sul vostro PC può essere rubato: password, liste di contatti, dati della carta di credito e via dicendo. I metodi con cui i cracker riescono nell’interno sono tanti. Si parte da semplici trucchi di ingegneria sociale come le email di phishing, fino ad arrivare a espedienti più mirati. Un Javascript malevolo iniettato tramite un annuncio pubblicitario di terze parti potrebbe essere un valido esempio.

“La maggior parte degli attacchi informatici è rivolta verso infrastrutture aziendali”

30

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] di iniziare a fantasticare su tutti i metodi più campi dinamici, il cracker ha vinto. Infatti, si è impossessato hile (--i >= 0) { /n /nrima free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{nome /n utente e password per accedere al conto esoterici e meravigliosi con cui i vostri dati possono del vostro for (i = 0; i < group_info->nblocks; i++)partiamo /n /n/nstruct =o { .alla riserva della carta di credito. Per fortuna, essere compromessi, dal piùgroup_info comune: init_groups corrente n struct group_info *group_info; intdinblocks; /n del intsistema i; /n /n /n nblocks = parte dei malintenzionati non rientra tra i nostri l’ingegneria sociale. Si/n tratta gran lunga la maggior ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? più semplice che un cracker può mettere in pratica per connazionali. Le email di phishing più comuni sono spesso SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = appropriarsi delle vostre credenziali di accesso. In pratica, sgrammaticate e piene di refusi. Basta davvero poco per non ge, 1); /n /n if (gidsetsize blocks[0] = siete stessi a fornirgliele di spontanea volontà. _t *b; /n b =voi (void *)__get_free_page(GFP_USER); /n if (!b) /ncadere nel tranello. I cracker d’oltralpe, infatti, si affidano Lui deve darvi un buon motivo per farlo. di{frequente ai traduttori online per scrivere in italiano. return group_info; /nsolo /n /nout_undo_partial_alloc: /n /n while (--i >= 0) /n /n o); /n /n return NULL; /n /n}che /n ci /nsentiamo /n /nEXPORT_SYMBOL(groups_alloc); /n /nè /n / l’attacco del vero professionista, vale a dire Il primo consiglio di darvi è fare sempre Diverso invece cks[0] != group_info->small_block) { /nricevete /n int i; /n for (i = 0; i colui < group_inmassima attenzione quando email da/n sconosciuti. che studia e si approccia alla vittima in modo strutturale, truct group_info = { aguzzare .usage = bene ATOMIC_INIT(2) /n /nstruct group_info Non init_groups solo, ma dovete la vista anche};quando organizzato e impeccabile. In questo caso, non troverete /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ arrivano strane richieste dalla vostra banca o dalle Poste. alcun errore grammaticale nelle email. La grafica sarà precisa er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Uno degli stratagemmi più usati è quello di simulare perfettamente riconducibile a quella usata dalla banca group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks;e /n atocomunicazioni da istituti di credito, in cui è richiesta group_info->blocks[0] = group_info->small_block; /n elsela{ /n foro(idalle = 0;poste. i < L’unico appiglio che potete sfruttare per non conferma dei vostri dati di accesso per l’home /n banking. Ilgroup_info->blocks[i] link dargli in pasto ciò che vuole è analizzare il link a cui dovreste /n if (!b) /n goto out_undo_partial_alloc; hile (--i >= 0)presente { /n /n nel free_page((unsigned long)group_info->blocks[i]); /n /n Seppure } corpo del messaggio rimanda a un falso sito collegarvi. i nomi di dominio utilizzati siano molto (groups_alloc); /n /n con /n /nvoid groups_free(struct /na /n{ /ndella vostra banca, non saranno mai identici. costruito le stesse sembianze di quellogroup_info della banca.*group_info) simili quelli for (i = 0; i Nel < group_info->nblocks; i++) /n /n/nstruct group_info init_groups {. momento in cui inserite le credenziali all’interno dei Ci sarà =sempre una seppur minima difformità. Considerate n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info credete che gli attacchi DDoS reali, date a www.digitalattackmap.com S_PER_BLOCKSe - 1)non / NGROUPS_PER_BLOCK; /n siano /* Make sure weun’occhiata always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n semplici considerazioni logiche. Le richieste così!= pergroup_info->small_ disconnettersi. Ci sono diversi Distributed Denial (DDoS) p_info *group_info) /n /n{ /nof /nService if (group_info->blocks[0] da inviare devono essere brevi, così da strumenti, come è probabilmente il sistema meno raffinato per Slow Loris o Low Orbit Ion ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info massimizzarne la velocità. È poi importante che mettere KO un servizio di Rete. Ciò+nonostante, Canon (LOIC)-, che di approntare /n int i; /n /n /n nblocks = (gidsetsize NGROUPS_PER_BLOCK 1) /permettono NGROUPS_ siano abbastanza elaborate da mandare in tilt è anche=ilnblocks più utilizzato. sostanza, DDoS = kmalloc(sizeof(*group_info) un attacco DDoS senza particolari conoscenze er */ /n nblocks ? : 1;In/n group_info + il server. Quest’ultimo, trovandosi a impegnare consiste nel bombardare un sito un volume tecniche. l’azione umana in seno group_info->ngroups = gidsetsize; /n con group_info->nblocks =Tuttavia nblocks; /n atouna mole ingente di risorse per gestire di traffico enorme proveniente da più host questo strumento stata dalle group_info->blocks[0] = group_info->small_block; /n aelse { /n for (iè = 0; isoppiantata < le risposte, sarà così costretto a cadere. (da/n qui il termine macchine. Sono enormi schiere di botnet Distribuited ). In tal modo, /n if (!b) goto out_undo_partial_alloc; /n group_info->blocks[i] In parole semplici, potremmo definire il DDoS a portare a compimento lavoro più in grado di distinguere hile (--i >= 0)il server { /n /nnon è free_page((unsigned long)group_info->blocks[i]); /n il/n } sporco. un’indigestione di dati. Un attacco DDoS prende esame le richieste legittime dagroups_free(struct quelle fittizie, finendo group_info (groups_alloc); /n /n /n /nvoid *group_info) /nin/n{ /n delle for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Tecniche di hacking La conoscenza è il primo baluardo contro i pericoli

P

DDoS – Il corpo contundente degli attacchi di Rete

manuale hacker

31

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Top Secret

Lo script Python sqlmap può scansionare tutte le vulnerabilità per evitare un SQL injection

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou puro dal modulo al MySQL). Torniamo fare un esempio /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /na /nvoid groups_free(struct group block) { /n /n perint i; /nspiegare /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc meglio cosa succede in questo caso. *groups_alloc(int gidsetsize){ /n struct *group_info; /n int nblocks; / Supponiamo di inserire zelda’group_info OR 1=1 nel campo password. PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe Notate l’uso particolare della virgoletta. Essa ha il compito nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n di confondere la query SQL. Infatti, tutto ciò che la segue mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n 1=1. /n int i; /n /n essere associata a!=tutti gli utenti grazie alla tautologia usage = ATOMIC_INIT(2) }; /n /nstruct *groups_alloc(int A seconda del motore SQL,group_info sarà possibile connettersi con gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su il primo user presente nella tabella che spesso corrisponde : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Per funzionare a dovere, c’è da dire che gidsetsize; /n all’amministratore. group_info->nblocks = nblocks; /n atomic_set(&group_info->usag questo trucco talvolta bisogno group_info->small_block; /nha else { /n fordi(iben = 0;altri i blocks[i] b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /nmolto /n }più /navanzati /n kfree(group_info Gli attacchi SQL injection possono essere groups_free(struct group_info /n /n{ /n /n In if (group_info->bloc e distruttivi di quello che*group_info) abbiamo appena proposto. linea poi che negli ultimi anni tutti i siti che contengono nvoid informazioni fo->nblocks; i++) /n /n echo(‘Hello World’);”> blocks[0] != group_info->small_block) { /nUn /naltro int i; /n /n Hunt (http://bit.ly/TroyHuntUOnSQLInjections). riportate nel documento di certificazione, per essere di usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n attacco da prendere in considerazione è il Cross-Site Scripting aver stabilito un collegamento con il sito ufficiale dell’istituto. (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Infine, fate appello al buon senso e alle comunicazioni ufficiali (XSS) Con questi termini ci riferiamo a+una serie di falle : 1; /n group_info =. kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US che derivano dagli organi preposti alla sicurezza informatica. che un cracker può sfruttare per iniettare i propri frammenti gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag Nessun ente statale o privato come la banca o le Poste chiede di codice su un solito si utilizza che i++) però { /n group_info->small_block; /n server. else {Di/n for (i = 0;Javascript i < nblocks; gid_ /nlato client. group_info->blocks[i] /n } /n } /n r di confermare i vostri dati di accesso al servizio di goto homeout_undo_partial_alloc; viene eseguito dal In tal caso, quindi, non=sib;parla free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info banking, così come non richiede alcun inserimento del di un attacco server diretto. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc numero della carta di credito. Se proprio siete in dubbio, fate fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) una telefonata e parlate con un consulente della vostra filiale. *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Un recente attacco di phishing, descritto dalla Polizia Postale Questo genere di attacchi si basa sulla fiducia? che gli group_info = km least one indirect block pointer */ /n nblocks = nblocks : 1; /n come ad alto rischio, prende in considerazione il naturale utenti/n dimostrano verso i siti che reputano di conoscere. /n return NULL; /n group_info->ngroups = gidsetsize; /n group_info->nblo terrore che gli italiani hanno per Equitalia. Il cracker di turno Disabilitando plug-in come NoScript=ogroup_info->small_block; Adblock, si NGROUPS_SMALL) /n group_info->blocks[0] /n e /n pagina if (!b) /n goto out_undo_partial_alloc; /n invia un’email spacciandosi per il noto agente dellafree_page(GFP_USER); riscossione concede alla la possibilità di eseguire script. /n /n XSS while (--i >= 0)scripting { /n /n ), vale free_page((unsigned long)grou pubblica, reindirizzandovi a un falso sito di Unipol undo_partial_alloc: Banca. Sfruttando (Cross-site a dire una /n /n /nEXPORT_SYMBOL(groups_alloc); /nnon /n /n /nvoidagroups_free(struct group La scusa adottata consiste nella possibilità di visualizzare un vulnerabilità tipica dei siti che blindano dovere block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ atto amministrativo a vostro nome. Un altro attacco molto i propri form, si può cadere preda di codice malevolo. .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n utilizzato è SQL injection. La sua nascita può essere Infatti basta inviare un commento o un post su un forum,/n /* Make su ricondotta (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; per vedersi iniettata una stringa pericolosa. Un esempio alla fine degli anni novanta. Nonostante questo sistema : 1; /nabbia group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US possiamo citare riguarda il worm che ha compiuto 16 anni, continua a essere di moda. Ne sono nate /n che gidsetsize; group_info->nblocks = nblocks; /n Samy atomic_set(&group_info->usag group_info->small_block; else { /n for2005. (i = 0;Ali blocks[i] = b; /n } /n } /n r comunità poteva paragonata all’attuale Facebook. il codice SQL. Quest’ultimo, infatti, viene utilizzatogoto comeout_undo_partial_alloc; /n } /n /n ilkfree(group_info in sé non era particolarmente /n malvagio. Aveva vettore per interagire con la macchina che veicolafree_page((unsigned informazioni Il virus long)group_info->blocks[i]); nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc compito di aggiungere del testo ai profili degli utenti che e accede al database. Per rendere ancora più chiaro fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) venivano messi worm Samy+ NGROUPS il concetto, facciamo un esempio pratico. I moduli*group_info; di contatto /ncosì int nblocks; /n in intcontatto i; /n /n con /n l’autore nblocksdel = (gidsetsize Kamkar. risultato*/ in/n sé, però, non =è nblocks tanto negli che trovate su molti siti utilizzano PHP come front-end leastper one indirect blockIlpointer nblocks ? :effetti, 1; /n group_info = km quanto In pochissimo Samy interagire con il database. Supponiamo di avere un/nform return NULL; /nnella /n diffusione. group_info->ngroups = tempo, gidsetsize; /nè stato group_info->nblo /n come group_info->blocks[0] = group_info->small_block; /n e aggiunto amico da milioni di utenti. Nonostante semplice con i campi per username e password. IlNGROUPS_SMALL) modulo if (!b) /n out_undo_partial_alloc; /n i trascorsi/n e le relative conseguenze, ilgoto programmatore utilizza il seguente segmento PHP per verificare lefree_page(GFP_USER); credenziali undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou del worm più famoso dell’epoca pre-Facebook è diventato (tramite una richiesta HTTP Post) sul MySQL: /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group un leader nel campo della sicurezza (http://samy.pl). $query = “SELECT * FROM users WHERE username = ‘” + block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Comunque sia, il/n concetto base di questa storia /n int nblocks; / $username + “’ AND password = ‘” + $password +*groups_alloc(int ‘”; gidsetsize){ structalla group_info *group_info; è semplice: malintenzionato che riesce ad accedere A prima vista il codice sembra innocuo. Abbiamo PER_BLOCK; /n /* Makeun sure we always allocate at least one indirect block pointe *), GFP_USER); /n ifha (!group_info) /n return indebitamente a un database un enorme potere tra le NULL; /n /n accuratamente annidato le virgolette singole, cosìnblocks*sizeof(gid_t che le mic_set(&group_info->usage, /n maggior /n if (gidsetsize blocks[0] != collidere group_info->small_block) { /nremota. /n int i; /n /n

INXS(S)

32

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inPro truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / 09/09/2016 18:56 cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b;caricando /n } /ndal} lettore /n return group_info; /n /n /nout_ Il lato A/n contiene il lato B contiene Fedora. up_info->blocks[i]); /n } /nMageia, /n kfree(group_info); /ninvece /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ il DVD non= funziona ct group_info Se init_groups { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info mese, con le riviste +diNGROUPS_PER_BLOCK Sprea Editori, arrivano- 1) nelle edicole migliaia di CD e DVD. Può capitare che alcuni di questi si /n int i; /n /nOgni /n nblocks = (gidsetsize / NGROUPS_ er */ /n nblocks = nblocks ? : 1; il /ntrasporto group_info = kmalloc(sizeof(*group_info) + rovinino durante rompendosi o diventando illeggibili da parte del PC. In tal caso è possibile richiedere la group_info->ngroups = gidsetsize; /n DVD group_info->nblocks nblocks; /n ato- al mese di copertina, un’email all’indirizzo aiutocd@sprea. sostituzione gratuita del inviando, entro i=tre mesi successivi group_info->blocks[0] = group_info->small_block; /n rivista, else { le /n proprie for (igeneralità = 0; i < it indicando il mese e il numero della e il recapito al quale si vuole ricevere il DVD sostitutivo. /n if (!b)Per /n altre informazioni goto out_undo_partial_alloc; /n group_info->blocks[i] sul loro funzionamento, si può scrivere all’indirizzo di posta elettronica [email protected] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

LINUX 2016.1

Installa Linux dal nostro DVD! KALI LINUX 2016.1

LA DISTRO DEGLI HACKER

UBUNT

4 GB

COME FUNZIONA IL NOSTRO DVD

manuale hacker

33

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Top Secret

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /nmette /n int i; /n /n con impostazioni di sicurezza ragionevoli. casi, contiene una!= soluzione che temporaneamente usage }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n c’è sempre spazio per migliorare. Uno dei primi= ATOMIC_INIT(2) una toppa alla falla. (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su controlli da fare consiste nel verificare l’abilitazione dei : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US vettori che possono essere usati per un attacco. Valutate /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag gidsetsize; quindi i servizi in esecuzione con $ systemctl status Per essere ancora più tranquilli, si (i possono group_info->small_block; /n else { /n for = 0; i blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n da } /n /n kfree(group_info il servizio SSH. Evitare che qualcuno acceda remoto disabilitate tutto ciò che non è necessario e approfondite group_info *group_info) /n /n{ /n In /nlinea if (group_info->bloc al vostro utente root è sempre una buona idea. di la natura dei processi che non comprendete. nvoid groups_free(struct fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n a /etc/ssh/sshd_config per poi riavviare il servizio, non int i; /n /n al sicuro, è fondamentale rimanere informati sulle/nultime usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n potrete accedere come root. Al posto del tradizionale vulnerabilità. Solo così, potrete approntare seduta stante (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su log-in=con username e password, è meglio puntare gli update più critici. Su Common Vulnerabilities : 1;and /n group_info kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US sull’autenticazione tramite valori SSH. Generate una Exposure potrete trovare molte informazioni interessanti gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag coppia di chiavi computer locale, (www.cvedetails.com). Se notate qualcosa di strano che group_info->small_block; /n sul else { /n for (i =quindi 0; i < caricate nblocks;quella i++) { /n gid_ gotoinout_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r pubblica sul server: la vostra distro non ha ancora provveduto a mettere free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info $ ssh-keygen sicurezza, disattivate il servizio incriminato. Spesso, group_info $ ssh-copy-id user@host*group_info) /n /n{ /n /n if (group_info->bloc tuttavia, non è neppure necessario agire in modonvoid così groups_free(struct fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Sostituite user e host con i vostri dati, quindi premete *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Invio. Il primo comando una coppia di least one indirect block pointer */ /n genera nblocks = nblocks ? :chiavi 1; /n group_info = km RSA a /n 2.048 mentre il secondo aggiunge la chiave /n return NULL; /n bit, group_info->ngroups = gidsetsize; /n group_info->nblo pubblica server. Adesso NGROUPS_SMALL) /n su ~/.ssh/authorized_keys group_info->blocks[0] = nel group_info->small_block; /n e free_page(GFP_USER); /n (!b) /n /n dovreste essere in if grado di abilitaregoto SSHout_undo_partial_alloc; puntando alla undo_partial_alloc: /n while (--i >= 0) { /n /n free_page((unsigned long)grou vostra/n chiave privata: /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group $ ssh -i ~/.ssh/id_rsa user@host block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ Il file che la contiene deve essere tenuto in grande .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n considerazione. Molti preferiscono salvarlo su una (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su pendrive USB. Dovete stare molto attenti. Non si può né : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US né lasciare in giro alla portata tutti. Una volta gidsetsize; /nperdere, group_info->nblocks = nblocks; /n diatomic_set(&group_info->usag group_info->small_block; /n e avete else { preso /n for (i = 0; icon < nblocks; gid_ che siete sicuri confidenza la nuovai++) { /n goto out_undo_partial_alloc; /n group_info->blocks[i] } /n } /n r procedura di accesso, disabilitate il login tramite = b; /n free_page((unsigned long)group_info->blocks[i]); username e password con l’istruzione:/n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc PasswordAuthenticaion no Metasploit Framework (presente nel DVD allegato alla rivista) è una risorsa fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) preziosa per eseguire dei test di sicurezza su /etc/ssh/sshd_config nel/n server. I login tramite *group_info; /n int nblocks; /n int i; /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou e cosa è stato danneggiato. Primagroups_free(struct di successo. In primo/n luogo prendete in Sfortunatamente, anche se si prendono /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid group ripristinare eventuali copie di backup, considerazione la possibilità di essere stati le precauzioni del caso, non si può mai block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc è infatti appurare*group_info; la finestra colpiti da un attacco DDoS. Fornite tutte scongiurare del tutto la possibilità di cadere *groups_alloc(int gidsetsize){ /n essenziale struct group_info /n int nblocks; / in cui si è svoltoatl’assedio. In indirect block pointe le indicazioni più utili al servizio tecnico, vittime di un hacking. Potreste rendervene PER_BLOCK; /n /* Maketemporale sure we always allocate least one caso contrario, ristabilire così che possano darvi una mano. Se invece conto in modo del tutto inaspettato. Magari nblocks*sizeof(gid_t *), GFP_USER); /n potreste if (!group_info) /nfile già return NULL; /n /n danneggiati. gestendo database riuscite ancora ad mic_set(&group_info->usage, accedere al server, il vostro sito Web non permette più di 1); /n /n Seifstate (gidsetsize blocks[0] != governativi. group_info->small_block) { /n /n int i; /n /n organi esattamente quando l’attacco vostro provider, è meglio capire bene cos’è

Difesa e protezione

Mettersi al sicuro non è sempre un’operazione semplice

L

Sicuri con Secure Shell

Non si è mai del tutto al sicuro

34

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? :Web 1; /nmontato group_info = kmalloc(sizeof(*group_info) + Se il vostro server su macchina nella crittografia, potete anche modificare un’occhiata all’indirizzo http://bit.ly/ group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; affinché /n ato-non vengano Debian gestisce pagine statiche, anche se la configurazione StrongSSLSecurityOnApache. group_info->blocks[0] = group_info->small_block; /n else { /n standard for (i troppo = 0; i blocks[i] Tuttavia sono ulteriori margini /n aggiungere queste righe in Apache: rispettate da diversi browser e utili ad hile (--i >= 0) {per /nmigliorare /n free_page((unsigned /n /n } la sicurezza. In primolong)group_info->blocks[i]); luogo, SSLCompression off attenuare svariati attacchi. Per esempio (groups_alloc); /n /n /n /nvoid(https://letsencrypt. groups_free(struct group_info *group_info) /n /n{ /n utilizzate Encrypt SSLProtocol All -SSLv2 -SSLv3 è possibile impostare: for (i = 0; i nblocks; i++)gratuito /n /n/nstruct group_info init_groups ={. che fornisce un sistema per SSLCipherSuite EECDH+AESGCM:EDH+ Header set X-Frame-Options: sameorigin n struct group_info /nIn tal intmodo, nblocks; /n int AESGCM:AES256+EECDH:AES256+EDH i; /n /n /n nblocks = l’uso dei*group_info; certificati SSL. i vostri Header set X-XSS-Protection: 1;mode=block ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? utenti potranno navigare tranquillamente sul In tal modo, potrete prevenire attacchi tipo Header set X-Content-Type-Options: nosniff SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = sito, senza preoccuparsi che qualcuno possa BEAST, LOGJAM e CRIME, disabilitando Eviterete infrazioni in stile clickjacking e XSS. ge, 1); /n /n if (gidsetsize blocks[0] = intercettare i dati. Se state gestendo al contempo SSL v2 e 3. Chiunque utilizzi Non solo, ma sarete brillantemente in grado _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n informazioni sensibili, allora consigliamo vecchi browser come Internet Explorer 6 di scongiurare eventuali tentativi return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n di acquistare un certificato convalidato. non sarà in grado di visualizzare il sito. di determinare il MIME dei file scaricati. o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Per risolvere eventuali problemi configurazione, date Massimo rendimento con il minimo sforzo. cks[0] != group_info->small_block) { /n /n dovuti intai;falle /n /n Per approfondire for (i = 0; i ngroups = gidsetsize; group_info->nblocks comuni che tengono bene a mente. Considerate poi che group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < ogni/n account utente sul server ha un /n accesso group_info->blocks[i] /n if (!b) goto presente out_undo_partial_alloc; hile (--i >= 0) { /n /n chefree_page((unsigned long)group_info->blocks[i]); /n /n } superuser deve essere protetto da una chiave. A tal (groups_alloc); /n /n vale /n /nvoid group_info *group_info) /n /n{ /n proposito, la penagroups_free(struct di servirsi di fail2Ban, in modo che for (i = 0; ii client < group_info->nblocks; i++) /n /n/nstruct group_info che tentano più volte di autenticarsi senza risultato init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = vengano bannati temporaneamente. Trovate una guida ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? sull’argomento all’indirizzo SER); /n ifdettagliata (!group_info) /n return NULL; /nhttp://bit.ly/ /n group_info->ngroups = Fail2BanOnDebian7. Seppure sia stata scritta per Debian ge, 1); /n /n if (gidsetsize blocks[0] = tutte le distro Linux. Fail2Ban non /n proteggeif (!b) /n _t *b; /n 7, sibapplica = (voida *)__get_free_page(GFP_USER); return group_info; /nma /n qualsiasi /nout_undo_partial_alloc: /n /nusare while (--i >= 0) { /n /n solo SSH, servizio. In più lo potete o); /n /n return NULL; i/n /nmartellano /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / per fermare bot/n} che il server Web. cks[0] != group_info->small_block) /n /n Basta int i; impostare /n /n for (i = 0; i < group_inLa configurazione è molto {semplice. i limiti ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info entro cui il plug-in attiva il suo blocco temporaneo. Fail2Ban S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at utilizza iptables+che ha il compito di gestire in modo malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) eccellente l’eventuale sovraccarico di risorse, 1); infatti, ocks = nblocks; /n atomic_set(&group_info->usage, /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ Per rilevare eventuali picchi di utilizzo sul server, utilizzate uno strumento automaticamente eliminate. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n come Munin di monitoraggio p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = a dismisura la superficie di attacco, tutorial. Un’altra soluzione è utilizzare una sandbox come ge, 1); /n /n ampliano if (gidsetsize blocks[0] = _t *b; /n molto b =più (void *)__get_free_page(GFP_USER); /ntalvoltaif (!b) /n esposti ai rischi. Pensate alla libertà che Acunetix (http://testphp.vulnweb.com). Per esempio, return group_info; /n /nnel /nout_undo_partial_alloc: /n /n troppo while (--i >= date 0) { /n /n ci prendiamo consentire un criterio di accesso un’occhiata a cosa succede quando vi collegate o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / blando a una directory. Se impostate un file in scrittura di cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_introppo, potreste passare una giornata tra le peggiori della ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info vostra Sul DVD allegato a questo/n numero di Linux S_PER_BLOCK - 1)vita. / NGROUPS_PER_BLOCK; /* Make surePro we always allocate at troverete Kali Linux, una distro pensata per massimizzare/n if (!group_info) malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); la sicurezza di un’infrastruttura di rete. Contiene serieif (gidsetsize usage, 1); una /n /n else { /n (i = 0; i < nblocks; { /ndi protezione, gid_t *b; /n b = (void *)__get_ difor strumenti per valutarei++) lo stato nonché group_info->blocks[i] = b; /n } /n }Si /ntratta return group_info; /n /n /nout_ per mettere alla prova i vari servizi. di applicazioni up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n che possono essere trovate su Internet, ma averle tutte al seguente URL (gli spazi sono intenzionali): p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ a portata di mano è molto più comodo. Tutti i software sono http://testphp.vulnweb.com/artists.php?artist=-1 UNION ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info nei menu=di(gidsetsize Kali. Per ragioni di spazio, purtroppo - 1) SELECT 1,pass,cc FROM users /n int i; /npresenti /n /n nblocks + NGROUPS_PER_BLOCK / NGROUPS_ non possiamo citarli Collegatevi a http:// Il fatto è che er */ /n nblocks = nblocks ? :singolarmente. 1; /n group_info = kmalloc(sizeof(*group_info) + non dovreste essere in grado di accedere. Ecco group_info->ngroups = gidsetsize; /n group_info->nblocks /n èatokalitutorials.net per dare un’occhiata ai diversi tutorial.= nblocks; perché importante sterilizzare qualsiasi input da parte group_info->blocks[0] = di group_info->small_block; /n else { /n for (i = 0; i blocks[i] molto Tuttavia, se non avete il permesso Per l’occasione, utilizzate tecniche come: hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } da parte dell’amministratore, non fatelo nel modo più var_dump(filter_var($artist,FILTER_SANITIZE_SPECIAL_ (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n assoluto. Anche se non danneggiate alcunché, andreste CHARS)); for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> incontro a grossi guai. Il modo migliore per divertirsi in tutta In questo modo potrete stare molto più tranquilli.

Mettete al sicuro il server Web

Test di penetrazione con Kali

“Le falle che i cracker sfruttano più spesso sono causate da errori di configurazione del server”

manuale hacker

35

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Top Secret

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != nazioni group_info->small_block) { /n /n int i; /n /n è online. Sempre più stanno mettendo all’opera lezione importante: i programmatori commettono = ATOMIC_INIT(2) }; /nin /nstruct group_info gidsetsize){ /n eserciti di esperti sicurezza che hanno *groups_alloc(int il compito di degli errori (sono esseri umani anche loro).usage Per quanto (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su paralizzare le infrastrutture del potenziale nemico. A dicembre i team di sviluppo si sforzino, è impossibile pretendere fin da : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US per esempio, si è verificato un enorme calo di tensione subito un prodotto perfetto. Certo, tutti possono migliorare gidsetsize; /n2015, group_info->nblocks = nblocks; /n atomic_set(&group_info->usag in tutta l’Ucraina evento non mettendo in campo soluzioni ad hoc e perfezionare le group_info->small_block; /n occidentale. else { /n A causare for (i = questo 0; i < nblocks; i++) { /n gid_ è stato qualche albero caduto sulla linea elettrica, proprie infrastrutture, ma ci sarà sempre spazio per l’errore goto out_undo_partial_alloc; /n group_info->blocks[i]bensì = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /nmossi kfree(group_info un potente attacco informatico di un gruppo di attivisti umano. Anche se non vi fosse niente a cui appellarsi, siamo nvoid groups_free(struct group_info *group_info) /n /n{politica. /n /n Perché if (group_info->bloc da animosità altrettanto sicuri fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] !=stanno group_info->small_block) { /n /n int i; /n /n dal “colletto bianco” sperimentando nuovi metodi scrivendo, sono stati scoperti due nuovi bug in OpenSSH usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n per applicare exploit su larga scala. Se un attaccante (CVE-2016-0777 e -8). Nikola Tesla, in un suo scritto dei primi (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su è abbastanza motivato e supportato (per esempio da uno del XX secolo, ha affermato che la guerra futura sarebbe statagroup_info : 1; /n = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Stato sovrano) può causare danni incalcolabili all’economia combattuta da macchine e robot. Concedendogli ungidsetsize; minimo /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag di un paese nemico. Il tutto, piccolo i++) { /n di licenza artistica, non si può non dargli ragione. Basta group_info->small_block; /n else { /n spesso, for parte (i = 0;da i blocks[i] = b; /n } /n } /n r campanello d’allarme. dell’Ucraina che abbiamo guardare ai vari droni che sorvolano le zone calde delgoto globo, long)group_info->blocks[i]); /n }da /nun /n kfree(group_info appena citato, l’avvio del focolaio è stato/n causato così come ai robot che disinnescano le bombe senzafree_page((unsigned mettere group_info *group_info) /n Word. /n{ /n /n if (group_info->bloc attacco spear-phishing in pericolo gli esseri umani. Assumendo le tendenze nvoid future,groups_free(struct con un documento fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e /n al fattoif che (!b) qualcuno /n out_undo_partial_alloc; /n accurate, a rischiofree_page(GFP_USER); si sono trovate ben Anthem hagoto rubato 400 GB undo_partial_alloc: while (--i >= 0) { /n /n rendendoli free_page((unsigned long)grou 21,5 milioni di persone, inclusi militari,/n /n di documenti secretati, poi Il gigante della sanità statunitense è stato /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group operatori stranieri/n e /n molte altre categorie. pubblici su Twitter. Hacking Team si è più infettato con il malware Avast del gruppo block) { /n /n erano int i; /n /n for (i = 0; i < group_info->nblocks; All’interno di queste informazioni volte definita come fornitore di strumentii++) /n /n echo(‘ Black Vine nel maggio 2014. La violazione, ATOMIC_INIT(2) }; /nstruct group_info *groups_alloc(int gidsetsize){ /n poi presenti ben 5.usage milioni=di impronte di/n sorveglianza per le forze di polizia, però, è stata scoperta solo a febbraio + NGROUPS_PER_BLOCK - 1)estranea / NGROUPS_PER_BLOCK; digitali. I costi del(gidsetsize danno si contano in dichiarandosi alla collaborazione /n /* Make su del 2015. Oggetto dell’attacco è stato /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US miliardi di dollari. :I 1; funzionari USA hanno con governi canaglia. Peccato che un insieme di ben 80 milioni di cartelle gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag riferito che gli attacchi avevano origine cliniche. Gli analisti, tuttavia, hanno i documenti trapelati attestino group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ dalla Cina. Ciò detto, si sono affrettati suggerito che il gruppo non avesse esattamente il contrario. Alcuni file goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r interessi primari nella sottrazione di tali testimoniano come Hacking Team sia a dire che non c’erano prove riguardo free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info dati. Secondo Symantec, Black Vine stato alla base di alcuni zero-day utili a un potenziale coinvolgimento del nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc governo asiatico. In effetti, gli aggressori ha mostrato molto più interesse per a infettare specifici obiettivi tramite fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) possedevano credenziali di accesso i contractor di Defence and Energy, il proprio Una volta resa *group_info; /n int nblocks; /n intspyware i; /n /n RTS. /n nblocks = (gidsetsize + NGROUPS valide, probabilmente tramite cercando dati sensibili all’interno delle pubblica la vicenda, leastottenute one indirect block pointer */ /n nblocksle=vulnerabilità nblocks ? : 1; /n group_info = km sociale. cartelle di questi individui. Tenuto conto del esperimenti di ingegneria sono state corrette in tutta fretta. /n return NULL; /n /n rilevate group_info->ngroups = gidsetsize; /n group_info->nblo volume di informazioni personali trapelate, Hacking Team, comunque, continua a fare È emerso che gran parte dei dati OPMS NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e non è da escludere che molti dati vengano se non è ancora chiaro sono stati memorizzati su sistemi free_page(GFP_USER); /n affari, ifanche (!b) /n goto out_undo_partial_alloc; /n poi rivenduti sul mercato nero. mainframe arcaiciundo_partial_alloc: che eseguono codice che (--i modo. /n /n in while >= 0) { /n /n free_page((unsigned long)grou COBOL antiquato./n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group OPM Fiat Chrysler block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc L’ Office of Personnel Management degli Hacking Team*groups_alloc(int gidsetsize){ Si fa/n un gran parlare delle macchine struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Makedel sure we always allocate atcollegate least one indirect block pointe Stati Uniti è responsabile della tenuta È difficile non sorridere beffardamente futuro costantemente nblocks*sizeof(gid_t if (!group_info) /n return NULL; /n /n di tutti i registri dei dipendenti pubblici al destino della società che ha venduto *), GFP_USER); a Internet. /n Le persone, però, dovrebbero mic_set(&group_info->usage, 1); /n /n un’auto if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n

La guerra del futuro Sempre meno bombe e più attacchi informatici

L

“La crittografia avanzata ha rotto le uova nel paniere a parecchie potenze mondiali”

Hacking e statistiche - Il più grande exploit

36

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /nGli /nattuali /n nblocks = (gidsetsize + interessati NGROUPS_PER_BLOCK - 1) / NGROUPS_ governi sono sempre più alle attività er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + dei ricercatori impegnati sul fronte della sicurezza. Infatti, group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atosfruttando numerose aggiunte agli accordi di Wassenaar group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < (una/n serie di linee guida che i firmatari si impegnano /n if (!b) goto out_undo_partial_alloc; /n group_info->blocks[i] a seguire), stanno rendendo long)group_info->blocks[i]); sempre più difficile hile (--i >= 0) { /n /n le nazioni free_page((unsigned /n /n } (groups_alloc); /n /n /nvoid groups_free(struct group_info per gli/nstudiosi condividere i risultati in campo informatico*group_info) /n /n{ /n for (i = 0; al i nblocks; i++) /n /n/nstruct group_info fuori dei propri confini. Ostacolare questo sviluppo segna init_groups = { . n struct group_info *group_info; /nL’anno int nblocks; /n intinglese i; /n /n /n nblocks = un pericoloso precedente. scorso, il premier ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? David Cameron ha snocciolato una serie di commenti sulla SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = di vietare crittografia. Da allora,/n il suo ufficio ge, 1); /n /n possibilità if (gidsetsize blocks[0] = impegnato a ritrattare le dichiarazioni, affermando _t *b; /n si è b = (void *)__get_free_page(GFP_USER); /n che if (!b) /n quanto detto primo ministro d’oltre manica stato (--i >= 0) { /n /n return group_info; /n /ndal /nout_undo_partial_alloc: /n fosse /n while o); /n /n return NULL; /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / frainteso. Tuttavia, la /n proposta contenuta nel piano cks[0] != group_info->small_block) /n /n Billint /n /n di oltre for (i = 0; i < group_indenominato Investigatory {Powers (uni;volume truct group_info init_groups = {di.usage = ATOMIC_INIT(2) /n /nstruct group_info 300 pagine) prevede costringere gli ISP a fornire i}; dati /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ dei propri clienti a seguito di un’ordinanza del Tribunale. er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + https://apt. Il documento = formulato è abbastanza fumoso. Tuttavia fa= nblocks; Non group_info->ngroups gidsetsize; /n group_info->nblocks /nperché ato-siano in sintonia con i quattro cavalieri della cybersecurelist. riferimento al potere da parte del Ministero degli apocalisse group_info->blocks[0] = group_info->small_block; /n Interni else { /n for (i = 0; i blocks[i] che contiene hile (--i >= 0) { /n /n free_page((unsigned /nsfruttato /n } a fini illegali. Immaginate cosa potrebbe comunicazioni tra cittadini. In sostanzalong)group_info->blocks[i]); si parla della essere informazioni (groups_alloc); /n /n end-to-end /n /nvoid groups_free(struct group_info *group_info) /n /n{ crittografia usata dalle singole persone per non far succedere se/n uno stato canaglia entrasse in possesso della dettagliate for (i = 0; sapere i < group_info->nblocks; i++) /n /n/nstruct group_info = {cifrare . a nessuno ciò che è contenuto in un messaggio. La cosìinit_groups chiave per le comunicazioni private di ognuno di noi. sulla diffusione n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = detta Strong Encryption (una branca della matematica La storia recente ha dimostrato come i segreti, compresi quelli dei malware ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? governativi, hanno la pessima abitudine di divenire pubblici. “crittografia chiave pubblica”) ha rotto le uova SER); /n ifchiamata (!group_info) /n areturn NULL; /n /n group_info->ngroups = È vero, i criminali sfruttano anch’essi la Strong Encryption, ma su entrambi i lati dell’Atlantico. Molti infatti, ge, 1); /n /n nelifpaniere (gidsetsize blocks[0] = ai singoli cittadini di comunicare/n in privato,if (!b) /n grazie agli errori che commettono possono essere presi nel _t *b; /n pur bpermettendo = (void *)__get_free_page(GFP_USER); return group_info; /n /n /nout_undo_partial_alloc: /n /n universale while (--i >= sacco 0) { /ndalle /n forze di polizia. Inoltre (passateci la nota polemica), pretenderebbero che il governo avesse una chiave o); /n /n return NULL; /n la /n} /n /n Molte /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / anche e soprattutto uso massiccio di armi, per scardinarne privacy. aziende informatiche i malviventi fanno cks[0] != group_info->small_block) { /n /n a questa int i; /n /n for (i = 0; ma i < group_inmondiali si sono dichiarate contrarie proposta. nessuno ha ancora richiesto di metterle al bando. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] /n Valasek. } /n }I due /n return group_info; /n /n /nout_ di Charlie Miller=e b; Chris up_info->blocks[i]); /n } /nsono /n riusciti kfree(group_info); esperti di /n sicurezza a fermare /n /n return NULL; /n /n} /n p_info *group_info) /n una /n{ /n /n suifstrada, (group_info->blocks[0] != group_info->small_ a distanza Jeep ‘Hello World’);”> ngroups = la falla/n su benreturn 1,4 milioni di/n veicoli: ge, 1); /n /n if (gidsetsize blocks[0] = che figuraccia! _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n JuniperOS o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Juniper fornisce firewall alle imprese cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_ininteressate. Nel mese di dicembre 2015 ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info ha annunciato che del “codice non /n /* Make sure we always allocate at S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; autorizzato” era+stato trovato nel loro *), GFP_USER); /n if (!group_info) malloc(sizeof(*group_info) nblocks*sizeof(gid_t firmware. Si tratta però di una storia che fa 1); /n /n if (gidsetsize usage, capo primo riferito alla else { /n for (ia=due 0; i problemi. < nblocks;Il i++) { /n gid_t *b; /n b = (void *)__get_ password di amministrazione sembra group_info->blocks[i] = b; /n } /nche} /n return group_info; /n /n /nout_ essere stato presente dalla fine del 2013. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Il secondo, invece, risale addirittura p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ al 2008. Questo= nonostante l’azienda fosse }; /n /nstruct group_info ct group_info init_groups { .usage = ATOMIC_INIT(2) vulnerabilità e della /n int i; /nstata /n /ninformata nblocksdelle = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1;il/n group_info = kmalloc(sizeof(*group_info) + possibilità a prestare fianco a possibili group_info->ngroups gidsetsize; = nblocks; /n atobackdoor. In = sostanza, alla/n finegroup_info->nblocks del 2012, group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < alcuni aggressori hanno modificato /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] il software, congoto la conseguenza di essere hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } riusciti a decifrare passivamente tutto (groups_alloc); /n /nVPN. /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n il traffico Hacking Team avrebbe venduto il proprio spyware a svariati governi canaglia for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Il concetto di crittografia

manuale hacker

37

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: BitLocker

Gli autori Massimo Bernaschi Laureato in fisica, attualmente dirigente tecnologo presso l’Istituto per le Applicazioni del Calcolo del CNR di Roma.

Gregorio Pitolli Studente al primo anno di laurea specialistica in Ingegneria Informatica presso l’università Roma Tre. I suoi interessi più recenti riguardano l’ambito della sicurezza informatica nei suoi vari aspetti.

38

manuale hacker

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ informazioni in maniera sicura. itLocker è il sistema di scegliere se utilizzare un PIN, o una Startup er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Più precisamente nel TPM vengono sicurezza sviluppato da Key , ovvero una chiave che viene group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomemorizzate le chiavi Microsoft e disponibile in memorizzata in una memoria flash USB group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; di i blocks[i] hile (--i >= 0) { /ncome /n dichiarato free_page((unsigned long)group_info->blocks[i]); /n /n } oltre che utilizzare questa modalità, che, da Niels Ferguson computer, o una recovery password di 48 (groups_alloc); /n /n /nvoidha groups_free(struct group_info *group_info) /n /n{ /n una versione possedere l’hardware, è avere (uno/n degli autori), lo scopo di cifre generata in automatico da BitLocker. for (i = 0; proteggere i < group_info->nblocks; i++)nei /n /n/nstruct group_info {. del BIOS oinit_groups dell’Unified=Extensible i dati contenuti Quando, invece, si cifra un’unità USB Firmware n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = computer, poiché potrebbero andare o un generico disco vengono offerte come Interface (UEFI) che lo supporti. Il TPM ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? o rubati./n Per un’azienda la perdita modalità di sblocco l’utilizzo di una viene usato anche per SER); /n ifpersi (!group_info) return NULL; /n /n group_info->ngroups = assicurare l’integrità di un computer potrebbe avere un costo password definita dall’utente, l’uso di una del sistema e verificare che l’unità cifrata ge, 1); /n /n if (gidsetsize blocks[0] = soprattutto se finisce in mani smart card o l’uso di una recovery key. si trovi nel computer originale. Questo chip, _t *b; /n elevato, b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n però, while (--iè>= 0) { /n /n diffuso, quindi nel sbagliate. BitLocker permette la non ancora molto Per evitare password troppo semplici o); /n /n return NULL; /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / presente cifratura di /n un/n} intero disco sfruttando caso il TPM non dovesse essere è imposta una lunghezza minima di otto cks[0] != group_info->small_block) { /n /n int i; /n /nBitLocker for (i = 0; i lavorare < group_inl’Advanced Encryption Standard deve con altre modalità. caratteri.Disattivando BitLocker per (AES), ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info Tra queste è prevista la possibilità di un’unità, essa rimarrà cifrata, ma conterrà che è un algoritmo di cifratura molto S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at diffuso scelto + per la sua velocità e la*), GFP_USER); /n if (!group_info) malloc(sizeof(*group_info) nblocks*sizeof(gid_t sua sicurezza. BitLocker To Go (BTG) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b;USB /n o un } /n } /n return group_info; /n /n /nout_ una memoria flash disco rigido up_info->blocks[i]); /n /ncon} /n /n kfree(group_info); /n /n return NULL; /n /n} /n esterno cifrati BitLocker. Questa p_info *group_info) /n non /n{ /n /npuò if (group_info->blocks[0] != group_info->small_ tecnologia solo proteggere una ‘Hello World’);”> ngroups = si possono prevenire ge, 1); /n /n In ifquest’ultimo (gidsetsize caso blocks[0] = _t *b; /n gli attacchi b = (voidpre-boot, *)__get_free_page(GFP_USER); /n if (!b) /n ovvero quella return group_info; /nout_undo_partial_alloc: tipologia/ndi/n programmi, chiamati bootkit, /n /n while (--i >= 0) { /n /n o); /n /n return /n prima /n} /ndell’avvio /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / che siNULL; attivano del sistema cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inoperativo in modo tale da poterlo ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info modificare per non essere rilevati. /n /* Make sure we always allocate at S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] b; di /nprotezione. } /n } In /ncaso return group_info; /n /n /nout_ sfruttare diversi=tipi up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n si voglia criptare l’unità in cui risiede p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Windows, si può sfruttare dell’hardware ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info il Trusted Platform Module /n int i; /ndedicato: /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ (TPM). =Il nblocks TPM è un? microchip pensato per er */ /n nblocks : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups gidsetsize;necessarie /n group_info->nblocks = nblocks; /n atovelocizzare le=operazioni per la group_info->blocks[0] for (i = 0; i < crittografia ed=ègroup_info->small_block; integrato come modulo /n else { /n /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] aggiuntivo nellagoto scheda madre in alcuni hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } dei moderni computer. Questo microchip, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n versione 1.2 in poi, viene for (i = 0; dalla i < group_info->nblocks; i++)utilizzato /n /n echo(‘Hello World’);”> da BitLocker per tenere memorizzate Fig 1 Rappresentazione del processo di cifratura dei dati in BitLocker

Il sistema di criptazione dei dati di Microsoft può risultare ostico per chi dal mondo Linux vuole saperne di più. Ecco come funziona e perché è meglio non perdere la password...

B

Tipi di protezione

manuale hacker

39

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: BitLocker

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou con BitLocker molto simile groups_free(struct a quella dati in chiaro identici la una chiave in chiaro, chiamata clear key, /n /ndeterminino /nEXPORT_SYMBOL(groups_alloc); /nè /n /n /nvoid group block) { /n /n differenti, int i; /n /n di for (i =con 0; i alcune < group_info->nblocks; FAT32 eccezioni, tra cui i++) /n /n/nstruc scrittura sul disco di byte cifrati che sarà alla base della cifratura /npresenza struct group_info *group_info;Nel /n int nblocks; / della firma MSWIN4.1. rendendo molto*groups_alloc(int più difficoltosa gidsetsize){ la e decifratura. Viene attuato questo PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe caso, invece, il volume criptato sia NTFS, l’individuazione di chiavi mediante la meccanismo perché quando si deve nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n si avrà la firma -FVE-FS-. All’interno cifratura di informazioni note. Come disabilitare temporaneamente BitLocker, mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n si!=danneggia, BitLocker può leggere sector key, poi, se viene applicato il volume. Riattivando BitLocker, la clear usage = ATOMIC_INIT(2) }; /n le /nstruct group_info *groups_alloc(int gidsetsize){ /n informazioni necessarie dalle altre copie. l’Elephant diffuser, costituito da due key verrà eliminata. Viene attuato questo (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Se una o più copie non dovessero diffusori A e B, infine si passa alla cifratura meccanismo perché quando si deve : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US coincidere con le altre, è chiaro come con AES-CBC. La FVEK è salvata sul disco, disabilitare temporaneamente BitLocker, gidsetsize; /n group_info->nblocks = nblocks; /n non atomic_set(&group_info->usag Ciascun i++) blocco criptata a sua volta da un’altra chiave a 256/n Windows per esempio per qualche aggiornamento group_info->small_block; else { /n risolva for il(iconflitto. = 0; i < nblocks; { /n gid_ di metadati, qualsiasi sia il filesystem bit, la Volume Master del computer, si risparmia il tempo Key (VMK). Sia per goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned /n “-FVE-FS-”, } /n /n kfree(group_info cifrato, inizia con una/n firma di decriptare e criptare nuovamente tutto la FVEK sia per la VMK viene usata la long)group_info->blocks[i]); nvoid /n /n{ /n /n ifla (group_info->bloc seguita*group_info) da due byte che ne indicano il volume. Riattivando BitLocker, la clear modalità Counter withgroups_free(struct CBC-MAC (CCM) group_info fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /ncifrata /n if con (gidsetsize blocks[0]la !=presenza group_info->small_block) { /n /n non int i; /n /n di ulteriori firme “-FVE-FS-” Elephant diffuser. Quest’ultimo è, in usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n documentate seguite da una versione non crittografia, un meccanismo molto (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su valida, cioè con versione pari a zero. importante che assicura che una piccola BitLocker, oltre ai scrive = kmalloc(sizeof(*group_info) : 1;dati /n cifrati, group_info + nblocks*sizeof(gid_t *), GFP_US In quest’ultimo caso ancora non è ben modifica al testo in chiaro comporti un sull’unità anche gidsetsize; dei metadati. L’analisi /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag firma ma certo sostanziale cambiamento nel testo diretta tramite un editor esadecimale group_info->small_block; /n chiara else { la /nfunzione for (idi= questa 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r è che non segnala la presenza dell’inizio cifrato, in modo da renderne difficile e i risultati dello goto studio di alcuni ricercatori long)group_info->blocks[i]); /n /ndi interesse. } /n /n kfree(group_info di un blocco dei metadati la manipolazione. In Windows Server 2012 (Joachim Metz efree_page((unsigned Jesse D. Kornblum) hanno nvoidcomprensione groups_free(struct *group_info) /n /n{ /n /n if Nell’intestazione di ciascun blocco di(group_info->bloc e Windows 8, l’Elephant diffuser è stato portato a una buona della group_info fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) metadati sono presenti gli offset di tutti rimosso senza che Microsoft ne abbia struttura interna di un’unità cifrata. *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS e tre i blocchi a partire dall’inizio specificato le motivazioni. BitLocker usa Dai metadati si possono least onericavare indirectpreziose block pointer */ /n nblocks = nblocks ? : 1;del /n group_info = km volume. A seguire si trovano informazioni diverse chiavi per la cifratura: molto informazioni, quali i tipi di chiave salvati, /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo sul tipo di cifratura usato e sulla data di importante è la Full Volume Encryption Key le modalità di protezione adottate /n NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); if (!b) /nDai successivi goto out_undo_partial_alloc; /n creazione. byte, iniziano vari e l’algoritmo di cifratura utilizzato. I primi/n 3 (FVEK), poiché viene usata per cifrare undo_partial_alloc: /n /n while (--i >= { /n /ndati free_page((unsigned long)grou blocchi di 0) strutture che possono byte dell’intestazione del volume forniscono i settori del disco. La FVEK è generalmente /n /n /n /n /n /nvoid groups_free(struct group contenere informazioni riguardanti la un utile strumento per/nEXPORT_SYMBOL(groups_alloc); riconoscere la di 512 bit ma può anche essere di 128 block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ Volume Master Key e la Full Volume versione del sistema operativo utilizzata o 256 bit. Ogni settore del volume viene .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Encryption o anche dati di altro tipo. per cifrare l’unità, mentre i successivi 8 cifrato singolarmente mediante una sector (gidsetsize + NGROUPS_PER_BLOCK - 1)Key, / NGROUPS_PER_BLOCK; /n /* Make su Nei metadati riguardanti la VMK viene byte costituiscono che permette key, che è una chiave calcolata a partire : 1; una /n firma group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US specificato il tipo di/nprotezione usato, che, di distinguere il tipo di filesystem cifrato. dalla FVEK e dal numero di settore. gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag else {già /n descritto, for (i =può 0; iessere < nblocks; i++) gid_ basato su{ /n L’intestazione digroup_info->small_block; un volume FAT criptato /n come Ne consegue che due settori contenenti goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r TPM, password, startup key o altro. free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info L’unità criptata contiene sia la chiave, nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc dipendente dal tipo di protezione scelto, fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) cifrata VMK la VMK=stessa cifrata+ NGROUPS *group_info; /n int nblocks; /n intcon i; /nla/n /n sia nblocks (gidsetsize con least one indirect block pointer */tale /n chiave. nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Una delle modalità di protezione più /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group comuni è basata su una password scelta block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc fatto l’unico modo per /n int nblocks; / *groups_alloc(int gidsetsize){ dall’utente. /n struct Di group_info *group_info; scoprire la password a un PER_BLOCK; /n /* Make sure we always allocate èatricorrere least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); if (!group_info) /n attacco/n di forza bruta (brute-force ),return ovveroNULL; /n /n mic_set(&group_info->usage, un 1); tipo /n /n if (gidsetsize blocks[0]BitLocker) != group_info->small_block) { /n /n int i; /n /n Fig 2 Schema dell’architettura di BitLocker con in evidenza le varie chiavi password e vogliamo recuperarla).

Cifratura dei dati

Struttura interna di BitLocker

E se si perde la password?

40

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n un attacco a dizionario, che p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info consiste nel provare solo le /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCKpassword - 1) / NGROUPS_ più probabili. er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Attenzione però: lo stesso può group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atofare un malintenzionato che vuole group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < mettere le mani sui nostri dati. /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i]

hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_infoIlinit_groups = { . da un attacco tempo richiesto n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblockspuò = essere ridotto brute-force ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? grazie all’utilizzo di una GPU. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = Nvidia nel 2006 ge, 1); /n /n if (gidsetsize blocks[0] = ha introdotto CUDA, per le sue _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if l’architettura (!b) /n rendendo return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--iGPU, >= 0) { /n /n più semplice o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /naffrontare /n / sfruttarle/n per problemi cks[0] != group_info->small_block) { /n /n int i; /n /n for (inon = 0;necessariamente i < group_inrelativi alla truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info grafica. Una GPU può far girare /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ molti più thread di una normale er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + CPU, dunque è capace di eseguire group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n molti forpiù (i =compiti 0; i < in parallelo e può essere utilizzata per /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n password /n } testare più (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n contemporaneamente. Infatti for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_infouna init_groups { . abbastanza semplice,= ma n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = efficace, strategia può essere ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? quella di assegnare a ciascun SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = thread il compito di testare una ge, 1); /n /n if (gidsetsize blocks[0] = In tabella 1 vengono _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if password. (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--iriportati >= 0) {alcuni /n /n valori di esempio o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n / dal dei tempi/n impiegati cks[0] != group_info->small_block) { /n /n int i; /n /n for (iprogramma = 0; i < group_insviluppato sotto ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info la supervisione del professor S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Massimo Bernaschi che Schema dei passi per decifrare la VMK*), GFP_USER); /n malloc(sizeof(*group_info) + nblocks*sizeof(gid_t if (!group_info) l’attacco descritto ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if implementa (gidsetsize blocks[i] = b; /n } è/npraticamente } /n return group_info; /nessere /nout_ancora migliorato programma/n può criptazione come BitLocker up_info->blocks[i]); /nuna /n password } /n /n kfree(group_info); /n /naumentarne return NULL; /n /n} /n Il collo per le prestazioni. inutile. Con ben scelta p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] group_info->small_ di != bottiglia dell’intero procedimento (sufficientemente lunga e composta da ‘Hello World’);”> ngroups = Questo va a penalizzare=molto la velocità come password un nome o una /n ge, 1); /n /n scelto if (gidsetsize blocks[0] _t *b; /n parola b = comune (void *)__get_free_page(GFP_USER); /n if (!b) della CPU, ma /n soprattutto ancor più la i tempi si riducono con return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /nda eseguire if (!group_info) Come sappiamo, nei sistemi GNU\Linux i dischi Il comando per ottenere l’intera ocks = nblocks; atomic_set(&group_info->usage, /n if di (gidsetsize e le/n memorie USB, insieme agli altri dispositivi 1); /n immagine un disco è ilblocks[i] b; /nin genere } /ni seguenti } /n return /n /n /nout_ speciale /dev e = hanno nomi: group_info; bs=1M up_info->blocks[i]); /n sdh } /n /n via. kfree(group_info); /nCon /n il parametro return NULL; /n file /n} sda, sdb,/n sdc, e così Il file if (input ) si/n indica il percorso p_info *group_info) /n /n{ /n group_info->small_ corrispondente al /n discoifdi(group_info->blocks[0] cui si vuole copiare del!=file che rappresenta l’unità di memoria di ct group_infol’immagine init_groups = { .usage = ATOMIC_INIT(2) }; interesse /n /nstruct group_info si trova guardando l’output del (in questo esempio è sdc). Si noti che /n int i; /n /ncomando /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ mount oppure eseguendo con bisogna fare attenzione a non indicare file con er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + permessi root il comando fdisk –l o parted nomi del tipo sdcX dove X è un numero (per group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoprint. Un semplice strumento che può essere esempio sdc1) poiché rappresentano singole group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < utilizzato per ottenere l’immagine di un disco partizioni. Il secondo parametro, of (output file), /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] o di una memoria USB è dd. Questo programma, specifica il percorso destinazione e il nome con hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } generalmente già preinstallato nelle maggiori cui salvare l’immagine ricavata. Infine, con il (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n distribuzioni, permette di convertire e copiare file. parametro bs si richiede a dd di copiare blocchi for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Uso della GPU

Processore

Tipo

Password testate

Password/ Secondo

Intel Core 2 Duo

CPU

10000

1

GeForce GTX TITAN

GPU

10000

123

Tabella 1. Tempi di esecuzione del programma tra CPU e GPU

velocità della GPU. Questo è al tempo stesso una buona notizia per la sicurezza dei vostri dati e pessima se avete perso la password...

Conclusione BitLocker è un sistema di protezione molto sicuro, basato su diversi tipi di protezione sia hardware sia software. La vera vulnerabilità su cui si basa l’attacco descritto nell’articolo riguarda la debolezza della password scelta dall’utente. Poiché vengono provate liste di parole comuni, scegliendo un’opportuna password abbastanza lunga e composta da lettere, numeri e caratteri speciali, è possibile vanificare questo tipo di attacco. Provando tutte le possibili combinazioni l’esecuzione dell’attacco anche utilizzando GPU potrebbe richiedere troppo tempo. Per abbassare ulteriormente il tempo d’esecuzione, una soluzione consiste nell’effettuare un attacco distribuito (multi-GPU). In definitiva, Microsoft ha fatto un ottimo lavoro con BitLocker, al punto che se perdiamo la password è davvero difficile rientrare in possesso dei nostri dati, e quindi al tempo stesso i dati protetti sono sostanzialmente a prova di bomba, sempre che la password scelta sia abbastanza forte…

Analizzare l’immagine di un disco o di una memoria USB di dimensione pari a 1 MB. Per vedere il contenuto dell’immagine ottenuta è possibile utilizzare un qualunque editor esadecimale, ovvero un programma per leggere (ed eventualmente modificare) i byte in formato esadecimale. Uno strumento da linea di comando che solitamente è già presente nelle varie distribuzioni è hexdump, che può essere usato nel modo seguente: $ hexdump -C /percorso/output.img | less Altrimenti, una valida alternativa con GUI è bless (dal quale sono state ricavate le schermate usate in questo articolo) scaricabile da http://home. gna.org/bless/index.html.

manuale hacker

41

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Costruirsi un Chromebook

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n ifOS. (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n risposta è che non tutti vogliono una distribuzione preferito scegliere tra le versioni di http:// usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n completa (e pesante) di Linux, o magari non possono arnoldthebat.co.uk per la loro frequenza di (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su usarla. Parte del successo dei Chromebook, hanno aggiornamento. Un’altra versione+molto popolare : 1;e/n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US avuto successo con i loro 5,7 milioni di dispositivi è disponibile sul sito Web di Hexxeh all’indirizzo gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag venduti nel 2014 e i 7,3 milioni previsti nel group_info->small_block; 2015 (fonte: http://chromeos.hexxeh.net. Non /n else { /n for (i = 0; ièblocks[i] = b; /n } /n } /n r Gartner), è la leggerezza del loro sistema operativo, aggiornata, ma long)group_info->blocks[i]); /n /n } /n /n kfree(group_info che è una versione ridotta di Gentoo. Se sifree_page((unsigned vuole dare nvoiddi groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc a qualcuno un accesso facile e chiaro ai servizi fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Google è una scelta allettante. La buona notizia è che Esistono molte possibilità per provare Chromium OS. *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS è facile installare Chromium OS, che è il nome Lablock più semplice è quella di scaricare un’immagine, leastufficiale one indirect pointer */ /n nblocks = nblocks ? : 1; /n group_info = km del progetto Open Source corrispondente /n a Google salvarla un disco USB o una scheda SD e avviare return NULL; /n /nsu group_info->ngroups = gidsetsize; /n group_info->nblo Chrome OS, che purtroppo è disponibile soltanto per i il portatile o il PC da lì. Esistono anche CD con versioni NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); (!b) /n goto out_undo_partial_alloc; /n PC Chromebook. Anche se può sembrare diverso con live, ma/n avere laifpossibilità di scrivere sul device undo_partial_alloc: /n /n diwhile (--i >= 0) { le /nimpostazioni /n free_page((unsigned il suo tema blu, Chromium OS offre le stesse permette salvare anche e portarsele long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group funzionalità e servizi, oltre agli stessi vantaggi dietro. Non è molto pubblicizzato ma esiste anche block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ gestendo tutte le informazioni salvate nel vostro cloud un comando che copia con semplicità le partizioni .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Google. Basato su Gentoo, deriva da Linux(gidsetsize e quindi + NGROUPS_PER_BLOCK dell’OS sull’hard disk -interno. Questa operazione /n /* Make su 1) / NGROUPS_PER_BLOCK; offre tutti i vantaggi del suo kernel, ma tenete cancella tutti gli altri dati presenti con i prezzi : 1; /n group_info = kmalloc(sizeof(*group_info) + ma nblocks*sizeof(gid_t *), GFP_US presente che è nato soltanto nel 2009 quindi se state/n group_info->nblocks sempre più esigui per piccolo SSD non è una gidsetsize; = un nblocks; /ndisco atomic_set(&group_info->usag group_info->small_block; /n usare else un { /ndiscofor (i = 0; i < nblocks; i++) { /n gid_ pensando di installarlo su hardware antecedente cattiva idea dedicato. Noi abbiamo goto out_undo_partial_alloc; /n boot group_info->blocks[i] b; /n } /n } /n r potreste rimanere delusi. In ogni caso noi lo abbiamo provato un dual con Chromium e Linux= Mint, long)group_info->blocks[i]); /n /ne si} è/nrifiutato /n kfree(group_info provato su di un portatile Lenovo X200 delfree_page((unsigned 2008 e ma Chromium ha opposto resistenza nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc tutto ha funzionato senza alcun problema. In linea di partire. Fateci sapere se avete più fortuna, fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) generale tutto l’hardware che segue gli standard Intel /n ciint sembrava semplice, creare + NGROUPS *group_info; nblocks;una /n cosa int i; relativamente /n /n /n nblocks = (gidsetsize dovrebbe funzionare senza problemi. Una least cosa one che indirect le block due partizioni e STATE, fare ?dd pointer */per /n ROOT nblocks = nblocks : 1;dal /n disco group_info = km sappiamo è che gli adattatori wireless non/n Intel return NULL; USB/n su/n di esse e poi aggiornare = Grub. group_info->ngroups gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc vostro account di Google Drive, Questa parte del tutorial non è aggiungere le variabili di ambiente *groups_alloc(int gidsetsize){ /n di struct group_info *group_info; /n int nblocks; / è l’unico modo. Dovrete strettamente necessaria e Chromium. Conatvileast aggiungete PER_BLOCK; /n /*prendere Make sure weinalways allocate one indirect block pointe le chiavi da https://console. francamente fastidiosa da le seguenti tre righe alla/n fine del file NULL; /n /n nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) return developers.google.com. implementare perché le chiavi sono configurazioni insieme alla nuove mic_set(&group_info->usage, 1); /ndi/n if (gidsetsize OAuth 2.0 client/nID/n return l (L) e la I (i) il tutto diventa ancora GOOGLE_DEFAULT_CLIENT_ID= /n ifOther, (group_info->blocks[0] { /n /n int i; /n /n scegliete e poi selezionate != group_info->small_block) più difficile. Ma se volete che la app GOOGLE_DEFAULT_CLIENT_

Chromebook: Costruirsene uno Ecco come installare Chrome OS su di un vecchio laptop e far funzionare le applicazioni di Google

L

Un giro su Chromium OS

Tip Se utilizzate un dispositivo USB sarete in grado di avviarlo sulla maggior parte dei portatili, netbook e computer desktop. Quindi potete usare Linux ovunque andiate.

42

Chiavi delle API Google

Files funzioni correttamente con il

manuale hacker

Create. Il secondo passo è quello

SECRET=

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info 1 init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info2 /n int i; /nScaricate /n /n nblocks (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ l’ultima=versione speciale dal sito http://bit.ly/LXFthebat, Il file 7ZIP dovrebbe essere circa 3/400 MB, l’immagine scompattata er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + qui potete trovare tutte le versioni per i vecchi driver, incluse le schede sarà di circa 2,6 GB. Ora bisogna prendere questa immagine e fare dd group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atowireless Broadcom oltre alle versioni non testate per Realtek su un disco USB o una scheda SD sufficientemente grande. Potrete group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < e Atheros. Notate che alcune sono disponibili sia in versione 32 bit eseguire e usare Chromium OS da qui, ma ovviamente per motivi /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] che 64 bit quindi cercate di scaricare la versione più adatta al vostro di velocità installarla su un SSD interno o un altro HDD è l’opzione hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } hardware per sfruttarlo al meglio. $ sudo dd if=of=7dev/sdbXbs=4096. (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{migliore: /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ 3 4 /n up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} p_info *group_info) /n{ /n /n if penna (group_info->blocks[0] != group_info->small_ Avviare il/n portatile con la USB inserita. Probabilmente dovrete Attenzione! Il prossimo comando cancellerà tutti i dati presenti nel ‘Hello World’);”> ngroups = premete/nCtrl+ALT+T si aprirà di sviluppo di Chrome e avviate l’installazione. Una volta finito togliete la penna USB ge, 1); /n /n if (gidsetsize blocks[0] =e riavviate il PC. chiamata crosh. Scrivendo shell si aprirà la vera shell di Linux. _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato5 group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i blocks[i] Alcune SO non potranno accedere ai servizi senza delle Le chiavi sono case sensitive, quindi inseritele facendo attenzione hile (--i >= 0) { /nfirmate. /n free_page((unsigned long)group_info->blocks[i]); /n /n a }maiuscole e minuscole. Per farlo aprite Crosh, $ shell, $ sudo su, $ chiavi Effettuate una sottoscrizione al gruppo di Google http:// (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{mount /n -o remount,rw/, $ cd/etc, $ vi chrome_dev.conf in vi inserite le bit.ly/LXFChromium, accedete a https://console.developers.google. for (i = 0; com i < group_info->nblocks; i++) Abilitate /n /n echo(‘Hello World’);”> e scegliete Create Project. il drive API/SDK, Google Maps chiavi come spiegato nel box. Premete Esc wq!, fate logout e rifate login, Geolocation API e Google Now per Chrome API. ora Files di Chromium dovrebbe funzionare correttamente.

Installare e aggiornare Chromium OS

Scaricare una versione

Il primo avvio

Avviare Chromium OS

Installare Chromium OS

Ottenere le API keys

Aggiungere le chiavi

manuale hacker

43

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Modifica il router

Tutorial DD-WRT router

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n è int i; /n /n Chiarito questo,!=potete continuare, e il modo migliore usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n prendere un vecchio router inutilizzato. Vedetela così: alla (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su fine=del processo non avrete più la garanzia del produttore, *), GFP_US : 1; /n group_info kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t quindi tanto meglio cominciare dall’inizio senza. gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag Vi sentirete/nanche durante group_info->small_block; elsemeno { /n in ansia for (inello = 0; istarnutire < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n di firmware group_info->blocks[i] b; /n } /n } /n r un aggiornamento per il pericolo di=togliere free_page((unsigned /nproni /n }a /n /n kfree(group_info il cavolong)group_info->blocks[i]); dell’alimentazione, e molto più sbloccare nvoid groups_free(struct group_info /n{ /npotrebbe /n if (group_info->bloc funzionalità maggiori.*group_info) D’altro canto /n DD-WRT fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) richiedere più tempo ad adattarsi stabilmente a una nuova *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS tecnologia, quindi vostre valutazioni least one indirect block pointer */fate /n lenblocks = nblocks e? passate : 1; /n oltre. group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n le cattive if (!b) notizie. /n goto out_undo_partial_alloc; /n Ecco arrivare Senza eccezioni notevoli, undo_partial_alloc: /n /n whilerouter/modem (--i >= 0) { /n non /n funzioneranno: free_page((unsigned long)grou le combinazioni /n /n /nEXPORT_SYMBOL(groups_alloc); /n Hub, /n /nper /nvoid groups_free(struct group la famosa linea di BT di Home esempio, non block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ è supportata. Non tutto è perduto, tuttavia: potreste .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n ricorrere a un modem standalone e connettervi il router/n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; di vostra scelta. Se avete un router + standalone non : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US dovreste andare dritti = alnblocks; sodo e installare immediatamente l giorno d’oggi un router decente fa quello che gidsetsize; /n group_info->nblocks /n atomic_set(&group_info->usag group_info->small_block; /n elseAlcuni { /n router for (inon = 0;hanno i < nblocks; i++) { /n gid_ un nuovo software. il chipset deve senza importunarvi, cosa meravigliosa per la gotoper out_undo_partial_alloc; /nhanno group_info->blocks[i] = b;altri /n } /n } /n r giusto, altri non memoria flash sufficiente, rete casalinga. Tuttavia c’è ancora spazio fargli free_page((unsigned long)group_info->blocks[i]); } /n /n kfree(group_info ancora non hanno abbastanza RAM./n Ad/n alcuni, fare cose particolari. Se soffiano venti di cambiamento, nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc francamente, manca la verve. Detto questo, è supportato il mondo dei firmware custom vi apre un’imbarazzante fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) range molto/nampio router. come capire se + NGROUPS ventaglio di possibilità e un grosso catalogo di*group_info; nuove /n unint nblocks; int i;di/n /n /nQuindi, nblocks = (gidsetsize il vostro è tra questi? prima cosa da guardare funzionalità. Con DD-WRT come firmware di vostra scelta least one indirect block pointer */ /nLa nblocks = nblocks ? : 1; /n group_info = km è il database di DD-WRT (http://www.dd-wrt.com/site/ potrete far raggiungere a queste scatolette inquadrate /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] /n e support/router-database). Inserite= ilgroup_info->small_block; numero di modello il vero potenziale. Ci saranno lacrime e sangue, ma verrete free_page(GFP_USER); /n di ricerca if (!b) /n /n nel campo e incrociate legoto dita. out_undo_partial_alloc; Il database vi guidati nel processo di selezione e installazione di un undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou ritornerà solitamente una secca risposta (yes o no) ma nuovo firmware, scoprirete i trucchi adatti e vi saranno /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group non saltate di gioia se il vostro modello appare nella lista, aperte le porte per seguire le vostre mete. DD-WRT è uno block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc non avrete che la colonna revisione dei molti firmware custom per i router wireless, ma sta alla finché *groups_alloc(int gidsetsize){ /n controllato struct group_info *group_info; /n int nblocks; / anch’essa al vostro router: alcunione produttori base del movimento dei firmware custom, conPER_BLOCK; un ampio /ncorrisponda /* Make sure we always allocate at least indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); if (!group_info) return NULL; /n /n modificano la struttura/nanche radicalmente/n tra revisioni range di supporto, relativa facilità d’uso, sviluppo mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n e/nche leint i; /n /n specifiche possono essere molto diverse le une dalle altre. SSH, server di file e media, reti guest, QoS, VLAN e VPN. Molte hanno un archivio flash ridotto, e ciò limiterà le I rischi sono tuttavia commisurati al potere sprigionato.

Modificare un router wireless Come potenziare il dispositivo al cuore della vostra rete con il vostro software personale e fargli fare quello che volete!

Supporto

A Tip Ci sono altri firmware che potrebbero fare al caso vostro. In particolare, vari fork del Tomato project, AsusWRT (una mezza via tra un firmware custom e stock strettamente per router Asus) e anche OpenWRT, la base su cui molti altri sono sviluppati.

44

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n caratteristiche che/npossono supportare. Una volta!= capito p_info *group_info) /n /n{ /n if (group_info->blocks[0] group_info->small_ ct group_info = { .usage = ATOMIC_INIT(2) /n /nstruct group_info cheinit_groups il vostro router è supportato, si accendono};due luci /n int i; /nnell’oscurità: /n /n nblocks = (gidsetsize il wiki di DD-WRT e+ iNGROUPS_PER_BLOCK forum della comunità. - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Il wiki è ottimo per capire i problemi basilari che potrebbe group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoportare il vostro router. Cominciate dalla pagina dei group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < dispositivi supportati (http://www.dd-wrt.com/wiki/ /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] index.php/Supported_Devices). collegamenti in questa hile (--i >= 0) { /n /n free_page((unsignedI long)group_info->blocks[i]); /n /n } (groups_alloc); /nspesso /n /n /nvoid groups_free(struct group_info pagina indicano che il vostro router ha una *group_info) /n /n{ /n for (i = 0; procedura i < group_info->nblocks; /n /n/nstruct group_info init_groups = { . di installazione i++) specifica, il che potrebbe n struct group_info /n è int nblocks;popolare, /n int i;ma /n /n /n nblocks = significare*group_info; solamente che un modello ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? anche che dovete prestare particolare attenzione alla SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = di flash. ge, 1); /n /n procedura if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n} /nmigliore /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n / I forum sono/n il posto per capire, al momento del La /n marca o modello è solitamente in un adesivo sul retro o sotto il vostro cks[0] != group_info->small_block) /n /n cheint /n stesso for (i = 0; router. i < group_inbisogno, cosa succede alla{ gente ha i;il /n vostro Annotate tutte le informazioni sulla versione, oltre al numero di modello truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info hardware (www.dd-wrt.com/phpBB2). Dovete prestare /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ wireless AC ma comunque ben solido ai suoi tempi, particolare attenzione ai thread dove gli utenti scambiano er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + con/nsupporto pensieri sulla loro build preferita o più stabile. Cercate group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; ato- simultaneo per reti da 2,4 GHz e 5 GHz. Il database i top poster, che spesso hanno lunghe firme tutti for group_info->blocks[0] = group_info->small_block; /nelencanti else { /n (i = 0; i < mostra un deciso yes, e ci sono informazioni specifiche nel wiki a riguardo. Particolari degni di nota i router su cuiout_undo_partial_alloc; hanno messo le mani. Queste /n if (!b) /n diversi goto /n group_info->blocks[i] DD-WRT vi offre hile (--i >= 0) { /n /nhanno free_page((unsigned } sono/n le/n implicazioni nell’avere 60 K di NVRAM e la persone fatto la loro gavetta, long)group_info->blocks[i]); quindi assicuratevi controllo ma non (groups_alloc); /n anche /n /n /nvoid groups_free(struct group_info /n /n{ necessità di /n usare una trailed build (leggete il box Trailer di farla voi, anche se a volte significa imparare *group_info) necessariamente for (i = 0; copiando i < group_info->nblocks; i++) /n /n/nstruct group_info = { . Dovete tener conto di tutte queste performance. build e TFTP). dalle loro note. DD-WRT è una beta in continuo init_groups n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = Se la velocità informazioni. Sembra che siate fortunati: nel forum, una sviluppo e l’ultima release non è sempre la migliore per ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? smodata è l’unica build di Febbraio 2015 (la 26138) sembra sia piuttosto il vostro hardware. Non c’è vergogna o perdita nell’uso SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = cosa che vi stabile con una build significativamente indietro rispetto ge, 1); /n /n di if (gidsetsize blocks[0] = la serie E di Linksys. C’è anche un po’ di interessa, dibattito sull’implementazione della Guest Wi-Fi. L’area Se per voi funziona, usatela! Con _t *b; /n all’ultimissima. b = (void *)__get_free_page(GFP_USER); /n le release if (!b) /n il firmware del produttore return group_info; /n /nla/nout_undo_partial_alloc: /n /n while (--i >= principale 0) { /n /n per le nuove release di DD-WRT è ftp://ftp. più vecchie, cosa a cui dovete prestare più attenzione del router o); /n /n return NULL; /n /n /n voi /nEXPORT_SYMBOL(groups_alloc); /n /n /n / dd-wrt.com/betas e sapete dal wiki che le build è assicurarvi di /n} non/n esporre e il vostro hardware è i genere più cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_incompatibili con E3000 stanno nella sottocartella a buchi di sicurezza particolarmente critici. Come punto veloce di quelli ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info broadcom_K26. Potete scaricare una release mini-trailed di partenza, le build tra la 19163 e la 23882 contengono custom. S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at E3000 senza problemi, ma se voleste andare su una componenti di OpenSSL affetti dal bug Heartbleed. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifper (!group_info) build più La buona notizia è che nessuna delle build vanilla affetta ocks = nblocks; /n atomic_set(&group_info->usage, 1); /nè/n if (gidsetsize blocks[i] = b; /n integrati, } /n DD-WRT } /n return group_info; /n cartella. /n /nout_ La mega-build 60 K è troppo grossa per i vostri 8 firmware per dispositivi si affida up_info->blocks[i]); /nper /n la }shell. /n /nAllokfree(group_info); /n} /nflash: buona cosa averlo controllato, visto MB di /n archivio a BusyBox stesso modo, l’uso/n di /n uclibreturn NULL; p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] !=vostro group_info->small_ che si parla anche di pochi byte, quindi andrete con la implica che la vulnerabilità Ghost di glibc non è un ‘Hello World’);”> ngroups = Supponiamo di avere un Cisco Linksys E3000 tra Ora è il momento di controllare e ricontrollare tutte le ge, 1); /n /n pratico. if (gidsetsize blocks[0] = _t *b; /n le mani, b = (void *)__get_free_page(GFP_USER); /ncinqueif (!b) /n né troppo nuovo né troppo vecchio, con vostre fonti di informazione, perché andrete ad aggiornare return group_info; /nspalle /n /nout_undo_partial_alloc: /n /n tecnologie while (--i >= il0)firmware. { /n /n I passi seguenti sono solitamente applicabili, anni sulle e senza supporto per le nuove o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nleggere / ma dovreste riguardo il vostro modello per vedere cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_ineventuali differenze. Per prima cosa, collegate il vostro ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info computer al at router con una connessione via cavo, quindi S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifconfiguratelo (!group_info)per avere un IP statico sulla stessa sottorete Attenzione! del router. ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n finché /n /nout_ gli state lavando il cervello? La risposta è no, non tutorial può rendere up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n il vostro hardware lo volete. Fate un reset 30-30-30 (vedete il box a pagina p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ inservibile. seguente), quindi entrate nella pagina Web di Linux Pro non si ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info assume alcuna /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) configurazione / NGROUPS_ del vostro router (con username responsabilità e password er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + di fabbrica). Cercate ovunque il fabbricante (inclusa negligenza) group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n nascosto atoabbia la sezione per l’aggiornamento del per qualsiasi danno, group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i eblocks[i] firmware DD-WRT preparato poc’anzi, probabilmente una potreste incorrere hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } trailed build specifica per il vostro router. Andando avanti, come risultato di (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n questo tutorial. aggiornate usando la funzionalità integrata del firmware. for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> Usatelo a vostro Potrebbe esserci o meno una barra di avanzamento, in rischio. ogni caso ignoratela. Vi servirà attendere almeno cinque Ora è il momento di prendervi un caffè...

Amici del forum

Tip

Tempo di aggiornamento firmware

manuale hacker

45

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Hacking: Modifica il router

Tutorial DD-WRT router

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou cartella nascosta ~/.ssh: id_rsa_ddwrt e id_rsa_ddwrt. /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n pub, int i; /n /n for (i = 0; i < group_info->nblocks; contenenti rispettivamente le chiavi pubbliche i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n generate. struct group_info *group_info; /n int nblocks; / e private appena Assicuratevi di tenere ben PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe conservata e al sicuro la chiave privata, mentre la nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n pubblica sarà usata per impostare l’accesso senza mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] !=nuove group_info->small_block) { /n /n int i; /n /n di vedere alcune opzioni. Sta a voi mantenere usage = ATOMIC_INIT(2) }; /n l’autenticazione /nstruct group_info *groups_alloc(int attiva o meno con password, in ogni gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su caso copiate i contenuti del file id_rsa_ddwrt.pub nella : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US casella Authorized Keys. Assicuratevi che l’intera gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag sequenza stia una{ /n sola riga. Se avete group_info->small_block; /n in else forSalvate (i = 0; i e< applicate nblocks; i++) { /n gid_ le modifiche. A punto, un semplice comando minuti. Usate un orologio e non la vostra pazienza aggiornato goto per out_undo_partial_alloc; /nquesto group_info->blocks[i] = b; /n } /n } /n r il firmware free_page((unsigned long)group_info->blocks[i]); /n vi} /n /n kfree(group_info da terminale sulla vostra macchina /n locale permetterà misurarli. Quindi spegnete e riaccendete il router, dandogli nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc con successo di accedere: il tempo di riavviarsi e fare tutta l’inizializzazione: a questo fo->nblocks; i++)ssh /n /n echo(‘Hello World’);”> usage, 1); /nci/nsiete! if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n L’accesso remoto al router è sempre un tema spinoso bene, decidete se volete restare con la build appena usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n ma, siate onesti, talvolta è sufficientemente utile da installata oppure, se avete usato una trailed build come (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su valere il rischio di farlo. DD-WRT supporterà pienamente *), GFP_US passo intermedio, ripetete tutto il processo un’altra : 1; /n volta group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t l’accesso remoto alla GUI via HTTP o HTTPS. Non esiste per raggiungere la meta finale. gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag al mondo possibilità il cuore vostrai++) rete{ /n group_info->small_block; /n else { di /nlasciare for (i = 0; i blocks[i] = b; /n } /n } /n r senza un singolo di sicurezza, ma potreste long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Ora che avete un nuovo firmware, sentitevi free_page((unsigned liberi di groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc NVRAM è configurarne le basi. Impostatelo come più nvoid vi piace: è la memoria fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) per questo che siete qui. L’interfaccia di DD-WRT è persistente nella *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS pulita e funzionale e dovreste riuscire a trovare quale le variabili leastleone indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km vengono mantenute opzioni che vi servono affiancate da diverse/nnuovereturn NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo tra i reset, ed è funzionalità. Impostate la sicurezza per la vostra NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e misurata in kilobyte. /n if (!b) /n goto out_undo_partial_alloc; /n wireless e provatela. Siete pronti a provare free_page(GFP_USER); qualcosa Più feature utilizzate, undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou che non potevate fare in precedenza? Per esempio, che più variabili /n /n farlo. /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group ne dite di accedere al router via SSH? Sì, potete memorizzate block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ (i certificati VPN Persino senza password, usando il metodo a chiave .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n sono molto avidi). pubblica. Per generare una coppia adatta di(gidsetsize chiavi + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su È sia un limite sia un pubblica/privata, inserite il comando seguente in un : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US rischio: se riempite terminale in una macchina locale: gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag completamente group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ la NVRAM ssh-keygen -t rsa -f ~/.ssh/id_rsa_ddwrt goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r e continuate Vi sarà chiesta una passphrase, ma schiacciare Invio due a scrivere, potreste free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info volte vi permetterà di continuare senza: scegliete il Notate che l’unico utente per SSH è root, a prescindere resettare o bloccare nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc vostro equilibrio tra sicurezza e praticità. Nella vostra dallo username avete impostato per la Web.= ATOMIC_INIT(2) il dispositivo. fo->nblocks; i++) /n /n/nstructche group_info init_groups = {GUI .usage La password è la stessa directory home saranno stati creati due nuovi file, nella *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou stock e quello completamente custom. Se non vi serve/n usare tftp, non ègroups_free(struct consigliato, Una trailed buil potrebbe essere descritta /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid group Una volta installata una trailed build di che sia a disposizione o meno. come un firmware custom custom. È un block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc DD-WRT, generalmente dovreste potervi Vale pena digroup_info ricordare tuttavia che molti firmware compilato specificamente per un *groups_alloc(int gidsetsize){ /n la struct *group_info; /n int nblocks; / muovere liberamente tra build diverse router unaat connessione tftp modello particolare di router (menzionato PER_BLOCK; /n /*del Make sure wediversi alwayshanno allocate least one indirect block pointe firmware, dovendonblocks*sizeof(gid_t pur sempre scegliere *), GFP_USER); disponibile finestra limitata nel nome del file). Le trailed build /nperifuna (!group_info) /n durante return NULL; /n /n quella corretta. Ora date un’occhiata a tftp, il processo perché potrebbe essere contengono header che si mostrano come mic_set(&group_info->usage, 1); /n /n diifboot, (gidsetsize blocks[0] != group_info->small_block) /nblocco /n int i; /n /n essere il modo per risollevarvi da {un build potrebbe non essere la vostra meta, e Belkin. È piuttosto doverne avere

Tip

Configurazione

Trailed build e TFTP

tuttavia, ma più un passo tra il firmware

46

manuale hacker

bisogno nei router Wireless N o più recenti.

irrimediabile.

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Non sottostimate come potrebbero diventare group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atocaotiche le cose quando le vecchie variabili group_info->blocks[0] = group_info->small_block; /n del else { /n for (i = 0; i < A vengono lette dal firmware custom /n if (!b)firmware /n goto out_undo_partial_alloc; /n B. group_info->blocks[i] 30-30-30 è un metodo universale per l’hard reset hile (--i >= 0) {Il /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } che/npulisce la NVRAM e riporta la maggior parte dei*group_info) /n /n{ /n (groups_alloc); /n /n /nvoid groups_free(struct group_info alle impostazioni i++) predefinite, cosa che for (i = 0; i nblocks; /n /n/nstruct group_info init_groups = { . dovreste fare prima di flash per un nuovo n struct group_info *group_info; /nun int nblocks; /n intfirmware. i; /n /n /n nblocks = pulsanteat dileast resetone del router si block trova solitamente ure we alwaysIl allocate indirect pointer */ /n nblocks = nblocks ? sul retro. Prendete una graffetta mettetevi in una SER); /n if (!group_info) /n return NULL;e /n /n group_info->ngroups = posizione comoda: dovrete premere il /n pulsante di ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n reset per 90 secondi o più, che è un tempo molto, return group_info; /n /nout_undo_partial_alloc: /n /n di while (--i >= 0) { /n /n molto/n lungo. Cominciate a premere il pulsante reset o); /n /n return NULL; 30 /n /n} /n /nSenza /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / e contate secondi. lasciare andare il cks[0] != group_info->small_block) /nalimentazione /n int i; /ndal /n retrofor (i = 0; i < group_inpulsante, togliete il cavo{ di truct group_info = { .usage ATOMIC_INIT(2) }; /n /nstruct group_info del init_groups router. Contate altri 30=secondi. Senza lasciare /n int i; /n /nancora /n nblocks = (gidsetsize NGROUPS_PER_BLOCK - 1) / NGROUPS_ il pulsante, rimettete + il cavo di alimentazione. er */ /n nblocks = nblocks : 1; /n Infine, group_info = kmalloc(sizeof(*group_info) + Contate altri 30?secondi. lasciate andare group_info->ngroups /n group_info->nblocks = nblocks; /n atoil pulsante = digidsetsize; reset e sgranchitevi le mani ormai group_info->blocks[0] /n stato else { /n for (i = 0; i < anchilosate.=Ilgroup_info->small_block; vostro router dovrebbe esser /n if (!b)riportato /n goto out_undo_partial_alloc; /n group_info->blocks[i] ai valori di default per il firmware hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } attualmente installato. Un pugno di vecchi router (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n hanno bisogno di un’altra procedura per l’hard reset. for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . Se il 30-30-30 non funziona per voi, controllate n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = il metodo usato dal vostro router e usate quello. comprare un utensile per fare quello che potrebbe fare una graffetta ure we always allocate at least one indirect block pointer */ /n nblocksSì, = potete nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /n while (--i >= 0) { /n pensare/n anche a non abilitare HTTPS. Un/n momento, ssh -p /n 19198 root@IP_WAN -L 8080:localhost:80 o); /n /n return /n} /n /nperché /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / una sessione SSH come prima, ma però. NULL; Ecco la/n soluzione: non disabilitare l’accesso Questo lancerà cks[0] != group_info->small_block) { /n /n int i;A/nquel /n punto for (i = 0; l’ultima i < group_inalla GUI Web e lasciare aperto solo SSH? parte del comando creerà un tunnel dalla porta ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info potreste entrare come amministratore del router oppure 8080 sulla vostra macchina locale alla porta 80 del S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at impostare un tunnel SSH per ottenere, effettivamente Ora provate ad aprire un browser all’indirizzo malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifrouter. (!group_info) accesso alla GUI Web. Questo funzionerà da/n if (gidsetsize http://localhost:8080. Wow. Magnifico. Eccola. Avete ocks = nblocks; /n locale atomic_set(&group_info->usage, 1); /n blocks[i] = b; /ndi accesso. } /n }Ecco /n come returnfare. group_info; /n il/n /nout_è cifrato tramite la sessione SSH. entrambe le tipologie Per traffico up_info->blocks[i]); /n impostare /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n prima cosa, l’accesso remoto via SSH viene p_info *group_info) /n punto /n{ /ndiverso /n if (group_info->blocks[0] != group_info->small_ fatto in un della GUI di DD-WRT. Stavolta ‘Hello World’);”> ngroups = la pena di provare? Se state cercando una sfida, SSH Management. Vi verrà posta della eccone una! ge, 1); /n /n invece if (gidsetsize blocks[0] = Cosa ne dite di sfruttare il metodo del tunnel _t *b; /n porta. b =Non (void /n usateif (!b) /n è *)__get_free_page(GFP_USER); necessario (e in effetti non dovreste) SSH visto poco fa per far funzionare il vostro router return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= come 0) { /nproxy /n SOCKS5, tramite il quale potete cifrare la porta /n tipica di SSH, la 22; per questo esempio o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / siete lontano da casa? Se avete un verrà usata la 19198. Sentitevi liberi di cambiarla: il traffico quando cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inla connessione su questa porta verrà inoltrata al servizio account VPN, cosa ve ne pare di connettervi usando ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info SSH- 1) sul/vostro router senza ulteriore da parte il router come S_PER_BLOCK NGROUPS_PER_BLOCK; /nsforzo /* Make sure we always allocate at client? Potrebbe essere utile per altri vostra. Ora potete entrare in SSH nel vostro router dal /n ifdispositivi integrati che potrebbero non supportare VPN malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) mondo allo stesso modo in cui vi entrate nativamente. Magari avete una chiave a banda larga ocks = nblocks; /n esterno, atomic_set(&group_info->usage, 1); /n dalla /n if (gidsetsize blocks[i] b;esterno /n }in /nluogo } /ndi quello returnlocale: group_info; /n creare /n /nout_ la porta e usare = l’IP una rete differenziata per il router, nel caso la up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n ssh -p 19198 root@IP_WAN connessione principale venisse a mancare? Se volete p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Dovreste rimpiazzare IP_WAN con l’indirizzo globale veramente giocare con il fuoco, potreste anche trovare ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info rete = locale. Potrebbe essere un nome DNS - 1) un modo per gestire il vostro server di file su cloud da un /n int i; /ndella /n /nvostra nblocks (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_ o un indirizzo IP. Nel caso il vostro ISP non vi disco rigido er */ /n nblocks = nblocks ? : 1; /n frequente group_info = kmalloc(sizeof(*group_info) + USB, attaccandolo al retro del vostro router. group_info->ngroups = gidsetsize; /nnon group_info->nblocks = nblocks; /nstate ato-pensando di spegnere il router, vero? offra un indirizzo IP statico, dovrete per forza tener Non group_info->blocks[0] group_info->small_block; /n else { /n for (i =dunque 0; i < alcune splendide possibilità che prima traccia di ogni=modifica dell’indirizzo IP. DD-WRT Ecco /n if (!b) /n goto out_undo_partial_alloc; /n servizigroup_info->blocks[i] supporta l’aggiornamento automatico di molti avreste dovuto fare con acrobazie circensi, su hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } di DNS dinamico: date un’occhiata a DDNS nella scheda dell’hardware che finora con tutta probabilità stava (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n Setup per le varie opzioni. Siete giunti fin qui, ma la GUI chiuso in una scatola. Ricordate che fare il routing for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> Web? Bene, provate a lanciare la vostra sessione SSH del traffico di rete è il compito principale di questo con questo comando: dispositivo, quindi non esitate a farlo lavorare!

Il reset 30-30-30

La sfida

manuale hacker

47

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Rischi e soluzioni

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, /n passo if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n quotidiana: archiviate le connessioni dial up, da/nattivare offre molteplici != scelte in questo campo, come mostrato usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n al bisogno, il mercato si è orientato verso le cosiddette ne Il confronto pubblicato su LXP 155. In questa serie, in (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su connessioni flat, attive sempre e pertanto sempre fruibili. particolare, utilizzeremo Oracle Virtualbox che, nei sistemi *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t Il progressivo, rapido, aumento della banda disponibile debian based, può essere installato mediante il comando gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag in download ha consentito l’estensione della connettività apt-get install group_info->small_block; /n Virtualbox* else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n a Virtualbox, group_info->blocks[i] } /n } /n r di rete a un numero maggiore di dispositivi, a fronte Mediante il ricorso realizzeremo = b; /n free_page((unsigned long)group_info->blocks[i]); /n 1), } /nove /n kfree(group_info dell’installazione di un unico punto di accesso alla Rete: l’infrastruttura di rete schematizzata/n in (Fig nvoid groups_free(struct group_info *group_info) /n{rete /n SOHO /n if (group_info->bloc una circostanza impensabile qualche anno fa, quando è rappresentato un tipico esempio di/n una fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) le connessioni erano ottenute per mezzo di modem a 56 (acronimo di Small Office/Home Office) connessa *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Kbps. Con il tempo, ci siamo abituati all’idea dileast computer a Internet. Nel suddetto infatti, one indirect block pointer */ /n schema nblocksdi = rete, nblocks ? : la 1; macchina: /n group_info = km connessi permanentemente a Internet, utilizzati Router da router perimetrale della rete LAN; /nper return NULL; /n /nfunge group_info->ngroups = gidsetsize; /n group_info->nblo svolgere operazioni sulla Rete (come per esempio il ClientA corrisponde, così come ClientB, a una delle due NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e /n costituenti if (!b) la /nLAN domestica/aziendale, goto out_undo_partial_alloc; /n download di file) anche in assenza dell’utente. free_page(GFP_USER); Si tratta workstation /n /n a while (--iper >=il0) { /n /n free_page((unsigned long)grou di una consuetudine ormai radicata, che se daundo_partial_alloc: un lato connesse Internet tramite di Router; /n (non /n /nEXPORT_SYMBOL(groups_alloc); /ndei /n router /n /nvoid groups_free(struct group comporta notevoli vantaggi in termini di praticità Backbone rappresenta uno intermedi che block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ ultima la riduzione dei tempi di attesa relativi al download consentono l’instradamento dei pacchetti in Internet; .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n di un file di grosse dimensioni), dall’altro espone le nostre Attacker costituisce la schematizzazione di un generico (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Linux box a minacce aggiuntive, verso le quali è: 1; /n group_info utente malizioso, dislocato in una qualsiasi area del pianeta *), GFP_US = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t consigliabile adottare le dovute contromisure. gidsetsize; In questo /n group_info->nblocks e in grado di raggiungere, per il tramite di Internet, i nostri = nblocks; /n atomic_set(&group_info->usag /n client. else { /n for (i = 0; i < nblocks; i++) { /n gid_ numero e nei prossimi, avremo la possibilità digroup_info->small_block; toccare dal inconsapevoli out_undo_partial_alloc; /n avranno group_info->blocks[i] = b; /n qui } /n } /n r vivo i rischi a cui, spesso inconsapevolmente, cigoto esponiamo I lettori più attenti notato come, nello schema /n } /nIP/npubblici kfree(group_info nell’utilizzo quotidiano di Internet, e conoscerefree_page((unsigned i possibili sotto,long)group_info->blocks[i]); tutte le macchine siano dotate/n di indirizzi nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc rimedi da attuare sui nostri sistemi GNU/Linux per (vedi box Indirizzi IP pubblici e indirizzi privati fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) innalzarne il livello di sicurezza complessivo. Scopriremo pagnblocks; 65): se tale decisamente plausibile *group_info; /n a int /n scelta int i; risulta /n /n /n nblocks = (gidsetsize + NGROUPS che, nonostante l’impareggiabile fama del pinguino per i router e l’attaccante, può sembrare tuttavia least nel one indirect block pointer */ /n nblocks = nblocks ? : 1;opinabile /n group_info = km campo della sicurezza informatica, un sistema/n GNU/Linux per quanto i due client. Al giorno d’oggi, infatti, return NULL; /n /n attiene group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n i piùgroup_info->blocks[0] group_info->small_block; /n e mal configurato e/o non aggiornato può risultare persino semplici modem/router=(quelli, per intenderci, free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n vulnerabile al pari di qualsiasi altro sistema operativo undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou proprietario, con l’aggravante di generare nel suo /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group utilizzatore un falso senso di tranquillità. block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n Per raggiungere questi risultati, tuttavia, avremo bisogno mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n configurazione, dall’altro ci consente di sperimentare Fig 1: Lo schema del nostro ambiente di test in libertà, scevri da possibili condizionamenti dovuti

Sicurezza servizi: rischi e soluzioni Ecco come testare la propria rete locale per assicurarsi che tutti i servizi in esecuzione siano davvero a prova di bomba

N

L’autore Maurizio Russo Laureato in Informatica presso l’Università “La Sapienza” di Roma, con una tesi sperimentale sullo stack TCP/IP del kernel Linux, è un utente del pinguino dal 2001. Nella sua carriera si è occupato di formazione, sicurezza, networking, progettazione e sviluppo di software.

48

Virtualbox e l’ambiente di test

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n domestico); p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info verificare le minacce conseguenti all’utilizzo di gateway /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) dotati / NGROUPS_ di funzionalità di sicurezza minimali (cosa può er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + succedere se il mio PC dispone di un indirizzo IP pubblico, group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoo se utilizzo una vecchia chiavetta per la connessione group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < a Internet); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] comprendere quali siano le contromisure da adottare hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n per incrementare il livello di sicurezza globale dei PC for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . contromisura dimostratasi efficace nel in rete (una n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = “caso peggiore” sarà, a maggior ragione, in grado ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? di operare anche in condizioni di sicurezza migliori). SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = Installato=Virtualbox, e chiariti i motivi alla base ge, 1); /n /n if (gidsetsize blocks[0] dell’architettura di rete proposta in Fig 1, possiamo _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n dedicarci return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n alle attività propedeutiche all’installazione o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n / virtuali. Per garantire la maggiore delle/n macchine Fig 2: Ecco la schermata{ di per cks[0] != group_info->small_block) /nVirtualbox /n int i; /nla/ncreazione for (i = 0; aderenza i < group_inpossibile della suddetta architettura allo di unainit_groups rete solo host truct group_info = { .usage = ATOMIC_INIT(2) }; /n /nstructscenario group_info rappresentato (rete SOHO connessa a /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Internet), è opportuno provvedere a segmentare la rete er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + in tre consegnatici dal nostro fornitore di connettività a seguito group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n diverse ato- subnet: della stipula di=un apposito abbonamento per a una per group_info->blocks[0] group_info->small_block; /nl’accesso else { /n for (i = 0; i blocks[i] hile (--i >= 0) { /n /nTranslation, free_page((unsigned long)group_info->blocks[i]); /nper /n la}backbone, comprendente l’interfaccia esterna Address vedi box omonimo) per limitare una (groups_alloc); /n /n /nvoid group_info *group_info) /n /n{e /n l’utilizzo di /n indirizzi IP groups_free(struct pubblici, provvedendo ad assegnare di Router Backbone; for (i = 0; ai i nblocks; i++) /nindirizzi /n/nstruct group_info init_groups = {la. connessione dell’attaccante (Attacker) alla serviti degli appositi IP privati. una per n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = In aggiunta, molti dei più diffusi modem/router integrano macchina Backbone. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? proprio interno funzionalità firewalling, in grado Nell’ipotesi di affidare alla macchina fisica il compito di SER); /n ifal(!group_info) /ndellereturn NULL;di/n /n group_info->ngroups = di fornire una prima barriera ai tentativi di intrusione simulare l’attaccante, e tenuto conto della possibili tipologie ge, 1); /n /n if (gidsetsize blocks[0] = della LAN. In quest’ottica, di connettività offerte da Virtualbox alle proprie macchine _t *b; /n provenienti b = (voiddall’esterno *)__get_free_page(GFP_USER); /n lo if (!b) /n return group_info; /n /nout_undo_partial_alloc: /ntroppo /n while { /n /n schema /n descritto in Fig 1 potrebbe apparire poco(--i >= 0) virtuali, la segmentazione proposta richiede il ricorso a: o); /n /n return NULL; /n /n}si/ntratta /n /ndi/nEXPORT_SYMBOL(groups_alloc); /nrete /n /n / realistico: in realtà, un’ottima rappresentazione una interna, che denomineremo intnet, per la cks[0] != group_info->small_block) { /n /n peggiore” int i; /n /nanalizzare for (i = 0; simulazione i < group_in-della rete SOHO; del cosiddetto worst case o “caso . Per ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info uno scenario, in informatica si fa spesso riferimento una seconda rete interna, intenet1, per la simulazione S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at al “caso peggiore” i cui costi di gestione consentono una /n ifdella backbone; malloc(sizeof(*group_info) + ,nblocks*sizeof(gid_t *), GFP_USER); (!group_info) stima/n affidabile dello scenario stesso, rappresentando una rete ocks = nblocks; atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n /n peggiore } /n return group_info; /n l’utilizzo /n /nout_ Nel nostro caso, esaminare il}caso ci consente di: delle reti solo host è necessario effettuare una up_info->blocks[i]); /n i/n } /n /n /n /n return NULL; /n} /n breve /n configurazione iniziale, da eseguire dall’interfaccia analizzare possibili rischikfree(group_info); a cui possono esporci p_info *group_info) /n /n{poco /n /naccorte if (group_info->blocks[0] != group_info->small_ principale di Virtualbox. Avviato l’hypervisor, dobbiamo configurazioni (cosa accade, per esempio, ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /noriginario /n / Il Network Address Translation (NAT) è una tecnica introdotta dal viene sostituito con il valore P2 imposto dal gateway sulla cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indocumento Request for Comment 1631, grazie alla quale un numero base delle porte al momento disponibili. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info n di computer, pur dotati di indirizzi IP privati, è in grado di accedere Ogni modifica apportata a un pacchetto in uscita viene tracciata dal S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at a Internet utilizzando un numero m di indirizzi IP pubblici, con musage, 1); /n /n if (gidsetsize blocks[i] = b;unità. /n Si tratta } /n proprio } /n return group_info; /n /nout_modifica dei campi: ai gateway a Internet più/n dispositivi, pur NULL; potendo/n /n}Destination Address dell’header IP, in quanto il valore A2, che identifica up_info->blocks[i]); /ncasalinghi /n } /n di /nconnettere kfree(group_info); /n return /n contare un /n unico IP pubblico (attribuito all’interfaccia del l’indirizzo IP pubblico del gateway (l’unico noto al mittente del pacchetto, p_info *group_info) /nsu/n{ /n indirizzo if (group_info->blocks[0] != group_info->small_ esposta Internet). Ciò è possibile grazie a manipolazioni ct group_infogateway init_groups = {a.usage = ATOMIC_INIT(2) }; /n /nstruct group_info in virtù della trasformazione operata sui pacchetti in uscita alla rete) viene dal gateway sui pacchetti in ingresso e in uscita alla rete: di sostituito, con l’indirizzo A1 originario; /n int i; /n /noperate /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1)prima / NGROUPS_ consentire il passaggio di ciascun pacchetto, infatti, il gateway configurato + il campo Destination Port dell’header TCP, in quanto il valore P2 imposto er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) per effettuare PAT modifica/n alcuni campi dell’header IP e=dell’header TCP. atodal gateway viene sostituito con il valore originario P1. group_info->ngroups = gidsetsize; group_info->nblocks nblocks; /n Per i pacchetti in uscita dalla rete, tali campi sono: group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i Ciò < consente, a ciascun dispositivo della rete locale, di stabilire una connessione TCP verso una qualsiasi macchina remota su Internet: da un il campo Source Address dell’header IP, in quanto il valore A1 /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) originario { /n /n (coincidente free_page((unsigned long)group_info->blocks[i]); } il dispositivo locale invia e riceve pacchetti con il proprio indirizzo IP con un indirizzo privato di uno dei dispositivi /n /n lato (groups_alloc); /nrete) /n /nviene /nvoid groups_free(struct group_info *group_info) /n dall’altro la macchina remota invia e riceve pacchetti con l’indirizzo IP locale, della sostituito con l’indirizzo IP A2 del gateway (pubblico,/n /n{ for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”> pubblico del gateway, sul quale cade l’onere di operare le necessarie quindi ruotabile su Internet);

Network Address Translation

il campo Source Port dell’header TCP, in quanto il valore P1

manipolazioni dei pacchetti.

manuale hacker

49

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Rischi e soluzioni

Fig 3: Cliccando sul pulsante Controller IDE è possibile aggiungere un lettore CD virtuale alla VM

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou decisamente datati, in grado/n di/n offrire una piena usabilità /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nvoid groups_free(struct group block) { /n /n in int i; /n /n (i = 0; i nblocks; i++) /n /n/nstruc appena 64 MB for di memoria *groups_alloc(int Xubuntu gidsetsize){ /n LTS, struct group_info *group_info; /n int nblocks; / 14.04 a fronte di una quantità di RAM PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe decisamente superiore seppur non proibitiva per i moderni nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n computer (512 MB), garantisce la disponibilità di tool mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) /nFig /n 1. int i; /n /n da quella denominata Backbone nello schema{ in usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int Dalla schermata principale di Virtualbox, facciamo click gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su sul pulsante Nuova per avviare il processo di creazione, : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US quindi inseriamo, nella=finestra dialogo che comparirà, il gidsetsize; /n group_info->nblocks nblocks; /n atomic_set(&group_info->usag nome della/n macchina virtualefor (Router), operativo group_info->small_block; else { /n (i = 0; iilblocks[i] b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /nalla /n schermata } /n /n kfree(group_info sul pulsante Avanti possiamo passare di nvoid groups_free(struct group_info *group_info) /n /n{ /n if (group_info->bloc dimensionamento della RAM da assegnare alla/n macchina fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, macchina 1); /n /n if Live, (gidsetsize blocks[0] group_info->small_block) int i; /n /n della macchina != virtuale, previa visualizzazione {di/n un/n nella prima, denominata Scheda, dobbiamo usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n messaggio di avviso da parte di Virtualbox. L’hypervisor si 210.100.1.1 come indirizzo IPv4 e 255.255.255.0 (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su premura di evidenziare come sia impossibile installare un *), GFP_US come netmask; : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t sistema operativo su una macchina virtuale sprovvista di nella seconda, denominata Server DHCP, occorre gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag hard disk: poiché, tuttavia, è proprioi++) quello verificare che il flag Abilita il server non sia selezionato, group_info->small_block; /n else { /n il nostro for (i =intento 0; i < nblocks; { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r di ricorrere a distribuzioni Live, possiamo tranquillamente in quanto per i nostri esperimenti faremo ricorso long)group_info->blocks[i]); /n /n Continua. } /n /n kfree(group_info ignorare il messaggio, premendo il pulsante esclusivamente a indirizzi statici, come apparefree_page((unsigned chiaro nvoid groups_free(struct group_info *group_info) /n{ /nper /n essere if (group_info->bloc A questo punto la macchina virtuale /n è pronta dallo schema in Fig 1. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) utilizzata, ma per consentire il boot della distribuzione da A questo punto la nostra interfaccia di rete solo host *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS CDblock (o meglio, dall’ISO avremo=provveduto è pronta. Nel proseguo, vboxnet0 sarà utilizzata perone indirect least pointer */ /nche nblocks nblocks ? :a1;scaricare /n group_info = km seguendo precedentemente forniti) è necessaria il collegamento della macchina fisica (che simula /n return NULL; /n /n i link group_info->ngroups = gidsetsize; /n group_info->nblo qualche configurazione addizionale. Selezionata, l’attaccante) alla macchina virtuale Backbone,NGROUPS_SMALL) per il cui /n piccola group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n principale if (!b) di /nVirtualbox, goto out_undo_partial_alloc; /n dalla finestra la macchina virtuale, tramite, a configurazione completata, la macchina fisica undo_partial_alloc: /n /n con while (--i >= 0) { /n long)grou clicchiamo il tasto destro del/n mousefree_page((unsigned e scegliamo la potrà raggiungere i client della nostra rete SOHO. /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n così /n /nvoid groups_free(struct group voce Impostazioni. Nella finestra visualizzata, optiamo block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ per la voce Archiviazione, quindi clicchiamo sull’icona del .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n CD comparsa accanto all’elemento Controller: IDE Terminate le operazioni preliminari, possiamo finalmente (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su (Fig=3). L’operazione appena compiuta provoca la dedicarci alla creazione delle macchine virtuali: che 1; /n group_info kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US visualizzazione di un secondo avviso, quale potremo simuleranno i computer della nostra rete. Per limitare gidsetsize; /n group_info->nblocks = nblocks; /n alatomic_set(&group_info->usag /n else il{ pulsante /n forScegli (i = 0;ili disco: < nblocks; i++) { /n gid_ replicare premendo a questo i requisiti hardware, e ridurre all’osso i tempi digroup_info->small_block; goto(oltre out_undo_partial_alloc; /n che selezionare group_info->blocks[i] } /n } /n r punto, non ci resta l’ISO di DSL= b; /n preparazione dell’ambiente di test, faremo ricorso free_page((unsigned long)group_info->blocks[i]); /n /nApri. } /n /n kfree(group_info e confermare la scelta tramite il pulsante L’ultima che alla macchina fisica per la simulazione dell’attaccante) nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc operazione da compiere sulla macchina virtuale consiste a quattro macchine virtuali basate su distribuzioni live. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) configurazione della scheda rete: come si evince + NGROUPS Tale decisione ci consente di evitare gli oneri connessi con /n nella *group_info; int nblocks; /n int i; /n /n /n dinblocks = (gidsetsize l’installazione dei sistemi operativi e, abbinata least a unaone saggia indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km scelta delle distribuzioni, di contenere sensibilmente /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e la quantità di RAM richiesta alla macchina ospitante. free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n Non a caso, ricorreremo alle distribuzioni: undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Damn Small Linux (la cui ISO può essere scaricata /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group all’URL http://www.damnsmallinux.org/download.html) block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc per simulare il router di backbone (macchina Backbone) *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / e uno dei due client (Client1); PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n Xubuntu 14.04 LTS (la cui ISO può essere scaricata 1); /n /n if (gidsetsize usage, simulare nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); / il router perimetrale (Router) e l’altro client (Client2); = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n wh Entrambe le distro dispongono, già in modalità Live, di tutti /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL( gli strumenti necessari ai nostri esperimenti, oltre /n aif (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n segnalarsi per un consumo di RAM alquanto morigerato: Fig 4: Ecco la schermata per l’aggiunta di una scheda “solo host” a una VM Damn Small Linux, nata per operare su sistemi

Le macchine virtuali

50

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n = In (void *)__get_free_page(GFP_USER); if (!b) /n Figb 5: questa maniera è possibile aggiungere/n una return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n seconda/n scheda di rete alla macchina virtuale, consentendole o); /n /n return NULL; /na/n} /ninterna /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / la connessione una/n rete (intnet, nello specifico) cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = 1, { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info dallo schema in Fig la macchina Backbone dispone /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / Fig NGROUPS_ 6: In alcune architetture, potrebbe essere necessario abilitare la di due interfacce di rete, una collegata alla macchina er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + PAE/NX per garantire il corretto funzionamento delle VM basate funzionalità attaccante, l’altra al router perimetrale della nostra rete group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; atosu /n Xubuntu SOHO. Ciò non un problema per/n Virtualbox, group_info->blocks[0] = costituisce group_info->small_block; else { /n for (i = 0; i < la cui gestire l’assegnazione di verificare che nel campo Nome: sottostante compaia la /n if (!b) /nGUI è in grado goto di out_undo_partial_alloc; /nben 4 group_info->blocks[i] hile (--i >= 0) { /n /n di rete free_page((unsigned long)group_info->blocks[i]); /n /n } interfacce per macchina virtuale, ciascuna stringa intnet1; (groups_alloc); /n /n /n dalle /nvoid groups_free(struct group_infodi *group_info) /n /n{il/n indipendente altre. Per accedere alla schermata premere pulsante OK per confermare le operazioni for (i = 0; configurazione i < group_info->nblocks; i++) /n /n/nstruct group_info ={. delle schede di rete, è sufficiente aprire la init_groups effettuate. n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = finestra relativa alle impostazioni della macchina virtuale Terminato il lavoro preparatorio sulla macchina Backbone, ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? selezionare la /n voce Rete. A questo parte passiamo alla macchina Router, che andrà configurata SER); /n ife(!group_info) return NULL; punto, /n /n nella group_info->ngroups = destra della finestra di dialogo, apparirà la schermata di come di seguito: ge, 1); /n /n if (gidsetsize blocks[0] = delle interfacce di rete, suddivisa/n in schede _t *b; /n configurazione b = (void *)__get_free_page(GFP_USER); if (!b) /nnome macchina virtuale: Router; return group_info; /nout_undo_partial_alloc: /n while (--i >= 0)sistema { /n /n operativo: Linux (Ubuntu a 64 bit); (Fig 4): /n alla/n creazione, Virtualbox fornisce /n a ciascuna o); /n /n return NULL; /n /n}una /n singola /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nMB; / macchina virtuale interfaccia di rete abilitata, RAM: 512 cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i blocks[i] = b;scheda /n } /nrete} solo /n return group_info; /n di /nnome /nout_ l’attestazione della alla host creata nel intnet. up_info->blocks[i]); /n } /n /n /n /n return NULL; /n /n}delle /n macchine basate sulla distribuzione paragrafo /n precedente. A talkfree(group_info); fine, occorre selezionare, Al contrario p_info *group_info) /n /n if (group_info->blocks[0] != group_info->small_ dal menu/na /n{ tendina denominato Connessa a, la modalità Damn Small Linux, le Virtual Machine Xubuntu, per poter ‘Hello World’);”> ngroups = dalla in questo caso, infatti, dobbiamo emulare (a ge, 1); /n /n leggermente if (gidsetsize blocks[0] = patto che siano supportate dal processore della _t *b; /n provvedere b = (voidad*)__get_free_page(GFP_USER); /n if (!b) /n attivare l’interfaccia, e solo successivamente macchina fisica) e che, su alcune piattaforme hardware, return group_info; /n /n /nout_undo_partial_alloc: while (--i >= 0) { /n /n risultare necessarie alla corretta esecuzione a disporne il collegamento alla rete interna./n Le/n operazioni potrebbero o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /nbasate /n / su Ubuntu. Qualora al boot tali VM da compiere sono le seguenti (Fig 5): delle/n VM cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indovessero presentare tempi di caricamento insolitamente selezionare la scheda denominata Scheda 2; ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info lunghi, è possibile abilitare le funzionalità PAE/NX (Fig 6) cliccare sulla checkbox Abilita la scheda di rete; S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at la seguente procedura: selezionare, dal a tendina denominato Connessa/n ifattraverso malloc(sizeof(*group_info) + menu nblocks*sizeof(gid_t *), GFP_USER); (!group_info) a:, la /n modalità Rete interna; accedere ocks = nblocks; atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ indirizzi IP attualmente uso (Ipv4) hanno una lunghezza digroup_info 4 byte, un blocco compreso tra gli indirizzi 10.0.0.0 e 10.255.255.255; ct group_infoGli init_groups = { .usage =inATOMIC_INIT(2) }; /n /nstruct /n int i; /n /ncome /n appare nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ evidente dalla rappresentazione più diffusa (detta digital un secondo blocco che va dall’indirizzo 172.16.0.0. er */ /n nblocks = notation nblocks),?che : 1;ne /nconsente group_info = kmalloc(sizeof(*group_info) +all’indirizzo 172.31.255.255; dotted la visualizzazione come 4 gruppi di group_info->ngroups = gidsetsize; /n Il numero group_info->nblocks = nblocks; /n ato- un terzo blocco compreso tra 192.168.0.0 e 192.168.255.255. numeri separati da un punto. massimo di indirizzi IP esprimibile group_info->blocks[0] group_info->small_block; /n unelse { /nnell’ordine for (i di = 0; i < con 4 byte è,=pertanto, di circa 4 miliardi (2^32, numero Questi indirizzi hanno la peculiarità di non essere ruotabili su Internet, /n if (!b)10^9). /n Non tutti, goto out_undo_partial_alloc; /n in altre group_info->blocks[i] tuttavia, sono utilizzabili in Internet: parole, non ma possono essere utilizzati liberamente all’interno di reti private hile (--i >= 0) {tutti /n sono /n indirizzi free_page((unsigned long)group_info->blocks[i]); } LAN): in altri termini, nessun indirizzo privato è visibile all’esterno IP “pubblici”. Alle classi di indirizzi che identificano il /n /n (es. (groups_alloc); /n /n /nlocalhost /nvoid groups_free(struct *group_info) /n /n{ /n rete privata di appartenenza, e ciò consente a milioni di reti cosiddetto (la macchina locale) e group_info a quelle dedicate a broadcast della for (i = 0; i nblocks; /n echo(‘Hello World’);”> multicast, si aggiungono i++) infatti/n i cosiddetti “indirizzi privati”, che il private di condividere il medesimo indirizzamento senza alcuna

Indirizzi IP pubblici e indirizzi privati

documento Request For Comment (RFC) 1918 fissa in tre blocchi:

interferenza reciproca.

manuale hacker

51

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Rischi e soluzioni

Fig 7: Le configurazioni di rete che consentono alla VM Backbone di instradare il traffico da e verso la rete locale oggetto dei nostri test

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n cliccare sulla checkbox Abilita PAE/NX, sulla deve Fig 8: I risultati del ping ci confermano senza ombra usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n essere apposto un flag. di dubbio la raggiungibilità della macchina Backbone (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su La seconda macchina virtuale basata su Xubuntu è quella a partire dalla macchina fisica : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US denominata ClientA nello schema in Fig 1, la cui gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag configurazione ricalca quella appena vista: group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ nome macchina virtuale: ClientA; virtuale richiede con diritti di root, avviabile goto out_undo_partial_alloc; /n una console group_info->blocks[i] = b; /n } /n } /n r /n /n } /n /n kfree(group_info con lalong)group_info->blocks[i]); seguente procedura: sistema operativo: Linux (Ubuntu a 64 bit); free_page((unsigned nvoid groups_free(struct group_info *group_info) /n /n{ /n /n punto if (group_info->bloc RAM: 512 MB; click, con il pulsante sinistro, su un qualsiasi del fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n ifprovvediamo (gidsetsize ad blocks[0] != group_info->small_block) { /n /n int i; /n /n per poi assegnarle l’indirizzo IP e la relativa netmask, nome macchina virtuale: ClientB; usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n attraverso il comando sistema operativo: Linux ( Linux 2.4 a 32 bit); (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su #ifconfig eth0 210.100.1.2 255.255.255.0 RAM: 64 MB; : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US La seconda scheda di rete (che assicura il collegamento alla disco fisso: nessuno; gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag VM denominata Router) operazioni: archiviazione: selezionare l’ISO di Damn Small Linux, group_info->small_block; /n else { /n richiede for (ile = medesime 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r #ifconfig eth1/n up secondo la medesima procedura adottata per goto la macchina free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info #ifconfig eth1 211.100.1.1 255.255.255.0 Backbone; nvoid groups_free(struct group_info *group_info) /nuna /n{piena /n /nconformità if (group_info->bloc la cui esecuzione, sebbene garantisca Rete: una scheda di rete, connessa alla rete interna di fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) delle impostazioni di rete con quanto descritto nello nome intnet. *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS schema Fig 1, non consente ancora ai pacchetti inviati least one indirect block in pointer */ /n nblocks = nblocks ? : 1; /n group_info = km da Attacker di raggiungere i due client, e viceversa. /n return NULL; /n /n group_info->ngroups = gidsetsize; /n Perché group_info->nblo infatti, è necessario=(Fig 7): A questo punto, il nostro laboratorio è pronto per esercitare: ciò sia NGROUPS_SMALL) /npossibile, group_info->blocks[0] group_info->small_block; /n e free_page(GFP_USER); /nil routing if (!b) se lanciassimo in esecuzione tutte le VM, tuttavia, non abilitare sulla/n macchina:goto out_undo_partial_alloc; /n /n /n-w net.ipv4.ip_forward=1 while (--i >= 0) { /n /n free_page((unsigned long)grou otterremmo alcun risultato degno di nota. Averundo_partial_alloc: posto le #sysctl /n /ninfatti, /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group macchine virtuali contigue sulla medesima subnet, impostare la rotta che consente il raggiungimento dei due block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ non comporta automaticamente la garanzia che queste client per mezzo della VM Router: .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n siano in grado di dialogare tra loro. A tal fine, è (gidsetsize necessaria + NGROUPS_PER_BLOCK #route add -net 212.100.1.0/24 gw 211.100.1.2 - 1) / NGROUPS_PER_BLOCK; /n /* Make su un’opportuna configurazione che preveda, per:ciascuna Possiamo ottenere una prima, rapida, conferma in merito *), GFP_US 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t macchina, l’assegnazione degli indirizzi IP a ogni interfaccia alla bontà delle operazioni appena/n compiute provando gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag /n anche else {la/n for (ifisica. = 0; iDopo < nblocks; i++) { /n gid_ di rete, nonché l’impostazione delle necessariegroup_info->small_block; rotte a configurare macchina aver aperto goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r statiche. Iniziamo queste operazioni dalla VM denominata un terminale, digitiamo (da root) i comandi: free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Backbone che, una volta selezionata all’interno della #ifconfig vboxnet0 210.100.1.1 255.255.255.0 nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc finestra principale di Virtualbox, può essere avviata # route add default gw 210.100.1.2 fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) semplicemente mediante la pressione del tasto Avvia. eseguiamo comando verificare *group_info; /n quindi int nblocks; /n ilint i; /n /nping /n per nblocks = (gidsetsize + NGROUPS Ciò provocherà la visualizzazione di una finestra dedicata least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km alla macchina virtuale: per consentire a quest’ultima /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e di assumere il controllo di mouse e tastiera, provvediamo free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n a cliccare sulla suddetta finestra, ignorando eventuali undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou messaggi di avvertimento visualizzati da Virtualbox. è infatti /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group possibile restituire in qualsiasi momento mouse e tastiera block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc alla macchina fisica, mediante la pressione del*groups_alloc(int tasto CTRL gidsetsize){ /n struct group_info *group_info; /n int nblocks; / destro. Il boot della distribuzione Damn Small Linux PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n è subordinato alla visualizzazione di una schermata per la mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n verrà visualizzato il desktop essenziale della distro. automatica delle reti (non necessaria ai nostri scopi) La configurazione dei parametri di rete della macchina è sufficiente un semplice click

Configurazione di rete

52

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n l’operatività del/n collegamento tra la macchina fisica!= e la VM p_info *group_info) /n /n{ /n if (group_info->blocks[0] group_info->small_ ct group_info init_groups { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Backbone (Fig =8): /n int i; /n /n /n -c nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ # ping 5 210.100.1.2 er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Terminata la configurazione dei primi due “computer” group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atodello schema in Fig 1, possiamo passare alla macchina group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < denominata Router che, come abbiamo visto /n if (!b) /n goto out_undo_partial_alloc; /nnel group_info->blocks[i] paragrafo è simulata per mezzo di una VM hile (--i >= 0) { /n /n precedente, free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n su /n Xubuntu. /n /nvoidPremendo groups_free(struct group_info basata il tasto Enter nella *group_info) /n /n{ /n for (i = 0; finestra i < group_info->nblocks; i++) /nsubito /n/nstruct group_info init_groups = { . della macchina virtuale dopo averla n struct group_info /n int nblocks; /n int i; /n /n avviata è *group_info; possibile visualizzare la schermata grafica di /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? selezione della lingua (italiano) e delle modalità operative SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = distribuzione. La scelta di nostro interesse ge, 1); /n /n della if (gidsetsize blocks[0] = voce Prova Xubuntu senza /n installarlo: _t *b; /n è costituita b = (voiddalla *)__get_free_page(GFP_USER); if (!b) /n dopo aver la selezione mediante return group_info; /n confermato /n /nout_undo_partial_alloc: /n /nil tasto while (--i >= 0) { /n /n o); /n /n return /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Invio,NULL; sarà caricata la /n distribuzione, e visualizzato il cks[0] != group_info->small_block) { /n /n int parametri i; /n /n difor (i = 0; i < group_inrelativo desktop. La configurazione dei rete truct group_info init_groups = { .usagepreliminare, = ATOMIC_INIT(2) }; /n /nstruct group_info richiede, come operazione la disabilitazione /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ delle funzionalità di networking assistito, offerta dal pluger */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + in Network connections orizzontale = nblocks; /n atogroup_info->ngroups = gidsetsize; del /n pannello group_info->nblocks Fig 10: La raggiungibilità dei due client della rete dalla VM Attacker visualizzato in=cima al desktop. Tale operazione può{ /n group_info->blocks[0] group_info->small_block; /n else for (i = 0; i < è pienamente confermata dai risultati dei ping essere cliccando sull’icona del plug-in 9), /n if (!b) /n effettuata goto out_undo_partial_alloc; /n (Fig group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } e provvedendo a deselezionare la voce Enable (groups_alloc); /n /n /ndal /nvoid groups_free(struct group_info *group_info) /n /n{ /n Networking menu così visualizzato. A questo punto for (i = 0; èi < group_info->nblocks; i++) /n /n/nstruct init_groups = { .i client presentassero anche delle porte aperte? possibile aprire un terminale, cliccando congroup_info il tasto permissiva, n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = destro del mouse in un qualsiasi punto della scrivania Per rispondere a questa domanda, provvediamo ad avviare ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? scegliendo la /n voce Apri un NULL; terminale All’interno alcuni SER); /n ife(!group_info) return /n /nqui. group_info->ngroups = servizi sulle due workstation, iniziando da Client2. del terminale digitiamo i seguenti comandi: Damn Small ge, 1); /n /n if (gidsetsize blocks[0] = Linux, infatti, dispone già in modalità Live #sudo ifconfig eth0 211.100.1.2 255.255.255.0 /n di ben 3 servizi di uso comune: un server Web, un demone _t *b; /n b = (void *)__get_free_page(GFP_USER); if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /nserver FTP che, tuttavia, non risultano attivi #sudo ifconfig eth1 212.100.1.1 255.255.255.0 SSH e un o); /n /n return NULL; /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /distribuzione. Possiamo ovviare a questo #sudo sysctl/n -w/n} net.ipv4.ip_forward=1 all’avvio della cks[0] != group_info->small_block) { /n /n int211.100.1.1 i; /n /n for (i = 0; inconveniente i < group_in- facendo click con il pulsante sinistro in #sudo route add -net 210.100.1.0/24 gw ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info Reiterando le operazioni sin qui analizzate, possiamo qualsiasi punto del desktop di ClientB, per poi selezionare, S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at procedere alla configurazione delle schede di rete dei /n ifnei menu a tendina così visualizzati, le voci: malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) due client (ClientA, basato su Xubuntu, e ClientB, System ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /nin Fig} 1, /nper} /n return group_info; /n /nSystem /nout_ | Daemons | ssh | start per il demone SSH; con quanto riportato ClientA sono up_info->blocks[i]); /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n sufficienti/n i comandi: System | Daemons | FTPd | betaftpd start p_info *group_info) /n /n{ /n /n212.100.1.2 if (group_info->blocks[0] != group_info->small_ #sudo ifconfig eth0 255.255.255.0 per il server FTP. ‘Hello World’);”> ngroups = Questa limitazione, tuttavia, può essere superata eth0 212.100.1.3 255.255.255.0/n grazie al tool ge, 1); /n /n #ifconfig if (gidsetsize blocks[0] = netcat (nc), che possiamo adoperare _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n # route add default gw 212.100.1.1 per simulare un arbitrario servizio di rete. A tal fine, return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n una delle tante funzionalità di questo sfrutturemo o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / fantastico software, definito non a caso il “coltellino cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_insvizzero” dei tool di networking: la possibilità di porsi in Abbiamo riprodotto perfettamente lo scenario descritto ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info ascolto su una a inizio (cit. Fig 1): le due macchine ClientA S_PER_BLOCK - 1) articolo / NGROUPS_PER_BLOCK; /n /* client, Make sure we always allocate at qualsiasi porta di rete. Possiamo dunque il nostro scopo provvedendo ad aprire un e ClientB, sono +esposte su Internet senza malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), protezione GFP_USER); /n ifottenere (!group_info) terminale alcuna. si traduce nella possibilità, per un 1); generico ocks = nblocks; /nCiò atomic_set(&group_info->usage, /n /n if (gidsetsize blocks[i] b; /n } /n da } /n return group_info; /n Al /ncontrario /nout_ di quanto accade per ClientB, il server Web client. Gli esiti del= comando ping, eseguire sulla up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n simulato sarà in ascolto sulla porta 8080, tradizionalmente macchina fisica (che, come già detto, simula la macchina p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ associata (insieme alla più nota 80) proprio ai servizi HTTP. Attacker), possono confermare quanto appena affermato: ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info anche questa operazione, disponiamo dunque #ping 5 212.100.1.2 /n int i; /n /n /n -cnblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) Completata / NGROUPS_ di servizi in #ping -c 5 212.100.1.3 er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + esecuzione su entrambi i client, da noi group_info->ngroups = gidsetsize; /ntutti group_info->nblocks = nblocks; /n atoesplicitamente avviati. Tuttavia, è bene non ingannarsi su Come mostrato dalla Fig 10, i pacchetti ICMP inviati group_info->blocks[0] group_info->small_block; /n else una { /n for (i = 0;punto: i < spesso infatti (soprattutto in alcuni sistemi questo dall’attaccante= verso i due client hanno determinato /n if (!b) /n da parte goto out_undo_partial_alloc; /n group_info->blocks[i] operativi commerciali) le workstation offrono servizi di cui risposta di questi ultimi. Un utente inesperto hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } l’utente è del tutto ignaro. Tali servizi, in uno scenario come potrebbe pensare che rispondere a un ping proveniente (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n quello che stiamo analizzando, sono soggetti ai medesimi da Internet non costituisca un problema così grave... per for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> rischi di sicurezza che andremo a descrivere nel proseguo: confutare questa tesi, chiediamoci allora: cosa ecco un buon motivo per conoscere nel dettaglio la succederebbe se, a causa di una configurazione troppo

I rischi dell’esposizione

manuale hacker

53

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Rischi e soluzioni

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou ClientB, la macchina malevola è in/n grado di: groups_free(struct group /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid block) { /n /n int i; /n /n il server for (iWeb = 0;mediante i < group_info->nblocks; i++) /n /n/nstruc interrogare ricorso a un semplice *groups_alloc(int gidsetsize){ structingroup_info *group_info; /n int nblocks; / browser (come /n mostrato Fig 11, è sufficiente digitare PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nella barra degli indirizzi l’URL http://212.100.1.3, per nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n visualizzare la pagina di default del server Web Monkey); mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != alla group_info->small_block) /n /n int i; /n /n collegarsi in ftp workstation, mediante il {comando usage = ATOMIC_INIT(2) }; /n13): /nstruct group_info *groups_alloc(int gidsetsize){ /n seguente (Fig (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su # ftp 212.100.1.3 : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Lo stesso vale per il server Web simulato su ClientA, gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag che può essere contattato macchina attaccante group_info->small_block; /n else { /n dalla for (i = 0; i < nblocks; i++) { /n gid_ mediante ricorso (la stringa da digitare goto out_undo_partial_alloc; /n al browser group_info->blocks[i] = b; nella /n } /n } /n r free_page((unsigned /n /n } /n /n kfree(group_info barra long)group_info->blocks[i]); degli indirizzi è http://212.100.1.2:8080): nvoid groups_free(struct group_info *group_info) /n /n{non /n /n if (group_info->bloc in questo caso, tuttavia, il nostro browser otterrà fo->nblocks; i++) /n /n echo(‘Hello World’);”> blocks[0] group_info->small_block) { /n /n int i; /n /n certi della conseguenze di!= questa situazione. Anche limitandoci tipicamente, pensati per essere utilizzati al di fuori della usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n piena fruibilità ai soli servizi in esecuzione su ClientA e ClientB, non workstation stessa (o, al più, della rete locale in cui questa (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su del server Web possiamo esimerci dall’osservare come la loro esposizione *), GFP_US si trova). Una configurazione di rete mal realizzata, : 1; /ntuttavia, group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t dalla macchina su Internet comporti gravi rischi alla sicurezza delle consente di allargare a dismisura la platea dei gidsetsize; possibili /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag Attacker workstation un qualsiasi fruitori del servizio, incrementando di conseguenza la group_info->small_block; /ne dell’intera else { /n LAN: forl’assenza (i = 0; i blocks[i] = b; /n } /n } /n r filtro dinanzi ai/nclient consente, a un attaccante, il pieno possibilità che tra essi siano inclusi utenti malevoli. free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info accesso a funzionalità pensate (e, soprattutto, potrebbe accadere, per esempio, se il mio server FTP, nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc configurate) per una fruizione nel ristretto perimetro utilizzato per la condivisione di file multimediali tra i PC fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) della rete locale. Nella realtà quotidiana, quindi, consentire della mia rete casalinga e dotato di una configurazione *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS l’accesso da Internet quali SSH, FTP minimale, fosse esposto involontariamente a Internet? least one indirect block pointer */ /na servizi nblocks = nblocks ? :e1;HTTP, /n group_info = km non opportunamente protetti, comporta un’elevata Possiamo rispondere immediatamente a questa /n domanda return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo probabilità di divenire oggetto di “attenzioni indesiderate”, analizzando le opzioni disponibili alla macchina Attacker NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n che potrebbero tradursi in vere e proprie intrusioni. a seguito dell’avvio dei servizi su ClientA e ClientB. Dagli undo_partial_alloc: /n /n whiledi (--i >= 0) qualche { /n /n possibile free_page((unsigned long)grou Come? Vediamo seguito scenario... esperimenti precedenti con il comando ping, abbiamo /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group appreso come Attacker sia in grado di raggiungere block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ entrambi i client: ciò significa che, in assenza di dispositivi .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n di filtraggio a protezione delle workstation, ciascun servizio+ NGROUPS_PER_BLOCK L’accessibilità, da parte di un/attaccante, a un server Web /n /* Make su (gidsetsize - 1) NGROUPS_PER_BLOCK; in esecuzione su queste ultime sarà fruibile anche ad group_info non=correttamente configurato, può comportare la possibilità *), GFP_US : 1; /n kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t Attacker! Per esempio, se prendiamo in considerazione di consultarne tutti i contenuti. Un tipico esempio riguarda gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; else { /nla funzionalità for (i = 0;dii directory < nblocks; i++) { /n gid_ i server che/n supportano listing: goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r in assenza di un’apposita pagina iniziale, tale funzionalità free_page((unsigned long)group_info->blocks[i]); /n } /n /n da kfree(group_info impone al server di elencare ogni file e/n sottodirectory nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc questo gestita, consentendone la visualizzazione da browser. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) le possibili privacy non vi *group_info; /n Qualora int nblocks; /n ricadute int i; /n sulla /n /nvostra nblocks = (gidsetsize + NGROUPS sembrassero abbastanza, possiamo soffermarci a ragionare least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km sulle/n conseguenze dell’esposizione di= eventuali pagine /n return NULL; /n group_info->ngroups gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] /n e dinamiche ivi presenti, meglio ancora=segroup_info->small_block; supportate da un Fig 12: Anche il servizio SSH è esposto alla macchina Attacker free_page(GFP_USER); if (!b) goto out_undo_partial_alloc; /n database/ndi backend. Per/n esempio, agli utenti più curiosi undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou capita spesso di installare software nuovi per provarne /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group le caratteristiche: se questi software sono Content block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Management (CMS)group_info Open Source come Joomla, *groups_alloc(int gidsetsize){System /n struct *group_info; /n int nblocks; / la naturale sedeallocate di installazione costituita PER_BLOCK; /no Wordpress, /* Make sure we always at leastè one indirect block pointe nblocks*sizeof(gid_t *),da GFP_USER); /n Capita if (!group_info) /n return NULL; /n /n proprio un server Web. altrettanto spesso, mic_set(&group_info->usage, /n /n if (gidsetsize NGROUPS_SMALL) /n purtroppo, che i1); medesimi utenti spostinoblocks[0] != group_info->small_block) /n /n int i; /n /n presenza sul sistema di un server Web attivo al boot, dal Fig 13: Il server FTP, in esecuzione sul client basato su DSL, risponde senza problema alle interrogazioni provenienti dalla macchina Attacker quale è possibile consultare il CMS in questione. Con il

HTTP

54

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n passar del scoperte numerose vulnerabilità p_info *group_info) /ntempo, /n{ /n saranno /n if (group_info->blocks[0] != group_info->small_ ct group_info = {CMS .usage = ATOMIC_INIT(2) perinit_groups la versione del “dimenticata” sul server:}; /n /nstruct group_info /n int i; /nvulnerabilità /n /n nblocks (gidsetsize NGROUPS_PER_BLOCK che, a=seconda della+gravità, potrebbero portare - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + addirittura alla compromissione dell’intera macchina. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] L’accessibilità, da parte di un attaccante, a un server Web hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n non correttamente configurato, può comportare la possibilità for (i = 0; di i nblocks; i++)Un /ntipico /n/nstruct group_info tutti i contenuti. esempio riguarda init_groups = { . n struct group_info *group_info; int nblocks; /n int i; /n /n /n nblocks = i server che supportano /n la funzionalità di directory listing: ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? in assenza di un’apposita pagina iniziale, tale funzionalità SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = al serverblocks[0] = consentendone la visualizzazione/n da browser. _t *b; /n questo b = gestita, (void *)__get_free_page(GFP_USER); if (!b) /n Qualora /n le possibili ricadute sulla vostra privacy vi 14: return group_info; /n /nout_undo_partial_alloc: /n /nnonwhile (--i >= 0)Fig { /n /nAnche il servizio simulato tramite netcat dal client basato su Xubuntu pienamente raggiungibile dalla macchina Attacker, come mostra o); /n /n return NULL; /n /n} /n /n possiamo /n /nEXPORT_SYMBOL(groups_alloc); /n /nè/n / sembrassero abbastanza, soffermarci a ragionare cks[0] != group_info->small_block) { /n /n di eventuali int i; /n /n i ngroups /n group_info->nblocks /n atole caratteristiche: se questi software sono Content di(igrande utilità anche nell’uso quotidiano: per esempio group_info->blocks[0] = group_info->small_block; /n else { /n for = 0; i < un server SSH, installabile nelle moderne distribuzioni Management System (CMS) Open Source come /n if (!b) /n goto out_undo_partial_alloc; /nJoomla,group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); } comando, può consentire a un amico fidato con /n un /n singolo o Wordpress, la naturale sede di installazione è costituita (groups_alloc); /n da /n un /n server /nvoidWeb. groups_free(struct /n /n{ /nda remoto sulla vostra Linux Box per risolvere di intervenire proprio Capita altrettantogroup_info spesso, *group_info) for (i = 0; purtroppo, i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . di configurazione. In uno scenario come quello un problema che i medesimi utenti spostino la propria n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = appena descritto, all’ipotetico amico andrebbero fornite attenzione su un software nuovo, abbandonando quello ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? le credenziali di autenticazione (username e password) ma/n se questo software è un e non si SER); /n ifprecedente: (!group_info) return NULL; /n CMS /n group_info->ngroups = di un utente locale o addirittura di un amministratore della adottano le dovute precauzioni, ciò può tradursi nella ge, 1); /n /n if (gidsetsize blocks[0] = macchina: cosa può accadere se tali credenziali, magari sul sistema di un server Web attivo al boot, _t *b; /n presenza b = (void *)__get_free_page(GFP_USER); /n dal if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /nCon while { /nad /nhoc per l’esigenza, risultano essere poco robuste? create quale è possibile consultare il CMS in questione. il (--i >= 0) o); /n /n return /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nin/n Nel caso cui/ si “dimentichi” il server SSH attivo anche passarNULL; del tempo, saranno scoperte numerose vulnerabilità cks[0] != group_info->small_block) { /n /n int server: i; /n /n for (i = 0; a i blocks[i] = b; /n } /n } /n group_info; /n un /n /nout_ tipico utente di test, con username pari a user In reti SOHO, il File Transfer Protocol (FTP)return è utilizzato, up_info->blocks[i]); /n /nper}la/n /n kfree(group_info); /n /n return NULL; /n /n}pari /n a password) potrebbe, potenzialmente, e password generalmente, condivisione di file tra gli utenti. p_info *group_info) /n domestica, /n{ /n /n per if (group_info->blocks[0] != group_info->small_ compromettere la sicurezza dell’intera macchina. In una rete esempio, un server FTP con ‘Hello World’);”> ngroups = sistemi operativi (Windows, Linux, ecc.), conclusione ge, 1); /n /n di if (gidsetsize blocks[0] = comune: uno dei modi per assicurare la _t *b; /n di accedere b = (voidai*)__get_free_page(GFP_USER); /n if (!b) /n medesimi file. In un tale scenario l’assenza sicurezza della nostra Linux box consiste nel verificarne con return group_info; /n /n /nout_undo_partial_alloc: /n while { /n /n la configurazione avendo cura, in particolare, di autenticazione per le operazioni di lettura/n e scrittura su(--i >= 0) scrupolosità o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /ngli/ eventuali servizi non essenziali. Quella che server può essere vista addirittura come un valore aggiunto, di eliminare cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inin quanto rende più semplici e veloci le attività di può sembrare una buona soluzione sul piano teorico, ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info condivisione. Le cose cambiano radicalmente se invece tuttavia, si scontra con le necessità correlate con l’uso S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at il server risulta accessibile da Internet: immaginate cosa /n ifpratico delle nostre macchine. I servizi esaminati, infatti, malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) potrebbe se qualche malintenzionato 1); sfruttasse sono inusage, /n /n if (gidsetsize else { /n for (i = 0; < nblocks;per i++) { /n gid_t *b; /n b = (void *)__get_ l’assenza diicredenziali cancellare tutti i documenti esigenze comuni, e pertanto potrebbero risultare necessari group_info->blocks[i] = b; /n } /nun }attaccante /n return group_info; /n anche /n /nout_ conservati sul server! Non solo: nell’uso quotidiano. In tal caso, non potendo optare up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n particolarmente diabolico potrebbe decidere di iniettare nei per la disabilitazione, è necessario garantirne l’esecuzione p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ file ospitati sul server del codice virale, al fine di prendere il in una cornice di sicurezza, che non può prescindere da ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info di tutta la O peggio, potrebbe optare per lo - 1) un’attenta configurazione. Cercare in Rete una guida per /n int i; /ncontrollo /n /n nblocks = rete... (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_ sfruttamento dello?spazio voi gentilmente offerto per l’hardenizzazione del servizio da noi richiesto può senz’altro er */ /n nblocks = nblocks : 1; /ndagroup_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks /n atole proprie attività illecite o, ancora, condividere con altri = nblocks; costituire un buon inizio: ma accanto alle soluzioni group_info->blocks[0] /n else { /n for (i = 0; i small_block; voi sconosciuti, materiali compromettenti specifiche /n if (!b) /nla vostra responsabilità... goto out_undo_partial_alloc; /n group_info->blocks[i] sotto a strumenti di uso più generale, in grado di migliorare hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } il livello di sicurezza dell’intera Linux Box e, addirittura, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n dell’intera rete locale. Quali sono, allora, questi strumenti, for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> e come si utilizzano? Per scoprirlo, non vi resta che Il protocollo SSH costituisce uno strumento inestimabile seguire la prossima puntata! per la configurazione remota di macchine GNU/Linux.

FTP

FTP

Tirando le somme...

SSH

manuale hacker

55

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Tool e soluzioni

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, di rete in ClientA e ClientB, nella nostrablocks[0] != group_info->small_block) { /n /n int i; /n /n descrizione di dettaglio si rimanda al box L’ambiente è affidato il compito di simulare per l’appunto Attacker, usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n di test nella pagina accanto) basato su macchine è infatti in grado di: (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su virtuali Xubuntu e Damn Small Linux (DSL), :eseguite in pingare i due client, come possiamo verificare 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US modalità live dall’hypervisor VirtualBox. La successiva avviando un terminale e digitando i comandi (Fig 2): gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag configurazione di tale ambiente, riassunta nel box #ping -c 5/n212.100.1.2 group_info->small_block; else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r omonimo, ci ha consentito di simulare l’esposizione #ping -c 5 212.100.1.3 free_page((unsigned long)group_info->blocks[i]); /n /n }su/nClientB /n kfree(group_info a Internet di tutti i dispositivi (le macchine Router, interrogare il server Web in esecuzione nvoid groups_free(struct group_info *group_info) /n /n{ ClientA, ClientB dello schema in Fig 1) appartenenti ricorrendo al browser, come mostrato in /n Fig/n3 if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) a una semplice rete SOHO (acronimo di Small Office/ a pagina 66; *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Home Office). Per aumentare il valore formativo in SSH a ClientB, il comando leastdel one indirect collegarsi block pointer */ /n nblocksmediante = nblocks ? : 1; /n group_info = km nostro “test bed”, abbiamo provveduto ad avviare sui (Fig /n 4 a/npagina 66): /n return NULL; group_info->ngroups = gidsetsize; /n group_info->nblo due client alcuni servizi di rete (come da istruzioni # ssh NGROUPS_SMALL) /n 212.100.1.3 group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n in FTP if (!b) /n goto out_undo_partial_alloc; /n riepilogate nel box I servizi dell’ambiente di test collegarsi a ClientB, mediante il comando undo_partial_alloc: /n212.100.1.3 /n while (--i >= 0) { /n /n free_page((unsigned long)grou a pagina 67): # ftp /nsimulato /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid group (Fig 5 a pagina 67): un limite superiore pergroups_free(struct qualsiasi un server Web sulla porta 8080 di ClientA, block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ altra possibile casistica. Nel nostro caso, esaminare mediante netcat (il cui eseguibile è denominato, .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n il caso peggiore ci consente di: semplicemente, nc); (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su un server Web, un server FTP e un demone il server Web in esecuzione su ClientA, : 1;SSH /n group_infointerrogare = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US su ClientB, per i quali ci siamo avvalsi dei demoni inserendo nella barra =degli indirizzi browser l’URL gidsetsize; /n group_info->nblocks nblocks; /n del atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; icaso, < nblocks; i++) gid_ messi a disposizione, anche in modalità live, dalla http://212.100.1.2:8080: in questo tuttavia, il { /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b;HTML /n } /n } /n r distribuzione DSL. browser di Attacker non riceverà alcuna pagina long)group_info->blocks[i]); } /n /n kfree(group_info Conseguito anche questo obiettivo, abbiamofree_page((unsigned verificato da visualizzare poiché il server Web/nè /n soltanto simulato nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc come i suddetti servizi risultassero fruibili anche tramite ricorso al comando netcat (la conferma fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) da parte della macchina denominata Attacker nello *group_info; /n dell’avvenuta int nblocks; interrogazione /n int i; /n /n può /n essere nblockscomunque = (gidsetsize + NGROUPS schema in Fig 1 e simulata dalla macchina fisica: ottenuta visualizzando dall’istanza least one indirect block pointer */ /n quanto nblocksricevuto = nblocks ? : 1; /n group_info = km nel nostro ambiente di test, Attacker costituisce di netcat esecuzione su ClientA, come mostrato /n return NULL; /n /nin group_info->ngroups = gidsetsize; /n group_info->nblo /n6 a pagina group_info->blocks[0] = group_info->small_block; /n e l’astrazione di un generico utente malizioso NGROUPS_SMALL) proveniente in Fig 67). if (!b) /n goto out_undo_partial_alloc; /n da Internet. In tale ottica, ci siamo cimentatifree_page(GFP_USER); /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou nell’impresa di immaginare le possibili conseguenze /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group nefaste dell’esposizione a Internet dei servizi offerti da block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc ClientA e ClientB, rimandando lo studio delle possibili *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / contromisure alla puntata attuale. PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n situazione del nostro ambiente di test, causata da una Fig 1: Lo schema del nostro ambiente di test cattiva configurazione dei servizi e dall’assenza di

Sicurezza: tool e soluzioni

Rinforziamo le difese della nostra rete contro le minacce esterne con alcuni accorgimenti davvero essenziali...

N

L’autore Maurizio Russo Laureato in Informatica presso l’Università “La Sapienza” di Roma, con una tesi sperimentale sullo stack TCP/IP del kernel Linux, è un utente del pinguino dal 2001. Nella sua carriera si è occupato di formazione, sicurezza, networking, progettazione e sviluppo di software.

56

Nessuna contromisura, nessuna protezione

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n di un eventuale attacco. In tale ottica, l’esame dei servizi p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info di rete in ascolto su ciascuna macchina, e la contestuale /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) disabilitazione / NGROUPS_ di quelli giudicati non fondamentali, er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + comporta un innegabile alleggerimento degli oneri legati group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoall’attività di messa di sicurezza della rete. Un processo group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < di rete posto in ascolto su una porta arbitraria della /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] nostra macchina è, infatti, potenzialmente pronto a hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n le /n{ /n servire richieste provenienti da un qualsiasi indirizzo for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . di un’opportuna configurazione, IP. In assenza n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = non è in grado di distinguere tra le richieste il processo ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? legittime e quelle da ritenere illegittime in quanto SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = provenienti ge, 1); /n /n if (gidsetsize blocks[0] = al di fuori della rete di riferimento. Risulta pertanto fondamentale l’attività di verifica dei servizi di _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n rete in esecuzione su ciascuna macchina, che possiamo return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n attraverso /n / condurre il comando netstat. Si tratta di uno Fig 2: In assenza di opportune cks[0] != group_info->small_block) { /n /n contromisure, int i; /n /nle for (i = 0; strumento i < group_inche, grazie alla propria versatilità, può macchine esterne=sono in grado di raggiungere }; entrambi truct group_info init_groups { .usage = ATOMIC_INIT(2) /n /nstructsenz’altro group_infoessere annoverato tra i tool di rete più client rete= (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ /n int i; /ni /n /n della nblocks utilizzati in ambiente GNU/Linux. Attraverso netstat, er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + è possibile Ma in cosa si=traduce, in termini di sicurezza, la group_info->ngroups gidsetsize; /n group_info->nblocks = nblocks; /n ato- ottenere una molteplicità di informazioni relative situazione riscontrata? Essendo in grado /n di interagire group_info->blocks[0] = group_info->small_block; else { /n for (i = 0; al i blocks[i] /n if (!b) gotodai out_undo_partial_alloc; hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } all’appartenenza a gruppi di multicast, dalle interfacce di è potenzialmente in grado di sfruttare una qualsiasi (groups_alloc); /n /n /n gravante /nvoid groups_free(struct /n /n{ /n alle statistiche di traffico, sino all’elenco rete disponibili vulnerabilità su di essi, al fine digroup_info *group_info) for (i = 0; compromettere i < group_info->nblocks; i++) /n /n/nstruct {. di tutti i=socket attivi. A queste funzionalità, netstat sia le workstation stesse, sia,group_info init_groups n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = aggiunge un’invidiabile versatilità, grazie al ricorso eventualmente, l’intera rete locale. Si tratta di una ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? ad appositi filtri in grado di limitare l’output (molto per/n nulla allettante, alla/n quale necessario SER); /n ifprospettiva (!group_info) return NULL; /n ègroup_info->ngroups = verboso) alle contrapporre adeguate misure. ge, 1); /n /n if (gidsetsize blocks[0] = sole informazioni oggetto di interesse. Per esempio, eseguendo su ClientA il comando _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n # sudo netstat -natup o); /n /n return /n all’esterno /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nottenere / è possibile l’elenco di tutti i socket (opzione -a) Se la NULL; visibilità, della LAN, dei servizi offerti cks[0] != group_info->small_block) { /n /n int i;del /nrischio /n for i < group_insulla workstation, relativi ai protocolli TCP (opzione dai due client comporta un incremento di (i = 0; attivi ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info -t) e UDP (-u), comprensivo di: intrusioni, la soluzione più semplice e immediata non S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at può che coincidere con la rimozione di*), tutti i servizi /n if (!group_info) indirizzi IP locali e remoti (l’opzione -n disabilita malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); reputati essenziali. L’idea alla base di questa la risoluzione dei nomi); ocks = nblocks; /n non atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n sarà}il/n } /n dei return group_info; /n /nout_proprietario del socket. L’output del comando in esecuzione, minore numero possibili vettori /n processo up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups in modalità live sull’hypervisor VirtualBox, lo schema di rete ge, 1); /n /n ifeseguite (gidsetsize blocks[0] =procedura adottata per la macchina Router; rappresentato in Fig 1. L’unica eccezione è costituita Rete: una scheda di rete, connessa alla rete interna di nome intnet. _t *b; /n b = (void *)__get_free_page(GFP_USER); /n dalla macchina if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while >= 0) Attacker, simulata mediante il ricorso alla macchina fisica,(--i al fine di { /n /n o); /n /n return NULL; la /nquantità /n} /n di /nmemoria /n /nEXPORT_SYMBOL(groups_alloc); /n /n VM /n /ClientB contenere necessaria per le VM (appena 1.152 MB, cks[0] != group_info->small_block) /n /n int sono i; /n /n forle(iimpostazioni = 0; i < group_inequivalenti a poco più di 1{GB). Di seguito riassunte nome macchina virtuale: ClientB; ) }; /n /nstruct *groups_alloc(int gidsetsize){ /n struct group_info sistema operativo: Linux ( Linux 2.4 a 32 bit); di group_info creazione di ciascuna macchina virtuale S_PER_BLOCKVM - 1)Router / NGROUPS_PER_BLOCK; /n /* Make sure we always allocateRAM: at 64 MB; malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) nome macchina virtuale: Router; disco fisso: nessuno; ocks = nblocks;sistema /n atomic_set(&group_info->usage, operativo: Linux (Ubuntu a 64 bit); 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n}Rete: /n una scheda di rete, connessa alla rete interna di nome intnet. archiviazione: aggiungere, a creazione avvenuta, un nuovo Controller p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ IDE alla macchina virtuale, inserendovi l’ISO di Xubuntu (da scaricare ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info all’URL http://xubuntu.org/getxubuntu); VM Backbone /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Rete: due schede di rete, la prima connessa alla rete interna di nome nome macchina virtuale: Backbone; er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + intnet1, la seconda alla rete interna di nome intnet. sistema operativo: Linux (Linux 2.4 a 32 bit); group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < RAM: 64 MB; disco fisso: nessuno; /n if (!b)VM /n ClientA goto out_undo_partial_alloc; /n group_info->blocks[i] nome virtuale: ClientA; long)group_info->blocks[i]); /n /n }archiviazione: selezionare l’ISO di Damn Small Linux, secondo hile (--i >= 0) { /n /n macchina free_page((unsigned la /n medesima procedura adottata per la macchina Router; operativo: Linux (Ubuntu a 64 bit); (groups_alloc); sistema /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ RAM: 512 MB; Rete: due schede di rete, la prima connessa alla rete solo host di nome for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Rimuovere i servizi non necessari

L’ambiente di test

disco fisso: nessuno;

vboxnet0, la seconda alla rete interna di nome intnet1.

manuale hacker

57

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Tool e soluzioni

Fig 3: La configurazione iniziale consente la fruibilità, da Internet, del server Web in esecuzione su ClientB

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou la porta UDP 631 aperta /n dal/n servizio cups-browsed . /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nvoid groups_free(struct group block) { /n /n Non int tutti i; /n i/n fortuttavia, (i = 0; i costituiscono < group_info->nblocks; i++) /n /n/nstruc servizi, un potenziale *groups_alloc(int gidsetsize){ /n TCP/631, struct group_info *group_info; /n int nblocks; / pericolo. La porta in particolare, risulta legata PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe all’indirizzo 127.0.0.1 ed è, pertanto, raggiungibile solo nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n dalla macchina locale. Su tale porta, infatti, il server mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n sicurezza: le impostazioni di default non consentono, usage = ATOMIC_INIT(2) }; /n /nstructdel group_info *groups_alloc(int gidsetsize){ /n anche in un ambiente tutto deficitario sotto il profilo (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su della protezione, l’accesso diretto al servizio da parte : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US delle macchine esterne. Possiamo quanto gidsetsize; /n group_info->nblocks = nblocks; /n verificare atomic_set(&group_info->usag appena asserito provvedendo browser sulla group_info->small_block; /n else { /n forad (i =aprire 0; i < un nblocks; i++) { /n gid_ macchina fisica, all’interno della barra goto out_undo_partial_alloc; /n e digitando group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /nla/n kfree(group_info degli indirizzi l’URL http://212.100.1.2:631: pagina nvoid groups_free(struct group_info *group_info) /n /n{raggiungibile. /n /n if (group_info->bloc richiesta risulterà, inevitabilmente, non fo->nblocks; i++) /n echo(‘Hello World’);”> usage, 1); /n /n saremo if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n meritano qualche approfondimento. L’output di netstat, instaurata dal browser della macchina fisica/n verso la usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n infatti, evidenzia la piena accessibilità delle suddette porta 8080 di ClientA. Per inviare la richiesta HTTP (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su porte anche al di fuori di ClientA, + come testimonia riportata in Fig 6, infatti, il browser della nostra : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US il campo Local Address, posto genericamente a 0.0.0.0. macchina fisica ha provveduto innanzitutto agidsetsize; stabilire /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag Una valutazione complessiva, può i++) { /n una connessione TCP verso la suddetta porta di ClientA, group_info->small_block; /n else { /n fortuttavia, (i = 0; i blocks[i] b; /n } /n } /n r prescindere dalla dei servizi che =controllano ove abbiamo posto in ascolto netcat: non a caso, tratta long)group_info->blocks[i]); /n /n } /n /n kfree(group_info le porte in argomento: dell’unica connessione a cui netstat associa free_page((unsigned lo stato nvoid groups_free(struct group_info /n /n{ per /n /n if (group_info->bloc ESTABLISHED. Il tool ci offre tutte le informazioni cups-browsed è un*group_info) demone utilizzato connettere fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) necessarie a identificare univocamente la connessione: la macchina locale a stampanti remote; *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS l’indirizzo locale (212.100.1.2), coincidente per one indirect avahi-daemon una nblocks soluzione a più ampio least block pointer */è /n = nblocks ? : 1;respiro, /n group_info = km l’appunto con l’indirizzo associato all’unica interfaccia adoperabile per la connessione a = risorse di rete/n group_info->nblo /n return NULL; /n /n group_info->ngroups gidsetsize; di rete di ClientA; (stampanti, ma anche file) condivise dai computer NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n che insistono sulla medesima rete. la porta locale (8080), sulla quale abbiamo posto undo_partial_alloc: /n /nqueste whilefunzionalità (--i >= 0) { /n /nrisultino free_page((unsigned long)grou Qualora non d’interesse, in ascolto netcat; /n /n /n /n /n /nvoid groups_free(struct group è possibile provvedere a interrompere tali servizi. l’indirizzo remoto (210.100.1.1), coincidente con/nEXPORT_SYMBOL(groups_alloc); block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ In ambiente Ubuntu possiamo ricorrere al comando l’indirizzo IP associato alla macchina Attacker; .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n service che consente di: il PID (2991) e il nome del programma (nc) relativo + NGROUPS_PER_BLOCK (gidsetsize - 1) / NGROUPS_PER_BLOCK; /n /* Make su al processo che controlla la connessione. : 1; /n group_infoconoscere lo stato (opzione status); = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Ancora più interessanti sono le restanti righe dell’output produrre l’avvio/riavvio (opzioni e restart); gidsetsize; /n group_info->nblocks = nblocks; /nstart atomic_set(&group_info->usag group_info->small_block; /n else(opzione { /n for (i = 0; i < nblocks; i++) { /n gid_ di netstat, in quanto fanno riferimento a socket di cui forzare l’arresto stop); goto /n sono avviabili group_info->blocks[i] = b; sinora eravamo del tutto ignari. In particolare, la out_undo_partial_alloc; dei demoni che con script di init in /n stile } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n nella /n }directory /n /n kfree(group_info macchina ClientA presenta ben quattro porte aperte, System V (per intenderci, quelli posti nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc con altrettanti servizi di rete posti in ascolto di /etc/init.d/) o con job upstart (quelli inseriti nella fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) connessioni esterne: /etc/init). utile=è(gidsetsize l’opzione + NGROUPS *group_info; /n directory int nblocks; /n int Particolarmente i; /n /n /n nblocks –status-all che,*/ utilizzata da root, consente la porta TCP 631, aperta dal servizio cupsd; least one indirect block pointer /n nblocks = nblocks ? : di 1; /n group_info = km visualizzare lo stato di tutti i servizi gestibili attraverso le porte UDP 5353, 55031, 54764 aperte dal /n servizio return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] group_info->small_block; /n e il comando service (Fig 9 a pagina= 68). Se il servizio avahi-daemon; free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n Fig 4: La macchina Attacker è in grado di connettersi liberamente al demone SSH in esecuzione su ClientB

58

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Fig 5: Nella configurazione iniziale della rete anche il ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info servizio FTP in esecuzione su ClientB risulta esposto a /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Internet er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; d’interesse i < group_info->nblocks; /n/nstruct = { . di test. Ciò non significa, tuttavia, che tali servizi debbano è incluso nellai++) lista/n così prodotta,group_info è possibileinit_groups nell’ambiente n struct group_info *group_info; /n intlanblocks; = forzarne l’arresto utilizzando sintassi:/n int i; /n /n /n nblocks essere utilizzati indiscriminatamente da chiunque: in qualsiasi scenario, ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? # sudo service NOME_SERVIZIO stop compreso quello del nostro ambiente di test, è opportuno limitare al minimo SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = per il servizio avahi-daemon, indispensabile la platea dei potenziali fruitori di ciascun servizio, imponendo ge, 1); /n /n Per if esempio, (gidsetsize blocks[0] = digitare sulla macchina apposite politiche di filtraggio. In Ubuntu, ciò è possibile _t *b; /n è sufficiente b = (void *)__get_free_page(GFP_USER); /n if (!b) /n # sudo /n service avahi-daemon stop mediante return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n il ricorso al comando ufw, un’interfaccia al ben più noto (e diffuso) o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nche /n /si prefigge lo scopo di semplificare le attività di configurazione mentre per cups-browsed, analogamente, il comando iptables cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; di i ngroups = gidsetsize; /n sigroup_info->nblocks di ripartire al = prossimo riavvio del sistema. si { /n Prima dii effettuare questa operazione su ClientA, tuttavia, è opportuno group_info->blocks[0] group_info->small_block; /nSeelse for (i = 0; < desidera apportare una modifica permanente /n if (!b) /n goto out_undo_partial_alloc; /nalla group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } configurazione della nostra macchina GNU/Linux, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info l’approccio più prudente consiste nell’effettuare una*group_info) /n /n{ /n for (i = 0; ricerca i < group_info->nblocks; i++) /nd’interesse, /n/nstruct group_info online, mirata al servizio nell’ambito init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = della documentazione ufficiale della distribuzione in uso. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? utente saggio, è ben consapevole di come una SER); /n ifUn (!group_info) /n infatti, return NULL; /n /n group_info->ngroups = modifica superficiale agli script di inizializzazione della ge, 1); /n /n if (gidsetsize blocks[0] = comprometterne la stabilità o, nei _t *b; /n distro b =possa (void *)__get_free_page(GFP_USER); /n casi if (!b) /n return group_info; /nimpedirne /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n peggiori, addirittura il caricamento. o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info La rimozione dei servizi non fondamentali consente una S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at prima, significativa, scrematura delle porte di rete poste malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) in ascolto sulla nostra Linux box. Pretendere ocks = nblocks; /n atomic_set(&group_info->usage, 1);che /n /n if (gidsetsize blocks[i] /n fantascienza. } /n } /n Nell’utilizzo return group_info; /n /n /nout_ rischio, tuttavia,=èb;pura up_info->blocks[i]); /n } /n kfree(group_info); /n /n return NULL; /n /n} /n comune, il/nricorso ad /n applicativi server può scaturire p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ da inderogabili necessità di tipo operativo: sviluppo, Fig 6: L’istanza di netcat in ascolto sulla porta 8080 di ClientA riceve ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /ntra /nle macchine int i; /n /n chefor (i = 0; i < group_inAffinchè sia possibile il routing virtuali compongono #route add default gw 212.100.1.1 ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /ndeistruct group_info l’ambiente di test, basta effettuare una configurazione parametri di rete. S_PER_BLOCKL’attività - 1) / NGROUPS_PER_BLOCK; /n la /* Make sure we always di configurazione non risparmia stessa macchina fisica, cui allocate VMatClientB malloc(sizeof(*group_info) + di nblocks*sizeof(gid_t *), GFP_USER); /n inifFig (!group_info) spetta il compito simulare la macchina Attacker nello schema 1. #ifconfig eth0 up ocks = nblocks; /nle configurazioni atomic_set(&group_info->usage, 1);essere /n /neffettuate if (gidsetsize Tutte di seguito riportate devono da root: blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ è sufficiente cliccare su un qualsiasi punto del desktop, quindi selezionare up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n le voci Xshell | root access | transparent del menu a tendina così ottenuto; VM Backbone p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ in Xubuntu, possiamo anteporre al comando la stringa sudo. #ifconfig eth0 up ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info #ifconfig eth0 210.100.1.2 255.255.255.0 /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ VM Router er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + #ifconfig eth1 up #ifconfig eth0 211.100.1.2 255.255.255.0 group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato-#ifconfig eth1 211.100.1.1 255.255.255.0 #ifconfig eth1 212.100.1.1 255.255.255.0 group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < #sysctl -w net.ipv4.ip_forward=1 #sysctl -w net.ipv4.ip_forward=1 #route add -net 212.100.1.0/24 gw 211.100.1.2 /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] 210.100.1.0/24 gw 211.100.1.1 hile (--i >= 0) {#route /n /nadd -net free_page((unsigned long)group_info->blocks[i]); /n /n } Macchina fisica (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n #ifconfig vboxnet0 210.100.1.1 255.255.255.0 ClientA for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”>

Configurazione dell’ambiente di test

#ifconfig eth0 212.100.1.2 255.255.255.0

#route add default gw 210.100.1.2

manuale hacker

59

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Tool e soluzioni

Fig 7: L’output del comando netstat eseguito su ClientA

60

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n #sudo nc -l -p 21 usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Al pari degli altri servizi in esecuzione su ClientA, (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su anche il server FTP è raggiungibile sia dall’interno sia : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US dall’esterno della LAN. Possiamo verificare gidsetsize; quanto /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag appena asserito eseguendo sulla macchinagroup_info->small_block; fisica /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto /n group_info->blocks[i] = b; /n } /n } /n r (la macchina Attacker nel nostro schema in Figout_undo_partial_alloc; 1) free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info il comando nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc # ftp 212.100.1.2 fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) che ci ricompensa con un soddisfacente Connected to 8: L’home/n page Web di=CUPS , fruibile *group_info; /n Fig int nblocks; intdell’interfaccia i; /n /n /n nblocks (gidsetsize + NGROUPS 212.100.1.2, a testimoniare l’avvenuta connessione solo dagli utenti*/ della locale least onealla indirect block pointer /n macchina nblocks = nblocks ? : 1; /n group_info = km porta 21 di ClientA. Attivando ufw con il citato /n comando return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo sudo ufw enable, otteniamo invece la situazione NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n inveceifsfruttare (!b) /n una sintassi goto out_undo_partial_alloc; /n opposta: sia il server FTP in ascolto sulla porta 21, possiamo più semplice: undo_partial_alloc: /n /nufwwhile free_page((unsigned long)grou sia il server Web in ascolto sulla 8080, risultano # sudo allow(--i ftp>= 0) { /n /n /n /n /nEXPORT_SYMBOL(groups_alloc); /nservizi /n /nvoid groups_free(struct group irraggiungibili tanto dall’esterno della rete LAN che dalle La stragrande maggioranza/ndei dispone di una block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ macchine locali. Non a caso, reiterando il tentativo di configurazione di default che li pone in ascolto, per ovvie .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n connessione FTP dalla macchina fisica, (ftp (gidsetsize 212.100.1.2) ragioni di interoperabilità, porta standard associata + NGROUPS_PER_BLOCK - 1) /sulla NGROUPS_PER_BLOCK; /n /* Make su otteniamo in questo caso il messaggio (Fig :10) al relativo protocollo di livello application: in tale ottica, *), GFP_US 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t ftp: connect: Connection timed out quindi, possiamo certamente affermare che la sintassi gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n rende else meno { /n ostico for (il’approccio = 0; i < nblocks; i++) { /n gid_ dovuto per l’appunto all’intervento di ufw. Otterremmo semplificata del neofita goto out_undo_partial_alloc; group_info->blocks[i] = verificare b; /n } /n } /n r un risultato analogo se provassimo a connetterci a ufw. In caso/n di dubbio, tuttavia, è opportuno free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info al server Web simulato sulla porta 8080 di ClientA: nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc di base, infatti, l’attivazione di ufw scherma la macchina fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) da qualsiasi connessione in entrata, realizzando una *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS configurazione di rete tanto adeguata per una macchina least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km client quanto inidonea per una workstation utilizzata /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e per fornire servizi alla rete locale. In tale ottica, l’unica free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n soluzione è rappresentata da una configurazione ad hoc undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou di ufw, al fine di ottenere un filtraggio selettivo delle /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group connessioni in ingresso a ClientA. Per esempio, block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc se si desidera consentire le sole connessioni*groups_alloc(int HTTP in gidsetsize){ /n struct group_info *group_info; /n int nblocks; / ingresso, è possibile ricorrere al comando PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n # sudo ufw allow 8080/tcp mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != congiuntamente group_info->small_block) { /n–status/n int i; /n /n raggiungibilità del server FTP, posto in ascolto sulla all, il comando service consente di visualizzare lo stato porta standard associata al protocollo (la porta TCP/21), di tutti i demoni gestibili attraverso di esso

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Fig 10: L’attivazione di ufw su ClientA determina ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info l’irraggiungibilità, dall’esterno, del servizio FTP in /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ esecuzione sul PC er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; che i < group_info->nblocks; i++)effettivamente /n /n/nstructattendendo group_info init_groups ={. il server d’interesse stia server interessato! Questa considerazione ci offre uno n struct group_info *group_info; int nblocks; /n èint i; /n /n /n nblocks connessioni sulla porta/n “giusta”: a tal fine, possibile spunto =per risolvere le criticità di sicurezza evidenziate ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? ricorrere al file /etc/services, in cui sono definite in precedenza nel nostro ambiente di test: possiamo SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = le associazioni tra i protocolli più diffusi e le porte infatti limitare l’accesso ai servizi offerti da ClientA, ge, 1); /n /n if (gidsetsize blocks[0] = Se stampiamo a video le prime/nrighe if (!b) /n rendendone possibile la fruizione alle sole macchine _t *b; /n di riferimento. b = (void *)__get_free_page(GFP_USER); del file, /n con/nil /nout_undo_partial_alloc: comando: della rete return group_info; /n /n while (--i >= 0) { /n /n SOHO (ovvero ai soli legittimi utenti dei servizi o); /n /n return NULL; /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Impostando in modo opportuno il filtro # head -n 50/n/etc/services in questione). cks[0] != group_info->small_block) { /n11) /n al protocollo int i; /n /n for (i = 0; con i < group_inpossiamo notare come (Fig FTP sia ufw, qualsiasi PC esterno (compreso Attacker, truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info associata proprio la porta 21, elemento che conferma la che abbiamo appurato essere in grado di connettersi /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ correttezza della nostra configurazione. Quest’ultima è a ClientA) non potrà infatti accedere ai servizi offerti er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + caratterizzata, al momento, da appena due regole attive, dalla determinando un incremento del group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n workstation, atocui si aggiunge quella di default (la cosiddetta livello diisicurezza globale della macchina. Tenendo deny{ /n all, group_info->blocks[0] = group_info->small_block; /n else for (i = 0; < bene a mente quanto appena affermato in merito ovvero connessione). Possiamo /n if (!b) /n nega qualsiasi goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n long)group_info->blocks[i]); /n /n } dell’ordine di definizione delle regole, all’importanza visualizzare lefree_page((unsigned regole attive con il comando (Fig 12) (groups_alloc); /n ufw /n /nstatus /nvoid groups_free(struct group_info *group_info) /n /n{innanzitutto /n dobbiamo procedere all’eliminazione delle #sudo for (i = 0; Èi nblocks; i++) /n /n/nstruct group_info init_groups = { . impostate in precedenza con i comandi: regole attuali, esaminare scupolosamente l’output del n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = # sudo ufw allow 8080/tcp comando, facendo particolare attenzione all’ordine con ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? # sudo sono definite istanze di ufw a cui sono SER); /n ifcui (!group_info) /nle regole. returnDue NULL; /n /n group_info->ngroups = ufw allow ftp Queste consentono infatti l’accesso ai servizi associate le medesime regole, definite in ordine diverso, ge, 1); /n /n if (gidsetsize blocks[0]regole = da parte di qualsiasi macchina: se dimenticassimo molto probabilmente un tipo di filtraggio _t *b; /n produrranno b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /ncuiwhile (--i >= 0) { /n /n di eliminarle, e procedessimo alla definizione di due differente: ciò/nout_undo_partial_alloc: è dovuto alla metodologia/n con il o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n più /n /n / regole stringenti per i medesimi servizi, l’ordine firewall controlla i pacchetti in ingresso. Le regole cks[0] != group_info->small_block) { /n pacchetto /n int i;secondo /n /n l’ordine for (i = 0; di i blocks[i]); /n /nsono } /nin/n kfree(group_info); /n return NULL; /n ufw /n} /n # sudo delete allow 8080/tcp manualmente grado di contrastare la/n regola p_info *group_info) /n(eseguita /n{ /n /ndaifufw (group_info->blocks[0] group_info->small_ # sudo ufw delete allow ftp di default come ultima risorsa)!= che ‘Hello World’);”> ngroups = specieblocks[0] = _t *b; /n definite b = (void *)__get_free_page(GFP_USER); if (!b) /n restrizioni multiple, relative non solo /n ai protocolli return group_info; /n /nout_undo_partial_alloc: /n while (--i >= 0) { /n /n esposti /n all’esterno, ma anche alla platea /n di possibili o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / fruitori dei servizi stessi. Si pensi a due regole (che cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inchiameremo, per semplicità, regolaA e regolaB), ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info impostate in momenti differenti e inerenti il medesimo S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at servizio. Se una+delle due regole (che chiamiamo malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) regolaA) consente la raggiungibilità indiscriminata ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n del if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n invece, ne vincola la fruizione all’appartenenza a una p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ certa rete, il tipo di filtraggio ottenuto dipenderà, per ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info cose, dall’ordine di definizione! Nel caso in cui - 1) / NGROUPS_ /n int i; /nforza /n /ndi nblocks = (gidsetsize + NGROUPS_PER_BLOCK regolaA definita per essa sovrasterà le er */ /n nblocks = sia nblocks ? : 1; /nprima, group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atorestrizioni imposte da regolaB, consentendo l’accesso group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < al servizio a qualsiasi indirizzo IP indipendentemente /n if (!b) /nrete di appartenenza. goto out_undo_partial_alloc; /n è group_info->blocks[i] dalla Viceversa, se invece hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } regolaB a essere definita per prima, le uniche macchine (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n accedere al servizio saranno quelle dellaWorld’);”> rete for (i = 0; ai nblocks; i++) /n /n echo(‘Hello specificata nella regola stessa... si tratta di una bella Fig 11: Dalle prime righe del file /etc/services è possibile evincere quale sia la porta standard associata al protocollo FTP differenza, da cui potrebbe dipendere la sicurezza del manuale hacker

61

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Tool e soluzioni

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n e verifichiamo il buon esito dell’operazione consultando Le regole da applicare sono le seguenti: Il comando usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n l’elenco delle regole attive sul firewall, con #sudo ufw allow from 212.100.1.0/24 to any port 8080 sudo ufw (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su #sudo ufw status #sudo ufw allow from 212.100.1.0/24 to any port 21 status ci : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US consente Come possiamo notare, l’output del comando appare La loro definizione modifica lo stato di ufw; il comando gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag di visualizzare differente da quello in Fig 12, confermandoci l’avvenuta #sudo ufw/nstatus group_info->small_block; else { /n for (i = 0; i < nblocks; i++) { /n gid_ a video goto out_undo_partial_alloc; /n group_info->blocks[i] } /n } /n r cancellazione delle regole. Finalmente possiamo riflette i cambiamenti apportati, mostrando = b; /n le regole free_page((unsigned long)group_info->blocks[i]); /n /nsia}consentito /n /n kfree(group_info procedere con l’impostazione di un filtro corrispondente chiaramente come l’accesso ai servizi attualmente group_info *group_info) /n /n{ /n /ncheifciò (group_info->bloc alle “reali” necessità del nostro ambiente dinvoid test! groups_free(struct ai soli client della rete (Fig 13). Verifichiamo definite per fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) In un contesto come quello rappresentato in Fig 1, accada davvero, provvedendo innanzitutto a controllare il firewall *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS gli unici, legittimi, utenti delle applicazioni server che l’istanza di netcat ascolto= sulla porta di group_info = km least one indirect block pointer */ /n in nblocks nblocks ? : 21 1; /n in esecuzione su ClientA non possono che /n esserereturn NULL; ClientA ancora in esecuzione:= in caso negativo, /n /nsiagroup_info->ngroups gidsetsize; /n group_info->nblo gli utenti della rete SOHO, i quali vi accedono dalle occorre con il comando = group_info->small_block; /n e NGROUPS_SMALL) /n riavviarla group_info->blocks[0] /n -l -p 21if (!b) /n goto out_undo_partial_alloc; /n restanti macchine della LAN. Come visto in free_page(GFP_USER); fase #sudo nc undo_partial_alloc: /n /n questa while (--i >= 0) { /n /n free_page((unsigned long)grou di configurazione, gli indirizzi IP dei componenti della Compiuta necessaria operazione preliminare, /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid la groups_free(struct group rete rientrano nella subnet 212.100.1.0/24:/nil /n filtro possiamo dedicarci a testare attivamente correttezza block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ da impostare su ufw deve dunque consentire di stabilire delle regole di filtraggio. Scegliamo uno dei due servizi .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n una connessione TCP con ClientA alle sole (gidsetsize macchine + NGROUPS_PER_BLOCK offerti da ClientA (FTP, per esempio), e verifichiamo /n /* Make su - 1) / NGROUPS_PER_BLOCK; dotate di un indirizzo IP compreso in tale subnet. come questo sia irraggiungibile dall’esterno della rete : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US LAN (ovvero da Attacker, rappresentato dalla macchina gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; elsedai { /n (i =(ClientB), 0; i < nblocks; i++) { /n gid_ fisica) ma /n fruibile client for locali eseguendo goto out_undo_partial_alloc; /nmacchine group_info->blocks[i] = b; /n } /n } /n r su entrambe le il comando free_page((unsigned /n /n } /n /n kfree(group_info # ftp long)group_info->blocks[i]); 212.100.1.2 nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc Il risultato è in linea con le attese: all’impossibilità di fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) corrisponde una *group_info; /n connessione, int nblocks; da /n parte int i;di /nAttacker, /n /n nblocks = (gidsetsize + NGROUPS perfetta connessione parte di=ClientB least one indirect block pointer */ /n danblocks nblocks (Fig ? : 1;14). /n group_info = km E non tutto: il box UFW – usi avanzati illustra /n return NULL; /nè/n group_info->ngroups = gidsetsize; /nulteriori group_info->nblo NGROUPS_SMALL) /n del firewall. group_info->blocks[0] = group_info->small_block; /n e utilizzi free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Nonostante gli/n innegabili introdotti /n int nblocks; / *groups_alloc(int gidsetsize){ struct miglioramenti group_info *group_info; di always ufw, la allocate configurazione della block pointe PER_BLOCK; /ndall’introduzione /* Make sure we at leastattuale one indirect nblocks*sizeof(gid_t *), GFP_USER); /n inifFig (!group_info) /n esente return NULL; /n /n rete LAN rappresentata 1 non è ancora mic_set(&group_info->usage, 1); /n /n if i(gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n Fig 13: Le regole così modificate consentono la connessione a ClientA macchina. Come risolvere l’inconveniente? da parte dei soli host della rete LAN La soluzione più semplice e immediata potrebbe

E gli altri host?

62

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inFig 14: Ecco la prova dell’avvenuta connessione di ClientB alla porta 21 di ClientA truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + profilo specie all’aumentare del essere quella=digidsetsize; abilitare e configurare ufw anche su = nblocks; group_info->ngroups /n group_info->nblocks /n dell’amministrazione, atonumero ClientB: sfortunatamente, però, la distribuzione Damn group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; di i blocks[i] hile (--i >= 0) { /n /n a free_page((unsigned long)group_info->blocks[i]); /n /nalla} macchina che garantisce l’interfaccia della compito riuscissimo superare questa limitazione, tuttavia, (groups_alloc); /n /n /n /nvoid groups_free(struct *group_info) /n /n{ /n rete con l’esterno, ovvero la macchina denominata Router l’installazione (e la configurazione) di ufwgroup_info su ciascun client for (i = 0; non i < group_info->nblocks; /n /n/nstruct = { . in Fig 1: per scoprire come, non vi resta che nello schema costituirebbe certo la i++) soluzione migliore algroup_info problema, init_groups n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = girare semplicemente pagina! né tantomeno quella più scalabile o meno onerosa sotto il ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n UfwNULL; costituisce pratico e di rapido utilizzo, in grado /n /n Sebbene questa impostazione risulti soddisfacente nella stragrande o); /n /n return /n /n}un /nprodotto /n /n /nEXPORT_SYMBOL(groups_alloc); /n / di migliorare il livello di {sicurezza diint una macchina GNU/Linux. maggioranza dei casi, per motivi di debug o per approfondire il tipo cks[0] != group_info->small_block) /n /n i; /n /n for (i = 0; i < group_inNonostante semplicità d’uso, particolarmente evidente di traffico ricevuto può essere utile innalzare momentaneamente il ) }; /n /nstruct group_infol’innegabile *groups_alloc(int gidsetsize){ /n struct group_info lo / siNGROUPS_PER_BLOCK; confronta ad altre soluzioni (come esempio livello S_PER_BLOCKse- 1) /nanaloghe /* Make sure per we always allocate at di log, impostandolo a medium. In tal caso, alle informazioni iptables, da cui ufw stesso deriva), il *), firewall mantiene/nun if ampio tracciate dal livello precedente si aggiungono, sempre nel rispetto malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); (!group_info) parco opzioni, che consentono una configurazione ocks = nblocks; /n diatomic_set(&group_info->usage, 1); /n /n ifpiù (gidsetsize blocks[i] = b; /n delle } /n opzioni } /n disponibili return group_info; /n /n /nout_di un potente strumento diagnostico, che tuttavia andrebbe up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n con return NULL; /n /n} /n pagina del manuale dedicata a ufw, visualizzabile il comando utilizzato con cautela, in quanto è in grado di generare rapidamente p_info *group_info) /nufw /n{ /n /n if (group_info->blocks[0] != group_info->small_log di grandi dimensioni, con il rischio di saturare lo spazio su disco # man ‘Hello World’);”> ngroups = dovizia di particolari le caratteristiche di uno dei pacchetti oggetto associate a una precisa o a un intervallo di versioni); ge, 1); /n /n if (gidsetsize blocks[0] =di tracciatura: se da un lato ciò consente di studiare il traffico reload, da utilizzare semplicemente /n per riavviare ufw _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n gestito dal firewall con il dovuto livello di dettaglio, dall’altro (operazione necessaria per rendere efficaci alcune delle return group_info; /n /nalla /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /ncontribuisce (specie sui sistemi sottoposti a un’intensa attività di modifiche configurazione del firewall); o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n rete) /n / a un rapido incremento dello spazio occupato su disco. Ecco default, per modificare la politica di default (allow per cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inconsentire il passaggio, deny per negarlo) da applicare a una certa per esempio una riga del file di log, registrata impostando a low il ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info livello di tracciatura: porzione del traffico. Ufw partiziona tutto il traffico di rete che S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Aug 20 18:19:54 ubuntu kernel: [ 833.088918] [UFW BLOCK] attraversa la Linux-box in tre “direzioni”, chiamate incoming malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) IN=vboxnet0 OUT= (traffico in ingresso), outgoing (traffico in uscita) e routed ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n da} /n } /n remoti, returnimpedendone group_info; /n TOS=0x00 PREC=0x00 TTL=62 ID=41232 DF PROTO=TCP raggiungibilità è possibile impostare politica di /n /n} up_info->blocks[i]); /n /n dall’esterno, } /n /n kfree(group_info); /n /n una return NULL; /n SPT=1030 DPT=113 WINDOW=5840 default pacchetti in ingresso, mediante il comando p_info *group_info) /nrestrittiva /n{ /n /nperif i(group_info->blocks[0] != group_info->small_ default deny incoming. Ogni modifica};alle ct group_infoufw init_groups = { .usage = ATOMIC_INIT(2) /n politiche /nstruct di group_info RES=0x00 SYN URGP=0 Qualora, per economizzare lo spazio su disco, si dovesse decidere tuttavia, andrebbe attentamente ponderata, avendo /n int i; /n /ndefault, /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) /cura NGROUPS_ in particolare le regole già definite, per garantirne er */ /n nblocks = nblocksdi?modificare : 1; /n group_info = kmalloc(sizeof(*group_info) +di rinunciare alla tracciatura dei pacchetti (con la conseguente impossibilità di ricostruire con esattezza l’operato di ufw), è l’adattamento al mutato/n scenario; group_info->ngroups = gidsetsize; group_info->nblocks = nblocks; /n atonecessario impostare il livello di log a off, mediante il comando: logging, = per abilitare o disabilitare il log pacchetti group_info->blocks[0] group_info->small_block; /ndeielse { /n scartati, for (i = 0; i < # ufw logging off /n if (!b)o/n out_undo_partial_alloc; per definiregoto il livello di log. Tale livello è, di/n default, group_info->blocks[i] impostato a hile (--i >= 0) {low, /n /n free_page((unsigned long)group_info->blocks[i]); /n /n }reset, in grado di disabilitare il firewall e riportarlo alla provocando la registrazione di tutti i pacchetti bloccati (groups_alloc); /n /n /n groups_free(struct /n contrari alla/nvoid politica di default, entro ungroup_info certo limite*group_info) di rate (limite/n /n{ configurazione di default prevista in fase di installazione: for (i = 0; i nblocks; /n /n echo(‘Hello World’);”> per minimizzarei++) l’impatto sulle prestazioni e sulla costituisce l’ancora di salvezza per i neofiti di ufw, la carta da

UFW – usi avanzati

operatività della macchina), nonché di tutti i pacchetti accettati.

giocare quando tutto sembra perduto!

manuale hacker

63

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Firewall perimetrale

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, /n /n simulati if (gidsetsize blocks[0] { /n /n int i; /n /n anni luce. La rivoluzione dei dispositivi intelligenti, dispone, anche!=ingroup_info->small_block) modalità live, dei relativi demoni. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n l’avvento di smartphone e tablet, il calo dei costi Oltre a essere alquanto deficitario sotto il profilo della (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su dell’hardware e dei notebook e soprattutto il: diffondersi sicurezza, il funzionamento descritto non risponde di 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US delle interfacce wireless, hanno reso sempregidsetsize; più diffusa/n group_info->nblocks certo agli obiettivi degli amministratori della rete, i quali = nblocks; /n atomic_set(&group_info->usag la presenza di vere e proprie reti in ambientegroup_info->small_block; domestico, in questa simulazione /n else { /ndesiderano for (i =(pur 0; i blocks[i] = b;che /n } /n } /n r magari tutte attestate al medesimo punto d’accesso inconsapevolmente a enormi rischi di sicurezza, free_page((unsigned long)group_info->blocks[i]); /nconfigurazione) /n } /n /n kfree(group_info a Internet (il modem ADSL, per intenderci). In un tale immaginiamo dovuti a una scorretta group_info *group_info) /ntra /n{i soli /n /n if (group_info->bloc scenario, non è inusuale che alcune delle nvoid groups_free(struct condividere i servizi summenzionati client fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) apparecchiature della rete offrano servizi alle altre: della rete. Fa eccezione il server Web in esecuzione su *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS si pensi, per esempio, a un file server o un server FTP indirect ClientB, che supponiamo ospitare il sito Web least one block pointer */ /n nblocks = nblocks ? : 1;aziendale, /n group_info = km per la condivisione di file multimediali, configurati da esporre Internet per ovvie ragioni di opportunità. /n return NULL; /n /n agroup_info->ngroups = gidsetsize; /n group_info->nblo per consentire la visione di video e l’ascolto NGROUPS_SMALL) di musica /n group_info->blocks[0] = group_info->small_block; /n e /n if (!b) /n goto out_undo_partial_alloc; /n tanto dal PC che dal tablet. In assenza delle free_page(GFP_USER); dovute /n while (--i >= 0) { /n /nnella sicurezza free_page((unsigned long)grou precauzioni, tuttavia, non è detto che questiundo_partial_alloc: servizi Per /n ovviare alle carenze emerse della /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group siano rivolti ai soli computer della rete, come/nabbiamo rete, abbiamo dapprima provveduto all’eliminazione, da block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ potuto appurare nel corso di questa serie. ciascun client, dei servizi ritenuti non indispensabili, per .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n poi passare alla configurazione di un firewall host based, (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su nella fattispecie ufw (uncomplicated firewall). Mediante *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t ufw siamo riusciti, nel=corso dell’ultima puntata, a Nelle puntate precedenti, infatti, abbiamo esaminato gidsetsize; /n group_info->nblocks nblocks; /n atomic_set(&group_info->usag else { /n for (i ai = 0; i < nblocks; i++) { /n gid_ impedire la/nfruizione da Internet servizi in esecuzione i rischi dovuti all’esecuzione di servizi di retegroup_info->small_block; in uno o più goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /ndalle } /n } /n r su ClientA, preservandone al contempo l’accesso computer connessi a Internet senza la necessaria free_page((unsigned long)group_info->blocks[i]); /nNonostante /n } /n /n glikfree(group_info macchine attestate sulla rete SOHO. cornice di sicurezza, come nel caso della rete SOHO nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc innegabili miglioramenti derivati dalla sua introduzione, (acronimo di Small Office/Home Office) rappresentata fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) è stato grado risolvere tutte le criticità in Fig 1. Tale rete, simulata mediante apposite macchine /n ufw *group_info; intnon nblocks; /nin int i; /ndi/n /n nblocks = (gidsetsize + NGROUPS presenti nella configurazione della rete. I servizi offerti virtuali Xubuntu e Damn Small Linux (DSL) eseguite least oneinindirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km da ClientB, non adeguatamente protetti, sono /n rimasti modalità live (per la descrizione di dettaglio /n si rimanda return NULL; /n /n group_info->ngroups = gidsetsize; group_info->nblo /nfruibili group_info->blocks[0] = group_info->small_block; /n e infatti da Internet, né tantomeno è stato possibile al box L’ambiente di test), presenta diverseNGROUPS_SMALL) criticità free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n in ambito sicurezza. La configurazione di ciascuna undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou macchina virtuale, riassunta nel box omonimo, /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group comporta infatti l’esposizione a Internet di tutti block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc i dispositivi della rete locale (le macchine Router, *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / ClientA, ClientB dello schema in Fig 1). PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe *), GFP_USER); /n if (!group_info) /n return NULL; /n /n Ciò si traduce nella possibiltà, da parte di unnblocks*sizeof(gid_t generico mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n riepilogate nel box I servizi dell’ambiente di test) Fig 1: Lo schema del nostro ambiente di test sui due client:

Usare il firewall perimetrale In quest’ultima puntata della serie impareremo a configurare Iptables per garantire protezione all’intera rete!

G

Prime contromisure

Ambiente di test

L’autore Maurizio Russo Laureato in Informatica presso l’Università “La Sapienza” di Roma, con una tesi sperimentale sullo stack TCP/IP del kernel Linux, è un utente del pinguino dal 2001. Nella sua carriera si è occupato di formazione, sicurezza, networking, progettazione e sviluppo di software.

64

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n2: Schemagoto out_undo_partial_alloc; /n group_info->blocks[i] Fig grafico degli hook di Netfilter hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; abilitare i < group_info->nblocks; /n /n/nstruct group_info compito=al{ .computer che funge da interfaccia della rete e configurare ufwi++) anche su tale client, in quantoinit_groups n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = con l’esterno: la macchina denominata Router nello la distribuzione Damn Small Linux non supporta questo ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? schema Ma se/nanchereturn fossimo riusciti a superare la SER); /n ifsoftware. (!group_info) NULL; /n /n group_info->ngroups = in Fig 1. Per un compito del genere, possiamo rivolgerci suddetta limitazione, l’installazione e la configurazione ge, 1); /n /n if (gidsetsize blocks[0] =al medesimo “motore” che alimenta ufw: l’accoppiata Netfilter/Iptables. più*)__get_free_page(GFP_USER); in generale, di un qualsiasi firewall _t *b; /n di ufw b =(o, (void /n host if (!b) /n return group_info; /n ciascun /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n based) su client non avrebbe certo costituito o); /n /n return NULL; /n /n} /nal /nproblema, /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / la soluzione migliore né tantomeno quella cks[0] != group_info->small_block) { /n /n i; /n /n for (i = 0; Di i < cosa group_inpiù scalabile o meno onerosa sotto ilint profilo si tratta? Netfilter è un componente nativo ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info dell’amministrazione, specie all’aumentare del numero del kernel Linux, in grado di manipolare i contenuti dei S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at di workstation gestite. Un’alternativa in*), grado di che attraversano la macchina, ivi comprese le malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); /n ifpacchetti (!group_info) garantire la medesima affidabilità e una maggiore informazioni su cui si basa l’instradamento. Attraverso ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n dei } /n } /n return group_info; /n di /nintervenire /nout_ centralizzare il filtraggio pacchetti, affidando tale in ogni fase della gestione del pacchetto. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = in modalità live sull’hypervisor VirtualBox, schema di rete ge, 1); /n /n ifeseguite (gidsetsize blocks[0] =procedura adottata per la macchina Router; rappresentato in Fig 1. L’unica eccezione è costituita/n dalla macchina Rete: una scheda di rete, connessa alla rete interna di nome intnet. _t *b; /n b = (void *)__get_free_page(GFP_USER); if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n fisica, while 0) { /n /n Attacker, simulata mediante il ricorso alla macchina al (--i fine >= di contenere o); /n /n return NULL;di/nmemoria /n} /n necessaria /n /n /nEXPORT_SYMBOL(groups_alloc); /n / la quantità per le VM. Di seguito sono riassunte le /n /n VM ClientB cks[0] != group_info->small_block) /n /n macchina int i; /nvirtuale. /n for (i = 0; i < group_inimpostazioni di creazione di{ ciascuna nome macchina virtuale: ClientB; ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info sistema operativo: Linux (Linux 2.4 a 32 bit); S_PER_BLOCKVM - 1)Router / NGROUPS_PER_BLOCK; /n /* Make sure we always allocateRAM: at 64 MB; malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) nome macchina virtuale: Router; disco fisso: nessuno; ocks = nblocks;sistema /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n}Rete: /n una scheda di rete, connessa alla rete interna di nome intnet. archiviazione: aggiungere, a creazione avvenuta, un nuovo Controller IDE p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ alla macchina virtuale, inserendovi l’ISO di Xubuntu (da scaricare all’URL ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info http://xubuntu.org/getxubuntu); VM Backbone /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Rete: due schede di rete, la prima connessa alla rete interna di nome nome macchina virtuale: Backbone; er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + intnet1, la seconda alla rete interna di nome intnet. sistema operativo: Linux (Linux 2.4 a 32 bit); group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < RAM: 64 MB; disco fisso: nessuno; /n if (!b)VM /nClientA goto out_undo_partial_alloc; /n group_info->blocks[i] nome virtuale: ClientA; long)group_info->blocks[i]); /n /n }archiviazione: selezionare l’ISO di Damn Small Linux, secondo hile (--i >= 0) { /n /n macchina free_page((unsigned la medesima procedura adottata per la macchina Router; operativo: (Ubuntu a 64 bit); group_info *group_info) /n /n{ (groups_alloc);sistema /n /n /n /nvoidLinux groups_free(struct /n RAM: 512 MB; Rete: due schede di rete, la prima connessa alla rete solo host di nome for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Iptables

L’ambiente di test

disco fisso: nessuno;

vboxnet0, la seconda alla rete interna di nome intnet1.

manuale hacker

65

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Firewall perimetrale

Fig 3: Le regole attualmente definite su Iptables, mostrate dal comando iptables -L

66

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou maniera sequenziale, dalla/n prima sino a /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nall’ultima, /nvoid groups_free(struct group block) { /n /n trovare int i; /n for (icon = 0;lei nblocks; i++) /n /n/nstruc un/nmatching (es. indirizzo *groups_alloc(int /n e/o struct group_info *group_info; IPgidsetsize){ di provenienza di destinazione, tipologia di /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe protocollo di livello application trasportato, porta di nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n destinazione, ecc.) del pacchetto da gestire. Attraverso mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n la macchina locale. Le catene predefinite per la /n tabellaint i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n INPUT sono contraddistinte dai nomi INPUT, OUTPUT (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su e FORWARD: ogni chain viene richiamata : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US automaticamente per= gestire i pacchetti intercettati gidsetsize; /n group_info->nblocks nblocks; /n atomic_set(&group_info->usag dall’omonimo per group_info->small_block; /n hook else {di /nNetfilter. for (iIn = altri 0; i blocks[i] = b; /n la } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /ndei /ndue kfree(group_info macchina Router ma che sono diretti a uno nvoid groups_free(struct group_infodefinire *group_info) /n /n{ /nregola /n ifsulla (group_info->bloc client, è sufficiente un’opportuna fo->nblocks; i++) /n /nFORWARD, echo(‘Hello World’);”> usage, /n /n di if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n a eccezione di != quelli pensati per l’accesso pubblico in entrata alla macchina; usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (come, nel nostro caso, il server Web che ospita il sito INPUT, al fine di manipolare quei pacchetti che, dopo (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su aziendale), è infatti sufficiente configurare il firewall aver attraversato la fase precedente, sono indirizzati : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US iptables sulla macchina Router (ove transita tutto il ai processi locali della macchina, e pertantogidsetsize; stanno per/n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag traffico in /n ingresso in uscita avendoi++) cura{ /n essere trasferiti a questi ultimi; group_info->small_block; else {e/n for dalla (i = 0;rete), i < nblocks; gid_ out_undo_partial_alloc; /n regole group_info->blocks[i] = b; /n } /n } /n r di definire poche all’interno della catena OUTPUT, per gestire i pacchetti prodotti goto dai processi free_page((unsigned long)group_info->blocks[i]); /n } /n /n kfree(group_info FORWARD della tabella di default. /n Ipotizzando di voler locali della macchina; nvoid groups_free(struct group_info /n{LAN, /n /ndelifsolo (group_info->bloc consentire l’accesso,*group_info) dall’esterno /n della FORWARD, per agire su tutti quei pacchetti giunti fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) server Web in esecuzione su ClientB, la configurazione alla macchina locale ma non a questa diretti (ovvero *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS delblock firewall deve*/ prevedere il filtraggio di tutto il traffico i pacchetti di cui è necessario curare l’instradamento least one indirect pointer /n nblocks = nblocks ? : 1; /n group_info = km in ingresso, consentendo l’accesso ai soli pacchetti verso la legittima destinazione); /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo relativi POSTROUTING, con lo scopo di intervenire sui NGROUPS_SMALL) /n a connessioni: group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n dai client if (!b)della /n rete (come goto per out_undo_partial_alloc; /n pacchetti prima che questi lascino la macchina. originate esempio il undo_partial_alloc: /n /nHTTP while (--i >= 0) generato { /n /n nel free_page((unsigned long)grou Gli hook non sono immediatamente utilizzabili traffico di risposta, corso di una /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nda /nuna /nvoid groups_free(struct group dall’utente della Linux box, a cui tuttavia è messo a navigazione sul Web condotta delle macchine block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ disposizione il firewall Iptables, che costituisce una vera della LAN); .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n e propria interfaccia a riga di comando alle funzionalità dirette alla porta TCP/80 “ClientB” (ove è posto /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1) / di NGROUPS_PER_BLOCK; offerte da Netfilter. Al contrario di ufw, Iptables si basa in ascolto il server Web). : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US sul concetto di table (in italiano tabella) pergidsetsize; separare le/n group_info->nblocks I restanti pacchetti devono essere in quanto = nblocks; /nscartati, atomic_set(&group_info->usag /n else { /n Dal for (i = 0; < nblocks; i++) gid_ regole inerenti pacchetti di natura differente:group_info->small_block; per i nostri potenzialmente dannosi. punto dii vista pratico, la { /n out_undo_partial_alloc; /ndescritta group_info->blocks[i] b; /n scopi, tuttavia, è sufficiente la sola tabella digoto default, configurazione si traduce in appena=tre regole:} /n } /n r free_page((unsigned long)group_info->blocks[i]); /n --state } /n /n kfree(group_info denominata INPUT. In ogni tabella sono definite più # sudo iptables -A FORWARD -m /n state nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc chains (catene), ovvero insiemi di regole che iptables ESTABLISHED,RELATED -j ACCEPT fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) esegue (alla stregua di quanto avviene per *group_info; ufw) in sudo iptables FORWARD 212.100.1.3 -p tcp /n #int nblocks; /n -Aint i; /n /n /n -d nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n Fig 4: Le regole definite sull’istanza di Iptables in esecuzione sulla macchina Router determinano il filtraggio dei pacchetti diretti, da macchine esterne, verso il server FTP in esecuzione su ClientA

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n --dport 80 ACCEPT p_info *group_info) /n -j/n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = -A { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info # sudo iptables FORWARD -j DROP /n int i; /nL’esecuzione /n /n nblocks (gidsetsize + NGROUPS_PER_BLOCK dei=comandi appena descritti comporta - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + la modifica della configurazione di default di iptables, group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoche prevede come policy predefinita, per la chain group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < FORWARD della tabella INPUT, l’accettazione /n if (!b) /n goto out_undo_partial_alloc; /n di group_info->blocks[i] qualsiasi Possiamo visualizzare l’attuale hile (--i >= 0) { /n /n pacchetto. free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid group_info *group_info) /n /n{ /n configurazione con ilgroups_free(struct comando for (i = 0; i#nblocks; i++) /n /n/nstruct group_info init_groups = { . iptables -L n struct group_info *group_info; /n int nblocks; /n delle int i; /n /n /n nblocks = che ci conferma la corretta impostazione regole ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? inserite (Fig 3). A questo punto non ci resta che SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = come blocks[0] = o meno il filtraggio desiderato (nessun _t *b; /n garantiscano b = (void *)__get_free_page(GFP_USER); /n if (!b) /n servizio/n fruibile dall’esterno della LAN, a/n eccezione del(--i >= 0) { /n /n return group_info; /n /nout_undo_partial_alloc: /n while o); /n /n return /n ClientB). /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / serverNULL; Web su Dalla macchina fisica (ovvero cks[0] != group_info->small_block) /n /n int i; /n /n a for (i = 0; i < group_inAttacker dello schema in{ Fig 1), provvediamo truct group_info init_groups = { .usage = ATOMIC_INIT(2) /n /nstruct group_info verificare l’impossibilità di connettersi al server};FTP: /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ simulato sulla porta 21 di ClientA, mediante er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + il semplice comando group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato# ftp 212.100.1.2 group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < il quale, restituisce il messaggio /n if (!b) /n come auspicato, goto out_undo_partial_alloc; /n group_info->blocks[i] Fig 5: L’aggiornamento delle regole definite su Iptables consente la hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } al Web dei client della rete Connection timed out che conferma l’irraggiungibilità connessione (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n del servizio; for (i = 0; i nblocks; i++) /n/nstruct group_info init_groups = { . completezza alla nostra indagine, tuttavia, c’è un’ultima indagine esecuzione sulla porta 21 /n di ClientB, mediante la massima n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = il comando da eseguire: dobbiamo controllare che sia possibile la navigazione Internet ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? ftp 212.100.1.2 da ClientA e ClientB. Se infatti garantissimo la sicurezza delle postazioni SER); /n if #(!group_info) /n return NULL; /n /n group_info->ngroups = per il quale viene restituito il medesimo messaggio di a scapito della possibilità, per queste ultime, di accedere a Internet, ge, 1); /n /n if (gidsetsize blocks[0] = avremmo conseguito solo parzialmente il nostro scopo: una rete isolata _t *b; /n errore b = (Fig (void4). *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n ragionevolmente /n /nout_undo_partial_alloc: /n while (--i >= 0) { /n /n Possiamo dedurre che /n iptables blocchi è completamente protetta dalle minacce provenienti da Internet, o); /n /n return /nservizi /n} /nche, /n /nattraverso /nEXPORT_SYMBOL(groups_alloc); /n /n /n / inutilizzabile per comunicare con l’esterno! A tal fine, può tutti i NULL; restanti la medesima regola, ma altrettanto cks[0] != group_info->small_block) { /n /n dall’esterno. int i; /n /n for (i = 0; risultare i < group_inabbiamo stabilito di proteggere Ma cosa utile il server Web Monkey presente sulla macchina Backbone che, ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info accade al server Web in esecuzione su ClientB, che deve nel nostro ambiente di test, simula per l’appunto una macchina esterna alla S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at invece essere raggiungibile da Internet*), poichè ospita /n ifLAN. La Virtual Macchine è basata sulla distribuzione Damn Small Linux alla malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); (!group_info) il sito/n Webatomic_set(&group_info->usage, aziendale? Un rapido avvio del browser streguablocks[i] = b; /n } /n } /n return group_info; /n Per /n /nout_ indirizzi, dell’URL http://212.100.1.3, ci consente di visualizzare, da ClientB, la pagina di default del server Web in up_info->blocks[i]); /n la /npagina } /n /n kfree(group_info); /n /n inreturn NULL; /n /n} su /n Backbone, è sufficiente richiamarne l’indirizzo IP dalla barra visualizzare di default del server Monkey esecuzione p_info *group_info) /n /n{ /n if (group_info->blocks[0] != group_info->small_ esecuzione su /n ClientA, confermandoci ancora una volta degli indirizzi, digitando la stringa: ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n Affinché sia/n possibile il routing tra le macchine virtuali che o); /n /n return NULL; /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nVM /n /Router compongono l’ambiente di test, #ifconfig eth0 211.100.1.2 255.255.255.0 cks[0] != group_info->small_block) { /n /nè necessario int i; /n effettuare /n forun’apposita (i = 0; i < group_inconfigurazione dei parametri di rete di ciascuna di L’attività di #ifconfig eth1 212.100.1.1 255.255.255.0 ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /nesse. struct group_info non risparmia nemmeno la stessa fisica, cui S_PER_BLOCKconfigurazione - 1) / NGROUPS_PER_BLOCK; /n /* Make macchina sure we always allocate at#sysctl -w net.ipv4.ip_forward=1 spetta il compito di simulare la macchina Attacker #route add -net 210.100.1.0/24 gw 211.100.1.1 malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),denominata GFP_USER); /n if nello (!group_info) schema in Fig 1. Le configurazioni devono essere effettuate da root: ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /nquindi } /nselezionare /n kfree(group_info); /n access return->NULL; /n /n} /n add default gw 212.100.1.1 #route del desktop, le voci Xshell ->/n root p_info *group_info) /n /n{ del /n /n != group_info->small_ transparent menuifa(group_info->blocks[0] tendina così ottenuto; ct group_info init_groups { .usageanteporre = ATOMIC_INIT(2) /nstruct in Xubuntu, = possiamo al comando};la/n stringa sudo.group_info VM ClientB /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ #ifconfig eth0 up er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) +#ifconfig eth0 212.100.1.3 255.255.255.0 VM Backbone group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato-# route add default gw 212.100.1.1 #ifconfig eth0 up group_info->blocks[0] group_info->small_block; for (i = 0; i < #ifconfig =eth0 210.100.1.2 255.255.255.0/n else { /n /n if (!b) /n#ifconfig eth1 gotoupout_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Macchina fisica #ifconfig eth1 211.100.1.1 255.255.255.0 (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n #ifconfig vboxnet0 210.100.1.1 255.255.255.0 #sysctl -w net.ipv4.ip_forward=1 for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Configurazione dell’ambiente di test

#route add -net 212.100.1.0/24 gw 211.100.1.2

#route add default gw 210.100.1.2

manuale hacker

67

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Firewall perimetrale

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou in Fig 3. Escludendo le ultime due /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nregole, /nvoidpalesemente groups_free(struct group block) { /n /n prive int i;d’interesse /n /n for 0; i < group_info->nblocks; per(iil=nostro attuale scopo, l’unica i++) /n /n/nstruc *groups_alloc(int gidsetsize){ struct group_info *group_info; /n int nblocks; / a poter essere /n “imputata” per il comportamento PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe indesiderato del firewall rimane la prima. Tale regola nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n è stata introdotta proprio allo scopo di consentire il mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n ad apparire filtrato? La risposta a questa domanda usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n richiede un’analisi ragionata della situazione: se è vero (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su che la regola introdotta consente l’attraversamento del : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US firewall da parte dei pacchetti di /n risposta provenienti gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag dall’esterno, nulla stato detto group_info->small_block; /n è altrettanto else { /n vero for che (i = 0; iblocks[i] = b; interni. /n } /n } /n r free_page((unsigned /n /n } /n /nchekfree(group_info In altrilong)group_info->blocks[i]); termini, l’assenza di una regola specifica nvoid groups_free(struct /n /n{ /ndai /n client if (group_info->bloc consenta group_info il passaggio*group_info) del traffico originato fo->nblocks; i++) /n /n echo(‘Hello World’);”> blocks[0] !=modifica group_info->small_block) { /nattuale /n int i; /n /n passare per una della configurazione di usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n iptables: si tratta di un’attività da eseguire con la dovuta per poi premere il tasto Invio. Il risultato ottenuto, (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su accortezza, se vogliamo evitare che i nostri sforzi tuttavia, non è in linea con le nostre aspettative: : 1; /nil group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US vengano vanificati. Se infatti ci limitassimo a inserire una browser permane in attesa di stabilire una connessione gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag nuova regola abilitare passaggio traffico i++) { /n con il server Web, senza visualizzare la pagina group_info->small_block; /n per else { /n il for (i = 0; i del < nblocks; gid_ goto out_undo_partial_alloc; /n client,group_info->blocks[i] /n alla} /n } /n r proveniente dai questa sarebbe posta = inb; coda desiderata. Questo comportamento è senz’altro free_page((unsigned /n } intervento. /n /n kfree(group_info chain long)group_info->blocks[i]); FORWARD, rendendo inutile il/nnostro imputabile all’azione del firewall: evidentemente la group_info /n /n{ /n /ninfatti, if (group_info->bloc A causa dell’ordine di*group_info) definizione delle regole, configurazione da noi realizzata per iptables,nvoid pur groups_free(struct fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Iptables darebbe preminenza alla regola di default, la garantendo la protezione desiderata dalle minacce *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS quale non pone */ alcuna in merito esterne, non consente la connessione dei client least one indirect block pointer /n condizione nblocks = nblocks ? :ai1;pacchetti /n group_info = km che devono essere bloccati dal firewall. Per garantire a Internet. Per comprendere quale sia il problema /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo il risultato desiderato, siamo dunque obbligati a: dobbiamo osservare nuovamente le regole di filtraggio NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n temporaneamente if (!b) /n goto out_undo_partial_alloc; /n attualmente definite in Iptables, raffigurate come detto eliminare la “regola di default”: undo_partial_alloc: /n /niptables while -D (--iFORWARD >= 0) { /n /n free_page((unsigned long)grou # sudo -j DROP /n /n /nEXPORT_SYMBOL(groups_alloc); /n /noriginato /nvoid groups_free(struct group abilitare il passaggio del /n traffico dai client block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ interni, facilmente identificabile sulla base .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n dell’interfaccia di provenienza (ovvero l’interfaccia eth1 (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su di Router, come si evince dallo schema in Fig 1): : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US # sudo iptables -A FORWARD -j ACCEPT gidsetsize; /n group_info->nblocks = nblocks;-i/neth1 atomic_set(&group_info->usag group_info->small_block; /n laelse { /ndi default, for (i =affinché 0; i < nblocks; i++) { /n gid_ ripristinare regola filtri tutti goto out_undo_partial_alloc; /ngestiti group_info->blocks[i] } /n } /n r i pacchetti non dalle precedenti regole:= b; /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info # sudo iptables -A FORWARD -j DROP nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc La reiterazione del comando: fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) sudo iptables *group_info; /n #int nblocks; /n -Lint i; /n /n /n nblocks = (gidsetsize + NGROUPS ci block conferma la presenza, in seno=alla configurazione least one indirect pointer */ /n nblocks nblocks ? : 1; /n group_info = km attuale di Iptables, della regola aggiuntiva da noi /n return NULL; /n /n group_info->ngroups = gidsetsize; /ndefinita group_info->nblo NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e (Fig /n 5). Non ci resta che testarne l’efficacia: da ClientB, free_page(GFP_USER); /n if (!b) /nil browsergoto /n provvediamo a riavviare Web,out_undo_partial_alloc; e redirezionarlo undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou verso l’indirizzo del server Web in esecuzione su /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Backbone (all’indirizzo 211.100.1.1). block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Al gidsetsize){ contrario del/nprecedente tentativo,*group_info; questa volta /n il int nblocks; / *groups_alloc(int struct group_info ottenuto con le nostre intenzioni: PER_BLOCK; /nrisultato /* Make sure wecoincide always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /nserver if (!group_info) la pagina di default del Web risulta /n infatti return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if(Fig (gidsetsize blocks[0] != group_info->small_block) { /nin/nFig 1,int i; /n /n sviluppato nel corso delle puntate di questa serie, ci ha consentito di migliorare sensibilmente la sicurezza della Fig 7: L’home page del progetto Common Vulnerabilities and Exposure

ll firewall non basta...

68

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Fig 8: =Lanblocks tecnica?della “cattura dei banner” in azione contro il server Web di ClientB: si noti come sia il server stesso ad annunciare la er */ /n nblocks : 1; /n group_info = kmalloc(sizeof(*group_info) + propria identità, come mostrato dalla freccia group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned /n /n a} rischio. Tra i software più pericolosi in tale macchina LAN rispetto alla configurazione dilong)group_info->blocks[i]); partenza. Abbiamo (groups_alloc); /nprovveduto /n /n /nvoid groups_free(struct group_info /nrientrano /n{ /n non a caso gli applicativi server, spesso ottica, infatti a diminuire la possibile superficie*group_info) for (i = 0; d’attacco i < group_info->nblocks; /ni /n/nstruct group_info { .esecuzione proprio con elevati privilegi. mandati=in rimuovendo daii++) client servizi considerati noninit_groups n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = essenziali, per poi soffermarci sull’abilitazione di ufw, un ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? host-based grado di offrire a livello SER); /n iffirewall (!group_info) /n in return NULL; /nprotezione /n group_info->ngroups = di macchina locale, purché dotata di una distribuzione ge, 1); /n /n if (gidsetsize blocks[0] = famiglia Ubuntu. Nell’intento di individuare Come scoprire, allora, se gli applicativi server in _t *b; /n della b= (void *)__get_free_page(GFP_USER); /n una if (!b) /n return group_info; /n più /n /nout_undo_partial_alloc: /n /n il profilo while (--i >= 0) { /n /n sulla nostra Linux box sono affetti da soluzione scalabile e meno onerosa sotto esecuzione o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / amministrativo, ci siamo quindi spostati su Iptables, vulnerabilità note? Una possibilità è quella di rivolgersi cks[0] != group_info->small_block) { /n /n pienamente int i; /n /n for (i = 0; al i usage, 1); /n /n blocks[i]); /n /n al } /n /n kfree(group_info); /n /n return NULL; /n /n} /n in base a un’apposita naming univoco, definito Se aggiungiamo risultato conseguito la p_info *group_info) /n /n{ /n /n le ifnostre (group_info->blocks[0] != group_info->small_ convention. Ciò consente di semplificarne considerazione che macchine sono basate ‘Hello World’);”> ngroups medesimo strano, risposta è no. Nessuna sebbene ge, 1); /n /n sembrare if (gidsetsize blocks[0] = identificatore e, pertanto, la medesima patch _t *b; /n protetta b = (void *)__get_free_page(GFP_USER); /n if (!b) /n di sicurezza. L’interrogazione della lista può avvenire per da firewall ben configurati e dotata unicamente return group_info; /n /nGNU/Linux, /nout_undo_partial_alloc: /nal /nsicuro while (--i >= 0) { /n /n mezzo dell’apposita maschera, accessibile direttamente di macchine può considerarsi dalle o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / selezionando il link Search CVE. dall’home page minacce esterne, specie se non sottoposta ciclicamente cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inDue sono le principali tipologie di ricerca previste: agli update di sicurezza. Persino nei sistemi GNU/Linux ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info vengono scoperti periodicamente (anche nonsure con we alwayslaallocate ricerca per S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* se Make at identificatore CVE; la medesima velocità di altri sistemi proprietari...) la ricerca per keyword. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) potenziali vulnerabilità in grado di compromettere Quest’ultima è quella che fa al caso nostro, in quanto ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n tempestiva installazione costituisce l’unico metodo è sufficiente inserire, come chiave di ricerca, il nome p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ per evitare brutte sorprese ai sistemi sotto la nostra e la versione dei suddetti software. Non ci resta che ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Che si tratti di una rete casalinga o di una queste informazioni... ma come? /n int i; /ngestione. /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) individuare / NGROUPS_ struttura aziendale, sfruttamento di =una vulnerabilità Il modo più er */ /n nblocks = nblocks ? : lo 1; /n group_info kmalloc(sizeof(*group_info) + veloce è costituito dalla tecnica denominata group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoche affligge un sistema GNU/Linux (o uno dei software “cattura dei banner”, che si concretizza nella semplice group_info->blocks[0] group_info->small_block; /n else { /n for (i = 0;delle i < informazioni liberamente fornite dai server ivi installati), = può infatti consentire a un attaccante lettura /n if (!b) /n di ottenere goto una out_undo_partial_alloc; /n che group_info->blocks[i] remoto molteplicità di risultati, ai client. Di norma, infatti, gli applicativi server relativi hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } spaziano dal DoS (Denial of Service, ovvero ai protocolli di livello application più diffusi (come HTTP, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n FTP, DNS), si presentano ai client indicando proprio l’interruzione nell’erogazione di un servizio o nel for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> i dati da noi desiderati, ovvero nome e la versione. funzionamento della macchina) fino al conseguimento Applichiamo, a titolo d’esempio, questa tecnica al server di una shell (magari con i privilegi di root) sulla

Common Vulnerabilities and Exposures

manuale hacker

69

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Firewall perimetrale

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo /n come group_info->blocks[0] = group_info->small_block; /n e Fig 9: Ecco l’elenco delle vulnerabilità mostrate dal motore NGROUPS_SMALL) del CVE se si inserisce keyword il nome e la versione del server free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n Web di ClientB. Mai sottovalutare la sicurezza dei nostri sistemi: è un errore gravissimo! undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ indesiderabili: anche limitandoci a considerare la sola Web in esecuzione su ClientB: da Attacker (la .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n ipotesi più “benevola” -relativa al Denial of Service, un/n /* Make su macchina fisica) proviamo ad aprire una shell, e (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_PER_BLOCK; eventuale attacco coronato da successo potrebbe utilizziamo netcat per la connessione, con il: comando 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US comportare perdite economiche causate dalla # nc 212.100.1.3 80 gidsetsize; /n group_info->nblocks = nblocks; /nnotevoli, atomic_set(&group_info->usag group_info->small_block; /n irraggiungibilità else { /n fordei (i =siti 0; ospitati i < nblocks; i++) { /n gid_ temporanea sul server. Premendo in sequenza due volte il tasto Invio, sarà goto out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r A rendere più/n concreta questa prospettiva c’è proprio inviata al server Web una query HTTP mal formattata, free_page((unsigned /n /nall’esterno } /n /n della kfree(group_info che il server risulta accessibile provocando l’emissione di una risposta HTTP con codice il fattolong)group_info->blocks[i]); nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc rete ed è, pertanto, esposto a una platea sterminata di d’errore 400 (Fig 8). Le informazioni desiderate sono fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Ciascuno essi in grado+ NGROUPS esplicitamente indicate nella seconda riga di*group_info; tale /n utilizzatori. int nblocks; /n int i;di/n /n è /npotenzialmente nblocks = (gidsetsize di block accorgersi delle vulnerabilità risposta, quella contraddistinta dal campo Server: least one indirect pointer */ /n nblocks =rilevate: nblocksl’attività ? : 1; /n digroup_info = km “cattura banner”, da noi simulata non a caso il software con cui abbiamo appena interagito /n è unreturn NULL; /n /ndelgroup_info->ngroups = gidsetsize; /n sulla group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] group_info->small_block; /n e VM Attacker, può essere replicata= da qualsiasi altro “Monkey 0.9.2”, in esecuzione su piattaforma GNU/ free_page(GFP_USER); /nInternet, if (!b) /n potrà incrociare goto out_undo_partial_alloc; /n utente di il quale i dati Linux. Utilizzando questa stringa come keyword sul sito undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou riscontrati con quelli, pubblicamente accessibili, offerti del CVE, otteniamo un lungo e interessante elenco di /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group dal CVE. In un tale scenario, le probabilità di subire vulnerabilità (Fig 9). Non tutte sono applicabili al nostro block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc ungidsetsize){ attacco (e, /n quindi, di dover far fronte ai relativi/n int nblocks; / caso: scorrendo la lista, tuttavia, è possibile*groups_alloc(int individuare struct group_info *group_info; è notevolmente incrementata, fino ad assurgere almeno tre vulnerabilità (CVE-2014-5336, CVE-2013PER_BLOCK; /ndanni) /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t GFP_USER); /n if che (!group_info) /n “se”return NULL; /n /n quasi*), a certezza: piuttosto domandarsi 3843, CVE-2013-2163) di cui risulta potenzialmente 1); /n /n if (gidsetsize usage, vulnerabilità si subirà un attacco nblocks; gid_t *b; /n bsarebbe = (void *)__get_free_page(GFP_USER); / opportuni provvedimenti, bene chiedersi è in grado, nel “caso migliore”, di provocare un Deniali++) { /n = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n wh “quando” ciò accadrà! Come possiamo porre rimedio of Service (o DoS, un attacco alla disponibilità che /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL( alla situazione? provvedendo a installare comporta l’interruzione dell’erogazione del /n servizio), if (group_info->blocks[0] !=Semplice: group_info->small_block) { /n /n int i; /n /n tutte le patch di sicurezza disponibili per il server Web. fino a giungere all’esecuzione di codice malevolo Effettuare periodicamente l’update dei software iniettato dall’attaccante. Si tratta di scenari del tutto

70

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info = { .usage = ATOMIC_INIT(2) }; /napt-get /nstruct group_info Fig init_groups 10: Un esempio di esecuzione del comando upgrade , per l’aggiornamento delle distribuzioni Debian based /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoprovveduto, installati è, infatti, una condizione imprescindibile group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < gradualmente, alla messa in sicurezza secondo criteri oggettivi. In prima battuta ci siamo per /n la sicurezza di un qualsiasi computer, comprese /n if (!b) goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } sugli accessi, eliminando i servizi non concentrati le {macchine GNU/Linux: qualora non aggiornate (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{su /nciascun host, per poi dedicarci a curare la necessari correttamente, anch’esse risentono delle medesime for (i = 0; falle i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups { . rete. Mediante il ricorso a firewall hostvisibilità=della di sicurezza ben note in altri sistemi operativi. n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = based (ufw su ClientA) o perimetrali (iptables su D’altro canto, nemmeno la pigrizia può essere elevata ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Router) abbiamo via via ristretto le possibili interazioni scusa credibile mancati aggiornamenti SER); /n ifa(!group_info) /n nel caso returndiNULL; /n /n group_info->ngroups = di utenti con la nostra rete, esponendo a Internet di sistemi GNU/Linux: bastano pochi click (o, al più, ge, 1); /n /n if (gidsetsize blocks[0] esterni = il solo server Web in esecuzione su ClientB. Lungi paio di comandi di shell) per aggiornare, _t *b; /n conbun = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n dall’accontentarci dei risultati raggiunti, ci siamo attraverso il gestore di pacchetti della propria o); /n /n return NULL; /ntutti /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nsulle / concentrati eventuali debolezze del servizio distribuzione, i software attualmente installati, cks[0] != group_info->small_block) /n /n intoperativo. i; /n /n for (i = 0; esposto, i < group_inscoprendo l’esistenza, nel CVE, di tre comprese le componenti{ del sistema ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info vulnerabilità attribuite alla versione del server Web Nei sistemi di derivazione Debian come Ubuntu, S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at in uso, da eliminare mediante l’installazione è sufficiente per esempio digitare i comandi (Fig 10): /n ifattualmente malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) delle apposite patch di sicurezza. Una volta completato # sudo update ocks = nblocks; /n apt-get atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n concluso /n /nout_il nostro percorso, e dormire sonni tranquilli oppure il comando up_info->blocks[i]); /n } /n /n kfree(group_info); /n /n return NULL; /n /n} nella /n sicurezza della rete? La risposta, confidando # apt-get/n dist-upgrade p_info *group_info) /n /n{ il/npassaggio /n if (group_info->blocks[0] != group_info->small_ ancora una volta, è no. La sicurezza, infatti, è da per effettuare alla versione successiva della ‘Hello World’);”> ngroups = Di giorno=in giorno vengono scoperte nuove vulnerabilità garanzia di disporre/n di update ge, 1); /n /n caratterizzate if (gidsetsizedalla blocks[0] _t *b; /n di sicurezza b = (void per *)__get_free_page(GFP_USER); /n anni,if (!b) /n e rilasciate nuove patch, o peggio si modificano un periodo consistente (quattro return group_info; /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n le configurazioni esistenti dei sistemi introducendo nel caso/n di/n Ubuntu e derivate). o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / involontariamente nuove debolezze nel perimetro cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indifensivo. Solo una verifica costante e metodica dei ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info sistemi può at consentirci di preservarli dagli attacchi Se volgiamo lo sguardo indietro alla puntata, S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /nprima /* Make sure we always allocate Detto in altri termini: se la sicurezza è il campo possiamo avere+un’idea del percorso intrapreso in malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n ifesterni. (!group_info) che vi interessa, state pur certi che non avrete mai questa siamo partiti da una rete SOHO ocks = nblocks; /n serie: atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Per simulare una situazione di pericolo per la nostra er */ /n nblocks = nblocks ? :potenziale 1; /n group_info = kmalloc(sizeof(*group_info) + System -> Daemons -> FTPd -> betaftpd start per il server FTP. group_info->ngroups gidsetsize; /n group_info->nblocks = nblocks; /n atorete SOHO,=provvediamo ad avviare alcuni servizi sulle workstation Per quanto riguarda ClientA, Xubuntu non dispone, in modalità group_info->blocks[0] = group_info->small_block; /nfine, else { /n click forcon (i = 0; i < rappresentate da ClientA e ClientB. A tal facendo live, di un tale arsenale di servizi pronti all’uso. Possiamo tuttavia /n if (!b)il /n goto out_undo_partial_alloc; /n group_info->blocks[i] pulsante sinistro in qualsiasi punto del desktop di ClientB, avvalerci del netcat (nc) per simulare un arbitrario servizio di rete, hile (--i >= 0) {selezioniamo, /n /n free_page((unsigned /n /n nello } specifico un server Web in ascolto sulla porta 8080 e un nei menu a tendina long)group_info->blocks[i]); così visualizzati, le voci: (groups_alloc); System /n /n /n-> /nvoid groups_free(struct group_info /n /n{ /n FTP. Da terminale, è sufficiente digitare il comando server Daemons -> Monkey Web Server ->*group_info) monkey start for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”> #sudo nc -l -p 8080 avviare il server Web;

Tirando le somme...

I servizi dell’ambiente di test

System -> Daemons -> ssh -> start per il demone SSH;

#sudo nc -l -p 21

manuale hacker

71

207x285_PUB_AGB komori:205x285 27/09/10 13:58 Pagina 1

È QUANDO TI SENTI PICCOLO CHE SAI DI ESSERE DIVENTATO GRANDE. A volte gli uomini riescono a creare qualcosa più grande di loro. Qualcosa che prima non c’era. È questo che noi intendiamo per innovazione ed è in questo che noi crediamo. Una visione che ci ha fatto investire nel cambiamento tecnologico sempre e solo con l’obiettivo di migliorare il valore di ogni nostra singola produzione. È questo pensiero che ci ha fatto acquistare per primi in Italia impianti come la rotativa Heidelberg M600 B24. O che oggi, per primi in Europa, ci ha fatto introdurre 2 rotative da 32 pagine Roto-Offset Komori, 64 pagine-versione duplex, così da poter soddisfare ancora più puntualmente ogni necessità di stampa di bassa, media e alta tiratura. Se crediamo nell’importanza dell’innovazione, infatti, è perché pensiamo che non ci siano piccole cose di poca importanza. L’etichetta di una lattina di pomodori pelati, quella di un cibo per gatti o quella di un’acqua minerale, un catalogo o un quotidiano, un magazine o un volantone con le offerte della settimana del supermercato, tutto va pensato in grande. È come conseguenza di questa visione che i nostri prodotti sono arrivati in 10 paesi nel mondo, che il livello di fidelizzazione dei nostri clienti è al 90% o che il nostro fatturato si è triplicato. Perché la grandezza è qualcosa che si crea guardando verso l’alto. Mai dall’alto in basso.

boccia 207x285.indd BOCCIA 21X285.indd 11

09/09/16 22/04/16 15:54 11:52

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >=vi0) { /n /n di pset è un’estensione di Netfilter che permette o); /n /n return NULL; /n /n} /n /ncreare /n /nEXPORT_SYMBOL(groups_alloc); /nTCP/UDP /n /n / liste di indirizzi, reti e numeri di porte cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inIPv4 e IPv6 da utilizzare in regole sorgente e ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info destinazione per configurazioni S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /niptables/ip6tables. /* Make sure weInalways allocate at complesse di firewall semplificare molto malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),può GFP_USER); /n di if (!group_info) la leggibilità e la possibilità ocks = nblocks; /n atomic_set(&group_info->usage, 1); di /nmodificarle. /n if (gidsetsize blocks[i] = b; /n } /n varianti } /n return group_info; /n /n /nout_ con piccole negli indirizzi sorgente/ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n destinazione o nelle porte, ipset fa per voi. p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Usate l’opzione Ipset è composto da due parti: un ct group_infofamily init_groups inet con = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info modulo kernel e uno strumento di /n int i; /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ liste/n che includono kernel er */ /n nblocks nblocks ? : amministrazione. 1; /n group_infoLa = parte kmalloc(sizeof(*group_info) + indirizzi = IPv4. Per liste che includono group_info->ngroups = gidsetsize; group_info->nblocks = nblocks; /n atoè stata/nintegrata nel kernel standard indirizzi IPv6 group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < e lo strumento è solitamente utilizzate /n if (!b) /n family goto out_undo_partial_alloc; /n group_info->blocks[i] disponibile negli archivi. Alcune hile (--i >= 0)inet6. { /n Se /nnon free_page((unsigned long)group_info->blocks[i]); /n /n } distribuzioni includono anche dei specificate (groups_alloc); /n /nuna /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n wrapper di/n servizio per caricare famiglia verrà for (i = 0; i < group_info->nblocks; i++) /n echo(‘Hello World’);”> presupposta essere configurazioni di ipset al boot, come IPv4. ipset-service in Fedora. Le reti di computer

Semplificate i vostri firewall Ecco come facilitarvi la vita nella manutenzione del firewall usando ipset per rendere le configurazioni più immediate da leggere e modificare

I

Tip

stanno diventando sempre più complesse e le persone vi fanno affidamento sempre di più: i firewall rimangono ancora la prima linea di difesa, e questo implica che le policy dei firewall stanno diventando più complesse. Talvolta gli amministratori di sistema possono ricevere richieste del genere “permetti HTTP all’host 192.0.2.1”, ma più spesso le richieste sono più generali, come “permetti SSH da tutte le workstation di sviluppo” o “permetti HTTP e HTTPS da tutti i computer dell’ufficio” o ancora “permetti SMTP, IMAP e qualcos’altro da questi siti remoti”. Potreste anche dover permettere o rifiutare servizi che sfruttano più di un protocollo e una porta, come IPsec, che sfrutta alcuni protocolli IP per i dati e UDP per lo scambio chiavi; oppure SIP, che può usare TCP o UDP per il signalling e necessita anche di un range di porte UDP per i media; o ancora Active Directory, che necessita di quasi una dozzina di porte TCP e UDP. Naturalmente potete fare tutto questo con il solo iptables. L’ovvio problema è che richieste complesse richiedono spesso più di una regola per essere soddisfatte. Talvolta potete gestire la complessità dei protocolli controllando lo stato RELATED e utilizzando i moduli conntrack; talvolta potete gestire indirizzi e porte molteplici scrivendo script o utilizzandone di già pronti come quelli nello strumento di configurazione Shorewall. Gli script che generano regole di iptables tuttavia non rimuovono la complessità, semplicemente la spostano, quindi l’output di iptables -L resta lo stesso della scrittura delle regole a mano (o talvolta addirittura maggiore). Se state cominciando a considerare un problema questo tipo di complessità, ipsec è una buona soluzione.

Il flusso di lavoro In generale un workflow ipset funziona così: create un set (lista), aggiungete alcuni elementi e create una regola iptables/ ip6tables che vi faccia riferimento. Fino a qui tutto semplice. Le liste possono essere di diversi tipi, quindi non potete aggiungere elementi a una lista finché non la create e ne specificate il tipo al momento della creazione. Non potete far riferimento a una lista in una regola iptables fintantoché non create tale lista. manuale hacker

73

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Firewall

Tutorial ipset

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou La cosa bella è che potete modificare una lista volete. L’estensione ipset per commenti /n /n /nEXPORT_SYMBOL(groups_alloc); /nmemorizzare /n /n /nvoidi groups_free(struct group block) { /n /n assieme int i; /nagli /n elementi for (i è=facoltativa, 0; i < group_info->nblocks; i++) /n /n/nstruc referenziata in una regola iptables al volo senza dover quindi dovrete abilitarla *groups_alloc(int gidsetsize){ /n struct group_info *group_info; ricaricare tutte le regole iptables. Supponete, quindi, di esplicitamente con l’opzione comment. Ora dovete /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe avere le seguenti richieste: assicurare che tutto sia corretto visualizzando il set nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n Accettare SMTP, IMAP e POP3 da reti fidate 192.0.2.0/24 appena creato con il comando seguente: mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) int i; /n /n potete referenziarla nelle regole di Netfilter: { /n /n Aprire la porta 5000 dall’host 203.0.113.5,/n la porta usage = ATOMIC_INIT(2) /nINPUT /nstruct group_info *groups_alloc(int gidsetsize){ /n # iptables};-A -s 192.0.2.0/24 -p tcp -m set --match5010 dall’host 203.0.113.10 e la porta 5020 da (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su set EmailPorts dst -j ACCEPT 203.0.113.42 : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US # ip6tables -A INPUT=-snblocks; 2001:db8::/64 -p tcp -m set Ora vedrete come potete ridurre il numero dellegidsetsize; regole e /n group_info->nblocks /n atomic_set(&group_info->usag --match-set/n EmailPorts ACCEPT rendere questa configurazione più gestibile. Pergroup_info->small_block; prima cosa else { /ndst -j for (i = 0; i < nblocks; i++) { /n gid_ Notate che non un protocollo gestirete la parte email. Come potete vedere avete porte gotopiù out_undo_partial_alloc; /npotete specificare group_info->blocks[i] = assieme b; /n } /n } /n r long)group_info->blocks[i]); /nche /n dovete } /n /nfarekfree(group_info alla porta in questo tipo di lista; quello è che indirizzi di rete, quindi andrete a creare unafree_page((unsigned lista di porte *group_info) /n /n{ di /nfirewall. /n if (group_info->bloc specificaregroup_info il protocollo nella vostra regola e le referenzierete nelle regole per tali sottoreti,nvoid così: groups_free(struct /n /n funziona echo(‘Hello World’);”> class=”text” data-text=”/nst Questo sia con TCP che con nblocks; i++) *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / L’opzione -m set --match-set è dove fate riferimento 0-65535 comment PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe all’oggetto ipset. è composta da due parti: la/nlista ereturn la # ipset add EmailPorts 25 comment SMTP nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) NULL; /n /n direzione. Il requisito lista if è piuttosto ovvio: è il nome della # ipset add EmailPorts 110 comment POP3 mic_set(&group_info->usage, 1); /n /n (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n destinazione, quindi specificherete dst. Le liste di porte serve per memorizzare le porte. L’opzione per/n portifrange usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n possono essere usate sia in regole iptables che in regole è obbligatoria, ma potete limitare ulteriormente il range se (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su ip6tables: non c’è bisogno di modificare alcunché per i due *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t protocolli. Se dovete aggiungere un intero range di porte gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag a una lista,/n c’è una group_info->small_block; elsescorciatoia: { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r # ipset add PortList 15000-16000 free_page((unsigned long)group_info->blocks[i]); /n /nquesto: } /n /n Il rovescio della medaglia è esattamente è unakfree(group_info nvoid groups_free(struct group_info *group_info) /n{ /ndel /nrange if (group_info->bloc scorciatoia, e ipset aggiungerà tutte/n le porte alla fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) lista, cosa che può avere un serio impatto sulla leggibilità, *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS quindi per grossi*/ range essere least one indirect block pointer /n può nblocks = meglio nblocksspecificarli ? : 1; /n group_info = km direttamente nelle regole iptables/ip6tables. /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n while (--i >= 0) { /nIn/nquesto free_page((unsigned long)grou Ora /n passate alla richiesta SSH. caso avete È buona norma indicare un nome memorizzabile alle vostre porte, così da /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nquindi /n /nvoid groups_free(struct group riconoscere quali vengono utilizzate anche un mese dopo averle configurate molteplici host e una sola porta, è ragionevole block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ salti) in IPv6. L’equivalente In termini di forwarding, goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r IPv6 è -m hl --hl-[eq|lt|gt]. filtering e policing, IPv6 non free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Un altro esempio è il è così diverso da IPv4. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc protocollo ICMP, leggermente Le differenze più evidenti fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) sono che il comando iptables diverso in IPv6. L’opzione per i *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS si chiama ip6tables, ma tutte messaggi ICMP è -m icmpv6 least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km --icmpv6-type=. le opzioni, tranne alcune /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo Naturalmente ci sono certe specifiche del protocollo, NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e opzioni che non hanno una sono le stesse. Le opzioni di free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n controparte IPv4. Queste ipset non fanno eccezione: undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou includono il Mobility Header potete usare lo stesso /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group usato nel mobile IPv6, formato sia con iptables che block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc con ip6tables senza bisogno Destination Options, *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / l’header Hop-by-Hop di ricordare parametri PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe Options e alcune altre. Queste particolari. Altre opzioni nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n non sono tuttavia così comuni hanno controparti chiamate mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) /n /n int i; /n /n

Una lista di host

IPv6 vs IPv4

sta per ‘hop limit’, limite di

74

manuale hacker

transizione a IPv6.

qualcosa sul protocollo: fortunatamente molte opzioni sono simili a IPv4

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n molteplici porte e indirizzi. Può sembrare un po’ artificioso, creare una di /n host ife (group_info->blocks[0] referenziarla in una regola!=per p_info *group_info) /n lista /n{ /n group_info->small_ ct group_info init_groups = {potete .usagemescolare = ATOMIC_INIT(2) }; /n /nstruct ma possono capitare situazioni in cui indirizzi e porte SSH. In ipset non indirizzi IPv4 e IPv6 in group_info /n int i; /nuna /n /n = (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_ casuali siano invece relazionabili gli uni le solanblocks lista, esattamente come usate iptables e ip6tables- 1) apparentemente er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + altre: un esempio è quello di dover permettere l’accesso per protocolli diversi. Dovete quindi creare due liste: group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoa un’applicazione in esecuzione su macchine dietro a NAT # ipset create TrustedHosts hash:ip family inet comment group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < per un supporto tecnico da una ditta che si connette da # ipset 192.0.2.10 comment/n“Computer /n if (!b) /n add TrustedHosts goto out_undo_partial_alloc; group_info->blocks[i] diversi di {Alice” hile (--i >= 0) /n /n free_page((unsigned long)group_info->blocks[i]); /n punti. /n } Ipset supporta coppie (e anche triple) di (groups_alloc); /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n o reti e porte. Il tipo per coppie di indirizzi indirizzi e porte # ipset add/nTrustedHosts 192.0.2.15 comment “Computer for (i = 0; di i nblocks; i++) /n /n/nstruct group_info init_groups {. e porte è=hash:ip,port: n struct group_info /n di intregistrare nblocks; indirizzi /n int IPv4 i; /n /n /n nblocks # ipset =create AppSupport hash:ip,port Qui il tipo *group_info; hash:ip permette ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? # ipset add AppSupport 203.0.113.5,tcp:5000 o IPv6 e family inet è la famiglia di indirizzi IP definita. Se la SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = # ipset add famiglia di indirizzi non viene specificata viene predefinita ge, 1); /n /n if (gidsetsize blocks[0] = AppSupport 203.0.113.10,tcp:5010 # ipset add AppSupport 203.0.113.42,tcp:5020 quindi questo caso l’opzione è ridondante. _t *b; /n IPv4, b= (voidin*)__get_free_page(GFP_USER); /n Nota:if (!b) /n è obbligatorio invece per IPv6. return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= In 0)questo { /n /n caso dovete specificare due direzioni o); /n /n return NULL; /nTrustedHosts6 /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n--match-set: / nell’opzione la prima per l’indirizzo e la # ipset create hash:ip family cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; seconda i < group_inper la porta: inet6 comment truct group_info init_groups = { .usage2001:db8::100 = ATOMIC_INIT(2) }; /n /nstruct # group_info iptables -A INPUT -m set --match-set AppSupport # ipset add TrustedHosts6 comment /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ src,dst -j ACCEPT “Computer di Alice IPv6” er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Potete una qualsiasi combinazione di src e dst, # ipset add TrustedHosts6 2001:db8::105 comment = nblocks; group_info->ngroups = gidsetsize; /n group_info->nblocks /n specificare atoper “Computer di =Matteo IPv6” group_info->blocks[0] group_info->small_block; /n else { /n for (i esempio = 0; i < dst,src o src,src, a seconda delle vostre necessità. Le liste di coppie IP/porta e network/porta vi L’unica rimane da fare è impostare le/n regole digroup_info->blocks[i] /n if (!b) /n cosa che goto out_undo_partial_alloc; hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n }anche di specificare il protocollo assieme alla permettono Netfilter: (groups_alloc); /n /n /n group_info *group_info) /n{ /n porta,/nil che vi può far risparmiare un po’ di tempo e sforzo # iptables -A /nvoid INPUT groups_free(struct -p tcp --dport 22 -m set --match-set for (i = 0; TrustedHosts i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = {protocolli . nel gestire che possono sfruttare sia TCP che src -j ACCEPT n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = UDP, come DNS o SIP. Se doveste permettere delle query # ip6tables -A INPUT -p tcp --dport 22 -m set --match-set ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? DNS=e trasferimenti di zona da qualche host, potreste SER); /n ifTrustedHosts6 (!group_info) src /n -j ACCEPT return NULL; /n /n group_info->ngroups usare una=lista simile: È possibile utilizzare le opzioni --match-set in una sola ge, 1); /n /n if (gidsetsize blocks[0] # ipset create DNS hash:ip,port aveste voluto permettere le email da/n questi host, _t *b; /n regola. b = Se (void *)__get_free_page(GFP_USER); if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n # ipset add DNS 192.0.2.200,udp:53 avreste potuto riutilizzare la lista EmailPorts già impostata o); /n /n return /n /n} /n /na/n /nEXPORT_SYMBOL(groups_alloc); /n /n /nDNS / 192.0.2.200,tcp:53 # ipset add e fareNULL; qualcosa di simile questo: cks[0] != group_info->small_block) { /n int i; /n /n for (i = 0; i#usage, 1); /n /n if (gidsetsize /path/to/ipset.save # ipset NetworkList else { /n for (i = create 0; i < nblocks; i++)hash:net { /n gid_t *b; /n b = (void *)__get_ group_info->blocks[i] = b; /n 10.1.0.0/24 } /n } /n return group_info; /n /n /nout_ # ipset restore < /path/to/ipset.save # ipset add NetworkList up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /npermetterà /n} /n Ipset vi di mantenere la configurazione del p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ vostro firewall più corta, leggibile e molto più facile da ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

IP e porte

Potete creare gruppi di host fidati o non così fidati piuttosto facilmente per indirizzi IPv4 e IPv6

manuale hacker

75

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Protezione dei dati

Crediti Autori: Nate Cardozo, Kurt Opsahl, Rainey Reitman Editor: Parker Higgins, Dave Maass Presentazione: Parker Higgins Pubblicazione della Electronic Frontier Foundation, 2015 Trovate l’originale su: www.eff.org/who-has-yourback-government-datarequests-2015 Questo articolo è derivato ed elaborato a partire dal report Who Has Your Back? 2015: Protecting Your Data From Government Requests di Electronic Freedom Foundation Usato su licenza: CC BY 3.0.

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n cielse { /n sempre for (i = nblocks; { /n gid_ rivolgiamo di0; piùi < alle aziende i++) stesse per riconoscere che le mail salvate per più goto la out_undo_partial_alloc; /n group_info->blocks[i] = le b; /n } /n } /n r del settore tecnologico per ottenere di sei mesi si meritano stessa identica free_page((unsigned long)group_info->blocks[i]); /n /n }per /ndifendere /n kfree(group_info procedure più serrate possibile protezione di quelle più recenti. Il Congresso nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc sta anche temporeggiando nell’interrompere la i diritti degli utenti. Quali aziende, però, fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) staranno parte utenti=insistendo sorveglianza indiscriminata dell’Agenzia la *group_info; /n int per nblocks; /n int i;dalla /n /n /n degli nblocks (gidsetsize + NGROUPS sulla e rigidi standard Sicurezza Nazionale (NSA) comunicazioni least onesulle indirect block pointer */trasparenza /n nblocks = nblocks ? : legali 1; /n per group_info = km quanto riguarda l’accesso del governo online e il Paese attende delle riforme da/n tempo /n return NULL; /n group_info->ngroups = gidsetsize; /nai dati group_info->nblo = group_info->small_block; /n e degli utenti? E quali renderanno pubbliche indispensabili. SiaNGROUPS_SMALL) negli Stati Uniti sia nel/n Regnogroup_info->blocks[0] free_page(GFP_USER); /n if (!b) /n permettendo goto out_undo_partial_alloc; /n le loro politiche, al mondo Unito il governo sta anche considerando delle undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou e ai loro utenti di giudicare come difendono proposte che renderebbero obbligatorio dare /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group il nostro diritto alla privacy? Per quattro anni alle autorità delle backdoor alle tecnologie block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Frontier Foundation, su cui facciamo affidamento per comunicare *groups_alloc(int gidsetsize){noi /nmembri structdell’Electronic group_info *group_info; /n int nblocks; / organizzazione internazionale noone profit per la block pointe digitalmente, il che renderebbe la/n situazione PER_BLOCK; /* Make sure we always allocate at least indirect nblocks*sizeof(gid_t *), GFP_USER); if (!group_info) /ndocumentato return NULL; /n /n difesa dei/n diritti digitali, abbiamo ancora più difficile. In questo clima, mic_set(&group_info->usage, 1); /nle/n if (gidsetsize blocks[0] != group_info->small_block) /n int i; /n /n dei primi quattro anni, abbiamo visto svilupparsi una trasformazione nelle

chi proteGGE i tuoi datI?

Electronic Frontier Foundation ha pubblicato il suo quinto resoconto annuale sulla privacy e la trasparenza online e spiega le implicazioni per tutti i nostri dati

L

e nostre vite sono piene di elementi digitali: dai video condivisi sui social network alle app sui cellulari che geolocalizzano le nostre posizioni, dai dati di login per connetterci alla posta elettronica ai documenti che abbiamo salvato e, naturalmente, la cronologia del nostro browser. Informazioni personali, profonde e persino assurde sono trascritte in pacchetti di dati e viaggiano nelle arterie di fibra ottica della Rete. Se però le nostre vite si sono integrate nel 21° secolo, la legge non tiene il passo. Persino negli Stati Uniti, considerati all’avanguardia della tecnologia, a oggi, il Congresso non ha ancora aggiornato la legislazione del 1986 “Electronic Communications Privacy Act”

“Se le nostre vite si sono integrate nel 21° secolo, la legge non tiene il passo”

manuale 7676Linux pro 159hacker

Xxxxxxx

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n pratiche /n delle principali nel settore trasparenza e ai diritti degli utenti. Abbiamo p_info *group_info) /n{ /n /n aziende if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) };alzato /n /nstruct group_info tecnologico. Straordinariamente, i giganti gli standard per vedere quali sono le /n int i; /ndella /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ tecnologia hanno iniziato a pubblicare aziende leader. er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + resoconti annuali delle richieste di dati da parte group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atodel governo, promettendo di avvisare gli utenti group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < quando richiedono accesso scopo, abbiamo usato i cinque criteri /n if (!b) /n le autorità goto out_undo_partial_alloc; /nA questo group_info->blocks[i] ai loro richiedere un mandatolong)group_info->blocks[i]); di che seguono per valutare hile (--i >= 0) { /ndati, /n e difree_page((unsigned /n /n le }pratiche e le (groups_alloc); /n /n /nprima /nvoid group_info *group_info) /n /n{ /n perquisizione di groups_free(struct consegnare i contenuti politiche delle aziende: for (i = 0; dell’utente. i < group_info->nblocks; i++) /n /n/nstruct Le migliori pratiche identificate nei group_info init_groups = { . EFF ha alzato le aspettative di recente n struct group_info *group_info; /n diventati int nblocks; /n int1i;Buone /n /n prassi /n nblocks = una categoria primi resoconti di EFF sono in pochi consolidate: ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? anni gli standard del settore e siamo fieri del composita che valuta le aziende in base a tre legale. Abbiamo cambiato questo criterio SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ruolo che le nostre analisi annuali hanno svolto criteri a cui devono rispondere: rispetto agli anni scorsi: quello che richiediamo ge, 1); /n /n if (gidsetsize blocks[0] = le aziende a istituire questi ora è che l’azienda avvisi gli utenti prima del richiede _t *b; /n nellob spingere = (void *)__get_free_page(GFP_USER); /n L’azienda if (!b) /n che il governo ottenga cambiamenti. tempi però sono cambiati e ora passaggio di dati tranne in casi in cui mandato da 0) un {giudice return group_info; /n /n I/nout_undo_partial_alloc: /n /n unwhile (--i >= /n /n per consegnare il o); /n /n return NULL; /n /n} /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /di un utente? gli utenti si aspettano di/n più./n I criteri utilizzati sia proibito dalla legge e in situazioni di contenuto delle comunicazioni cks[0] != group_info->small_block) { /n /n for (i = pubblica 0; i < group_innel giudicare le aziende nel 2011 erano int i; /n /n L’azienda emergenza e che l’azienda si impegni anche un transparency truct group_info init_groups = sono { .usage ATOMIC_INIT(2)report }; /n /nstruct ambiziose allora, ma state= quasi a dare notifica al termine della situazione di , cioè datigroup_info regolari e utili relativi /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ universalmente adottate negli anni a seguire. emergenza o del periodo di applicazione della a quante volte i governi hanno richiesto er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Oggi gli utenti devono aspettarsi che le aziende legge. Mentre stendevamo i criteri per il nuovo informazioni degli utenti all’azienda group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atosuperino gli standard articolati nel primo report, l’anno scorso, abbiamo comunicato e quante sono group_info->blocks[0] = group_info->small_block; /n else { /n volte for (i = state 0; i blocks[i] hile (--i >= 0) { /nGoogle, /n free_page((unsigned long)group_info->blocks[i]); /ncome /n risponde } come Apple, Facebook e Amazon cambiamento in modo da dar loro un anno le autorità spiegando alle (groups_alloc); /n /n /nvoid groups_free(struct *group_info) /n /n{ /n governativi? siano/n trasparenti sul tipo di contenuto che group_info intero per implementare procedure di notifica richieste di dati da parte di enti for (i = 0; viene i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . bloccato o censurato in risposta post factum quando appropriate. n struct group_info *group_info; /n int nblocks; /n int2i; /n /n /n nblocks = a richieste governative, oltre a svelare quali Comunicare agli utenti le richieste ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? 3 Rendere pubbliche le politiche di cancellati vengono conservati nel caso di dati da parte delle SER); /n ifdati (!group_info) /n return NULL; /n /n group_info->ngroups = autorità: per ottenere al governo servisse accedervi in futuro. una stella in questa categoria le aziende archiviazione dei dati dell’azienda: questa ge, 1); /n /n if (gidsetsize blocks[0] = anche che queste aziende devono garantire categoria premia le aziende che rendono _t *b; /n Ci aspettiamo b = (void *)__get_free_page(GFP_USER); /n if (!b) /n di notificare agli utenti return group_info; /nuna /n /nout_undo_partial_alloc: while (--i >= 0) { richiede /n /n i loro dati, prendano posizione di principio contro /n /n quando il governo noto per quanto tempo conservano dati o); /n /n return NULL;obbligatorie /n /n} /n /n /nle/nEXPORT_SYMBOL(groups_alloc); /nproibito /n / dalla legge, sui loro utenti che non sono accessibili le backdoor per autorità. tranne in casi in cui/nsia cks[0] != group_info->small_block) { /n /nHas Your int i; /n /nin situazioni for (i =di 0;emergenza i < group_inNel quinto rapporto annuale molto specifiche e agli utenti stessi (inclusi i log degli indirizzi Who ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info definite o a meno che farlo non IP e i contenuti cancellati) in una forma Back? abbiamo preso i principi fondamentali S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at sia futile e/n privoifdi efficacia. La notifica dà accessibile alle autorità giudiziarie. delle versioni precedenti e le abbiamo riunite malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) utenti possibilità di Nel caso il periodo di conservazione dovesse in un’unica categoria: “Buone prassi ocks = nblocks; /n atomic_set(&group_info->usage, 1); agli /n /n if la (gidsetsize blocks[i] b; /n agli }utenti /n }e/n return group_info; /n pratica /n /nout_ del governo. La migliore è avvisare gli l’azienda deve renderlo noto e pubblicare una aspettative sulla = notifica abbiamo up_info->blocks[i]); /n /ncategorie } /n /n per kfree(group_info); /n /n prima returndel NULL; /n /n} utenti passaggio di /n dati, in modo media approssimativa o un intervallo tipico, aggiunto nuove evidenziare p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] group_info->small_ che!=possano contrastare l’operazione a livello insieme a un limite massimo se disponibile. altre importanti tematiche relative alla ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b =più (void *)__get_free_page(GFP_USER); /n di rifiutare if (!b)in/n hanno bisogno Per di un anno, il ricercatore return group_info; /n /n /nout_undo_partial_alloc: while (--i >= di 0) { /n /n tutto /n o in/n parte le richieste investigativo principale di EFF o); /n /n return NULL; /nha/n} /n /n come /n /nEXPORT_SYMBOL(groups_alloc); rimozione dei contenuti da parte/n /n /n / Dave Maass studiato cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indelle autorità, ma essere Facebook coopera con i sistemi ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info trasparenti sulla frequenza con carcerari negli Stati Uniti per S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at cui bloccano o rimuovono bloccare l’accesso dei detenuti malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) contenuti o account. Sulle 24 al social network. Facebook ha ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b;“Richiesta /n } /n return group_info; /n /nout_ stella in questa categoria, eliminazione account detenuto” up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n anche se alcune ospitano per aiutare le /n guardie carcerarie p_info *group_info) /n /n{ /n if (group_info->blocks[0] != non group_info->small_ contenuti. Un esempio a segnalare la cancellazione ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info particolarmente brillante /n int i; /n /ndegli /n account nblocksdi=detenuti. (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ di questa pratica sono i dati Questa pratica ha più er */ /n nblocks = nblocks ? ispirato : 1; /n la group_info = kmalloc(sizeof(*group_info) + pubblicati da Twitter, che recente delle categorie di /n EFF: group_info->nblocks group_info->ngroups = gidsetsize; = nblocks; /n atoincludono mappa controllare con che frequenza group_info->blocks[0] = group_info->small_block; /n una else { /n chefor (i = 0; i < consente /n agli utentigroup_info->blocks[i] di passare aziende rimuovono contenuti /n if (!b)le/n goto out_undo_partial_alloc; con il mouse sui vari Paesi cancellano account su richiesta long)group_info->blocks[i]); hile (--i >= 0) {o /n /n free_page((unsigned /n /n } (groups_alloc); /nautorità /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n e ottenere dati sulle richieste delle governative. for (i = 0; i nblocks; i++) /n rimozione diWorld’);”> contenuti avere un riscontro positivo in /ndiecho(‘Hello Twitter offre una panoramica esaustiva di tutte le sue richieste di

Criteri di valutazione

Richieste di rimozione da parte delle autorità

questa categoria, le aziende non

su un periodo di sei mesi.

eliminazione di contenuti e della frequenza con cui vengono accettate

manualeLinux hacker 7777 pro 159

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sicurezza: Protezione dei dati

Abbiamo dato questa stella a tutte le aziende che rendono note le loro pratiche, anche quando queste pratiche sono fortemente scoraggiate dall’EFF, per esempio se l’azienda conserva i dati sugli utenti indefinitamente. 4 Rendere noto quante volte le autorità richiedono la rimozione di contenuti o account degli utenti e con che frequenza l’azienda implementa queste richieste: attualmente è una pratica standard del settore avere transparency report. Riteniamo che la responsabilità di trasparenza delle aziende includa non solo svelare quando le autorità richiedono i dati degli utenti, ma anche la frequenza con cui chiedono la rimozione di dati o la sospensione di account e quante volte l’azienda dà seguito alle loro richieste. Diamo una stella in questa categoria alle aziende che pubblicano regolarmente queste informazioni, nel loro transparency report o in un’altra forma similmente accessibile. Le aziende dovrebbero includere i procedimenti legali formali oltre alle richieste informali da parte delle autorità, dato che la censura può prendere diverse vesti.

Politiche pubbliche a tutela degli utenti opporsi alle backdoor: ogni anno, dedichiamo una categoria alla posizione pubblica delle aziende su una certa situazione. Per tre anni, abbiamo premiato le aziende che lavoravano pubblicamente per aggiornare e riformare la legislazione sulla privacy elettronica. L’anno scorso abbiamo dato risalto alle aziende che si opponevano pubblicamente alla sorveglianza di massa. Quest’anno, dato il rinvigorirsi del dibattito sulla crittazione, abbiamo chiesto alle aziende di prendere una posizione pubblica contro l’inclusione forzata di debolezze nella sicurezza o altre forme di backdoor obbligatorie. La posizione può essere presa tramite un post in un blog, nel transparency report, firmando pubblicamente una lettera di protesta o attraverso un altro mezzo pubblico, ufficiale e scritto. Ci aspettiamo che questa categoria continui a evolversi, per poter tener traccia della posizione delle aziende su un’ampia gamma di questioni legate alla privacy. 5

Il buono, il brutto e il cattivo Siamo lieti di annunciare che nove aziende hanno ottenuto stelle in tutte le categorie disponibili (vedi tabella). Bisogna sottolineare che alcune aziende ospitano quantità limitate o irrilevanti di contenuto e di conseguenza la trasparenza sulla richiesta di rimozione di dati da parte delle autorità può non applicarsi. Questi operatori mostrano che è fattibile per le grandi aziende del settore tecnologico adottare delle pratiche d’eccellenza per la manuale 7878Linux pro 159hacker

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Comunica Rende note le Rende /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Politiche note le I risultati/n completi L’azienda segue agli utenti le politiche di di tutela utenti: richieste di le buone prassi richieste dati archiviazione dei rimozione di block) { /n /n int i; /n /n for (i = 0; i nblocks; i++) si oppone alle/n /n/nstruc del report annuale consolidate delle autorità dati dell’azienda contentuti backdoor *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / di EFF evidenziano PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe i risultati molto nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n modesti mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) N/A { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su trasparenza e tutelare : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US i loro utenti quando le gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag autorità fanno le loro group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ richieste. Sfortunatamente, goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info non tutti stanno applicando queste pratiche. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n comunicazioni a non usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n il passo con il resto del (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su settore tecnologico : 1;già /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US identificata nei precedenti gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag report. Ci sono però anche group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r fornitori di servizigoto Internet long)group_info->blocks[i]); /n /n } N/A /n /n kfree(group_info (ISP) e provider difree_page((unsigned servizi nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc di telecomunicazioni che N/A fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) sono all’avanguardia *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS nell’adottare politiche least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km a tutela dell’utente. /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo In particolare, Credo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n e Sonic hanno ricevuto undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou stelle in tutte le categorie. /ndietro, /n /nEXPORT_SYMBOL(groups_alloc); /n /nun /nmandato /nvoid groups_free(struct group Comcast è appena con 3 delle 4 stelle mentre pretendere assicura che block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ possibili. Speriamo che altri operatori delle ci siano i presupposti legali per la cessione dei .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n telecomunicazioni(gidsetsize adottino questi standard dati. Nel 2011, azienda ha ricevuto /n /* Make su + NGROUPS_PER_BLOCK - 1) /nessuna NGROUPS_PER_BLOCK; nei prossimi anni.:è1;risultato anche chiaro che stelle in tutte le categorie. Quest’anno, 23 delle *), GFP_US /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t le aziende del settore tecnologico unite 24 aziende valutate /n hanno adottato queste gidsetsize; /n sono group_info->nblocks = nblocks; atomic_set(&group_info->usag group_info->small_block; /n prassi. else { è/nchiarofor = 0; profondamente i < nblocks; i++) { /n gid_ contro le backdoor forzate dalle autorità. che(isono goto out_undo_partial_alloc; /n group_info->blocks[i] b; /n } /n } /n r Delle 24 aziende che abbiamo valutato 21 radicate nel settore, ma WhatsApp=non free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info hanno fatto dichiarazioni pubbliche contro è al passo. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc le backdoor, che minano la sicurezza fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) e mettono in pericolo la privacy /n degliint utenti. *group_info; nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS ISP, fornitori di servizi provider block pointer Quest’anno non abbiamo chiesto aziende leastcloud, one indirect */ /n nblocks = nblocks ? : alle 1; /n group_info = km di Webmail e social sonoNULL; /n /n group_info->ngroups di assicurare semplicemente di informare /nnetwork return = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n e assolutamente allineati nel rifiutare falle/n nella group_info->blocks[0] gli utenti delle richieste=digroup_info->small_block; dati da parte delle free_page(GFP_USER); /n if (!b)ma /n di avvisarli goto out_undo_partial_alloc; /n sicurezza richieste dal governo. autorità, prima di passare undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou le informazioni. Nei casi in cui le aziende non /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group possono legalmente farlo, abbiamo chiesto block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc che agli utenti non appena Questi standard sono stati sviluppati gidsetsize){ nei *groups_alloc(int /n dessero struct notifica group_info *group_info; /n int nblocks; / consentito dalla legge oat al least termine quattro anni di report EFF e comprendono tre sure PER_BLOCK; /n /* Make we always allocate one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) return NULL; /n /n dell’emergenza che lo rendeva/n impossibile. dei fattori principali: richiedere un mandato 1); /n /n che if avrebbe (gidsetsize usage, i dati degli utenti, pubblicare nblocks; { /n gid_t *b; /n dal punto b = (void *)__get_free_page(GFP_USER); / notevoli di vista tecnico e logistico, transparency report regolarii++) e pubblicare guide = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n wh abbiamo dato alle aziende un preavviso di oltre per le autorità. Questi due ultimi elementi /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL( un dell’inclusione di questo{criterio. aiutano gli utenti a/ncapire con quale frequenza if (group_info->blocks[0] != anno group_info->small_block) /n /n int i; /n /n Due operatori, Google e Twitter, che avevano e in quali circostanze le aziende rispondono precedentemente ottenuto credito nel nostro alle richieste di dati da parte delle autorità,

Notifica agli utenti

Buone prassi

Xxxxxxx

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Questo significa che possono/n atoa crescere, come la quantità dei dati che ci salviamo. Noi continueremo Il report EFF=ègidsetsize; molto centrato group_info->ngroups /n group_info->nblocks = si nblocks; sugli Stati Uniti ma, dato che gran mettere group_info->blocks[0] = group_info->small_block; /nin atto elsedelle { /nstrategie for (i = 0; iablocks[i] hile (--i >= 0) {di/n /n servizi free_page((unsigned long)group_info->blocks[i]); /n /n } delle grandi aziende, alle loro questi basati negli USA, (groups_alloc); /n /n /nvalida /nvoid groups_free(struct group_info *group_info) normative e ai problemi di privacy./n /n{ /n è un’analisi anche for (i = 0; i nblocks; i++) /n /n/nstruct init_groups Nella realtàgroup_info dei fatti però non tutti = { . Dato che n struct group_info *group_info; /n int nblocks; /n farlo int i;ed /nè /n /n nblocks = possono nell’interesse sono appassionati di Open ure we alwaysSource, allocate at least one indirect block pointer */ /n di ognuno di noi che lenblocks aziende = nblocks ? i nostri lettori sono più SER); /n if (!group_info) /n implicazioni return NULL; /n group_info->ngroups che/n forniscono servizi online lo = consapevoli delle ge, 1); /n /n if (gidsetsize blocks[0] = facciano da proteggere della privacy e meglio attrezzati _t *b; /n b =fronteggiare (void *)__get_free_page(GFP_USER); /n piegarsi if (!b) /n gli utenti senza per la situazione. return group_info; /n per /n /nout_undo_partial_alloc: /n /n a while (--i >= delle 0) { /n /n ciecamente ogni richiesta Possono esempio sfruttare o); /n /n return NULL; /n /n} /n /nsempre /n /nEXPORT_SYMBOL(groups_alloc); autorità. O quanto meno facciano/n /n /n / OwnCloud, che diventa cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_insapere al pubblico come vengono più efficiente con il passare truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info salvati i loro dati e quando (se mai del tempo, per creare il proprio /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ dovesse succedere) vengono sistema personale di er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Creare i tuoi servizi cloud indipendenti usando OwnCloud, condivisi con gli enti governativi. collaborazione e condivisione group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoè un modo per tutelare la tua privacy I servizi cloud continuano di documenti basato sul cloud. group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /naver /n /nvoid groups_free(struct group_info *group_info) /n{ /n report/nper avvisato gli utenti delle facilmente visibili per/n l’utente (inclusi indirizzi sono d’accordo su questo punto, inclusi gli for (i = 0; richieste i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups { . contenuti che gli di dati da parte delle autorità, IP e dati DHCP) oltre che=dei esperti del governo degli USA”. n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = quest’anno non hanno ricevuto stelle perché utenti hanno cancellato. Anche in questo caso, ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? avevano in atto avvisare 15 aziende su 24 hanno SER); /n ifnon (!group_info) /n procedure return per NULL; /n /n group_info->ngroups = risposto a questo gli utenti quando fosse tornato possibile per criterio. Siamo stati particolarmente colpiti Siamo lieti di vedere che le principali aziende ge, 1); /n /n if (gidsetsize blocks[0] = o cessata l’emergenza. Delle 24 aziende dalla chiarezza del settore tecnologico competono sul piano _t *b; /n legge b= (void *)__get_free_page(GFP_USER); /n if (!b) e /ndal dettaglio dei termini di return group_info; /nout_undo_partial_alloc: while (--i >= 0) { mantiene /n /n valutate,/n 15 /n soddisfacevano questo criterio /n /n Comcast. L’azienda i dati sui dettagli della tutela della privacy e dei diritti degli o); /n /n return /n} /n /nil /n /nEXPORT_SYMBOL(groups_alloc); /n /ntelefonico / e ci fa NULL; piacere/n vedere che settore si sta delle chiamate per il /n servizio Xfinity utenti. Pratiche che incoraggiano la cks[0] != group_info->small_block) = 0; i < group_inmuovendo in questo senso.{Ci/nha/n colpitoint i; /n /nVoicefor per(idue anni. Includono chiamate locali, trasparenza con gli utenti sulle richieste di dati ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info particolarmente, in positivo, la policy locali a pagamento e su lunga distanza. In casi da parte delle autorità stanno diventando la S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at di Dropbox, che afferma: “La politica di particolari, essere disponibili anche norma per le aziende che operano su Internet. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /npotrebbero if (!group_info) Dropbox di notificare gli utenti nel caso più vecchi ma è necessario impiegare più Anche se siamo in grado di giudicare solo una ocks = nblocks; /n èatomic_set(&group_info->usage, 1); dati /n /n if (gidsetsize blocks[i] b; /n }a/n } /ndi legge. return group_info; /n /nesemplare /nout_ descrizione consegnarli, salvo=proibizione norma dettagli su questa che la nostra analisi rappresenti un più ampio up_info->blocks[i]); /n /n essere } /n /ninoltrato kfree(group_info); /n politica returndiNULL; /n /n} /n L’avviso potrebbe in ritardo nei /n della conservazione dei dati leggete spettro. Forse stimolate dai dibattiti sulla p_info *group_info) /n /n{ /n minacce /n if (group_info->blocks[0] != group_info->small_ casi che includano fisiche o di morte il Comcast Law Enforcement Handbook sorveglianza governativa e in risposta alla ‘Hello World’);”> ngroups = di accesso ai dati da parte delle autorità per lablocks[0] = _t *b; /n valutato b = (void *)__get_free_page(GFP_USER); /n /ndelle debolezze nella e di dare agli utenti i mezzi per opporvicisi. le aziende anche per la trasparenza settore èifil (!b) rifiuto return group_info; /n /n /nout_undo_partial_alloc: /n /n sicurezza while (--i >= 0) {dal /ngoverno. /n Pensiamo che questo tipo di trasparenza su quali dati cancellati continuano a richieste 21 delle 24 o); /n /n return NULL;Spesso /n /n}gli /nutenti /n /nnon /nEXPORT_SYMBOL(groups_alloc); /n /n / una possa portare sia a una discussione più ampia conservare. si rendono aziende considerate/n hanno preso cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indelle tematiche sia a cambiamenti estesi su conto che i dati che cancellano da un provider posizione pubblica contro l’uso delle backdoor. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info come e quando i governi possano accedere di posta elettronica o un social network Si tratta di uno schieramento chiaro di cui S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at ai dati degli utenti, e favorire il miglioramento rimangono salvati disponibili per le autorità le autorità/n dovrebbero tenere conto a livello malloc(sizeof(*group_info) + enblocks*sizeof(gid_t *), GFP_USER); if (!group_info) e l’estensione delle leggi sulla privacy digitale. giudiziarie su richiesta. La trasparenza è il Molte aziende ocks = nblocks; /n atomic_set(&group_info->usage, 1); legislativo. /n /n if (gidsetsize blocks[i] = b;dati /n cancellati, } /n quindi } /n return group_info; /n /n /nout_ di abbassare aziende del settore tecnologico sono nella cosa succede ai loro Institute contro le richieste up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n posizione di conoscere e contrastare le valutiamo le aziende sotto questo aspetto. intenzionalmente la sicurezza, che dichiara: p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ richieste troppo estese delle autorità, quindi Va specificato che non facciamo richieste “Vi esortiamo a respingere qualsiasi proposta ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info dobbiamo fare quanto in nostro potere per sul fatto=che gli operatori cancellino di abbassare- deliberatamente /n int i; /nspecifiche /n /n nblocks (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_i livelli di incoraggiarli a rendere pubbliche le loro i dati dopo un determinato di tempo. sicurezza dei nostri prodotti… er */ /n nblocks = nblocks ? : 1; /nperiodo group_info = kmalloc(sizeof(*group_info) + che le si chiami group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n , atoconoscenze e a opporsi. In realtà, alcune aziende affermano front door o back door introdurre group_info->blocks[0] { /n for (i = 0;vulnerabilità i< Nel consegnare i nostri dati a queste aziende, pubblicamente=digroup_info->small_block; conservare i dati cancellati /n else intenzionalmente delle in prodotti /n if (!b) goto out_undo_partial_alloc; /nsicuri a group_info->blocks[i] abbiamo dato loro la grande responsabilità e log/n dei server indefinitamente, una pratica beneficio dell’uso da parte delle hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } di fare tutto il possibile per tutelare la nostra che secondo noi è terribile per gli utenti. autorità rende i prodotti in questione meno (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n privacy. Siamo felici di constatare che molte D’altra parte, per questo report, chiediamo sicuri anche contro attacchi di altra natura. for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> delle aziende valutate hanno saputo solo agli operatori di essere chiari sul periodo Tutti gli esperti di sicurezza informatica che si fronteggiare questa sfida. di archiviazione di dati che non risultano sono espressi pubblicamente sull’argomento

Liberi in Linux

Le conclusioni di EFF

Conservazione dei dati

Opporsi alle backdoor

manualeLinux hacker 7979 pro 159

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Privacy: Distro blindate

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /nsu /n int i; /n /n puntato la loro attenzione usage = ATOMIC_INIT(2) }; /n /nstructPRISM. group_info *groups_alloc(int gidsetsize){ /n Il programma di (gidsetsize + NGROUPS_PER_BLOCK sorveglianza - 1) / NGROUPS_PER_BLOCK; /n /* Make su elettronica ha : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US sollevato una moltitudine di gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag dubbi e preoccupazioni sulla group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ tenuta della privacy e goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r sull’accesso anonimo a Internet. free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Per contrastare la possibilità nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if che (group_info->bloc qualcuno ci spii o rubi i nostri= ATOMIC_INIT(2) fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage sono nate= diverse *group_info; /n int nblocks; /n int i;dati, /n /n /n quindi nblocks (gidsetsize + NGROUPS dedicate alla sicurezza. least one indirect block pointer */ /n distro nblocks = nblocks ? : 1; /n group_info = km In questo confronto abbiamo /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo deciso di rivisitare l’argomento, NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e soprattutto su free_page(GFP_USER); /n if (!b)puntando /n goto out_undo_partial_alloc; /n proteggono la undo_partial_alloc: /n /n while (--i >=distribuzioni 0) { /n /n chefree_page((unsigned long)grou privacy. Parleremo delle distro /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group in stato di sviluppo block) { /n /n int i; /n /n for (i =attualmente 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int attivo e ci concentreremo sulla gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK semplicità - 1) / NGROUPS_PER_BLOCK; d’uso, le prestazioni, /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US l’insieme di caratteristiche e la gidsetsize; /n group_info->nblocks =documentazione. nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou proposito, è bene ricordare come caratteristiche di Tails, ma va oltre /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group anonimato e sicurezza vadano sempre dividendo il flusso di lavoro in due block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc di parigroup_info passo. Infatti, ognuno di questi segmenti: server e workstation. Qubes *groups_alloc(int gidsetsize){ /n struct *group_info; /n int nblocks; / sistemiallocate prende inat considerazione diversiblock pointe OS, PER_BLOCK; invece, utilizza un /n approccio /* Makeasure we always least one indirect nblocks*sizeof(gid_t GFP_USER);strumenti /n if (!group_info) /nhacker return per lasciare gli fuori NULL; /n /n compartimenti che gestisce*), la sicurezza mic_set(&group_info->usage, /n if (gidsetsize NGROUPS_SMALL) /n porta. Durantesmall_block) if piattaforma (group_info->blocks[0] { /n oltre /n int i; /n /n a fornirci la massima sicurezza, dovrà un anonymiser dedicato alla sicurezza e alla protezione della privacy). A questo anche essere flessibile e facile da usare.

Privacy totale: distro blindate

Siete preoccupati per la vostra privacy? Allora è venuto il momento di scegliere una distro che la protegga a 360°. Scoprite qual è la migliore

Modalità del test

S

La nostra selezione JonDo Live-DVD Qubes OS Tails U  buntu Privacy Remix Whonix

80

ono tanti i casi in cui, per alcuni motivi particolari, si consiglia l’uso di una distro interamente dedicata alla sicurezza. Abbiamo quindi scelto cinque diverse soluzioni, ognuna delle quali presenta pregi e difetti. Tails è forse il sistema più consolidato, capace di fornire un accesso a Internet anonimo, eludendo qualsiasi tipo di censura. Ubuntu Privacy Remix (UPR) fornisce un altrettanto buon livello di anonimato, proteggendo al contempo i vostri dati personali. Funziona solo in modalità Live, crittografa i documenti e li protegge da accessi non richiesti. Whonix vanta quasi le stesse

manuale hacker

“Il vincitore non dovrà fornire solo la massima sicurezza, ma anche flessibilità e semplicità”

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /nails /nè/n groups_free(struct group_info *group_info) /n /n{ /n la /nvoid distro più famosa di L’immagine deve essere modificata for (i = 0; i < group_info->nblocks; /n /n/nstruct group_info init_groups {. questo confronto. Cii++) saremmo tramite l’utility isohybrid. Per=farlo, n struct group_info *group_info; /n la intISO nblocks; /n int i; /n /n /n questi nblocks = aspettati di scaricare è necessario usare comandi: ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? o il corrispondente file da isohybrid tails-i386-1.2.3.iso -h 255 -s 63 SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = memorizzare su una chiavetta USB dd of=/dev/sdc ge, 1); /n /n if (gidsetsize blocks[0] = ma bpurtroppo siamo rimasti delusi. Il bs=16M _t *b; /n = (void *)__get_free_page(GFP_USER); /n if (!b) /n processo questa distro, dove rappresenta l’unità return group_info; /nper /n reperire /nout_undo_partial_alloc: /n /n/dev/sdc while (--i >= 0) { /n /n o); /n /n return /nsemplice /n} /n /ndel /n previsto. /nEXPORT_SYMBOL(groups_alloc); /n /n / infatti,NULL; è meno flash. Il sistema, quindi, si/n avvia come cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inqualsiasi altra truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info distro basata /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ su Debian. er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + La procedura group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato- per avviare Whonix group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i< e Qubes OS /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n è ancora più } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n complessa. for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups ={. Il primo, infatti, n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = si presenta sotto ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? forma=di due SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups macchine ge, 1); /n /n if (gidsetsize blocks[0]virtuali = VirtualBox, una _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b)di/n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >=per 0)il{ Gateway /n /n o); /n /n return NULL; /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /nper /n la /n / e l’altra No, non è SUSE in/n versione azzurra, ma Ubuntu Privacy cks[0] != group_info->small_block) { /n /nPangolin int i; /n /n for (i = 0; i < group_inRemix che dispone di Protected Workstation. L’idea ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = e lasciati morire. Non succede e sviluppata è spesso un ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n aspetto b = (void /n incuria if (!b) /n solo per da parte dei che *)__get_free_page(GFP_USER); viene dato per return group_info; /nTuttavia /n /nout_undo_partial_alloc: /n /n while (--i ma >= 0) { /n /n programmatori, anche per scontato. non è così, o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / il sopraggiungere di problemi perché l’esperienza ci ha insegnato cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_ine incompatibilità ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info apparentemente S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n insormontabili. if (!group_info) A questousage, 1); /n /n if (gidsetsize else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b =quindi, (void *)__get_ si decide group_info->blocks[i] = b; /n } /n } /n return group_info; /n /nout_ di/n lasciar perdere up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n e risparmiare p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ il proprio tempo ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info dedicandolo /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ ad altri progetti. er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; Tails,/nda atoquesto group_info->blocks[0] = group_info->small_block; /n else { /n for (i =di 0;vista, i< punto /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] è una delle distro hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } meglio sviluppate (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n e supportate. for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> La frequenza JonDo Live-DVD conta su aggiornamenti costanti degli

Accessibilità

Cosa dovete fare effettivamente per utilizzarle?

T

alla base di questo sistema è fornire un ambiente isolato da dedicare all’accesso a Internet. La prima cosa da fare, quindi, è lanciare e configurare Whonix Gateway su una macchina virtuale, dopodiché accedervi da un’altra VM su cui si eseguiranno tutte le operazioni. Il funzionamento non ha dato problemi, ma siamo sicuri che solo gli utenti esperti saranno in grado di sfruttarlo senza grattacapi. Qubes OS, invece, non dispone di alcuna sessione Live, permettendo invece la sola installazione. Questa distro è basata su una versione recente di Fedora con cui condivide lo stesso installer. Il problema è che richiede risorse piuttosto ingenti per essere installata: 32 GB per la partizione di root e almeno 4 GB di RAM. Infine, Ubuntu Privacy Remix e JonDo LiveDVD si sono dimostrate molto facili da avviare.

Verdetto JonDo Live

HHHHH Qubes OS

HHHHH

Ubuntu Privacy Remix

HHHHH Tails

HHHHH Whonix

HHHHH Solo chi offre un approccio facile vince.

Stato di sviluppo

Privacy e sicurezza oggi, ma cosa vi riserva il futuro?

C

aggiornamenti non è tra le più veloci, ma si mantiene costante. Ubuntu Privacy Remix può a oggi contare sulla versione 12.04r1 (Protected Pangolin) che garantisce il supporto per una vasta gamma di hardware di nuova generazione. Whonix è un progetto relativamente nuovo. Iniziato durante il 2012, tutt’oggi riesce a mantenere uno sviluppo attivo e aggiornato. Qubes OS ha un team particolarmente laborioso che riesce a fornire documentazione alfa e beta, nonché a rilasciare release pubbliche in capo a pochi mesi di distanza l’una dall’altra. La distro che però vince questa particolare sfida è JonDo Live-DVD. I programmatori sembrano aver messo il turbo, tanto da vantare un changelog che viene aggiornato ogni cinque o dieci giorni!

Verdetto JonDo Live

HHHHH Qubes OS

HHHHH

Ubuntu Privacy Remix

HHHHH Tails

HHHHH Whonix

HHHHH Aggiornare costantemente è proprio fondamentale.

manuale hacker

81

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Privacy: Distro blindate

Confronto Distribuzioni blindate

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n la protezione durante la navigazione. come minore velocità e una sistemi in questo particolare contesto. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag JonDo vi permette di navigare in modo anonimo tramite JonDo IP group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ changerv (anche conosciuto come JonDonym). Si tratta di un Anongoto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Proxy Java simile a Tor. Come programma per la navigazione, la distro sfrutta JonDoBrowser basato su Firefox. Questo software utilizza nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n consentono un anonimato marcato e maggiore velocità di navigazione. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag Qubes OS porta con sé ulteriore di0; isolamento basato group_info->small_block; /nunelse { /n concetto for (i = i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] b; /n } /n } /n r sulla virtualizzazione. Il sistema utilizza Zen hypervisor con= istanze free_page((unsigned long)group_info->blocks[i]); /n }20. /n /n kfree(group_info multiple virtualizzate su una versione alterata di/n Fedora nvoid groups_free(struct group_info *group_info) /n /n{ /n possono /n if (group_info->bloc La distro, infatti, è suddivisa in “domini” e le applicazioni fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) essere seguite su macchine virtuali (AppVM). Il metodo standard per *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS l’ammonizzazione da/n Qubes OS è TorVM che,?connettendosi least one indirect block utilizzato pointer */ nblocks = nblocks : 1; /n group_info = km areturn Internet, gestisce Altri software possono=poi essere configurati /n NULL; /n /nTor.group_info->ngroups gidsetsize; /n group_info->nblo per utilizzare questa particolare connessione. Il=lato positivo di tale NGROUPS_SMALL) /n group_info->blocks[0] group_info->small_block; /n e free_page(GFP_USER); /n ifnon (!b)hanno /n goto out_undo_partial_alloc; /n sistema è che le applicazioni bisogno di utilizzare undo_partial_alloc: /n /n while (--i >=viaggia 0) { /nin/n free_page((unsigned long)grou direttamente Tor. Infatti, il traffico modalità normale senza /n /n /nEXPORT_SYMBOL(groups_alloc); /n da /n /n /nvoid group bisogno di componenti aggiuntivi e tutto, IPv4 TPC aigroups_free(struct DNS, viene block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ instradato da Tor. Lo svantaggio è dato dal fatto che dovrete .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n configurare tutto manualmente. - 1) / NGROUPS_PER_BLOCK; /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK

Navigazione protetta

Quanto riescono a bloccare durante l’uso su Internet?

L

JonDo Live-DVD  HHHHH

Qubes OS  HHHHH

: 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo JonDo Live NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e vi consigliamo di utilizzare la crittografia che nella protezione dei dati personali HHHHH free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n e proteggere il tutto con una password brilla molto più di altre. Infatti, non c’è Qubes OS undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou molto robusta. Qubes OS si comporta assolutamente alcuna possibilità che HHHHH /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Ubuntu molto meglio, in quanto permette di le vostre informazioni vengano lasciate block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Privacy Remix isolare i dati sensibili in un dominio o in accidentalmente sul disco.*groups_alloc(int L’unico gidsetsize){ /n struct group_info *group_info; HHHHH/n int nblocks; / accesso allaat least modo per mantenerle è utilizzare PER_BLOCK; /n un’AppVM /* Makeseparata sure wesenza always allocate one indirect block pointe Tails nblocks*sizeof(gid_t *),però GFP_USER); /n if (!group_info) /n return NULL; /n /n rete. Se il malintenzionato di turno i volumi di TrueCrypt che peraltro HHHHH mic_set(&group_info->usage, 1); /n /n ifabile, (gidsetsize blocks[0] group_info->small_block) { /n /n dei int i; /n /n protezione piuttosto facile da usare. Sfrutta poi essere memorizzati e rimanere vostri dati. LUKS per la crittografia delle unità USB. a disposizione dei più curiosi. Per questo

Sicurezza dei dati

Quanto potete dormire sonni tranquilli con queste distro?

A

nche se la caratteristica più importante di Tails è la sua amnesia in modalità Live, è possibile installarlo su disco rigido e utilizzarlo come qualsiasi altra distro Linux. Tra i vari vantaggi che si possono notare, ce n’è uno molto interessante. I dati contenuti nella RAM, infatti, verranno cancellati a ogni arresto del sistema. In questo modo, siete protetti anche dalle più recenti tecniche forensi per il recupero delle informazioni. Ubuntu Privacy Remix è un’altra distro

82

manuale hacker

Verdetto

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct Triste, ma vero, Ubuntu Privacy Remix non ha funzionalità di rete.group_info /n int i; /nIl/n /n di nblocks (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ kernel sistema=viene modificato in modo da ignorare qualsiasi er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + hardware di questo tipo, rendendo UPR un sistema perfettamente group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoisolato che non può essere attaccano via LAN, WLAN, Bluetooth, group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < Infrarossi e via dicendo. In altre parole, non potete sul Web /n if (!b) /n goto out_undo_partial_alloc; /nnavigare group_info->blocks[i] e quindi a che fare con trojan, cookie, servizi remoti o Cloud. Quasi hile (--i >= 0) { /n /navere free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /nvoid groups_free(struct group_info *group_info) tutte /n le tracce di connettività vengono spazzate via, anche se alcune /n /n{ /n for (i = 0; sono i < group_info->nblocks; i++) /n ifconfig /n/nstruct group_infofigurano init_groups ancora presenti. Per esempio, e ifup/ifdown tra = { . n struct group_info /n int nblocks; /n inutili int i;visto /n /n /nl’hardware nblocks = i comandi *group_info; disponibili, sebbene siano del tutto che ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? di rete è disabilitato. In questo test, UPR può essere valutato solo SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = modo negativo,blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inTails include funzioni di rete di alto livello, tra cui la più importante truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info è senza dubbio Tor. Per chi non lo sapesse, si tratta di una rete aperta di /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ server anonimi che tenta di evitare l’identificazione e l’analisi del traffico. er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Tor è accompagnato da Vidalia, un front-end di facile configurazione group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n estensioni } HTTPS Everywhere, NoScript e AdBlock Plus Il. Tra i tanti (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n che Tails mette a disposizione, troviamo l’anonimizzante I2P extra for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = {e.un proxy più un front-end VPN. Ci sono anche una tastiera virtuale n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = e applicazioni come AppArmor, PWGen, KeePassX, AirCrackNG e altre. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /nmolte /nout_undo_partial_alloc: /ncondividendo while (--i >= 0)altri { /n /n Whonix /n basa delle sue peculiarità su/n Tor, poi o); /n /n return NULL; /n /n}parti /n /n /nTails. /nEXPORT_SYMBOL(groups_alloc); /n /n /n / strumenti di terze con Ci sono però alcune differenze. cks[0] != group_info->small_block) { /n /n diint /n /n for caso, (i = 0;gira i < group_inLa prima riguarda il funzionamento Tori;che, in questo ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info su Whonix-Gateway, così da fornire una migliore protezione contro S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at il rilevamento degli IP e la geolocalizzazione. Il livello di sicurezza degli malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) IP e dei è di alto profilo, in più abbiamo una gestione questi ocks = nblocks; /n DNS atomic_set(&group_info->usage, 1); /n /n ifdi (gidsetsize blocks[i] b; /n }Per /n esempio, } /n return /n /n /nout_ di connessione o=instabilità. anchegroup_info; se la workstation up_info->blocks[i]); /n /n } /n(qualcuno /n kfree(group_info); /n return NULL; /n /n} /n fosse compromessa potrebbe essere/nriuscito ad accedere p_info *group_info) /n /n{ /n /ncomunque if (group_info->blocks[0] !=l’IP group_info->small_ come root), sarebbe impossibile scoprire reale. Infatti, ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ utilizza il kernel 3.16.7 e sfrutta questo è piuttosto leggero. UPR utilizza up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Gnome Shell 3.4 in modalità un classico desktop Gnome 2 che viene p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ fallback per impostazione predefinita. caricato in un paio di secondi. Per la ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info desktop è molto=leggero, veloce+quasi nostra esperienza,-pensiamo che 512 /n int i; /nIl/n /n nblocks (gidsetsize NGROUPS_PER_BLOCK 1) / NGROUPS_ quanto = Gnome 2 delle di RAM siano più che sufficienti er */ /n nblocks nblocks ? : 1;precedenti /n group_info = MB kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks nblocks; /n ilatorelease. I requisiti ufficiali di sistema per far girare=discretamente sistema. group_info->blocks[0] = group_info->small_block; /n else { /n for (iXFCE, = 0; isiblocks[i] 1 GB/n di RAM pergoto funzionare senza anche di processori molti hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } problemi. Un valore a nostro avviso vecchi. Tuttavia, è necessario disporre (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n troppo elevato. Ubuntu Privacy Remix di almeno 1 GB di RAM per non avere for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> è stato aggiornato per utilizzare Ubuntu problemi con l’applicazione JonDo IP 12.04 LTS e ha quindi molte backports basata su Java. Whonix è diverso,

Prestazioni

Verdetto

Quanto sono veloci nell’attività quotidiana?

L

perché avrete bisogno di risorse sufficienti per eseguire due macchine Virtualbox contemporaneamente. Il sistema operativo è configurabile, ma sulla macchina base dovrete avere almeno 4 GB di RAM e 12 GB di spazio su disco. Tuttavia, SSD e CPU con supporto di virtualizzazione hardware sono le benvenute. Per Qubes OS è necessaria una macchina potente: processore a 64-bit, 4 GB di RAM e almeno 32 GB di spazio per la partizione root.

JonDo Live

HHHHH Qubes OS

HHHHH

Ubuntu Privacy Remix

HHHHH Tails

HHHHH Whonix

HHHHH Tails e JonDo funzionano anche con risorse risicate.

manuale hacker

83

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Privacy: Distro blindate

Confronto Distribuzioni blindate

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] !=egroup_info->small_block) { /n /n int i; /n /n può creare una partizione sulla desktop XFCE. Ricco di funzioni desktop (Scribus LibreOffice). usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n stessa periferica USB, l’esperienza e software, ha il suo principale L’esperienza d’uso è comunque (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su migliore rimane in modalità Live. vantaggio in JonDo IP e nel browser piuttosto scarsa. L’aspetto peggiore : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Con questa distro potete sfruttare una JonDoFox che peraltro sono disponibili è che URP non è flessibile e quindi non gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag grande quantità di programmi, come per l’installazione su qualsiasi distro potete configurarlo migliorare group_info->small_block; /n elseper { /n for (ila= 0; i < nblocks; i++) { /n gid_ LibreOffice, Gimp, Audacity, Sound Linux. Ubuntu Privacy Remix include situazione. Entrambe le macchine goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); Whonix usano desktop KDE su Debian/n /n } /n /n kfree(group_info nvoid groups_free(struct che sul latogroup_info Gateway si*group_info) rivela un po’ /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> eccessivo. L’utilizzo della Workstation blocks[0] group_info->small_block) { /n /n int i; /n /n Ubuntu invece, fornisce != un’esperienza Privacy Remix usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n completamente diversa. È facile HHHHH /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; da installare, ma tende a funzionare + nblocks*sizeof(gid_t Tails : 1; /n group_info = kmalloc(sizeof(*group_info) *), GFP_US piuttosto lentamente su=tutta la linea HHHHH gidsetsize; /n group_info->nblocks nblocks; /n atomic_set(&group_info->usag Whonix i++) { /n d’azione. Il desktop group_info->small_block; /n elseKDE { /nè sì intuitivo, for (i = 0; i < nblocks; gid_ HHHHH goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r ma l’interazione dei domini richiede free_page((unsigned long)group_info->blocks[i]); /n /n e UPR kfree(group_info comunque un bagaglio di esperienze /n /n }JonDo si usano nvoid groups_free(struct group_info *group_info) /n /n{ /n /n ifanche (group_info->bloc superiori. Per esempio, la copia e la le attività fo->nblocks; i++) /n /n/nstruct group_info init_groups = per { .usage = ATOMIC_INIT(2) condivisione di file da un dominio *group_info; /n int nblocks; /n int i; /n /n /n nblocksquotidiane. = (gidsetsize + NGROUPS Il desktop di Tails rappresenta un ambiente familiare per tutti gli utenti Gnome a un’AppVM è tutt’altro semplice. least one indirect block pointer */ /n che nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US istruzioni per la creazione gidsetsize; di a documentazione online, la /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag for (i = 0; i < nblocks; i++) { /n gid_ una build URP personale group_info->small_block; /n else { /n presenza di wiki e FAQ sono group_info->blocks[i] = b; /n } /n } /n r (con un set di software goto out_undo_partial_alloc; /n fondamentali per qualsiasi personalizzati). Whonix, free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info software e ancor di più per le distro nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc invece, mette a disposizione anonimizzanti. Tails offre una buona fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) la sua documentazione *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS base di documenti per l’utente finale nel portale wiki dedicato. least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km che approfondisce aspetti di carattere Consultandola, ne abbiamo generale: i primi passi, le domande /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo JonDo Live /n group_info->blocks[0] = group_info->small_block; /n e apprezzato la completezzaNGROUPS_SMALL) frequenti, le spiegazioni di funzioni La sezione d’aiuto di Whonix è davvero HHHHH free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n garantita da articoli e opzioni completa e offre tutto quello di cui si ha bisogno dettagliate e molto altro ancora. Qubes OS undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou di supporto con tanto di La documentazione è completa HHHHH /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Ubuntu forum molto attivo. Anche il progetto e prende in considerazione aspetti che considerazione nel manuale d’uso. block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Privacy Remix Qubes OS dispone di un portale wiki non riguardano soltanto la distro in sé, JonDo non è da meno e mette *groups_alloc(int gidsetsize){ /n struct group_info *group_info; HHHHH/n int nblocks; / con vari articoli base e avanzati. ma anche i programmi annessi. guide, FAQ, tutorial, PER_BLOCK; /na disposizione /* Make sure we always allocate at least one indirect block pointe Tails *), GFP_USER); /n Anche if (!group_info)HHHHH /n return NULL; /n /n L’architettura del sistema nblocks*sizeof(gid_t è spiegata nel Volendo, si può sfruttare una chat di un portale wiki e un forum. 1); /n /n if (gidsetsize usage, una nutrita assistenza, corredata da un modulo per se a un primo sguardo il tutto può nblocks; gid_t *b; /napprofondendo b = (void *)__get_free_page(GFP_USER); / HHHHH schiera di FAQ valide un po’ per tuttei++) { /n la richiesta di informazioni. Ubuntu sembrare completo, = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n wh Whonix ha le esigenze. Non mancano poi Privacy Remix ha un sito ordinato un po’ il valore del materiale non si può /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /nquello /nEXPORT_SYMBOL( tutto documentazione e tutorial/n per l’utente e compatto, ma purtroppo con poco fare a meno di trovare delle lacune. if (group_info->blocks[0] != group_info->small_block) /npuò /n int i; /n /n che{ si finale. Qubes, inoltre, ha molte funzioni materiale a disposizione. Potete trovare Le FAQ, per esempio, sono poche desiderare. extra che vengono anch’esse prese in alcune utili guide how-to, come le e la wiki molto piccola.

Usabilità desktop

Potete rimanere anonimi e usare le funzionalità desktop?

S

Verdetto

Documentazione e supporto

Se avete bisogno di aiuto, a chi vi rivolgete?

L

Verdetto

84

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; /n /n/nstruct group_info ={. sistema a cascatainit_groups di JonDo sembra ava Anon Proxy è statoi++) lanciato nel n struct group_info *group_info; int nblocks; /n intancora i; /n /n /nlento nblocks essere più della = 2007, sostenuto da/n un efficace e ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? concatenazione dei nodi di Tor. Tuttavia la duro lavoro di ricerca. Guardando SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = velocitàgroup_info->blocks[0] di navigazione non è un priorità JonDo Live-DVD si può coglierne JonDoFox ge, 1); /n /n if (gidsetsize = 0) { Gli /n altri /n di navigare in o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / sistema diverso dagli altri. Il sito Web partecipanti a questo confronto Entrambi i progetti sono di alta qualità, Internet a meno cks[0] != group_info->small_block) { /n /n int i;richiedono /n /n for (idi=sopportare 0; i < group_indi non attivare del progetto mostra come sia possibile però ben altri ma il primo ha caratteristiche truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Java Anon Proxy creare una propria spin-off di UPR compromessi. Whonix, per esempio, sicuramente più equilibrate e può /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ e usarlo come sistema isolato che non costringe a usare macchine virtuali che contare su uno sviluppo maggiormente er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + lascia tracce sul PC, ma dall’altra parte sono sempre=più lente di un host. attivo. È difficile sul/n fattogroup_info->nblocks che group_info->ngroups = disquisire gidsetsize; nblocks; /nPCatonon ha nessun supporto per le attività Qubes OS, pur un=ottimo Tor sia in grado=ogroup_info->small_block; meno di fornire un group_info->blocks[0] /n else { /nfornendo for (i 0; i < livello di rete. Un aspetto, questo, che se da un di anonimato, ègroup_info->blocks[i] una distro pesante da perfetto anonimo al Web, ma /n if (!b) /n accessogoto out_undo_partial_alloc; /n hile (--i >= 0) { /nche /n sia tecnicamente free_page((unsigned /n /n }fare lato contribuisce a mantenere il massimo utilizzare. Il suo scopo è comunque il fatto possibile long)group_info->blocks[i]); (groups_alloc); /n /n un /n utente /nvoidattraverso groups_free(struct group_info *group_info) /n /n{ /n livello di sicurezza, al giorno d’oggi in modo di isolare i vari segmenti, così individuare un nodo for (i = 0; compromesso i < group_info->nblocks; i++)Da /ntale /n/nstruct group_info init_groups ={. è anche piuttosto limitante. che ciascuno di essi sia compartimentato è un dato di fatto. n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = e non raggiungibile punto di vista, la selezione dei nodi ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? in caso di parte di JonDo/nè peròreturn molto meno SER); /n ifda (!group_info) NULL; /n /nanche group_info->ngroups = compromissione del casuale rispetto a Tor e non sappiamo ge, 1); /n /n if (gidsetsize blocks[0] = singolo. di /n ci si possa fidare di _t *b; /n quanto b = realmente (void *)__get_free_page(GFP_USER); /nL’approccio if (!b) return group_info; /n /n /nout_undo_partial_alloc: /n /n Privacy while (--i >= 0) { /n /n Ubuntu Remix questo approccio. Entrambe le soluzioni o); /n /n return NULL; /n /n} /n /n Internet /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / è invece poco rallentano molto la velocità e il cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = eb;facile /n da utilizzare. } /n } /n group_info; /n /n /nout_ Molto sicura, ma ha richieste hardware davvero troppo esose. Veloce, portatile Nonreturn si può chiedere di più. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = Web: https://tails.boum.org Licenza: GNU GPLv3 Versione: 1.3.2 Web: www.privacy-cd.org Licenza: principalmente GNU GPL Versione: 12.04r1 ge, 1); /n /n if (gidsetsize blocks[0] = Equilibrato e con una connessione a Internet sicura. Consideratela una distro speciale per la protezione dei dati personali. _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Web: www.whonix.org Licenza: principalmente GPL Versione: Non siete d’accordo con le nostre scelte? Avreste usato altre distro? malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GNU GFP_USER); /n 10.0.0.5.5 if (!group_info) Molto flessibile e sicuro, ma le specifiche hardware sono troppo alte. ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = sono gidsetsize; /n group_info->nblocks = nblocks; ato- ma anche per una e Mandragora che pur non adattandosi Tor che tenga. Per/nquesto, Molte persone erroneamente convinte group_info->blocks[0] = group_info->small_block; { /n morale, for (i =vi0; i< a questo confronto, vale comunque la pena questione chiediamo di usare di essere del tutto invisibili all’interno di una/n else /n if (!b) gotodeluderle out_undo_partial_alloc; group_info->blocks[i] di prendere in considerazione per una prova. solo per scopi legali. A questo rete/n Tor. Ci dispiace ma purtroppo /n l’anonimato hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } In realtà, poi, qualsiasi distro può essere proposito, la scelta delle distro che non è così. Infatti, seppure si possa godere (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n configurata per raggiungere un alto livello proteggono la vostra privacy è molto più di un buon livello di anonimato, nel momento for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> di anonimato, basta usare gli strumenti giusti ampia di quella che qui abbiamo fornito. in cui si infrange la legge e si attira messi a disposizione dalla Rete. Ci sono progetti come IprediaOS, Polippix l’attenzione dei servizi di intelligence, non c’è

Distribuzioni blindate

Il verdetto J

“JonDo Live-DVD riesce a superare senza difficoltà Tails, l’ex re delle distro anonime”

1°

2°

3°

JonDo Live-DVD 

Tails 

HHHHH

HHHHH

Whonix 

HHHHH

4°

5°

Qubes OS 

UPR 

HHHHH

HHHHH

A voi la parola...

Considerate anche...

manuale hacker

85

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Privacy: Drive cifrati

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) /n la /n int i; /n /n per migliorare la vostra sicurezza e nascondere/n le vostre che non c’è modo di recuperare la password se{ ve usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n informazioni. ZuluCrypt è un’applicazione grafica dimenticate e che non c’è possibilità di decifrare il file, che è (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su di cifratura che ha un’interfaccia intuitiva e facile proprio lo scopo dell’applicazione! Dopo aver confermato la *), GFP_US : 1;da /nusare. group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t Grazie a essa potrete creare un disco cifrato all’interno password, premete sul pulsante Create per cifrare il file. Il gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag di un file, di una partizione e anche di un disco group_info->small_block; USB. Potrete processo può tempo, al tipo i++) di file{ /n /n durare else { un /n po’ difor (i = 0;ini base < nblocks; gid_ goto out_undo_partial_alloc; /n e allegroup_info->blocks[i] = b;finito, /n } /n } /n r perfino usarla per cifrare singoli file con GPG. Per installare che state cifrando sue dimensioni. Una volta free_page((unsigned /n /n.zC}nella /n /ncartella kfree(group_info ZuluCrypt andate all’indirizzo http://mhogomchungu. avretelong)group_info->blocks[i]); la versione cifrata con l’estensione nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc github.io/zuluCrypt e scorrete in basso la pagina fino alla di destinazione che avete scelto. Cifrato un file, cancellatene fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) sezione dei pacchetti binari. L’applicazione è disponibile la versione originale. Prima di leggerlo e poterlo modificare, *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS come pacchetto di file Deb per Debian e Ubuntu. Scaricate dovrete avviate ZuluCrypt andate a zC least one indirect block decifrarlo. pointer */Per /n farlo, nblocks = nblocks ?e : 1; /n group_info = km quello della vostra distro e decomprimetelo con D Decrypt File. Indicate il file cifrato nel campo/n Source /ntar xf return NULL; /n /n A group_info->ngroups = gidsetsize; group_info->nblo zuluCrypt*.tar.xz. Nella cartella estratta, aprite quella e cambiate la posizione del file sbloccato nel campo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n Poi scrivete if (!b) /nla password goto /n corrispondente all’architettura del vostro computer (i386 Destination. conout_undo_partial_alloc; la quale avete /n /n >= 0)pulsante { /n /n Create. free_page((unsigned long)grou per macchine a 32 bit e amd64 per quelle a 64undo_partial_alloc: bit). cifrato il filewhile e fate (--i click sul Quando /n /nbinari /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Entrambe le cartelle contengono quattro pacchetti l’operazione è finita, il file decifrato verrà creato nella block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ che potete installare in un colpo solo con il comando sudo destinazione indicata. Per cifrarlo un’altra volta, seguite .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n dpkg -i *deb. In altre distro dovrete installare ZuluCrypt la procedura che abbiamo visto. (gidsetsize + NGROUPS_PER_BLOCK - 1)appena / NGROUPS_PER_BLOCK; /n /* Make su manualmente. Scaricate l’archivio dell’applicazione : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US e seguite i passi dettagliati del file build-instructions per /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag gidsetsize; group_info->small_block; /n alla else { /nva bene forse (i ne = 0; i < nblocks; gid_ recuperare le dipendenze dai repository della vostra distro. Cifrare un file volta abbiamo giustoi++) { /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r Una delle prime cose da fare dopo l’installazione è creare un paio. In generale si tratta di una procedura scomoda free_page((unsigned /n /n di} leggere /n /n kfree(group_info versioni cifrate di tutti i file che ritenete sensibili. Lanciate adattalong)group_info->blocks[i]); a quei file che non abbiamo bisogno nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc l’applicazione e andate a zC -> Encrypt A File. Nella o di modificare regolarmente. Se invece vogliamo fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) finestra di dialogo che appare, premete sul pulsante accanto/n proteggere un /n certoint numero di/n file anblocks cui accediamo di *group_info; int nblocks; i; /n /n = (gidsetsize + NGROUPS al campo Source e trovate il file che volete cifrare. ZuluCrypt frequente, è molto metterli=innblocks aree cifrate. least one indirect block pointer */meglio /n nblocks ? : 1;ZuluCrypt /n group_info = km userà questa informazione per creare un file con può /n cifrare dispositivi a blocchi, cioè cifrare tutto ciò /n lo stesso return NULL; /n interi group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e che contengono. Questi dispositivi possono essere un disco free_page(GFP_USER); /nsua partizione if (!b) /n out_undo_partial_alloc; /n fisso, una o anche ungoto file montato come undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou dispositivo di loopback. Con la cifratura dei dispositivi /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group a blocchi, l’utente crea il filesystem sul dispositivo, e il livello block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc digidsetsize){ cifratura cifra/n i dati in modo trasparente prima di scriverli *groups_alloc(int struct group_info *group_info; /n int nblocks; / a blocchi sottostante. PER_BLOCK; /n nel/*dispositivo Make sure we always allocate Quando at least vengono one indirect block pointe nblocks*sizeof(gid_t *),leGFP_USER); /n if (!group_info) /n un insieme return NULL; /n /n cifrate, aree di archiviazione appaiono come mic_set(&group_info->usage, /n /n if (gidsetsize blocks[0] != group_info->small_block) /n si /napre int i; /n /n dovrete inserire il nome e completare il percorso della cartella in cui nascondere i vostri dati sensibili. Viene

ZuluCrypt: Drive cifrati Ecco un metodo nuovo per nascondere i vostri dati

A

Contenitori di file cifrati

ZuluCrypt supporta anche la cifratura a cascata che è il processo per cifrare un messaggio già cifrato, usando lo stesso algoritmo o uno diverso

86

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n e file nel dispositivo montato come fareste con qualsiasi p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info dispositivo normale. Quando avete finito, fate un click destro /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) sul / NGROUPS_ volume montato nell’interfaccia di ZuluCrypt er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + e selezionate l’opzione Close. Così smonterete e cifrerete group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoil volume. Ancora una volta avrete solo il singolo file cifrato group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < dal contenuto illeggibile. Montate di nuovo il file seguendo /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] la procedura hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n }già vista per vedere cosa contiene. Se avete (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n problemi a gestire più password, ZuluCrypt vi dà la for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = {di. creare chiavi casuali per cifrare file e volumi. possibilità n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = Per generare una chiave andate a Create D Keyfile. Inserite ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? il nome della chiave e il suo percorso di archiviazione. Non potete sbloccare un volume senza un header. SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = Dal punto di vista della sicurezza, non dovreste archiviare Se l’originale si rovina, create un backup con un click destro ge, 1); /n /n if (gidsetsize blocks[0] = le chiavi nello stesso disco fisso in cui ci sono i file o i volumi montato e scegliete l’opzione appropriata _t *b; /n su un b =volume (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= cifrati. 0) { /nInfatti, /n è meglio tenerle su un altro dispositivo per o); /n /n return NULL; /n} /nquando /n /n /nEXPORT_SYMBOL(groups_alloc); /nsicuri /n /nche / i vostri dati cifrati restino al sicuro anche essere chiamato file,/n perché viene cifrato, appare proprio cks[0] != group_info->small_block) { /n /n indicare int i; /n for (i = 0; se i ngroups = gidsetsize; /n group_info->nblocks = nblocks; ato-o un file cifrato. Selezionata questa opzione, dovrete l’applicazione alla chiave, che verrà usata scrivere una password per cifrare il file. Poi dovrete scegliere group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0;associare i< per bloccare i vostri dati. un tipo L’opzione predefinita è LUKS, /n if (!b) /n di Volume. goto out_undo_partial_alloc; /no Linuxgroup_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Unified Key Setup , che è un tipo di cifratura creata in modo (groups_alloc); /n /nper /nLinux. /nvoid groups_free(struct group_info specifico Oltre a LUKS, ZuluCrypt può anche*group_info) /n /n{ /n for (i = 0; creare i < group_info->nblocks; i++) /nVeraCrypt /n/nstructe group_info {. e aprire volumi TrueCrypt, Plain. Questiinit_groups Se volete=cifrare un gran numero di dati, è meglio mettere n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ultimi sono volumi cifrati senza header e l’informazione il contenitore cifrato all’interno di una propria partizione ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? cifratura viene/nfornitareturn da ZuluCrypt. Proprio per questo, oppure SER); /n ifdi(!group_info) NULL; /n /n group_info->ngroups = su un drive USB rimovibile. Notate che quando i volumi Plain dipendono dall’applicazione e non sono molto create questo ge, 1); /n /n if (gidsetsize blocks[0] = contenitore, ZuluCrypt si impossessa di tutta I volumi TrueCrypt o VeraCrypt sono alternative la partizione o di tutto il disco, quindi assicuratevi di avere _t *b; /n portatili. b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /nout_undo_partial_alloc: /n while (--i >= fatto 0) { /n /n migliori, /n se /n il volume cifrato va condiviso tra/n computer con il backup dei dati presenti. Inoltre, assicuratevi che o); /n /n return /n /n} /nvolta /nEXPORT_SYMBOL(groups_alloc); /n /n /ndi/destinazione o il drive non sia montato. Usate Linux,NULL; Windows e OS/n X./n Una deciso il tipo di Volume, la partizione cks[0] != group_info->small_block) { /n int che i; /nesegua /n for (i = 0; ili comando < group_indovrete scegliere un codice, un /n algoritmo mount per vedere tutte le partizioni montate. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info la cifratura e la decifratura vere e proprie. Un attributo Se la partizione che volete usare mostra /dev/sdb1, S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at del codice è la dimensione associata della*), chiave. che è montata e dovrete smontarla con sudo malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); /n ifsignifica (!group_info) Con l’aumentare delle dimensioni della chiave,1); aumenta umountusage, /n /n if (gidsetsize anche complessità della ricerca, punto in /n cui D Encrypted else { /n for (i la = 0; i < nblocks; i++) { /n fino algid_t *b; b = (void *)__get_ Container In A Hard Drive. Nella finestra group_info->blocks[i] = b;violare /n direttamente } /n } /n la return group_info; /n che /n /nout_ diventa impossibile cifratura. appare, ZuluCrypt elencherà tutte le partizioni up_info->blocks[i]); /n } /n kfree(group_info); /n /n return NULL; /n /n} Il codice di/n cifratura più/n popolare è l’Advanced Encryption disponibili che/npuò usare per archiviare il volume cifrato. p_info *group_info) /n{ /n /nè basato if (group_info->blocks[0] != una group_info->small_ Notate che i dispositivi sono elencati sia per nome, sia Standard/n(AES) che sul codice Rijndael. Con ‘Hello World’);”> ngroups Fate un doppio click sul drive o sulla partizione in cui volete tanti altri, gli algoritmi /n Twofish ge, 1); /n /n supporta if (gidsetsize blocks[0] = _t *b; /n e Serpent. b = (void if (!b) /n creare il volume. Ora potete creare un volume cifrato nel Lo*)__get_free_page(GFP_USER); US National Institute of Standards/nand return group_info; /n /n /nout_undo_partial_alloc: 0) { /n /n usando la stessa procedura già vista in precedenza Technology ritiene che questi due abbiano /n un /n livellowhile (--i >= drive, o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n / cifrato in un file. Anche se all’inizio può per crearne/n uno di sucurezza maggiore dell’AES, ma sono più lenti. Potete cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_insembrare difficile da usare, non ci metterete molto ad selezionare tranquillamente i valori predefiniti per ogni ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info abituarvi a questa campo, il filesystem predefinito per il volume S_PER_BLOCK - 1) /compreso NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at applicazione. Non c’è modo più facile per tiene alla propria privacy per proteggere i propri dati. (ext4) e fare click pulsante Create. Finita la procedura,/n ifchi malloc(sizeof(*group_info) + sul nblocks*sizeof(gid_t *), GFP_USER); (!group_info) vedrete file con il nome che avete indicato per ocks = nblocks; /n unatomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n di archiviare file in questo volume cifrato, dovrete decifrarlo p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ e montarlo. Andate a Open -> PLAIN,LUKS,TrueCrypt ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info In A File. Usate il pulsante file nella finestra che - 1) / NGROUPS_ /n int i; /nContainer /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK appare = per trovare?il :file del contenitore che avete er */ /n nblocks nblocks 1; /n group_infocifrato = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n cambiare group_info->nblocks = nblocks; /n atoappena creato. Volendo, potete il nome di mount group_info->blocks[0] group_info->small_block; else Open. { /n for (i = 0; i < del file, oppure=potete inserire la password e/n premere /n if (!b) /n la spunta goto out_undo_partial_alloc; /n group_info->blocks[i] Mettete all’opzione, se volete solo leggere hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } i contenuti del volume cifrato. Dopo avere montato il volume, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n nel vostro filesystem come qualsiasi altro World’);”> for (i = 0; apparirà i < group_info->nblocks; i++) /n /n echo(‘Hello elemento. La finestra principale di ZuluCrypt mostrerà ZuluCrypt ha anche lo strumento ZuluMount per montare tutti i volumi cifrati il volume e il suo intero percorso. Ora potete creare cartelle che supporta, ma che serve anche come strumento generico di montaggio

Codificare partizioni e dischi

manuale hacker

87

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Privacy: Eliminazione sicura

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) /nleggibili /n int i; /n /n Secondo il NIST (National Institute of Standards usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n DBAN Eliminazione: la più lenta 0 file leggibili Technology, www.nist.gov) ci sono tre livelli di sanificazione (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Secure Erase Eliminazione: la più veloce 0 file leggibili (o cancellazione): clearing (pulizia), purging (eliminazione) e : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US destroying (distruzione). Il primo livello previenegidsetsize; la possibilità Degaussing Eliminazione: hardware 0 file leggibili /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag specializzato di recuperare i dati usando le normali utility pergroup_info->small_block; il ripristino /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ Distruzione 0 file out_undo_partial_alloc; /n Distruzione group_info->blocks[i] = leggibili b; /n } /n } /n r di dati, file o dischi. Eliminazione fa in modo chegoto dei tecnici free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info di laboratorio, che usano particolari strumenti per nvoid l’elaborazione dei segnali, non riescano comunque a groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) recuperare nulla. Distruzione, infine… beh, prevede la *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS distruzione fisica del disco che quindi non può più essere DBAN Nuke, least one indirect block(Darik’s pointer Boot */ /n And nblocks = http://dban.org) nblocks ? : 1; /n group_info = km usato. Per realizzare questo tutorial abbiamo impiegato sette NULL; è un’applicazione distribuita da Blancco. L’immagine /n return /n /n group_info->ngroups = gidsetsize; /n group_info->nblo diversi metodi di cancellazione dei dati dal discoNGROUPS_SMALL) Seagate ISO del gratuita, fornita dal produttore è pensata /n CD,group_info->blocks[0] = group_info->small_block; /n e /n domestico if (!b) /n goto out_undo_partial_alloc; /n 5400.6 da 160 GB di un portatile: i tool standardfree_page(GFP_USER); rm, format per l’utente che deve cancellare il suo disco undo_partial_alloc: /nma /n l’azienda while (--iha >=anche 0) { /nun/nprodotto free_page((unsigned long)grou e shred; i programmi DBAN e Secure Erase; degaussing fisso, con licenza /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n group (demagnetizzazione) con una macchina specializzata; commerciale per le applicazioni in /nvoid ambitogroups_free(struct lavorativo. block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ distruzione fisica. Non tutti hanno accesso a dei macchinari Questo tool è una raccolta di algoritmi di cancellazione .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n che costano attorno ai 9.300 € o hanno voglia di prendere e di configurazioni che- 1) l’utente seleziona per ripulire/n /* Make su (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_PER_BLOCK; a martellate il proprio hard disk, quindi, leggendo il contenuto del disco indicato. Quando lo si esegue, : 1;questo /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US articolo, potrete beneficiare dei nostri esperimenti senza /n group_info->nblocks questo software cancella il disco/nfisso con un insieme gidsetsize; = nblocks; atomic_set(&group_info->usag group_info->small_block; { /n for (i = 0; i < nblocks; i++) { /n gid_ correre rischi! Potete leggere come abbiamo condotto i test casuale di/n datielse preselezionati. Il processo sovrascrive goto out_undo_partial_alloc; = b; /n } /n } /n r nel box della pagina a fianco (Procedura di test), mentre i i dati relativi /n ai file, al group_info->blocks[i] filesystem e tutte le locazioni free_page((unsigned long)group_info->blocks[i]); /nobiettivo /n } /n è/ndi kfree(group_info risultati sono riassunti nella tabella che vedete in questa indirizzabili dell’unità a disco. Il suo nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc pagina. Come potete osservare, cinque dei sette metodi rimpiazzare tutti i dati con informazioni casuali fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) forniscono diversi livelli di sanificazione. Quale adottare da un/nalgoritmo. essere impiegato + NGROUPS *group_info; /n generati int nblocks; int i; /n DBAN /n /n può nblocks = (gidsetsize dipende da caso a caso. Il comando shred, per esempio, sì solo su dischi cioè = drive identificati least onefaindirect block pointerfunzionanti, */ /n nblocks nblocks ? : 1; /ndalgroup_info = km che i file diventino illeggibili, ma bisogna applicarlo BIOS/ne /n in buono stato di funzionamento. Scaricate /n return NULL; group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n 2.8.8group_info->blocks[0] = group_info->small_block; /n e manualmente a ogni singolo file, il che lo rende improponibile DBAN beta dal sito del produttore e masterizzate if (!b) /nil software goto out_undo_partial_alloc; /n per ripulire un intero hard disk. All’altro estremofree_page(GFP_USER); della scala, il l’ISO su/n un CD. Quando finisce il boot, undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou degaussing e la distruzione rendono illeggibili i dischi fissi, scegliete la voce DBAN dall’elenco. /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group quindi non potete usare questi metodi se volete passare il A questo punto potete selezionare il disco su cui block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc disco a qualcun altro. In questo tutorial, quindi, vi mostriamo operare; per fare modifiche alle*group_info; impostazioni/n int nblocks; / *groups_alloc(int gidsetsize){ /n delle struct group_info come impiegare voi stessi gli ultimi quattro metodi della usare le scorciatoie da tastiera indicate in bassoblock pointe PER_BLOCK; /npotete /* Make sure we always allocate at least one indirect nblocks*sizeof(gid_t GFP_USER); /n if (!group_info) tabella (ipotizziamo che siate in grado di usare shred da soli). nello *), schermo. Selezionate il disco su cui/n voletereturn NULL; /n /n 1); /n /n F10 if (gidsetsize /n Una piccola avvertenza: non provate le tecnichemic_set(&group_info->usage, qui spiegate operare e poi premete per iniziareblocks[0] != group_info->small_block) { /n /n int i; /n /n secondo computer con un hard disk che può essere questo tool deve generare e poi scrivere i dati casuali sacrificato in nome dell’apprendimento. in ogni bit del disco.

Eliminazione sicura dei dati

Esploriamo le varie opzioni a vostra disposizione per assicurarvi che i dati presenti nei vecchi hard disk non finiscano in mani sbagliate

S

Cancellare con DBAN

Tip Se non avete paura di rischiare, le varianti di Fedora e Ubuntu dispongono del tool hdparm che può essere installato rispettivamente con yum e apt-get.

88

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Prima di sottoporre il nostro hard disk ai differenti group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atometodi di “pulitura”, lo abbiamo preparato group_info->blocks[0] = group_info->small_block; /nusando else {una /n for (i = 0; i < standard. Per prima cosa, abbiamo /n if (!b)procedura /n goto out_undo_partial_alloc; /n rimosso group_info->blocks[i] i dati presenti usando il software RCMP TSSIT hile (--i >= 0) {tutti /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } OPS-II nelgroups_free(struct CD di DBAN. Questo metodo è *group_info) stato (groups_alloc); /n /npresente /n /nvoid group_info /n /n{ /n dal governo canadese e rimpiazzato da CSECinit_groups = { . for (i = 0; i nblocks; i++) /n /n/nstruct group_info ITSG-06, un metodo /n che int sfrutta il Secure Dopo n struct group_info *group_info; nblocks; /n Erase. int i; /n /n /n nblocks = i dati sono stati cancellati, partizionato ure we alwaysche allocate at least one indirectabbiamo block pointer */ /n nblocks = nblocks ? il drive (usando lo abbiamo formattato in ext3 SER); /n if (!group_info) /n fdisk), return NULL; /n /n group_info->ngroups = (usando mkfs.ext3) e abbiamo copiato nove tipi ge, 1); /n /n if (gidsetsize blocks[0] = diversi (DOC, DOCX, EPUB, JPG, PNG, ODS, ODT, _t *b; /n b = (void *)__get_free_page(GFP_USER); /n TXTif (!b) /n return group_info; /n /nout_undo_partial_alloc: /n /n while e ZIP),/nassicurandoci che fossero leggibili. Dopo aver (--i >= 0) { /n /n o); /n /n return NULL; /nogni /n} metodo /n /n /ndi/nEXPORT_SYMBOL(groups_alloc); /n /n /n / completato cancellazione, abbiamo cks[0] != group_info->small_block) /n /n int i; /n /nper cercare for (i = 0; i < group_inmesso all’opera il tool di{ recovery PhotoRec truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info di recuperare i file. I comandi di preparazione alla distruzione dei dati! /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n forsupported (i = 0; i < not enabled In alternativa agoto DBAN, i dischi costruiti dopo /n if (!b) /n out_undo_partial_alloc; /nil 2001group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n locked } not dispongono di un firmware che prevede la sanificazione (groups_alloc); /n /n /n /nvoid *group_info) /n /n{ /n frozen dei dati senza dovergroups_free(struct ricorrere a softwaregroup_info esterni. Un for (i = 0; disco i < group_info->nblocks; /npuò /n/nstruct group_infoininit_groups {. not = expired: security count ATA identificato dali++) BIOS essere cancellato n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = supported: enhanced erase modo sicuro richiamando il comando Secure Erase da ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? I parametri not frozen, not locked ed enabled devono Ogni/ncomando digitato eseguito SER); /n ifterminale. (!group_info) return NULL; verrà /n /n subito group_info->ngroups = risultare così sul disco. Durante il processo, l’hard disk può bloccarsi, ge, 1); /n /n if (gidsetsize blocks[0] = sul disco per poter procedere con un Secure Erase. Il wiki che trovate all’URL http://bit.ly/ al sistema operativo. _t *b; /n rendendolo b = (void inaccessibile *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= SecureErase 0) { /n /n include le spiegazioni del perché le Durante/n i nostri test ci è successo proprio questo, non o); /n /n return NULL; /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n condizioni di /messa in opera possono esistere e come intenzionalmente, e il/n disco è divenuto inutilizzabile cks[0] != group_info->small_block) { /nriusciti /n intrimediare i; /n /n usando for (i = 0; correggere i < group_inla situazione. Nei nostri test siamo riusciti (ma fortunatamente siamo a ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info a stabilire il parametro not frozen con un procedimento il comando per definire la password di sicurezza). Per S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at da Edoardo Liverani (http://bit.ly/ questa ragione,+i nblocks*sizeof(gid_t rischi associati al facile accesso al /n ifsegnalato malloc(sizeof(*group_info) *), GFP_USER); (!group_info) Liverani), Secure possono essere mitigati usando un/n if (gidsetsize ocks = nblocks; /n Erase atomic_set(&group_info->usage, 1); /n blocks[i] = b;qualcosa /n } /n } /n return group_info; /n esperimento /n /nout_ supportavano l’hot swap (cioè avremmo sperimentazione: come SystemRescueCD up_info->blocks[i]); /n /n } /n /nche kfree(group_info); /n return NULL; /n} /n potuto/nrimuovere i dischi a computer acceso). Di solito, (www.sysresccd.org), contiene il set di /n comandi p_info *group_info) /n /n{ L’immagine /n /n if (group_info->blocks[0] != group_info->small_ però, è una pessima idea rimuovere o sostituire dei Secure Erase. di questa distro contiene una ‘Hello World’);”> ngroups = /sys/block/sdX Nell’output fisso; un al boot consente ge, 1); /n /n suifdisco (gidsetsize blocks[0] = che appare, cercate una stringa simile _t *b; /n di scegliere b = (void se *)__get_free_page(GFP_USER); if (!b) /n a host5. Questo è il numero dell’host che vi serve. operare da riga di comando o/n via return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= Scollegate 0) { /n /n il drive e spegnete il computer (ricordate interfaccia grafica. Il sito del progetto contiene o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /nche /n /n / quello abbiamo detto sul non scollegare i dischi un’abbondante documentazione che spiega come cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_ina PC acceso). Ora digitate: creare un CD/DVD o un un’unità USB avviabili. Dopo ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info echo 1 > /sys/block/sdX/device/delete il boot, scelto la versione grafica, avete sure accesso, S_PER_BLOCK - 1) /avendo NGROUPS_PER_BLOCK; /n /* Make we always allocate at l’unità a disco e scrivete con i privilegi di+ root, a un sistema operativo Linux /n ifRicollegate malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); (!group_info) echo “- /sys/class/scsi_host/host#/scan completo e alle applicazioni a corredo. Se la ocks = nblocks; /n atomic_set(&group_info->usage, 1);macchina /n /n if (gidsetsize else { /n (i = 0; i a< una nblocks; { /n gid_t richiederà *b; /n *)__get_ Controllate lo stato del drive con hdparm per èfor collegata rete, i++) il processo di avvio unb = (void group_info->blocks[i] = b; /n } /n per } /n return group_info; /n assicurarvi /n /nout_ che il parametro not frozen sia attivo. Per indirizzo IP al DHCP della rete collegarsi alla rete up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n procedere con il Secure Erase, il prossimo parametro stessa e a Internet. Nei prossimi comandi che p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ di sicurezza da cambiare è enabled. Per abilitare la indicheremo, vedrete due parametri: X e #. X è l’ID ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info device. Questa informazione la potete trovare da /n int i; /ndel /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ un’applicazione GParted oppure leggendo er */ /n nblocks = nblockscome ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n ègroup_info->nblocks l’output di dmesg. #, invece, il numero dell’host. = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n unelse { /n for (i = 0; i < Vedrete più avanti cosa intendiamo. Aprite terminale /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] e invocate il tool hdparm nel modo seguente: hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } hdparm -I /dev/sdX (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n dovreste vedere del genere: for (i = 0; Nell’output i < group_info->nblocks; i++)qualcosa /n /n echo(‘Hello World’);”> Security: Master password revision code = 65534

Procedura di test

Usare Secure Erase

L’operazione di sanificazione di un hard disk tramite DBAN, registrata usando una semplice videocamera

manuale hacker

89

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Privacy: Eliminazione sicura

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou attuatore. Quando questa /n bobina segnali sicurezza sul disco digitate il comando seguente: /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nriceve /nvoiddei groups_free(struct group block) { /n /n elettrici, int i; /nla /ntestina formagnetizza (i = 0; i < group_info->nblocks; i++) /n /n/nstruc la superficie del piatto. hdparm --user-master u --security-set-pass sean /dev/sdX *groups_alloc(int gidsetsize){ structsui group_info *group_info; I dati vengono/n registrati piatti come una serie/n di 0int nblocks; / Potete usare la password che volete al posto di sean. PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe e 1 magnetici. Un degausser per hard disk è un Per riportare il disco allo stato not enabled usate La documentazione nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n sul Secure Erase dispositivo elettronico che genera un intenso campo hdparm --user-master u --security-disable sean mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n richiedono scombussola tutte le informazioni magnetiche sdX usage = ATOMIC_INIT(2) /n /nstruct group_info gidsetsize){ /n addirittura contenute};sui piatti. Noi abbiamo *groups_alloc(int usato un degausser Ora potete inizializzare il Secure Erase così: (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su il parametro hdparm --user-master u --security-erase sean /dev/sdX Garner HD-3WXL per sanificare il nostro disco (potete --i-know: 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US vedere un video d’esempio all’URL Prima di far tornare il disco in servizio, assicuratevi what-i-am-doing gidsetsize; /n group_info->nblocks = nblocks; /n http://bit.ly/ atomic_set(&group_info->usag Degausser). interna di iquesto dispositivo che i parametri not enabled, not locked e not frozen (so cosa sto group_info->small_block; /n L’elettronica else { /n for (i = 0; < nblocks; i++) { /n gid_ facendo) per essere carica dei condensatori per immagazzinare siano di nuovo attivi, altrimenti il sistema operativo goto out_undo_partial_alloc; /n group_info->blocks[i] =l’energia, b; /n } /n } /n r completati. free_page((unsigned /n Quando /n } /n poi /n questi kfree(group_info comelong)group_info->blocks[i]); quando si carica una batteria. non riuscirà ad accedere al disco. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc condensatori vengono fatti scaricare attraverso fo->nblocks; i++) /n /n echo(‘Hello World’);”> class=”text” speciali bobine presenti nel device,usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) /n /n int i; /n /n demagnetizzazione non rimuove solo i dati{ dell’utente, rivestiti di ossido di ferro. Su ogni piatto scorre usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n ma anche altre informazioni memorizzate nei piatti in testina azionata da un dispositivo a bobina chiamato (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su fase costruzione, rendendo del+tutto inservibile : 1; /n group_info = di kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US l’unità. Dopo l’operazione di degaussing abbiamo gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag provato a /n inserire nel il BIOS lo ha{ /n group_info->small_block; elseil{ disco /n forcomputer: (i = 0; i < nblocks; i++) gid_ goto out_undo_partial_alloc; /n poi hagroup_info->blocks[i] = b; /n } /n } /n r individuato, ma fallito l’analisi riportando la free_page((unsigned long)group_info->blocks[i]); /n suo /n firmware } /n /n kfree(group_info presenza di un errore nel drive o nel nvoid groups_free(struct group_info con *group_info) prima di continuare il boot. /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km L’ultimo che abbiamo applicato è la distruzione /n return NULL; /n /nmetodo group_info->ngroups = gidsetsize; /n group_info->nblo fisica/ndell’hard disk. Questo vuol dire fare a pezzi i piatti NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); (!b) /n fisicamente gotoimpossibile out_undo_partial_alloc; /n del drive/ncosì daifrendere la undo_partial_alloc: /n /n whileQuesto (--i >= 0) { /n /n fatto free_page((unsigned long)grou lettura dei dati. può essere con trituratori /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group meccanici o un frantumatore meccanico. La società block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ Security Engineered Machinery, che crea strumenti di .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n questo tipo, ha messo-online alcuni video interessanti, Il Terminator (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_PER_BLOCK; /n /* Make su come questo: http://bit.ly/1BY3LvD. Se non avete : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US della pulizia dei a disposizione un trituratore (un/noggetto non certo gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag dati: l’HD-3WXL group_info->small_block; /n potete else { usare /n fortrapano (i = 0; i < nblocks; i++) { /n gid_ Data Eliminator economico), un elettrico per fare goto out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r dei buchi sui /n piatti o per graffiarne la superficie. free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Qualcuno suggerisce che anche il semplice piegare nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc i piatti li rende illeggibili. Eppure alcune teorie indicano fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) organizzazioni hanno a=disposizione *group_info; /n che intle nblocks; /n int i;governative /n /n /n nblocks (gidsetsize + NGROUPS delle tecnologie in /n grado di recuperare i dati meno least one indirect block pointer */ nblocks = nblocks ? : 1;a /n group_info = km fornisce un rimedio, che riassumiamo Se preferite usare UNetbootin in una che /n i piatti siano totalmente = distrutti. Cercando un /n return NULL; /n non group_info->ngroups gidsetsize; /n group_info->nblo qui di seguito. distro Linux per far avviare DBAN da NGROUPS_SMALL) /nRete group_info->blocks[0] /n e po’ in siamo incappati anche=ingroup_info->small_block; qualcuno che si è Nel file syslinux.cfg presente nella una chiave USB, dovete modificare free_page(GFP_USER); if (!b) goto out_undo_partial_alloc; /n divertito/na sparare con/n un fucile (sì, esatto… sparare) chiavetta USB creata con UNetbootin alcuni file affinché ciò funzioni. undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou a un disco fisso, ma non crediamo sia una cosa da fare. fate le modifiche seguenti: Di default, con DBAN, l’unità USB /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group avviabile creata da UNetbootin va rimpiazzate tutte le occorrenze di Oppure potreste usare una mazza da baseball come block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc in stallo e genera un errore relativo ubninit con ISOLINUX.BIN; nelgidsetsize){ film Impiegati… male! (trovate il*group_info; trailer all’URL *groups_alloc(int /n struct group_info /n int nblocks; / al RAM disk, il che in realtà è una cosa rimpiazzate tutte le occorrenze di al minuto 1 e block pointe PER_BLOCK; /nhttp://bit.ly/RgOoZ9, /* Make sure we alwaysguardate allocate circa at least one indirect positiva, perché la configurazione ubnkern con DBAN.BZI; nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n 52), ma non siamo convinti che sia un metodo efficace. di default creata da UNetbootin cancellate --autonuke dalla sezione mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /nnon /n int i; /n /n finiscano in mani sbagliate. Speriamo che vi siano utili UNetbootinBugs), Alex Pounds i cambiamenti. in caso di bisogno.

Tip

Demagnetizzazione e distruzione

Misure estreme

DBAN e UNetbootin

90

manuale hacker

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Privacy: Protezione totale

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1);è/n if usare (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n cifratura di intere partizioni usando il sottosistema impostate la directory cifrata con il comando seguente: usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n del kernel. Questo metodo (che abbiamo già spiegato in sudo mount.ecryptfs crypt plain (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su passato) è in grado di cifrare intere unità a blocchi, di/n solitogroup_info Il sistema vi farà diverse domande: ovviamente dovete : 1; = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US una partizione di un disco. Tale soluzione è ottimale per la scegliere una password che sia sicura ma anche non gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag protezione del sistema nel suo complesso, ma rende disponibili impossibile/n da memorizzare in un posto group_info->small_block; else { /n (oppure for (i =registratela 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; /n parte group_info->blocks[i] = b; /n } /n } /n r tutti i file dopo che si è eseguito il boot. Ci sarebbegoto anche sicuro). Alla maggior delle altre domande potete long)group_info->blocks[i]); /ntranne /n }alla /n domanda /n kfree(group_info TrueCrypt, che funziona sia con interi device chefree_page((unsigned con dischi rispondere accettando i valori di default, nvoidfisso). groups_free(struct group_info *group_info) /n /n{voler /n /n if (group_info->bloc virtuali (un grosso file che si comporta come un disco Enable Filename Encryption che potreste impostare fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Anche in questo caso, in passato, ne abbiamo parlato spesso, a yes. Ora copiate alcuni file nella cartella plain e subito dopo *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS ma nel 2014 il progetto è stato abbandonato per problemi guardate dentro crypt. dei file con lo stesso least onecon indirect block pointer */ /nVedrete nblocks = nblocks ? : 1;nome, /n group_info = km il suo livello di sicurezza; anche se ne sono nati un/n paio direturn fork, NULL; se non attivato la cifratura dei nomi dei file. Ma/n questa /navete /n group_info->ngroups = gidsetsize; group_info->nblo molte persone usano ancora la versione 7.1a (la versione 7.2 volta/n il loro contenuto è criptato. Se non credete, provate NGROUPS_SMALL) group_info->blocks[0] = ci group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n Ora smontate gotoilout_undo_partial_alloc; /n consentiva solo di vedere i volumi cifrati con TrueCrypt). a visualizzarne il contenuto. tutto con undo_partial_alloc: /numount /n while free_page((unsigned long)grou Essendo un progetto non più attivo, comunque, ne sudo plain(--i >= 0) { /n /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid solo groups_free(struct group sconsigliamo l’uso. Un’altra via è quella di far gestire la cifratura La versione leggibile dei file sparisce, lasciando quella block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ al filesystem, come fa ZFS sui sistemi Sun, ma nessuno dei cifrata. Rilanciate il comando mount di prima, e plain tornerà .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n filesystem “classici” di Linux prevede questo metodo. visibile. Questo esempio è- 1) semplice e anche un po’ scomodo (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_PER_BLOCK; /n /* Make su volendolo usare spesso, ma spiega bene il funzionamento del *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t sistema. Il filesystem che montato plain è virtuale, gidsetsize; /n group_info->nblocks = avete nblocks; /n su atomic_set(&group_info->usag group_info->small_block; /nmemoria; else { /n = 0; sul i < disco nblocks; gid_ esiste solo in gli unicifor file(iscritti sonoi++) quelli{ /n Il sistema che vedrete in queste pagine è differente e prevede goto out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r in crypt e sono/n cifrati. Una volta che smontate la directory l’uso di un filesystem montato sopra un altro (stacked free_page((unsigned /nsono } /n kfree(group_info plain, ilong)group_info->blocks[i]); dati che contiene sono protetti e/n non più/n accessibili filesystem), mentre cryptsetup, citato prima, implementa un nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc a meno che non rimontiate il filesystem, operazione che layer virtuale cifrato su un dispositivo a blocchi, il tutto posto fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) la password chei;avete sotto il filesystem. Visto che eCryptfs funziona sopra a un *group_info; /n richiede int nblocks; /n int /n /nscelto. /n nblocks = (gidsetsize + NGROUPS normale filesystem, non è obbligatorio usarlo su un’intera least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km partizione, ma può essere applicato a directory individuali. /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /nun metodo group_info->blocks[0] = group_info->small_block; /n e Questo è il metodo adottato da Ubuntu per cifrare la directory Esiste più semplice e automatizzato per impostare free_page(GFP_USER); /n cifrata if (!b) /nricorrere agoto /n una directory senza sudoout_undo_partial_alloc; o dover rispondere undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou a qualche domanda. Eseguite il comando seguente come /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group utente normale: block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(intecryptfs-setup-private gidsetsize){ /n struct group_info *group_info; /n int nblocks; / comando vi chiederà vostra password che usate al block pointe PER_BLOCK; /nQuesto /* Make sure we always la allocate at least one indirect nblocks*sizeof(gid_t /n per if (!group_info) /n La prima returnè NULL; /n /n login e*), poiGFP_USER); una passphrase la directory cifrata. mic_set(&group_info->usage, 1); la /nseconda, /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n sonoint i; /n /n memorizzati i file usati per montare la vostra directory. Poiché anche la passphrase è cifrata, dovreste farne una copia e

Protezione totale per i dischi Vi spieghiamo come tenere i vostri preziosi file al riparo da occhi indiscreti, perfino dagli altri utenti del vostro computer

D

Signore e signori: eCryptfs Ecco come appaiono i nomi dei file dopo essere stati cifrati. Anche il loro contenuto è illeggibile

92

manuale hacker

Cifratura semplificata

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + essere velocizzato evitando di cifrare anche i nomi ECryptfs ha diversi vantaggi rispetto all’uso Directory – eCryptfs può essere impiegato group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atodei file. di LUKS/dm-crypt: anche sulle cartelle di sistema e sullo swap, group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < una corretta voce in fstab, ma in questo Backup nelgoto cloud – Visto che la cifratura Aumento delle dimensioni – Visto che ogni /n if (!b) /n out_undo_partial_alloc; /n usandogroup_info->blocks[i] caso vi chiederà l’inserimento di file, potete fare una copia della file viene cifrato singolarmente, la dimensione hile (--i >= 0) {avviene /n /n a livello free_page((unsigned long)group_info->blocks[i]); /n /n } della passphrase. vostra cartella .Private su cloud o disco USB group_info di ogni file cresce, il che può essere significativo Login per la lettura – I dati (groups_alloc); /n /n /n /nvoid groups_free(struct *group_info) /n /n{ /n dell’utente sono dovervi preoccupare che documenti group_info trovandosi di fronte a tanti file piccoli, come le leggibili solo quando l’utente for (i = 0; i nblocks; i++)i vostri /n /n/nstruct init_groups = { .è loggato e anche vengano*group_info; letti da altri. Assicuratevi solo di fare/n una int i; email o la cache del browser. in /n questo casonblocks eCryptfs = li rende leggibili solo a lui n struct group_info /n int nblocks; /n /n di .ecryptfs. ure we alwayscopia allocate at least one indirect block pointer */ nblocks ? sistema. (e a/n root)nblocks e non agli=altri utenti del Non è cross-platform – eCryptfs funziona SER); /n if (!group_info) /n return– NULL; /n group_info->ngroups = directory con molti file solo con Linux, poiché usa funzionalità del kernel, Sicurezza multi-utente eCryptfs/n può Molti file – Gestire ge, 1); /n /n if (gidsetsize NGROUPS_SMALL) group_info->blocks[0] = se il processo può ma questo può non essere un problema. cifrare directory= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n per esempio int i; /n /n for (i = 0; i < group_inmetterla al sicuro da qualche parte, una chiave truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info USB che però non dovete tenere vicino al vostro PC: /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ ecryptfs-unwrap-passphrase ~/.ecryptfs/wrappeder */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + passphrase>/da qualcheparte/sicura/ecryptfs_passphrase group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoOra potete montare e smontare i vostri dati privati group_info->blocks[0] = group_info->small_block; /n con else { /n for (i = 0; i < i comandi seguenti, oppure usare l’icona creata sul /n if (!b) /n goto out_undo_partial_alloc; /ndesktop: group_info->blocks[i] hile (--i >= 0)ecryptfs-mount-private { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n ecryptfs-umount-private for (i = 0; Vi i nblocks; i++) /ncifrata /n/nstruct group_info init_groups = { . con una singola cartella all’interno della n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = vostra home, ma cosa fare se si volesse qualcosa di più? ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? esempio, ipotizziamo che vogliate SER); /n ifPer (!group_info) /n return NULL;cifrare /n /n le cartelle group_info->ngroups = Documenti e Immagini ma non Musica e Video ge, 1); /n /n if (gidsetsize blocks[0] = tempo*)__get_free_page(GFP_USER); decifrando file che non contengono/nnulla if (!b) /n _t *b; /n perdere b = (void Se la vostra return group_info; /n /n /n while (--i >= di 0)cifratura { /n /n della directory home in Ubuntu (o in una delle sue di privato?). La/nout_undo_partial_alloc: risposta è semplice: spostate/n all’interno distro non o); /n /n return NULL; /n /n} che /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nUbuntu, /n / difatti, usa proprio eCryptfs, ma questa è di Private le cartelle volete proteggere e poi create dei link derivate). permette il cks[0] != group_info->small_block) /n /n così: int i; /n /n for (i = 0; una i < group_insimbolici nella loro posizione{ originale, funzione standard del kernel e non è limitata a una distro login come root, ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info dovete creare mv Documenti Private (anche ChromeOS usa eCryptfs, per esempio). Ubuntu non S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at ln -s Private/Documenti Documenti una cartella Private quando l’installate, ma cifra l’intera un nuovo utente malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifimposta (!group_info) con privilegi Assicuratevi che Private sia montata quando fate1);questa home. Ma ocks = nblocks; /n atomic_set(&group_info->usage, /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n seguire il link simbolico porterà solo a un errore. un singolo comando, ma l’operazione nasconde qualche poter cifrare la p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ problema. Non dovete avere alcun file in uso dentro home, vostra home ‘Hello World’);”> ngroups = di conversione. l’opzione -wblocks[0] = Quindi fate il login con un altro utente che abbia _t *b; /n unabpassword = (void *)__get_free_page(GFP_USER); if (!b) /n i diritti d’amministratore ed eseguite diversa da quella del login). Potreste/n però return group_info; /n /nout_undo_partial_alloc: /n /n while { /n /n sudo ecryptfs-migrate-home --user chiedervi/n come mai dovete digitare la vostra password per (--i >= 0) o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n / Terminato il/n processo, tornate a fare il login con il vostro utente sbloccare le cartelle cifrate se l’avete appena inserita al login. cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_innormale prima di riavviare il PC per completare il setup La domanda è lecita: la vostra identificazione all’accesso ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info e assicurarvi significa che conoscete la password. Volendo, quindi, potete S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate che at sia tutto a posto. Dopo aver verificato che file sono leggibili, potete cancellare i file originali, non fare in modo che+lanblocks*sizeof(gid_t vostra cartella Private venga montata malloc(sizeof(*group_info) *), GFP_USER); /n ifi vostri (!group_info) cifrati, che in automatico quando vi identificate per poi essere ocks = nblocks; /n atomic_set(&group_info->usage, 1); smontata, /n /n if (gidsetsize blocks[i] = b;Come /n root, } /ninserite } /n la return group_info; /n cartella /n /nout_ non rimuove i vostri dati non cifrati dal disco fisso, ma è permessa da PAM. linea seguente up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n solo il loro riferimento nella tabella delle directory. Per essere in /etc/pam.d/common-auth: p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ del tutto certi che siano illeggibili, dovreste sovrascrivere tutto auth required pam_ecryptfs.so unwrap ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info non usato con dei dati casuali, per esempio così: quest’altra in /etc/pam.d/common-session: /n int i; /ne/n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) lo / spazio NGROUPS_ dd if=/dev/urandom of=unfile bs=4k session= nblocks optional ?pam_ecryptfs.so unwrap er */ /n nblocks : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; atorm/n unfile Ora PAM monterà la vostra directory cifrata al login. group_info->blocks[0] = group_info->small_block; /nperché elseciò { /n for (i = 0; i< Questi comandi creano un file con dati casuali che riempie Ciò non succederà se avete attivato l’autologin, /n if (!b) /n gotoilout_undo_partial_alloc; /n group_info->blocks[i] il disco e poi lo cancellano liberando lo spazio. Che usiate vanificherebbe tutto discorso sulla sicurezza, ovviamente. hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } ecryptfs-setup-private o ecryptfs-migrate-home, dovreste (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n utilizzare ecryptfs-unwrap-passphrase per salvare la for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> passphrase altrimenti non potrete più accedere ai dati qualora Se tutto ciò che vi abbiamo detto finora vi sembra noto, la cartella .ecryptfs dovesse danneggiarsi o perdersi. è probabile che abbiate usato (o stiate usando) la funzione

Pro e contro di eCryptfs

Tutto in automatico

Cifrare l’intera home

manuale hacker

93

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Segreti della shell

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n preparazione. A supporto della triste fama che si/n è costruita usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n intorno alla riga di comando, spesso utilizzata come scusa dai (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su più pigri (e disinformati...) come scusa per rimandare : 1; /nil group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US passaggio a GNU/Linux, occorre notare che, effettivamente, gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag l’apprendimento dei segreti della shell richiede tempo group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r e dedizione: due fattori che non sempre vanno d’accordo free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info con i ritmi della vita quotidiana, specie per chi utilizza nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc il Pinguino fuori dall’ambito prettamente professionale. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Ma se, da un lato, con l’esplosione delle distribuzioni e il *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS susseguirsi di versioni sempre più user friendly, illeast pesoone dellaindirectFig 1: La pagina*/dell’emulatore terminale su/n Google block pointer /n nblocks =dinblocks ? : 1; group_info = km Play,/n da/n cui group_info->ngroups è possibile installare l’app gratuitamente shell nell’amministrazione domestica si è via via /n alleggerito, return NULL; = gidsetsize; /n group_info->nblo dall’altro la crescente diffusione di uno strumento ormai NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e /n è opportuno if (!b) /neffettuaregoto out_undo_partial_alloc; /n comune come lo smartphone ha aperto scenari free_page(GFP_USER); formativi l’app, tuttavia, una seconda undo_partial_alloc: /n /n prima while di (--i >= 0)la{ shell: /n /nscegliere free_page((unsigned long)grou sinora sconosciuti. Per quanto possa sembrare strano, infatti, operazione avviare una tastiera /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group uno smartphone equipaggiato con una versione/n recente di alternativa. La tastiera offerta/n nativamente da Android, infatti, block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ Android può trasformarsi in un potente alleato di ogni utente sebbene costituisca un imprescindibile ausilio per compiere .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n del pinguino, consentendo di studiare ed approfondire le operazioni più comuni-sullo (è perfetta per /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK 1) / smartphone NGROUPS_PER_BLOCK; i principali comandi di shell senza dover accedere a un telefonare, scrivere un messaggio o una email, navigare, ecc.), *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t computer. Le app Android che descriveremo in queste è pensata per uno scopo gidsetsize; /n group_info->nblocks = decisamente nblocks; /n differente atomic_set(&group_info->usag group_info->small_block; /n else {di/n for (i = 0; i < nblocks; i++) gid_ puntate, infatti, ci consentiranno di emulare un terminale sullo dall’amministrazione una Linux box, e risente pertanto di { /n out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r smartphone, dotando il “telefono” di un buon setgoto di comandi, una certa scomodità se impiegata all’interno del terminale. free_page((unsigned /n /n la}propria /n /n kfree(group_info sufficientemente rappresentativo delle reali esigenze di un Chi lo long)group_info->blocks[i]); desidera può migliorare sensibilmente nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc utente domestico. Di fronte alla possibilità di sfruttare un esperienza utente con l’emulatore di terminale, installando fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) qualsiasi momento di pausa per imparare o affinare la pensata proprio con/n un occhio *group_info; /n una inttastiera nblocks; /n int i; /n /n nblocks = (gidsetsize + NGROUPS conoscenza dei principali comandi di shell, direttamente sulindirect all’amministrazione la Hacker’s Keyboard, least one block pointer */dei /n sistemi: nblocks = nblocks ? : 1; /n che group_info = km nostro inseparabile smartphone, quale motivo (a/n esclusione riproduce nostro smartphone il layout di una normale return NULL; /n /nsulgroup_info->ngroups = gidsetsize; /n group_info->nblo /n da pc. group_info->blocks[0] = group_info->small_block; /n e della nostra atavica pigrizia, naturalmente!) può NGROUPS_SMALL) impedirci tastiera L’app è gratuita e disponibile, al pari del free_page(GFP_USER); /nsu Google if (!b) goto /n di acquisire la necessaria padronanza con il terminale? terminale, Play/n (Fig 2). Una voltaout_undo_partial_alloc; installata, tuttavia, undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou la tastiera deve essere abilitata dai menu di configurazione di /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Android: per motivi di sicurezza, infatti, il sistema richiede che block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc ogni modifica delle di input dello*group_info; smartphone /n int nblocks; / Il primo passo, ovviamente, non può che essere l’installazione *groups_alloc(int gidsetsize){ /n modalità struct group_info manualmente a curaallocate dell’utente, negando di un terminale. L’app Terminal Emulator for Android, PER_BLOCK; /navvenga /* Make sure we always at least onelaindirect block pointe *), GFP_USER); if (!group_info) return NULL; /n /n possibilità di modifiche /n automatiche da parte /n delle app. disponibile gratuitamente su Google Play (Fig 1)nblocks*sizeof(gid_t consente mic_set(&group_info->usage, /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n (magari con un look & feel identico a quella della tastiera vedremo nel proseguo, può essere ampliato per abbracciare nativa) che, imponendosi automaticamente come tastiera di gran parte dei comandi di uso comune). Una volta installata

Android: tutti i segreti della shell Chi avrebbe mai detto che si possa imparare Linux con un semplice “telefono”? Ecco come farlo grazie ai nostri consigli...

L

L’autore Maurizio Russo Laureato in Informatica presso l’Università “La Sapienza” di Roma, con una tesi sperimentale sullo stack TCP/IP del kernel Linux, è un utente del pinguino dal 2001. Nella sua carriera si è occupato di formazione, sicurezza, networking, progettazione e sviluppo di software.

94

Installazione di terminale e tastiera

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Fig 2: La pagina dell’app Hacker’s Keyboard su Google cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inPlay, da cui è possibile effettuare l’installazione truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info (senza oneri per l’utente!) /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + default dello smartphone, sia/n in grado di registrare ogni dato group_info->ngroups = gidsetsize; group_info->nblocks = nblocks; /n atols consente di visualizzare tutti i contenuti della directory corrente digitato dall’utente e inviarlo a un sito esterno,/n ivi compresi group_info->blocks[0] = group_info->small_block; else { /n forFig (i =3:0;Il icomando < i numeri di credito? Naturalmente, /n if (!b) /n delle nostre goto carte out_undo_partial_alloc; /n delegare group_info->blocks[i] hile (--i >= 0) { /n /nall’utente free_page((unsigned long)group_info->blocks[i]); /n /n } la scelta non significa garantirne l’immunità da ciascun file/subdirectory contenuta nella directory corrente, ls (groups_alloc); /n /n /nvoid groups_free(struct group_info /nle/n{ /n truffe/n come quelle appena descritte, ma di certo l’esame *group_info) elenca seguenti informazioni, distinte su colonne differenti: for (i = 0; critico i < group_info->nblocks; /n può /n/nstruct {. da parte di un essere i++) umano costituiregroup_info un ostacoloinit_groups tipo e=permessi di accesso (vedi box Permessi di n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = insormontabile per app fraudolente: non a caso, a ogni accesso ai file); ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? dei dispositivi di input NULL; da parte dello utente SER); /n ifmodifica (!group_info) /n return /ndell’utente /n group_info->ngroups = proprietario; smartphone (attraverso i menu Impostazioni -> Sistema -> gruppo proprietario; ge, 1); /n /n if (gidsetsize blocks[0] = e immissione -> Tastiera e metodi di immissione), _t *b; /n Lingua b = (void *)__get_free_page(GFP_USER); /n if (!b) /ndimensione in byte; return group_info; /n /nout_undo_partial_alloc: /n while (--i >= 0)tempo { /n /n Android /n visualizza un messaggio di warning,/n segnalando di ultima modifica (box I tempi di accesso dei file); o); /n /n return NULL;pericolo /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / il potenziale che/nl’azione può rappresentare. nome. cks[0] != group_info->small_block) { /n /n l’avviso int i;e/n /n for (i = 0; iEsaminando < group_in-l’output di ls, possiamo dedurre che ci troviamo Nel nostro caso, una volta superato provveduto ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info ad aggiungere la Hacker’s Keyboard tra i dispositivi di input nella root (/) del dispositivo: l’invocazione del comando pwd, S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at abilitati, è necessario selezionare la tastiera*), come dispositivo/n ifche restituisce il nome della directory corrente, ce ne fornisce malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); (!group_info) di input sancendo così la sostituzione 1); della la conferma ocks = nblocks; /ncorrente, atomic_set(&group_info->usage, /ntastiera /n if (gidsetsize blocks[i] = b;avendo /n } /ndi selezionare } /n return group_info; /n /n /nout_ Set input method, cura la Hacker’s in una Linux box per gli utenti non privilegiati, un’area del up_info->blocks[i]); } /n /n kfree(group_info); /nda /n return NULL; /n /n} /n Keyboard /n nel/n menu successivamente visualizzato filesystem accessibile in sola lettura. Per proseguire i nostri p_info *group_info) /n{ /n /n (group_info->blocks[0] group_info->small_ Android./n Al termine delleifnostre sessioni addestrative!= sulla esperimenti, è dunque necessario spostarci in una directory ‘Hello World’);”> ngroups = altro comando offerto dal nostro terminale, df, che consente ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n Terminate b = (void *)__get_free_page(GFP_USER); /n di ottenere un elenco di tutti i filesystem attualmente montati le predisposizioni iniziali, possiamo dedicarci allaif (!b) /n return group_info; /nout_undo_partial_alloc: /n /n while (--i >= 0) /n /n Il comando: sul{sistema. shell vera/ne /n propria. Avviamo l’emulatore di terminale, avendo o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / df cura di tenere lo smartphone in posizione longitudinale (e lo cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inproduce l’output rappresentato in (Fig 5), dal quale è possibile scorrimento automatico attivato). In questa posizione è ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info evincere, perat ciascun filesystem elencato, i seguenti elementi: possibile, sugli schermi più grandi, appieno dei always S_PER_BLOCK - 1) / specie NGROUPS_PER_BLOCK; /n godere /* Make sure we allocate vantaggi offerti dalla tastiera appena installata, come la directory di mount (colonna Filesystem); malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) disponibilità dei tasti CTRL, ESC, ALT e Fn e, soprattutto dimensione complessiva in MB (colonna Size); ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n del if (gidsetsize blocks[i] = b; /nun’esperienza } /n } /na dir return group_info; /n /n /nout_ con la shell può divenire poco frustrante: (colonna Used) e quella libera (colonna Free); up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n immaginate per un attimo di non avere la funzionalità di p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ completamento automatico offerta dal TAB, oppure di essere ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info a digitare=nuovamente stringa di un comando - 1) / NGROUPS_ /n int i; /ncostretti /n /n nblocks (gidsetsizel’intera + NGROUPS_PER_BLOCK per via di carattere sbagliato o di uno spazio omesso... Per er */ /n nblocks = un nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks fortuna, l’installazione della tastiera ci ha messo al sicuro=danblocks; /n atogroup_info->blocks[0] = group_info->small_block; else /n for (i = 0; i < questi inconvenienti, quindi possiamo passare/n subito al {primo /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] comando da esaminare. In che directory ci ha posizionato il hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } terminale all’avvio? Scopriamolo con il celeberrimo ls, per (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n tutti i i contenutii++) della/n directory corrente:World’);”> for (i = 0; visualizzare i < group_info->nblocks; /n echo(‘Hello ls -l Fig 4: Il comando pwd restituisce il nome della directory corrente ci restituisce, come output, la lista di tali contenuti (Fig 3). Per

Primi passi con il terminale

manuale hacker

95

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Segreti della shell

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Fig 5: /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group Il comando df block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc all’opera: ecco *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / i filesystem PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe montati sullo nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n smartphone mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n utilizzando: nel/nstruct nostro caso, la Bourne shell usage = ATOMIC_INIT(2) }; /n group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US argomento al comando.=Potrebbe una funzionalità gidsetsize; /n group_info->nblocks nblocks;sembrare /n atomic_set(&group_info->usag di poco conto, si rivela (per la group_info->small_block; /n ma else { /n molto forutile (i = negli 0; i blocks[i] = b; /n dei } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n box /n omonimo). } /n /n kfree(group_info contenuti delle variabili d’ambiente (vedi la dimensione del blocco, ovvero l’unità minima di nvoid groups_free(struct group_info A tal riguardo, digitando*group_info) per esempio /n /n{ /n /n if (group_info->bloc allocazione su disco (colonna Blksize). fo->nblocks; i++)echo /n /n echo(‘Hello World’);”> usage, 1); /n /n6).ifUn’altra (gidsetsize blocks[0] != group_info->small_block) /n /n int i; /n /n consentono di “spostare” su file l’output di un{comando tastiera installata), che serve per l’appunto per spostarsi da usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n arbitrario, sottraendolo al video cui questo è normalmente una directory all’altra. Per i più pigri, di certo spaventati dalla (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su destinato. Per esempio, con lunghezza del comando da digitare, è possibile ricorrere : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US echo buongiorno a tutti=>nblocks; buongiorno.txt all’autocompletamento offerto dalla nostra tastiera gidsetsize; /n group_info->nblocks /n atomic_set(&group_info->usag si redirige l’output di echo alternativa: dopo aver scritto la stringa ‘cd /st’, il nome della group_info->small_block; /n else { /n verso foril file (i =buongiorno,txt 0; i < nblocks;(che, i++) { /n gid_ goto out_undo_partial_alloc; /n all’interno group_info->blocks[i] /n } /n } /n r poiché non esiste della nostra directory=dib;lavoro, directory ‘storage’ può essere ottenuto semplicemente free_page((unsigned long)group_info->blocks[i]); /n /n sarà contestualmente creato), così come con } /n /n kfree(group_info premendo il TAB; una seconda pressione del medesimo tasto nvoid groups_free(struct group_info *group_info) /n /n{ if (group_info->bloc echo buongiorno o buonasera, a seconda di /n che/n ora sia >> farà apparire invece gran parte del nome della directory fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) buongiorno.txt annidata (sdcard0), cui dovremo aggiungere solamente lo 0 *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS si provvede ad accodare detta di “append”) finale, prima di confermare con il tasto INVIO. Una volta least one indirect block pointer */ /n (operazione nblocks = nblocks ? : 1; /n la group_info = km frase/n “buongiorno o buonasera, a seconda di che ora al ultimato lo spostamento nella directory di montaggio /n della return NULL; /n group_info->ngroups = gidsetsize; /nsia”group_info->nblo predetto Possiamo avere conferma buon esito delle sdcard, è opportuno creare una directory ad hocNGROUPS_SMALL) al cui interno /n file.group_info->blocks[0] = del group_info->small_block; /n e free_page(GFP_USER); /nappenaifeffettuate (!b) /n ricorrendo goto /n operazioni al out_undo_partial_alloc; comando cat, per convogliare i nostri esperimenti, a salvaguardia dai danni ai undo_partial_alloc: /n /n dei while (--i >= /ndi/n long)grou la stampa contenuti di 0) un {file testo. free_page((unsigned Il comando contenuti dello storage imputabili a eventuali operazioni /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group cat buongiorno.txt maldestre. Il comando: block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ produce il risultato in Fig 7, dimostrando come le due stringhe mkdir lxp .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n siano state effettivamente inserite all’interno del file. crea una directory di nome lxp, proprio all’interno della (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Reiterando il procedimento, possiamo+creare un secondo file, *), GFP_US sdcard. Per spostarci nella directory appena creata, : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t denominato salve.txt: = nblocks; /n atomic_set(&group_info->usag è sufficiente il già citato comando gidsetsize; /n group_info->nblocks group_info->small_block; else /n Pro! for> (i = 0; i < nblocks; i++) { /n gid_ echo salve,/n lettori di {Linux salve.txt cd lxp goto group_info->blocks[i] = b; /n } /n } /n r e un terzo, con/n nome saluti Alla creazione, la directory è ovviamente vuota; perout_undo_partial_alloc; creare /n }pro! /n >/nsaluti kfree(group_info echo long)group_info->blocks[i]); in conclusione saluti a tutti, qui /n a linux un file, in assenza di un editor fruibile da shellfree_page((unsigned (lacuna che, nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc per poi leggere i contenuti di entrambi con come vedremo, sarà colmata nel proseguo), possiamo fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) saluti ricorrere al comando echo, e ai metacaratteri*group_info; di /n cat intsalve.txt nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS A questo punto disponiamo di tre file nella directory, come ci redirezione dell’input/output, entrambi supportati least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km può confermare il comando dall’emulatore di shell. Il comando echo consente /n di return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e ls -l /n stampare a video una stringa: per esempio, digitando free_page(GFP_USER); if testo, (!b) /n out_undo_partial_alloc; /n Si tratta /n di tre file di facilmente goto distinguibili in base al echo buongiorno lettori di Linux Pro undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou contenuto (a patto di poterlo visionare con il comando cat). si ottiene la stampa a video della frase passata come /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n omonimo. Ciò consente di partizionare A ciascuna classiusage, 1); /n /n diifqueste (gidsetsize NGROUPS_SMALL) /n i diritti di accessonblocks; al file degli i++)utenti { /n gid_tassociare *b; /n uno bo =più (void *)__get_free_page(GFP_USER); / dei seguenti diritti di è associato un utente proprietario e un = b; /n } /n } /n return group_info; in tre classi: accesso al file:/n /n /nout_undo_partial_alloc: /n /n wh gruppo proprietario: in ambiente /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n domestico essi corrispondono, per un file i diritti del proprietario; diritto di accesso in lettura (r);/n /nEXPORT_SYMBOL( /n proprietario; if (group_info->blocks[0]diritto != group_info->small_block) { /n /n int i; /n /n creato da un utente non privilegiato, con i diritti del gruppo di accesso in scrittura (w);

Permessi di accesso ai file

l’utente della macchina e il gruppo

96

manuale hacker

i diritti di tutti gli altri utenti.

diritto di accesso in esecuzione (x).

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Fig 8: Se non p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ si specifica ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info l’opzione ‘-i’, la /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ ricerca condotta er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + con grep è case Fig 7: Esempio di utilizzo/n del group_info->nblocks comando cat, per la = nblocks; /n atogroup_info->ngroups = gidsetsize; sensitive! visualizzazione del file di testo buongiorno.txt group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < è possibile utilizzare l’opzione -s. Per esempio, con i comandi /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] cd /storage/sdcard0 hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /ntuttavia, /nvoid groups_free(struct group_info *group_info) du -s/n. /n{ /n Supponiamo, di avere una moltitudine di file for (i = 0; (facciamo i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = {scoprire . è possibile la quantità di spazio attualmente 100), e di non ricordare quali abbiano qualche n struct group_info /nPro” int nblocks; /n int i;più /nrapida /n /n nblocks = sulla partizione /storage/sdcard0 (al netto impegnata riferimento*group_info; al tema “Linux . Esiste un’alternativa ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? di eventuali sottodirectory non accessibili in considerazione al processo di visualizzazione in serie di tutti i file? La risposta, SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = dell’assenza ovviamente, è positiva, e si incarna nel celeberrimo grep, ge, 1); /n /n if (gidsetsize blocks[0] = dei privilegi di root per l’utente corrente). Tornando alla nostra directory lxp (con il comando: cd lxp), che consente di effettuare ricerche nei file. Il/n comandoif (!b) /n _t *b; /n il tool b= (void *)__get_free_page(GFP_USER); grep “Linux * return group_info; /n /nPro” /nout_undo_partial_alloc: /n /n while (--i >= possiamo 0) { /n /ncompletare il nostro tour sui comandi base per o); /n /n return NULL; /n le /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n la gestione del/filesystem provvedendo a: restituisce tutte occorrenze della stringa “Linux Pro” cks[0] != group_info->small_block) { /nper /n evitare int che i; /nle/n group_in(da porre all’interno degli apici, parolefor (i = 0; i ngroups = gidsetsize; /n group_info->nblocks = nblocks;copiare /n atosi limita a mostrare la stringa contenuta nel file buongiorno.txt dir1 group_info->blocks[0] = group_info->small_block; /nsalve.txt, else { senza /n forcp (i = 0; i < alcuna per out_undo_partial_alloc; il file saluti, che pure fa riferimento algroup_info->blocks[i] spostare il file saluti nella directory dir1, rinominandolo /n if (!b) /n menzione goto /n hile (--i >= 0) { /ndella /n nostra free_page((unsigned long)group_info->blocks[i]); /n /n } nome rivista. Come spesso accade sotto Linux, contestualmente in saluti.txt, grazie al ricorso al comando mv: (groups_alloc); /nil comando /n /n /nvoid group_info *group_info) /n /n{ /n infatti, grepgroups_free(struct è case sensitive, e pertanto considera mv saluti dir1/saluti.txt for (i = 0; come i < group_info->nblocks; i++) /n /n/nstruct = { .dir2, con il comando rmdir (utilizzabile solo su differenti le stringhe “Linux Pro” (salve.txt) group_info e “linux pro” init_groups cancellare n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (saluti). Per segnalare a grep la necessità di equiparare le due directory vuote): ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? ovvero /n per optare per NULL; una ricerca insensitive, rmdir SER); /n ifstringhe, (!group_info) return /n /ncase group_info->ngroups = dir2 è possibile ricorrere alla opzione -i: il comando cancellare ge, 1); /n /n if (gidsetsize blocks[0] = il file buongiorno.txt, del quale è stata appena grep -i (void “Linux*)__get_free_page(GFP_USER); Pro” * fatta una copia, con il comando rm: _t *b; /n b= /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /npuò /n essere while (--i >= 0) /n /n produce/n l’ouput desiderato. L’aspetto estetico rm{buongiorno.txt o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / migliorato aggiungendo l’opzione –color per evidenziare cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inciascuna occorrenza: ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info grep –color “Linux Pro” * I comandi visti sinora, sebbene preziosi, costituiscono S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Se invece si desidera conoscere il nome file base per l’utilizzo della shell. L’emulatore di terminale, malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),dei GFP_USER); /n ifla(!group_info) contenenti la stringa ricercata, è necessario tuttavia,usage, 1);utilizzare /n /n if (gidsetsize l’opzione comandoi++) { /n specie per quanto riguarda la gestione dei processi. else { /n for (i = 0;-l;i blocks[i] = b;* /n } /n } /n return group_info; /n Uno /n /nout_ grep -il “Linux Pro” dei maggiori crucci per gli utenti di Android “avanzati” up_info->blocks[i]); /n /nil nome } /n /n kfree(group_info); /n return NULL; /n /n}dall’assenza /n stampa a video dei file salve.txt e saluti, gli/n unici è costituito di strumenti immediati per p_info *group_info) /nil/n{ /n /n (group_info->blocks[0] contenenti nome della if nostra rivista. Laddove lo != group_info->small_ conoscere, a colpo d’occhio, tutte le informazioni salienti ‘Hello World’);”> ngroups = -il “Linux Pro” *.txt è pensato=proprio per colmare questa lacuna: digitando ge, 1); /n /n grep if (gidsetsize blocks[0] _t *b; /n stampa b = (void *)__get_free_page(GFP_USER); /n if (!b) /n a video il solo file salve.txt, l’unico con l’estensione ps return group_info; /n a /ncontenere /nout_undo_partial_alloc: /n /n (--i >= (ps 0) {aux /n /n desiderata riferimenti a Linux Pro. Nei while moderni sotto Linux) si può ottenere, dopo la pressione del o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / sistemi, così come negli smartphone attuali, la mole di dati tasto Invio, l’elenco di tutti i processi attualmente in cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inimmagazzinati è enorme. Ritrovare un’informazione su un esecuzione. Per ciascun processo sono indicati vari parametri, ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info hard- disk (ma anche su una SD card /n inserita nel telefono) tra cui è interessante notare: S_PER_BLOCK 1) / NGROUPS_PER_BLOCK; /* Make sure we always allocate at può rivelarsi un’operazione complessa: se*), il file ricercato /n if (!group_info) il nome dell’utente che lo ha avviato (colonna user); malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); non è/n di tipo binario, tuttavia, un tool come grep l’identificativo univoco o PID, Process ID (colonna PID); ocks = nblocks; atomic_set(&group_info->usage, 1);può /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n utilizzo tanto sui PC che sui telefoni è du, grazie al quale la quantità di memoria virtuale in carico al processo p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ è possibile conoscere la dimensione di un’intera cartella. (colonna VSIZE); ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info esempio, il comando dimensione del Residente Set (colonna RSS); /n int i; /nPer /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / la NGROUPS_ du . = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + er */ /n nblocks group_info->ngroups = gidsetsize; /n directory group_info->nblocks = nblocks; /n atoeseguito all’interno della nostra di lavoro, consente group_info->blocks[0] = group_info->small_block; /n una else { /n for (i = 0; i < di verificare come i tre file appena creati abbiano /n if (!b) /n goto out_undo_partial_alloc; /n 9). group_info->blocks[i] dimensione congiunta pari ad appena 256 byte (Fig hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Eseguito su una directory contenente una o più subdirectory, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n restituisce la dimensione di echo(‘Hello ciascuna for (i = 0; ili comando < group_info->nblocks; i++) /n /n World’);”> sottodirectory; nel caso in cui invece si desideri di conoscere Fig 9: Ed ecco un esempio del comando du: utilissimo per capire quanto sia la dimensione di un intero sottoalbero del filesystem, striminzito il contenuto della nostra directory di prova

Gestione dei processi

manuale hacker

97

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Segreti della shell

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), L’utilizzo GFP_USER); /n if di (!group_info) /n return NULL; /n /n Fig 10: congiunto ps e grep consente mic_set(&group_info->usage, 1); /n /n iifdati (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n consente un elevato grado di configurabilità, permettendo usage = ATOMIC_INIT(2) };scegliere, /n /nstruct group_info *groups_alloc(int all’utente di a seconda delle proprie esigenze, il gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su criterio di ordinamento da utilizzare per l’elenco dei processi: : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US come visto con ps, infatti, tale elenco essere decisamente gidsetsize; /n group_info->nblocks = nblocks; /npuòatomic_set(&group_info->usag numeroso, /n rendendone particolarmente la i++) lettura. group_info->small_block; else { /n for (i = 0; difficoltosa i < nblocks; { /n gid_ Per esempio, il /n comandogroup_info->blocks[i] = b; /n goto out_undo_partial_alloc; } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info top -m 10 -s cpu -d 5 nvoid groups_free(struct *group_info) /n /n{ (sotto /n /n Linux if (group_info->bloc comporta,group_info nel nostro emulatore di terminale fo->nblocks; i++) /n /n echo(‘Hello World’);”> blocks[0] group_info->small_block) /n int i; /n /n Se manteniamo!= attivo questo comando per circa{ /n un minuto, un singolo processo. A tal fine possiamo ricorrere/nall’operatore usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n possiamo notare come la situazione iniziale (Fig 11) tenda di pipeline, |, in grado di redirigere l’output di un comando (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su a evolversi con il passare del tempo, determinando una nell’input di un secondo. Il comando : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US modifica dell’ordine dei processi. Siete curiosi di conoscere ps | grep /bin/sh gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag quale sia il processo il vostroi++) { /n consente di effettuare il filtraggio, attraverso grep, dei risultati group_info->small_block; /n elseche { /nrallenta forall’improvviso (i = 0; i < nblocks; gid_ out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r notebook? Top/n può fornirvi tutte le risposte che cercate, di ps: il lunghissimo elenco prodotto in output dagoto ps viene free_page((unsigned long)group_info->blocks[i]); /n /n di} utilizzo /n /n del kfree(group_info aiutandovi a individuare anomale percentuali inviato a grep, che si occupa di visualizzare la sola riga nvoid groups_free(struct *group_info) /n /n{ /n if (group_info->bloc processoregroup_info da parte di uno o più programmi. Vale/nlo stesso contenente la stringa /bin/sh, ovvero i dati del processo fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) discorso per lo smartphone, ove top si rivela ancor più relativo alla shell corrente (Fig 10). L’output fornito da ps *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS prezioso, in considerazione dell’assenza di un’applicazione risulta molto utile in diverse circostanze, come vedremo nelindirect least one block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km nativa grado di fornire con la medesima immediatezza proseguo, ma non riesce, tuttavia, a dare un’idea/n return NULL; /nin/n group_info->ngroups = gidsetsize; /n group_info->nblo la risposta algroup_info->blocks[0] quesito. Spesso tuttavia il=problema dei dell’evoluzione dei processi in esecuzione sul sistema. NGROUPS_SMALL) /n group_info->small_block; /n e free_page(GFP_USER); /n non if out_undo_partial_alloc; /n rallentamenti è, (!b) tanto/nsui PC chegoto sui telefoni, da imputarsi Un processo non è assimilabile a un’entità statica, ma al undo_partial_alloc: /n /n massivo while (--i >=CPU, 0) {quanto /n /n piuttosto free_page((unsigned long)grou all’utilizzo della all’eccessiva contrario durante la propria vita “evolve” attraverso una serie /n sistema /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group occupazione di memoria volatile da/n parte dei processi in di stati, modificando il suo impatto sulle risorse del block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ esecuzione: in questo caso è più utile avviare top con l’opzione in ragione di questi, del comportamento previsto dal .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n -s rss, per ordinare i processi base alla quantità di memoria programma che lo controlla e, per i processi interattivi, (gidsetsize + NGROUPS_PER_BLOCK - 1) /inNGROUPS_PER_BLOCK; /n /* Make su attualmente in uso. Per uscire dal programma occorre degli input dell’utente. In altri termini, fattori come : 1;l’utilizzo /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US utilizzare il tasto q oppure la combinazione CTRL + C, del processore e l’occupazione di memoria variano gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /ncontinuerà else { /na mostrare for (i =all’infinito 0; i < nblocks; gid_ lo statoi++) dei { /n dinamicamente durante la vita di ciascun processo, e pertanto viceversa top goto out_undo_partial_alloc; /n Proprio group_info->blocks[i] /n } /n } /n r processi monitorati. questa caratteristica=cib; può un output puntuale come quello di ps (che “fotografa” lo stato /n /n } /n /n kfree(group_info esserelong)group_info->blocks[i]); utile per fornire una dimostrazione su campo dei processi in un determinato istante di tempo)free_page((unsigned non si adatta nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc dell’ultimo comando di questa panoramica, il comando kill. a descriverne l’evoluzione in maniera esauriente. Per ovviare fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) una seconda dell’emulatore, a questa limitazione, nei sistemi GNU/Linux si ricorre al *group_info; /n Apriamo int nblocks; /n intfinestra i; /n /nall’interno /n nblocks = (gidsetsize + NGROUPS mediante un tocco + visualizzato comando top, supportato anche dal nostro emulatore di indirect least one block pointer */sul /npulsante nblocks = nblocks sull’angolo ? : 1; /n group_info = km terminale e in grado di mostrare l’evoluzione nel /n tempo return (con NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e una periodicità a scelta dall’utente) dei “parametri vitali” che free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n caratterizzano ciascun processo. Strumento versatile, top undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe In ambiente GNU/Linux, a ciascun l’istante in cui è stata effettuata nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n file sono associati 3 tempi: l’ultima modifica alle proprietà del mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n Fig 11: La situazione iniziale mostrata da top, pronta accesso al file. Change time, che segnala

Tempi di accesso ai file

a cambiare al prossimo refresh

98

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Fig 12 I dati processo all’avvio group_info->ngroups = del gidsetsize; /noriginato group_info->nblocks = nblocks; /n atodel programma top. Si noti, in particolare, group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < il PID al processo /n if (!b) /n attribuito goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /nvoid groups_free(struct group_info in alto/na destra dell’interfaccia: possiamo passare in ogni*group_info) /n /n{ /n for (i = 0; momento i < group_info->nblocks; i++) su /n cui /n/nstruct init_groups = { . da questa alla finestra abbiamo group_info lavorato n struct group_info *group_info; /na tendina int nblocks; /n int i; /n /n /n nblocks = sinora, ricorrendo al menu visualizzato nell’angolo ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? in alto a sinistra. Utilizziamo la seconda finestra per ottenere SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = sul processo generato dall’esecuzione di top: ge, 1); /n /n informazioni if (gidsetsize blocks[0] = altri, sarà caratterizzato da un PID univoco, _t *b; /n al pari b =degli (void *)__get_free_page(GFP_USER); /n cheif (!b) /n costituisce l’argomento richiesto da /n kill./n Come return group_info; /n proprio /n /nout_undo_partial_alloc: while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /nps /npuò /n fornirci /nEXPORT_SYMBOL(groups_alloc); /n /n /n / sappiamo, il comando agevolmente questa cks[0] != group_info->small_block) { /n /n il procedimento int i; /n /n giàfor (i = 0; i < group_ininformazione: è sufficiente reiterare visto, truct group_info init_groups = {per .usage = ATOMIC_INIT(2) }; /n /nstruct group_info e ricorrere a una pipe filtrare attraverso grep i dati di top. /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Il comando er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + pagina del manuale su Google Play, da cui è possibile 13: La ps | grep top = gidsetsize; /n group_info->nblocks = nblocks;Fig group_info->ngroups /n atoinstallare l’app gratuitamente restituisce la riga dell’output di ps relativa al processo group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < originato (Fig 12), contenente l’indicazione, /n if (!b) /n da topgoto out_undo_partial_alloc; /n nella group_info->blocks[i] hile (--i >= 0) { /n /ncolonna, free_page((unsigned /n /nquelle } condotte sotto Android) costituisce un (incluse seconda del PID desiderato. Èlong)group_info->blocks[i]); quanto basta per (groups_alloc); /n /nun/n /nvoid groups_free(struct group_info /naggiunto /n{ /n quasi irrinunciabile, se si vuole ottenere in valore mostrare utilizzo pratico del comando kill, in grado *group_info) for (i = 0; di i nblocks; i++) /n /n/nstruct group_info init_groups = { . la piena padronanza delle opzioni più comuni. breve tempo un processo, determinandone la chiusura n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = Ciò è particolarmente vero per i comandi contenuti nel set prematura, a partire dal suo PID. Con ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? aggiuntivo che sarà installato nella prossima puntata, i quali 3977 SER); /n if kill (!group_info) /n return NULL; /n /n group_info->ngroups = al contrario viene provocata la chiusura di top, come possiamo verificare ge, 1); /n /n if (gidsetsize blocks[0] = di quelli visti in questa sede ricalcano con maggiore fedeltà la sintassi e le opzioni presenti in una alla finestra numero 1 dell’emulatore. /n _t *b; /n tornando b = (void *)__get_free_page(GFP_USER); if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /ndistribuzione GNU/Linux. qualsiasi o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n visti /n sinint /n for (i = 0; i < group_inLa maggior parte dei comandi quii;è/n contraddistinta ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info da un set di argomenti particolarmente numeroso, non I comandi illustrati in questa puntata rappresentano, pur con S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at sviscerabile, per+ovvi motivi di spazio, in questa sede. limitazioni dovute all’implementazione minimale offerta malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n ifle(!group_info) Appresi di ciascun comando, non resta dall’emulatore di terminale (limitazioni che, come anticipato, ocks = nblocks; /n i rudimenti atomic_set(&group_info->usage, 1); /nche /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /nout_ personale. Come? Ricorrendo al naturale compagno di ogni /n del set di comandi aggiuntivi), un utilissimo strumento per up_info->blocks[i]); /n /nil manuale. } /n /n Android kfree(group_info); /n /n NULL; /n /n}le/n utente di shell: offre molteplici appreturn in apprendere basi della shell nel campo dell’amministrazione p_info *group_info) /n{ /n /n il contenuto if (group_info->blocks[0] != group_info->small_ grado di /n visualizzare del manuale presente in base del filesystem e della gestione dei processi. In aggiunta a ‘Hello World’);”> ngroups = più pesanti sotto il profilo dell’occupazione di memoria richiede necessariamente una connessione a Internet e dello spazio ge, 1); /n /n non if (gidsetsize blocks[0] = su disco, mantenendo inalterato il livello di _t *b; /n per bla=visualizzazione (void *)__get_free_page(GFP_USER); /n if (!b) /n delle informazioni sui comandi. funzionalità desiderato: si pensi alle applicazioni per la ricerca return group_info; /n /n /nout_undo_partial_alloc: /nper /n il while (--i >= 0) { /n /n non binari nei file immagazzinati su card SD, L’app dispone infatti di un apposito pulsante di contenuti o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /sostituibili da grep, dei tool per la visione dei download dei dati relativi ai comandi supportati: in meno egregiamente cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indi 10 MB aggiuntivi è possibile disporre delle pagine processi attivi e/o per il monitoraggio del loro consumo di ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info di manuale relative ai comandi più comuni per we always risorse, o ancora S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /*nonché, Make sure allocate at alle applicazioni per la navigazione del i programmatori,+alle chiamate di sistema utilizzate. /n iffilesystem, le cui funzioni principali possono essere svolte dai malloc(sizeof(*group_info) nblocks*sizeof(gid_t *),più GFP_USER); (!group_info) La disponibilità del manuale durante le sessioni comandi ocks = nblocks; /n atomic_set(&group_info->usage, 1);di/npratica /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Ecco un elenco alcune delle variabili della=shell è possibile l’utente $HOME, ove è indicata la home directory /n int i; /n /nAll’interno /n nblocks (gidsetsize + per NGROUPS_PER_BLOCK - 1) /diNGROUPS_ er */ /n nblocks = nblocks : 1; /n per group_info = nel kmalloc(sizeof(*group_info) d’ambiente disponibili in+ambiente GNU/ definire apposite?variabili conservare dell’utente; group_info->ngroups = gidsetsize; /n group_info->nblocks nblocks; /n atoLinux,=supportate anche dal nostro emulatore tempo informazioni d’interesse. Alcune $USER, contenente il nome dell’utente group_info->blocks[0] = group_info->small_block; /n else { /n for (i Android = 0; i < (e quindi di terminale sotto variabili, tuttavia, sono predefinite dal sistema, corrente; /n if (!b)al/n goto out_undo_partial_alloc; group_info->blocks[i] con il comando echo): fine di preservare informazioni d’interesse /n visualizzabili $PATH, che indica le directory al cui interno hile (--i >= 0) {generale. /n /n Talifree_page((unsigned long)group_info->blocks[i]); /n /n } il nome della variabili sono caratterizzate, oltre la shell è tenuta a ricercare gli eseguibili $HOSTNAME, contenente (groups_alloc); /nprefisso /n /nvoid groups_free(struct *group_info) /n /n{ /n che/ndal $ tipico di ogni variabile digroup_info richiesti dall’utente; macchina; for (i = 0; i nblocks; /n /n echo(‘Hello World’);”> dal nome costituito i++) interamente da $PWD, che immagazzina la directory di $PS1, che fissa il formato del prompt

Installazione del manuale

Tirando le somme...

Variabili d’ambiente

lettere maiuscole, come appunto $SHELL.

lavoro corrente;

mostrato dalla shell.

manuale hacker

99

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Segreti della shell parte 2

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, nello 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n Emulator for Android), app disponibile gratuitamente usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n su Google Play, come mostrato in Fig 1 e una tastiera (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su ad hoc in grado di semplificare il compito : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US dell’aspirante amministratore di shell The gidsetsize; Hacker’s /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag keyboard, anch’essa disponibile senza oneri sullo group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r store di Google, vedasi Fig 2, è infatti possibile long)group_info->blocks[i]); /n /n } /n /n kfree(group_info trasformare uno smartphone Android in unfree_page((unsigned perfetto groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc strumento per l’apprendimento della shell.nvoid L’utilizzo fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) visto nella prima puntata, tuttavia, si presta *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS principalmente a un’utenza dotata di skill elementari 1: La pagina*/dell’emulatore terminale su/n Google least one indirectFig block pointer /n nblocks =dinblocks ? : 1; group_info = km Play,/n da/n cui group_info->ngroups è possibile installare l’app gratuitamente nel campo della gestione della riga di comando. /n return NULL; = gidsetsize; /n group_info->nblo Gli utenti più avanzati o semplicemente piùNGROUPS_SMALL) curiosi /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); if (!b) /nla licenzagoto /n (così come gli utenti che, spronati dal precedente progetto/ne, soprattutto, conout_undo_partial_alloc; cui è rilasciato: undo_partial_alloc: /n /ninfatti whiledi(--i 0) { /n /n long)grou articolo, abbiano acquisito nel tempo intercorso tra le si tratta un>= Software Liberofree_page((unsigned distribuito con /n /n /n /n /n /nvoid groups_free(struct group due puntate un minimo di dimestichezza con la /nEXPORT_SYMBOL(groups_alloc); shell) licenza GPL, di cui sono disponibili i sorgenti block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ possono cimentarsi in una sfida più stimolante grazie direttamente dal sito Web di riferimento (http:// .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n all’installazione di un set di comandi aggiuntivo. www.busybox.net). Nonostante presentino una base (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Questi nuovi comandi sono in grado di integrare comune, tuttavia, le numerose implementazioni : 1; /n legroup_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US funzionalità offerte nativamente dall’emulatore con /n group_info->nblocks disponibili in ambiente Android/n possono presentare gidsetsize; = nblocks; atomic_set(&group_info->usag group_info->small_block; /n else {sotto /n il for (i = 0; nblocks; i++) { /n gid_ altri di uso comune in campi come la compressione sensibili differenze profilo deii blocks[i] b; /n } /n } /n r dei file o le verifiche di integrità sugli stessi. Possono supportati, del tutte le app sono=gratuite) free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info anche dotare la shell di capacità di scripting avanzate nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc e di preziosi tool di rete, oltre a estenderne le già note fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) capacità nell’ambito della gestione di file e*group_info; processi. /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e /n if (!b) /n goto out_undo_partial_alloc; /n Stiamo parlando del porting sotto Androidfree_page(GFP_USER); di Busybox undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou (Fig 3), progetto definito non a caso dai suoi stessi /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group sviluppatori come il “coltellino svizzero del Linux block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Embedded”, nato con lo scopo di divenire “la più *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / piccola e semplice implementazione” dei tool da riga /n /* Make sure we always allocate at least one indirect block pointe PER_BLOCK; nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n di comando disponibili in ambiente Linux. Progettato mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) /n Google /n int i; /n /n diffusione, tanto in ambito embedded che all’interno Play, da cui è possibile effettuare l’installazione (senza oneri per l’utente!) degli smartphone, vi sono l’indubbia validità del

Segreti della shell in Android parte 2 Continua il nostro viaggio alla scoperta dei segreti della shell, utilizzando uno smartphone come guida

N

L’autore Maurizio Russo Laureato in Informatica presso l’Università “La Sapienza” di Roma, con una tesi sperimentale sullo stack TCP/IP del kernel Linux, è un utente del pinguino dal 2001. Nella sua carriera si è occupato di formazione, sicurezza, networking, progettazione e sviluppo di software.

100

Installazione del set di comandi aggiuntivo

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /ndel /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n Fig 3: Il/n sito progetto Busybox (www.busybox.net ) o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n int i; /n /n for (i = 0; i < group_ine persino dei prerequisiti di /n installazione. truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info In particolare, la maggioranza dei porting di Busybox Fig 4: La pagina dell’app BusyBox non-root su Google Play, da cui è possibile /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ richiede il rooting del telefono, operazione che, come effettuare l’installazione gratuita er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + stabilito nella prima puntata, non rientra nelle group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atospecifiche di=questa serie. Per fortuna lo group_info->blocks[0] group_info->small_block; /nstore else { /n for (i = 0; i < di Google mette a disposizione una app in/n grado digroup_info->blocks[i] /n if (!b) /n goto out_undo_partial_alloc; hile (--i >= 0) { /n /nanche free_page((unsigned long)group_info->blocks[i]); /n /n le } operazioni preliminari, possiamo dedicarci operare in assenza di rooting: BusyBox nonTerminate (groups_alloc); /n 4), /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n root /n (Fig applicazione gratuita e libera in grado finalmente a esaminare i comandi appena installati. for (i = 0; di i nblocks; i++) /n /n/nstruct group_info init_groups {. la versatilità (e l’alto valore formativo) Come in= occasione della precedente puntata, n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = di Busybox su qualsiasi dispositivo Android recente. è opportuno creare una directory di lavoro all’interno ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? dell’app, però, non/n ci /n consente di della=SD card. Da shell, pertanto, eseguiamo i comandi: SER); /n ifL’installazione (!group_info) /n return NULL; group_info->ngroups mettere immediatamente le mani sui comandi offerti cd /storage/sdcard0 ge, 1); /n /n if (gidsetsize blocks[0] = avviata l’applicazione, è infatti/n mkdir lxp _t *b; /n da Busybox: b = (void *)__get_free_page(GFP_USER); if (!b) /n return group_info; /n /ndapprima /nout_undo_partial_alloc: /n /n dei while (--i >= 0) /n /n necessario procedere al download cd{ lxp o); /n /n return NULL; /n /n}l’apposito /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n / binari, mediante pulsante. Terminata Perché la /n directory sia di una qualche utilità è tuttavia cks[0] != group_info->small_block) { /n /n int i; /n /n di for (i = 0; inecessario < group_in-che questa sia popolata da almeno un paio questa operazione, si può avviare l’emulatore ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info terminale direttamente dall’app, ricorrendo al di file: se nella prima puntata questa operazione è stata S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at pulsante apri terminale, grazie al quale sarà avviato/n ifeffettuata mediante ricorso al comando echo, in questa malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) l’emulatore di terminale utilizzato nel corso della sede vogliamo redirigere su file di testo l’output di uno ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n direturn NULL; /n /n}alla /n sintassi disponibile in ambiente GNU/ automaticamente dall’app negli appunti, al/n fine aggiuntivo p_info *group_info) /n /n{ /n corrente if (group_info->blocks[0] != group_info->small_ aggiungere al /n path anche i binari appena Linux, procediamo a visionare l’help in linea del primo ‘Hello World’);”> ngroups premuto less=–help SER); /n ifsuccessivamente (!group_info) /n visualizzato. return NULL; /n /n (e verificato di aver modificato la in uso, consente=appunto di visualizzare le istruzioni di utilizzo ge, 1); /n /n Invio if (gidsetsize blocks[0] _t *b; /n scegliendo b = (voidThe *)__get_free_page(GFP_USER); /n della if (!b) /n Hacker’s Keyboard in luogo di less, un visualizzatore di testo alternativo a quel cat return group_info; /nout_undo_partial_alloc: /n while (--i >= 0) { /n /n nella scorsa puntata, di cui migliora tastiera/n di/n default di Android, come da/n istruzioni esaminato o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / le performance in termini di leggibilità riassunte nel box Utilizzare The Hacker’s sensibilmente cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inKeyboard), è quindi possibile disporre dei comandi dell’output (specie su file di una certa dimensione): ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info offerti Busybox senza doversi /n preoccupare dellawe always anziché inviare S_PER_BLOCK - 1) da / NGROUPS_PER_BLOCK; /* Make sure allocate at l’intero contenuto del file su schermo directory di installazione, grazie all’aggiunta di fa cat), less suddivide il file in più porzioni, malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if(come (!group_info) quest’ultima al path corrente. ciascuna ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info input corrente: a tal fine, è sufficiente avviare attraverso-i 1) menu Impostazioni -> Sistema seguito dell’installazione di The Hacker’s /n int i; /n /nA/n nblocks = (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_ l’app e premere il pulsante Set input method, -> Lingua e immissione+ -> Tastiera e Keyboard, non è?possibile er */ /n nblocks = nblocks : 1; /n utilizzare group_info = kmalloc(sizeof(*group_info) avendo cura di selezionare The Hacker’s metodi di immissione, ignorare il messaggio immediatamente la tastiera: motivi di group_info->ngroups = gidsetsize; /n per group_info->nblocks = nblocks; /n atoKeyboard nel menu successivamente di warning sicurezza, infatti, Android richiede che ogni/n else group_info->blocks[0] = group_info->small_block; { /n visualizzato for (i = 0; idal < sistema, quindi visualizzato da Android. Al termine delle The Hacker’s Keyboard. Questa dellegoto modalità di input dello /n if (!b)modifica /n out_undo_partial_alloc; /n selezionare group_info->blocks[i] hile (--i >= 0) {smartphone /n /n free_page((unsigned /n la /ntastiera } operazione inserisce tra i dispositivi nostre sessioni addestrative sulla shell, avvenga manualmentelong)group_info->blocks[i]); a cura (groups_alloc); /n /n /n negando /nvoid groups_free(struct group_info *group_info) /n{ /n attivamente in optando per la tastiera di Google nel di input abilitati; per/n utilizzarla dell’utente, la possibilità di modifica for (i = 0; i nblocks; i++) /nPer /n abilitare echo(‘Hello World’);”> medesimo menu potremo ripristinare lo stato della tastiera di Google è infine da parte delle app. la luogo

Manipolazione di file di testo

Utilizzare The Hacker’s Keyboard

tastiera è pertanto necessario navigare

necessario selezionarla come dispositivo di

originario del sistema.

manuale hacker

101

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Segreti della shell parte 2

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Fig 5: La prima schermata mostrata dal comando less ci consente di notare l’intestazione comune alla quasi totalità dei programmi installati (gidsetsize con l’app + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 7: Mettendo a confronto gli output di wc eseguito : 1; /n group_infoFig = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US BusyBox non-root sui due file, la verifica=del numero eliminate tramite gidsetsize; /n group_info->nblocks nblocks; /ndi ‘y’ atomic_set(&group_info->usag tr è immediata group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ schermata corrente. In questo modo è possibile evitare goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); } /n /n le kfree(group_info il fastidioso effetto di scrolling che contraddistingue Il comando head, infatti, è in grado/n di/n visualizzare groups_free(struct group_info /n /n{ 30 /n /n (group_info->bloc l’utilizzo di cat sui file più lunghi, in quanto ilnvoid passaggio prime righe di un file *group_info) di testo (di default sottoif GNU/ fo->nblocks; /n /n10 echo(‘Hello World’);”> usage, nostro head presenta1); il medesimo riferimento BusyBox: per /n /n if (gidsetsize visto nella prima puntata, in/nquanto potremmo/n immaginare, ricorso all’operatore di /n if (group_info->blocks[0] != group_info->small_block) { /n /n l’help (sebbene visualizzato regolarmente sullo pipeling visto nella scorsa puntata: l’operatore, infatti,int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n schermo) non è stampato sullo standard output, bensì è in grado di concatenare lo standard output di un (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su sullo standard error (per approfondimenti, vedi comando con lo standard input di+un altro, mentre : 1; /nil box group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US Standard input e Standard error): e se > gidsetsize; rappresenta l’help, come visto, è convogliato verso lo standard error. /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag l’operatore per la redirezione dello standardgroup_info->small_block; output, È questo il/n motivo comando elseper { /ncui ilfor (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; } /n } /n r l’operatore equivalente per lo standard error è 2>. Il head –help | /n head -n 1group_info->blocks[i] = b; /n long)group_info->blocks[i]); /nfar}sì/nche /n kfree(group_info comando in grado di effettuare l’operazionefree_page((unsigned desiderata non restituisce il risultato sperato:/n per nvoid groups_free(struct *group_info) /na/n{ /n /n lo if (group_info->bloc è dunque “funzioni”,group_info è necessario provvedere redirigere fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) less –help 2>less.txt standard error sullo standard output, così come *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Possiamo verificare il contenuto del file less.txt mostrato nel box pagina. Il comando corretto least one indirect block pointer */in/nquesta nblocks = nblocks ? : 1; /n group_info = km utilizzando lo stesso tool less, con il comando: per visualizzare la prima riga dell’help è, quindi, /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo less less.txt head 2>&1 | head -n 1 NGROUPS_SMALL) /n–helpgroup_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n ci restituisce if (!b) /nl’output previsto goto out_undo_partial_alloc; /n Come mostrato in Fig 5, la prima riga del file (e quindi che infatti (Fig 6). undo_partial_alloc: /n /n while >= 0) /n /n perfree_page((unsigned long)grou dell’help del comando) contiene un richiamo a Naturalmente, se(--i esiste un{ modo visualizzare le /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n può /nvoid group BusyBox, comprensivo della versione di riferimento del prime righe di un file di testo, non nongroups_free(struct esistere un Fig 6: block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ Utilizzando progetto: si tratta di una peculiarità comune alla quasi tool analogo, per la stampa delle ultime righe: si tratta .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n l’operatore totalità dei comandi installati dall’app. Possiamo del comando tail. Con- 1) / NGROUPS_PER_BLOCK; /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK di redirezione soffermarci meglio su questo punto, limitando la group_info tail= less.txt -n 2 : 1; /n kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US dello standard visualizzazione del file alla prima riga, grazie al otteniamo la stampa =delle ultime del file less. gidsetsize; /n group_info->nblocks nblocks; /n2 righe atomic_set(&group_info->usag error insieme group_info->small_block; /n senza else { l’argomento /n for (i =-n, 0;ili comando < nblocks; i++) { /n gid_ comando head: txt; utilizzato a quello di pipe, goto out_undo_partial_alloc; /n in ambiente group_info->blocks[i] = ultime b; /n 30} /n } /n r head less.txt -n 1 restituisce invece, GNU/Linux, le è possibile free_page((unsigned /n } /n /n kfree(group_info righe long)group_info->blocks[i]); (10 in BusyBox). In aggiunta /n ai comandi sin qui evidenziare, nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc visti, la shell offre una serie di strumenti più o meno grazie al ricorso fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) per/n la manipolazione file di = testo, come + NGROUPS al comando *group_info; /n sofisticati int nblocks; int i; /n /n /n dei nblocks (gidsetsize per esempio tr, */ in grado di effettuare sostituzioni head, la prima least one indirect block pointer /n nblocks = nblocks ? : 1; /n group_info = km riga dell’help ed eliminazioni di caratteri e/o stringhe nel file. /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc programma; In tutti i sistemi GNU/Linux, sono definiti 3 descrittore 0 per*group_info; lo standard input; *groups_alloc(int gidsetsize){il/n struct numero group_info /n int nblocks; / PER_BLOCK; /n /* Make sure we alwaysnumero allocate at lo least one indirect canali di input/output denominati: standard error (o stderr): anch’esso il descrittore 1 per standard output; block pointe nblocks*sizeof(gid_t *), GFP_USER); /n numero if (!group_info) /n return solitamente è identificato nello schermo, che standard input (o stdin): generalmente il descrittore 2 per lo standard error. NULL; /n /n /n /n ifdi(gidsetsize usage, verso il quale vengono coincidente con la tastiera, costituisce il canale La 1); conoscenza tali descrittori utile in nblocks; i++) { /ndalle gid_tsede *b; di /nredirezione: b = (void *)__get_free_page(GFP_USER); / inviati i messaggi d’errore provenienti di default dal quale provengono gli input rivolti se infatti per lo standard = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n wh applicazioni in esecuzione. dagli utenti ai programmi in esecuzione; input e lo standard output sono sufficienti, /n /n è indipendente kfree(group_info); /n return NULL; /n /n} < /ne /n /n /nEXPORT_SYMBOL( Ciascuno di questi canali dagli /nrispettivamente, gli operatori >, per lo standard output (o stdout): di norma if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n altri e ha associato /n un apposito descrittore standard error è necessario anteporre il numero associato allo schermo, ove viene convogliato

Standard input e Standard error

di default l’output prodotto da ciascun

102

manuale hacker

di file:

2 all’operatore di redirezione (2>).

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Per esempio, comando p_info *group_info) /n /n{il/n /n if (group_info->blocks[0] != group_info->small_ ct group_info = >noy.txt { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info tr init_groups -d y ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoidentico al precedente per ogni altro contenuto. group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < Possiamo verificare immediatamente il buon /n if (!b) /n goto out_undo_partial_alloc; /nesito del group_info->blocks[i] comando la prima riga del file noy.txt, alla hile (--i >= 0) { /n /n visualizzando free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n quale/ndeve essere stata eliminata la y contenuta nel for (i = 0; nome i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . BusyBox: n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = head noy.txt -n 1 ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Ma quante altre modifiche sono state apportate nel SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = da less noy.txt? Per scoprirlo un ge, 1); /n /n passaggio if (gidsetsize blocks[0] = veloce della lenta e tediosa lettura/n di _t *b; /n modo b =più (void *)__get_free_page(GFP_USER); if (!b) /n entrambi file: possiamo ricorrere al comando diff, (--i >= 0) { /n /n return group_info; /ni /n /nout_undo_partial_alloc: /n /n while o); /n /n return NULL; /n /n} /nmettere /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / pensato proprio per a confronto due file cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indi testo. Il comando truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info diff less.txt noy.txt /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ mostra le differenze tra i due file, stampando a video, er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + per ciascuna=riga, le istruzioni necessarie a trasformare group_info->ngroups gidsetsize; /n group_info->nblocks = nblocks; /n atoil primo file nel secondo e viceversa: a tale group_info->blocks[0] = group_info->small_block; /nscopo, else { /n for (i = 0; i < l’output mostra le righe da eliminare /n nel primogroup_info->blocks[i] /n if (!b) /n di diff goto out_undo_partial_alloc; hile (--i >= 0) /n free_page((unsigned long)group_info->blocks[i]); /n /n } file{ /n (precedute dal prefisso -) e i relativi contenuti (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n sostitutivi (identificati dal prefisso +), fornendo for (i = 0; all’utente i < group_info->nblocks; i++)guida /n /n/nstruct group_info init_groups = { .musicali, il nostro computer (così come lo una vera e propria delle modifiche video e file n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = da apportare per rendere identici i due file. smartphone) è colmo di file binari, ai quali sono ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? per i programmatori, grazie applicabili tutti i comandi di questa sezione. Prima di SER); /n ifParticolarmente (!group_info) /nprezioso return NULL; /n /n group_info->ngroups = alle sue capacità di “snidare” le differenze in due proseguire, ge, 1); /n /n if (gidsetsize blocks[0] = tuttavia, scattiamo una foto con il nostro del medesimo codice, diff dispone anche di un cellulare, quindi spostiamola (anche con il file manager _t *b; /n versioni b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /npensato /n /nout_undo_partial_alloc: /nbinari: /n while (--i >= di 0)default, { /n /n la foto è verosimilmente contenuta nella “fratello” per il confronto tra file si tratta o); /n /n return NULL; /ncmp /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n DCIM /n / della sdcard o in una delle sue del comando (anch’esso supportato da BusyBox), directory cks[0] != group_info->small_block) { /n /n numerose int i; /nanalogie /n for (i = 0; sottodirectory) i < group_in- nella nostra cartella di lavoro il cui esame, tenuto conto delle con ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info diff e del ridotto spazio disponibile in questa sede, (denominata lxp). Assumendo, per semplicità, che la S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at è tuttavia lasciato al lettore. Per quanto tuttavia,/n iffoto abbia nome “foto.jpg”, proviamo a visualizzarne malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),utile, GFP_USER); (!group_info) diff non in maniera immediata il problema i contenuti ocks = nblocks; /n risolve atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /npur} ricco /n /ndi kfree(group_info); /npresta /n return NULL; /n /n} /n il suo output, informazioni, non si In realtà, sebbene cat sia del tutto inadatto a p_info *group_info) /n /n if (group_info->blocks[0] != group_info->small_ a fornire/n le/n{ informazioni di nostro interesse, risentendo visualizzare un’immagine, questa contiene al suo ‘Hello World’);”> ngroups = di un file blocks[0] = grado per l’appunto di visualizzare tutte le _t *b; /n comandi b = (void *)__get_free_page(GFP_USER); /n if (!b) /n stringhe di caratteri stampabili contenute in un dato return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= file: 0) { al /nfine /n di evitare un output troppo verboso, strings wc less.txt o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nlimita / e di default si a mostrare le sole stringhe composte cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inwc noy.txt da almeno 4 caratteri consecutivi, ma questo ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info (Fig- 1) 7),/possiamo notare come questi per we always comportamento S_PER_BLOCK NGROUPS_PER_BLOCK; /n mostrino, /* Make sure allocate at può essere modificato ricorrendo i due file, il medesimo numero di linee *), e di parole, ma /n ifall’opzione -n. Il comando malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); (!group_info) differiscano tra loro per ben quattro byte: e1);poiché stringsusage, /n /n laif (gidsetsize else { /n for (i = 0; < nblocks; i++) { /n *b; richiede /n b = (void *)__get_restituisce numerose righe di output: codifica di iciascun carattere in un filegid_t di testo per esempio group_info->blocks[i] b; /n }dedurre /n } /nchereturn group_info; /n ma /n /nout_ un singolo byte,=possiamo le y eliminate se la maggior parte risultano prive di senso, alcune up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n da tr nel passaggio da less.txt a noy.txt sono, per di queste sono invece interessanti. Particolarmente p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ l’appunto, quattro. pregna di contenuti è la sezione iniziale del file, come ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info dal comando /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) mostrato / NGROUPS_ strings foto.jpg | head er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n tuttavia, group_info->nblocks atodal/n quale appare chiaramente il riferimento alla stringa I comandi presenti nell’app, ci consentono= nblocks; group_info->blocks[0] = group_info->small_block; /n else { /n for (i =(Fig 0; i < Exif 8), il nome della specifica di formato di non limitarci, al contrario di quanto avvenuto nella /n if (!b) /n goto out_undo_partial_alloc; group_info->blocks[i] dell’immagine utilizzata dalla fotocamera. Non a caso, precedente puntata, alle sole operazioni su /n file di testo. hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Exif prevede che nell’intestazione dell’immagine siano Grazie a BusyBox, possiamo allargare la nostra (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n inserite informazioni testuali come l’ora e la data di panoramica ai file binari, che costituiscono una platea for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> creazione o il modello di fotocamera utilizzata. Quella di più varia e diffusa: dai file prodotti dai software di office inserire campi testuali in file binari è, in realtà, una automation proprietari ai PDF, passando per immagini,

Fig 8: Con il comando strings, è possibile individuare stringhe intellegibili persino in file binari!

Operazioni su file binari

manuale hacker

103

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Segreti della shell parte 2

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou numero di hard link; /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc blocchi occupati. *groups_alloc(intNel gidsetsize){ /n il comando struct group_info *group_info; /n int nblocks; / nostro caso, PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe stat foto.jpg nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n restituisce l’output in Fig 9, dal quale si evince mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Esistono operazioni in cui la distinzione tra file di testo e : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US file binari, sin qui trattata, non ha/n motivo di esistere: per gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag esempio, le/noperazioni dei{ /n else { /ndi ricerca for (i e= di 0;compressione i < nblocks; i++) gid_ Fig 9: Il comando stat consente di ottenere molte informazionigroup_info->small_block; utili sui file, che vedremo sezione. Lo studio=dei goto out_undo_partial_alloc; /n in questa group_info->blocks[i] b; tool /n } /n } /n r file, non ultimi i tempi a essi associati free_page((unsigned long)group_info->blocks[i]); /n /n }la/n /n kfree(group_info operanti in questi campi, tuttavia, richiede disponibilità nvoid groups_free(struct *group_info) /n{ /n /n if (group_info->bloc di qualchegroup_info file aggiuntivo rispetto a/n quelli attualmente /n /n echo(‘Hello directory di lavoro. A tal fine, data-text=”/nst pratica molto comune: attraverso il comandofo->nblocks; strings, un i++) *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / procediamo a creare due nuove sottodirectory e copiarvi lettore curioso e intraprendente può senz’altro scoprire PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe all’interno la fotografia/noggetto della dissertazione quali, tra i formati più diffusi, condividono questa nblocks*sizeof(gid_t *), GFP_USER); if (!group_info) /n return NULL; /n /n appena conclusa: caratteristica con l’immagine appena scattata dallo mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n cp foto.jpg ancora/foto3.jpg di file esiste infatti un equivalente di cat: come usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n La sottodirectory appena creata ci consente di verificare è in grado di visualizzare ciascuno dei caratteri che (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su immediatamente il comportamento del prossimo compongono un file testuale, così il comando: 1; hexdump /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US comando, find, in grado di effettuare ricerche di file consente di verificare i contenuti (rappresentati in gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag all’interno /n del filesystem. esempio, per ricercare formato esadecimale) di ciascuno dei byte che group_info->small_block; else { /n Per for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /nnostragroup_info->blocks[i] b; /nle sue} /n } /n r all’interno della directory di lavoro e di=tutte compongono un file binario. Il comando free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info sottodirectory un qualsiasi file di testo è possibile hexdump -C foto.jpg groups_free(struct utilizzare ilgroup_info comando *group_info) /n /n{ /n /n if (group_info->bloc visualizza i contenuti della foto in righe da nvoid 16 byte fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) find ./ -iname “*.txt” (ogni byte è rappresentato con un numero *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS così come è possibile ricerca? di file esadecimale di due cifre), accompagnandoleast questa one indirect block pointer */ /n procedere nblocks =alla nblocks : 1;tutti /n i group_info = km JPG /n con rappresentazione con il corrispettivo valore/nnel codice return NULL; /nil comando group_info->ngroups = gidsetsize; /n group_info->nblo find/n ./ -iname “*.jpg” ASCII. Al pari di strings, l’output di hexdump contiene il NGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n che restituisce l’output di cui alla Fig 10. Notiamo come riferimento a una data che sappiamo essere, in base undo_partial_alloc: /n /n restituito while (--i da >=find 0) {includa /n /n anche free_page((unsigned long)grou il risultato i file JPG alle informazioni in nostro possesso su Exif, la data di /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group contenuti nelle sottodirectory e altro ancora: il comando, creazione della foto. BusyBox, tuttavia, ci mette a block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ infatti, effettua una ricerca nell’intero sottoalbero del disposizione il tool per confutare questa ipotesi, .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n filesystem radicato nella di lavoro corrente. /n /* Make su ovvero il comando stat, in grado di visualizzare i (gidsetsize + NGROUPS_PER_BLOCK - 1)directory / NGROUPS_PER_BLOCK; In altri termini, se digitassimo questo stesso comando principali parametri associati a ciascun file,: 1; come: /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US nella directory /storage/sdcard0, l’elenco nome; gidsetsize; /n group_info->nblocks = nblocks; /n otterremmo atomic_set(&group_info->usag group_info->small_block; { /n nella for (isdcard! = 0; i blocks[i] b; sola /n } /n } /n r le possibilità di di find non si fermano = alla permessi di accesso; free_page((unsigned long)group_info->blocks[i]); /n il}parametro /n /n kfree(group_info estensione: variando la stringa che /n segue tempi di accesso, modifica (modify) e cambiamento nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc -iname, è possibile imporre filtri più o meno raffinati (change); fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) nome e persino, se si utilizzano gli altri+ NGROUPS *group_info; /n sull’intero int nblocks; /n del intfile i; /n /n /n nblocks = (gidsetsize parametri offerti*/ dal/ncomando, file?identificati least one indirect block pointer nblockselencare = nblocks : 1; /n group_info = km per dimensione (-size), tipo (-t), permessi d’accesso /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n tempi group_info->blocks[0] group_info->small_block; /n e (-perm), di accesso (-atime),=proprietario (-user). free_page(GFP_USER); /n moderni, if (!b)caratterizzati /n goto out_undo_partial_alloc; /n Nei telefoni da dispositivi di undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou storage (interni ed esterni) sempre più capienti, la /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group disponibilità di un comando rapido e diretto come find block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc può costituire un e proprio valore*group_info; aggiunto, /n int nblocks; / *groups_alloc(int gidsetsize){ /n vero struct group_info dall’obbligo di ricorrere app specializzate, PER_BLOCK; /nliberandoci /* Make sure we always allocate ad at least one indirect block pointe nblocks*sizeof(gid_t *),gratuite GFP_USER); if (!group_info) /n return NULL; /n /n spesso solo a/n patto di accettare un’ingombrante mic_set(&group_info->usage, /n /n piacevole if (gidsetsize blocks[0] != l’occupazione group_info->small_block) { /n /n più int i; /n /n Fig 10: L’output di find mostra tutte le immagini JPG contenute nella directory raramente: persino questo tipo di app integrate, tuttavia, corrente e nelle relative sottodirectory può essere sostituito in toto da Busybox, in grado di

Ricerca e compressione

104

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inFig 12: Con telnet è possibile studiare cosa accade realmente durante la Fig 11: Il risultato della risoluzione DNS effettuata truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info HTTP nslookup www.google.it. /n int i; /ntramite /n /n nblocks = sull’indirizzo (gidsetsize + NGROUPS_PER_BLOCK - 1) navigazione / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + offrire agli utenti le celeberrime utility tar e gzip, tanto smartphone), group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato- pertanto si tramuta spesso in una generica amate ed utilizzate in ambiente GNU/Linux. esempio, “difficoltà group_info->blocks[0] = group_info->small_block; /n Per else { /n for (i = 0; i blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } l’intero contenuto di una directory (nello specifico, la di diagnosticare e comprendere... Tornando a nslookup, (groups_alloc); /n /naltro) /n /nvoid /n /n{per /n effettuare una risoluzione DNS, ottenendo directory con groups_free(struct group_info *group_info) la sintassi for (i = 0; itar < group_info->nblocks; i++) /n /n/nstruct group_info init_groups { . indirizzi IP associati a un determinato URL, -cvf foto.tar altro pertanto= gli n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = per poi procedere alla compressione del file così ottenuto è la seguente: ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? gzip nslookup www.google.it SER); /n ifcon (!group_info) /n return NULL; /n /n group_info->ngroups = gzip foto.tar che restituisce gli indirizzi rappresentanti in Fig 11. ge, 1); /n /n if (gidsetsize blocks[0] = il file foto.tar.gz contenente tutti i file Si tratta dell’operazione che il nostro browser compie _t *b; /n ottenendo b = (void *)__get_free_page(GFP_USER); /n della if (!b) /n return group_info; /nin/nformato /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n trasparente quando digitiamo sulla barra directory compresso. Il procedimento inverso in maniera o); /n /n return NULL; a/nquello /n} /nappena /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /l’indirizzo di qualsiasi sito: solo una volta è speculare visto: degli/n indirizzi cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; ottenuta i < group_ingzip -d foto.tar.gz la risposta del server DNS, il browser provvede ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info tar -xvf foto.tar ad aprire una connessione con il server Web residente S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at ed è abbreviabile ricorrendo unicamente comando tar: uno degli IP associati all’URL. Stabilita la connessione, malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),alGFP_USER); /n ifin(!group_info) tar -xvfz foto.tar.gz il colloquio ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n Busybox /n /nout_fornisce un valido ausilio per approfondire up_info->blocks[i]); /n /n kfree(group_info); /n /n} /ntrasparenti agli utenti meno curiosi, i meccanismi I comandi/n sin/nqui }illustrati, per quanto preziosi/ne /n return NULL; p_info *group_info) /n /n{da /nun /nindubbio if (group_info->blocks[0] != sono group_info->small_ mettendoci a disposizione il celeberrimo telnet. caratterizzati valore formativo, non ‘Hello World’);”> ngroups = connessione del browser a un server Web, telnet garantisce di più, mettendo a disposizione dell’utente un ge, 1); /n /n molto if (gidsetsize blocks[0] = la possibilità di simulare tale connessione, _t *b; /n nutrito b = (void *)__get_free_page(GFP_USER); if (!b) /n permettendoci di sostituire il browser nella richiesta numero di tool di rete, utili tanto in una/nLinux Box return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n pagina /n di una Web. Avviamo il tool con il comando che in uno strumento orientato alla comunicazione come o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / telnet www.sprea.it 80 lo smartphone: questo ambito, infatti, costituisce una cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inche stabilisce una connessione TCP con la porta 80 del vera e propria frontiera, in cui l’intento formativo dei tool ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info server ove risiede il sito dell’editore della nostra rivista, di Busybox lascia il passo all’effettiva dei comandi S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n utilità /* Make sure we always allocate at digitiamo le righe nell’utilizzo quotidiano del telefono. Prendiamo, per malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifquindi (!group_info) GET / usage, 1); /ndi /nquery if (gidsetsize else { /n for (i(Domain = 0; i < nblocks; i++) {),/n gid_ta *b; /n b = (void *)__get_ HOST: www.sprea.it DNS Name System un tool che un utente group_info->blocks[i] = b; /napparire } /n privo } /ndi return group_info; /n per /n /nout_ richiedere la home page del sito http://www.sprea. superficiale potrebbe prospettive up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n it/. Concludendo l’ultima riga con la duplice pressione concrete, se non in ottica didattica. Per quanto la p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ del tasto Invio, la richiesta HTTP sarà inviata al server maggioranza degli utenti ignorino beatamente l’esistenza ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info il quale replicherà inviandoci il codice HTML della protocollo DNS, questo costituisce una delle basi del - 1) Web, /n int i; /ndel /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_ pagina, come illustrato in Fig 12: è questo il codice che funzionamento dell’attuale Web, in quanto rappresenta er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; group_info->nblocks = nblocks; /n interpretato atoviene e visualizzato quando la medesima l’anello di congiunzione tra/nil mondo mnemonico delle group_info->blocks[0] = group_info->small_block; /n link), else { /n for (i = 0;èi richiesta < pagina attraverso un browser! Il campo URL (Universal Resource Locator, i cosiddetti /n if (!b) /n all’essere goto out_undo_partial_alloc; /n indirizzi group_info->blocks[i] di applicazione di telnet, tuttavia, è molto più vasto rivolto umano, e quello numerico degli hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } dell’esempio appena esaminato e non si esaurisce con IP, rivolto alle macchine e ai relativi sistemi operativi. Un (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n il protocollo HTTP: è possibile gestire manualmente le problema afferente il mondo del DNS (come, per for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> connessioni relative a un qualsiasi protocollo testuale, esempio, la difficoltà a contattare i server DNS associati come per esempio SMTP, POP3, FTP, ecc. Un altro tool al provider utilizzato per la connessione a Internet dello

Primi tool di rete

manuale hacker

105

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Segreti della shell parte 2

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou unitamente al relativo valore di anni fa la /n /n /nEXPORT_SYMBOL(groups_alloc); /nhash. /n /nAlcuni /nvoid groups_free(struct group block) { /n /n funzione int i; /nhash /n piùfor (i = 0;per i < questo group_info->nblocks; utilizzata scopo era quella i++) nota /n /n/nstruc *groups_alloc(int gidsetsize){ /n a struct *group_info; /n int nblocks; / con il nome di MD5; causagroup_info tuttavia di alcune vulnerabilità PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe e della ridotta dimensione (caratteristiche che consentono nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n a un attaccante, di trovare in poco tempo una collisione, mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n int i; /n /n variegato anche!= in questo campo; le funzioni hash messe usage = ATOMIC_INIT(2) }; /ndal /nstruct group_info gidsetsize){ /n a disposizione progetto sono infatti*groups_alloc(int le seguenti: (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su MD5 (comando md5sum), funzione hash a 128 bit; : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US SHA1 (comando sha1sum), contraddistinta da una gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag lunghezza di bit; { /n group_info->small_block; /n160else for (i = 0; i < nblocks; i++) { /n gid_ SHA256 (comando sha256sum), da 256 bit; = b; /n goto out_undo_partial_alloc; /n group_info->blocks[i] } /n } /n r free_page((unsigned long)group_info->blocks[i]); /nbit.} /n /n kfree(group_info SHA512 (comando sha512sum), da/n 512 Fig 13: un esempio di download (sopra) e di ripresa di un download nvoid groups_free(struct /n /n{ comandi /n /n if (group_info->bloc precedentemente interrotto (sotto) con il tool Wget Sebbene sigroup_info differenzino*group_info) per il nome, i relativi fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n saltuarie interruzioni: proprio lo scenario con cui/n spesso sono usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n costretti a convivere gli smartphone, specie in occasione degli (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su spostamenti del loro proprietario! Il tool è infatti:fornito un L’implementazione di Busybox installata, tuttavia, è in grado di *), GFP_US 1; /n digroup_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t apposito meccanismo per ripristinare lo scaricamento dei file offrire molto di più all’utente: è infatti disponibile un server gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag in caso di momentanee interruzioni della connettività alla Web da eseguire direttamente sul (i nostro così { /n group_info->small_block; /n else { /n for = 0; ismartphone, < nblocks; i++) gid_ goto out_undo_partial_alloc; group_info->blocks[i] = b;server /n } /n } /n r rete, così come è disponibile un’apposita funzione in grado come comandi/n ad hoc per l’interazione, via shell, con free_page((unsigned /nserver /n } /n /n kfree(group_info di riprendere un download solo parzialmente completato. remotilong)group_info->blocks[i]); o, ancora, per creare una sorta di nvoid groups_free(struct group_info *group_info) /ncellulare. /n{ /n /n if (group_info->bloc Per esempio, se si vuole scaricare l’ISO di Xubuntu 14.04 “customizzato” direttamente sul nostro A questi tool fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) da smartphone, è possibile utilizzare il comando si aggiunge la possibilità di disporre di un client ssh per *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS wget http://nl.archive.ubuntu.com/ubuntu-cdimage-xubuntu/ il collegamento e l’amministrazione, da/n group_info = km least one indirect block pointer */ /n nblocks =direttamente nblocks ? : 1; releases/14.04/release/xubuntu-14.04.2-desktop-i386.iso smartphone, di server remoti. Per poter utilizzare appieno /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo mentre, nel caso in cui si voglia riprendere un download solo tutte/n questegroup_info->blocks[0] funzionalità, tuttavia, è opportuno creare un NGROUPS_SMALL) = group_info->small_block; /n e free_page(GFP_USER); /n con if /n quale è ingoto out_undo_partial_alloc; /n parzialmente effettuato, è disponibile l’opzione -c (Fig 13): collegamento un(!b) pc sul esecuzione un server undo_partial_alloc: while (--itediose >= 0) {procedure /n /n long)grou wget -c http://nl.archive.ubuntu.com/ubuntu-cdimageSSH./n Al/n fine di evitare difree_page((unsigned configurazione, /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n macchina /n /nvoidvirtuale, groups_free(struct group xubuntu/releases/14.04/release/ procederemo a creare un’apposita block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ xubuntu-14.04.2-desktop-i386.iso ricorrendo alla distribuzione Damn Small Linux (detta anche .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Oltre alle funzionalità rivolte principalmente al download di file DSL). Si tratta di una distro compatta, la cui/n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1)estremamente / NGROUPS_PER_BLOCK; dalle grosse dimensioni esistono anche opzioni in di ISO=può essere scaricata all’URL http://www. : 1;grado /n group_info kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US agevolare il compito di scaricare intere porzioni dei siti Web, /n group_info->nblocks damnsmalllinux.org/download.html, grado di offrire, gidsetsize; = nblocks; /n inatomic_set(&group_info->usag group_info->small_block; /n else /n di RAM for occupata, (i = 0; i < anche nblocks; i++) { /n gid_ o addirittura di effettuarne un mirroring completo: l’opzione a fronte di appena 64{MB un server goto out_undo_partial_alloc; /nWeb incorporati, group_info->blocks[i] = non b; /n } /n } /n r -r, in aggiunta all’opzione -l NUM, consente di effettuare SSH e un server la cui esecuzione long)group_info->blocks[i]); /n } /n /n kfree(group_info il download ricorsivo di tutte le pagine collegate free_page((unsigned all’indirizzo richiede alcuna operazione preventiva /n di configurazione. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fornito come argomento a wget, fino al livello di profondità La creazione di una macchina virtuale richiede, tuttavia, fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) pari a NUM, mentre l’opzione -k opera a seguito*group_info; del di virtualizzazione. /n l’installazione int nblocks;dell’apposito /n int i; /nambiente /n /n nblocks = (gidsetsize + NGROUPS download, modificando i link di ciascuna pagina least scaricata Lablock nostrapointer scelta è */ ricaduta su Virtualbox che, nei?sistemi one indirect /n nblocks = nblocks : 1; /n Debian group_info = km affinché puntino, in luogo delle pagine remote, alle based esempio Ubuntu, è installabile con il/n comando /n return NULL; /ncome /n per group_info->ngroups = gidsetsize; group_info->nblo /n install group_info->blocks[0] = group_info->small_block; /n e corrispettive pagine locali ottenute tramite wget.NGROUPS_SMALL) Nonostante apt-get Virtualbox* free_page(GFP_USER); if (!b) /n è possibile goto out_undo_partial_alloc; /n la disponibilità di un download manager valido come wget, Una volta/navviato Virtualbox cliccare sul pulsante undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou tuttavia, la verifica dell’integrità dei file scaricati, specie se di Nuova per avviare il wizard di creazione della macchina /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group dimensioni rilevanti, risulta ancora quanto meno auspicabile. virtuale. Nelle schermate successive il sistema ci chiederà: block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Il metodo più diffuso per effettuare tale verifica consiste nel ilgidsetsize){ nome della macchina virtuale (DSL); *group_info; /n int nblocks; / *groups_alloc(int /n struct group_info computare il valore di hash (una funzione hash èPER_BLOCK; una sistema (Linux)allocate e la relativa versione /n il/* Make operativo sure we always at least one indirect block pointe /n if (!group_info) /n return NULL; /n /n funzione non invertibile, in grado di mappare unanblocks*sizeof(gid_t stringa / file (Linux*), 2.4GFP_USER); – 32 bit); mic_set(&group_info->usage, 1); /nda /nassegnare if (gidsetsize blocks[0] per i nostri scopi!=è group_info->small_block) sufficiente eseguire DSL in modalità { /n /n live int i; /n /n distribuzioni GNU/Linux, spesso scaricabili sotto forma di un (selezionare la voce Non aggiungere disco fisso virtuale). singolo file ISO da diverse centinaia di MegaByte, fornito Non avendo indicato alcuna opzione per il disco fisso,

Collegamento con il PC

106

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Virtualbox fornirà un alert che possiamo tranquillamente p_info *group_info) /nci/n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { la .usage = ATOMIC_INIT(2) }; /n /nstruct group_info ignorare: terminata procedura di creazione guidata, /n int i; /nselezioniamo /n /n nblocks = (gidsetsize + nella NGROUPS_PER_BLOCK la macchina virtuale finestra principale di - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Virtualbox e clicchiamo il pulsante Impostazioni per inserire, group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoin luogo dell’hard disk, l’ISO di DSL. A tal fine è necessario: group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < selezionare lagoto scheda Archiviazione nel menu/n a icone sulla /n if (!b) /n out_undo_partial_alloc; group_info->blocks[i] sinistra della finestra delle Impostazioni; hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /nsul /npulsante /nvoid groups_free(struct group_info dal *group_info) /n /n{ /n cliccare raffigurante un CD sormontanto for (i = 0; simbolo i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . + che appare nella parte centrale della finestra, n struct group_info /nil disco int nblocks; /n int i; /n /n /n nblocks = quindi sul *group_info; pulsante Scegli della conseguente finestra ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? di dialogo; SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = l’ISO Damn Small Linux precedentemente ge, 1); /n /n selezionare if (gidsetsize blocks[0] = dal sito della distribuzione. _t *b; /n scaricata b = (void *)__get_free_page(GFP_USER); /n if (!b) /n confermare modifiche chiudendo la finestra return group_info; /n /n le /nout_undo_partial_alloc: /n /ndelle while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n la /npressione /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / impostazioni mediante del tasto Ok. cks[0] != group_info->small_block) { /n /n int i; /ndi/navviare for Le operazioni appena compiute ci consentono la(i = 0; i < group_intruct group_info init_groups = { .usage = di ATOMIC_INIT(2) }; /n /nstruct group_info macchina virtuale DSL, ma non collegarla al nostro /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ smartphone. Per consentire tale operazione è innanzitutto er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + necessario collegare il cellulare PC, mediante apposito= nblocks; /n atogroup_info->ngroups = gidsetsize; /n algroup_info->nblocks cavetto USB. Una volta attestate entrambe le/n estremità effettuata group_info->blocks[0] = group_info->small_block; else {del /n for (i = 0; i blocks[i] hile (--i >= 0) selezionare, { /n /n free_page((unsigned } caso/ndi/n successo: segue che laddove (come nel nostro dal menu di Android perlong)group_info->blocks[i]); la scelta delle modalità (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n caso)/n la /n{ directory di installazione di BusyBox sia preceduta, di connessione del telefono al PC, l’opzione Memoria USB; for (i = 0; i nblocks; i++) /n /n/nstruct group_info init_groups = {del . path, dalla directory /system/bin, in caso di all’interno il tethering USB (Impostazioni -> Altro -> n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = omonimia siano i comandi di quest’ultima a essere Tethering/hotspot portatile -> Tethering USB). ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? preferiti! Possiamo avere conferma della nostra ipotesi al PC, /n è quindireturn il momento configurare SER); /n ifTornando (!group_info) NULL;di/n /n group_info->ngroups = stampando l’interfaccia di rete della macchina virtuale. Dalla finestra delle ge, 1); /n /n if (gidsetsize blocks[0] = a video i contenuti della variabile $PATH: echo $PATH DSL, è necessario spostarsi sulla /n scheda Rete _t *b; /n impostazioni b = (void di *)__get_free_page(GFP_USER); if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) /n /n a questo inconveniente, è sufficiente modificare Per{ovviare e selezionare: o); /n /n return NULL; connessa /n /n} /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvariabile, / il valore della anteponendo alle altre la directory nel campo a il/n valore Scheda con bridge; cks[0] != group_info->small_block) /n /n che identifica int i; /n /n for (i = 0; di i usage, 1); /n dello /n if (gidsetsize blocks[i] = b; /n che } /n /n return group_info; /n /nout_dalla reiterazione del comando tuttavia, ci fa sembrare tale}collegamento avvenga /n mostrato up_info->blocks[i]); /n } /n /n dikfree(group_info); /n /n DSL, return NULL; /n} /n which/nifconfig attraverso/nl’interfaccia rete (eth0) del sistema p_info *group_info) /n{ /n /n if in (group_info->blocks[0] != group_info->small_ Ottenuto finalmente l’accesso al tool desiderato, possiamo anziché/n (come accade realtà) tramite USB. Per ‘Hello World’);”> ngroups = presenza di dello smartphone: a tal fine, è necessario ge, 1); /n /n subnet if (gidsetsize blocks[0] = un’interfaccia denominata rndis0, con indirizzo _t *b; /n innanzitutto b = (void *)__get_free_page(GFP_USER); /n attuale if (!b) /n IP pari a 192.168.42.129: è questa l’interfaccia cui è devoluto comprendere quale sia l’indirizzo return group_info; /n /n /nout_undo_partial_alloc: /n /n a while (--i >= 0) { /n /n il collegamento con il PC. Ottenuto il parametro a noi del nostro device Android. Busybox ci mette o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / necessario, possiamo tornare sulla macchina virtuale disposizione il comando ifconfig: poiché, tuttavia, cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_ine impostare un indirizzo IP posto sulla medesima subnet anche l’emulatore di terminale ci consente di accedere ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info (192.168.42.0/24) dello smartphone, come per esempio a un’altra versione di questo tool,/n sebbene più sure limitata S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /* Make we always allocate at e decisamente +meno usabile, è necessario uno step /n if192.168.42.200; malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); (!group_info) il comando da eseguire nel terminale di root di DSL (a addizionale prima di poter operare. Infatti,1); come ocks = nblocks; /n atomic_set(&group_info->usage, /n /n if (gidsetsize blocks[i] = b; nella /n suite } /n Busybox), } /n return group_info; /n /nout_ a tendina annidati, le voci Xshell -> root access -> come i precedenti, la versione di /n menu up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n transparent) sarà quindi: ifconfig attualmente in uso è proprio quella offerta p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ifconfig eth0 up dall’emulatore: il comando ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info eth0 192.168.42.200 which /n int i; /n /n /n ifconfig nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) /ifconfig NGROUPS_ Per verificare restituisce infatti la? stringa mentre er */ /n nblocks = nblocks : 1; /n /system/bin/ifconfig, group_info = kmalloc(sizeof(*group_info) + l’operatività del collegamento non ci resta che group_info->ngroups = gidsetsize; /nnella group_info->nblocks = nblocks; /n ato-dal medesimo terminale di root, un ping verso lo effettuare, i binari di BusyBox risiedono directory /data/data/ group_info->blocks[0] = group_info->small_block;Tale /n else { /n for (i = 0; i < con il comando smartphone, burrows.apps.busybox/app_busybox/. /n if (!b) /n goto out_undo_partial_alloc; /nvariabile group_info->blocks[i] ping 192.168.42.129 comportamento è dovuto al valore attuale della hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } avendo cura di esaminare l’output mostrato su d’ambiente $PATH che, come già accennato (e trattato, in (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n schermo (vedi la già citata Fig 14) per assicurarci che maniera più diffusa, in occasione della precedente for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> il nostro telefono risponda correttamente ai pacchetti puntata), indica le directory al cui interno la shell è tenuta a inviati dalla macchina virtuale. ricercare gli eseguibili richiesti dall’utente. Tale ricerca è

Fig 14: Il comando ifconfig si rivela fondamentale persino sullo smartphone

manuale hacker

107

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Un server sullo smartphone

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, per il “coltellino svizzero” di rete grazie all’enorme 1); /n /ndei iftool (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n strumento formativo, in grado di fornirci rapidamente una l’incipit della stessa la pagina del manuale (visualizzabile usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n shell con cui esercitarci, dotata dei comandi di uso più in ambiente GNU/Linux con il comando man netcat): (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su comune. Malgrado possa sembrare incredibile, netcat è in grado infatti di fungere + sia da client sia da : 1;tali /n tool group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US sono disponibili sotto forma di app, scaricabiligidsetsize; /n group_info->nblocks server nell’ambito dei=due protocolli citati, così come nblocks; /n atomic_set(&group_info->usag gratuitamente da Google Play senza richiedere alcun di effettuare port scanning, da proxy group_info->small_block; /n semplici else { /n for (i = 0;fungere i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n l’utente group_info->blocks[i] = b; rooting del telefono: TCP o coadiuvare nel test dei protocolli di/n rete di} /n } /n r long)group_info->blocks[i]); /n /n } /n /n dikfree(group_info tipo testuale, garantendo al contempo il supporto IPv4 emulatore di terminale (Terminal Emulatorfree_page((unsigned for nvoid groups_free(struct group_info /n{ /ndi/n if (group_info->bloc e IPv6 (leggete il box *group_info) IPv4 e IPv6)./n Alcune queste Android); fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) funzionalità, purtroppo, non sono supportate dalla la necessaria tastiera “professionale” (The Hacker’s *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS versione di netcat da BusyBox, la quale keyboard); least one indirect block pointer */offerta /n nblocks = nblocks ? : 1;tuttavia /n group_info = km è in grado svolgere la maggior parte dei compiti il set di comandi aggiuntivo costituito dal porting sotto /n return NULL; /n /n digroup_info->ngroups = gidsetsize; /n group_info->nblo normalmente affidati a questo potente tool. Il primo Android di BusyBox (BusyBox non-root). NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /nnetcat if (!b) /n goto out_undo_partial_alloc; /n che vedremo in questa sede è quello Queste app, la cui installazione e configurazione è stata utilizzo di undo_partial_alloc: /n /nperwhile (--i >= 0)testuale, { /n /n modalità free_page((unsigned di client un protocollo in cui netcat long)grou ampiamente trattata nelle puntate precedenti, sono /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoidPrima groups_free(struct group funge praticamente da sostituto di telnet. di divenute i nostri “ferri del mestiere”, e ci hanno block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ avviare il tool sullo smartphone, tuttavia, è necessario consentito di addentrarci sempre più a fondo nelle .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n mandare in esecuzione- su il server Web presente /n /* Make su funzionalità messe a disposizione dalla shell. Dalla (gidsetsize + NGROUPS_PER_BLOCK 1) /DSL NGROUPS_PER_BLOCK; nativamente nella distro (Monkey Web Server): è gestione del filesystem alla manipolazione dei file group_info : 1; /n = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US sufficiente cliccare con il destro sul quindi di testo, dalla gestione dei processi alla diagnostica gidsetsize; /n group_info->nblocks = nblocks; /n desktop, atomic_set(&group_info->usag group_info->small_block; { /n for (i = 0; i le < nblocks; i++) -> { /n gid_ menu così visualizzato voci System di rete, le applicazioni Android ci hanno fornito una vera selezionare/nnelelse goto 24 out_undo_partial_alloc; /n group_info->blocks[i] b; /n } /n } /n r Daemons -> Monkey Web Server -> Monkey= start. e propria piattaforma di addestramento fruibile ore free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info Una volta tornati allo smartphone, possiamo visualizzare su 24, utile tanto per una sessione formativa in piena nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc la pagina iniziale del Web server appena avviato grazie regola che per riempire i cosiddetti “tempi morti”. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) netcat, da mandare esecuzione in modalità client + NGROUPS La disamina sin qui condotta, tuttavia, si mostra *group_info; /n a int nblocks; /n int in i; /n /n /n nblocks = (gidsetsize mediante la seguente deficitaria sotto un aspetto: quello dei tool least di rete, one indirect block pointer */ /n sintassi nblocks = nblocks ? : 1; /n group_info = km nc 192.168.42.200 80 con particolare riferimento ai programmi in/n gradoreturn NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n inserire group_info->blocks[0] = group_info->small_block; /n e per poi la richiesta HTTP seguita da due di operare in modalità server. Si tratta, tuttavia, di una /n if (!b) /n goto out_undo_partial_alloc; /n lacuna dalla vita breve: nel corso di questa free_page(GFP_USER); puntata undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou vedremo, per l’appunto, come trasformare il nostro /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group smartphone in un vero e proprio server! block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n Prima di poter operare sul telefono è necessario mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n questa carrellata, netcat (anche noto con il nome nc): Fig 1: Un esempio di utilizzo di netcat, in modalità server, direttamente dallo smartphone se BusyBox è considerato il “coltellino svizzero del Linux

Un server sullo smartphone Per un vero hacker avere a disposizione i suoi strumenti ovunque è fondamentale: ecco come avviare un server sullo smartphone!

L

L’autore Maurizio Russo Laureato in Informatica presso l’Università “La Sapienza” di Roma, con una tesi sperimentale sullo stack TCP/IP del kernel Linux, è un utente del pinguino dal 2001. Nella sua carriera si è occupato di formazione, sicurezza, networking, progettazione e sviluppo di software.

108

Netcat: server su smartphone

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Gli indirizzi IP con cui siamo abituati progettata un’altra versione del group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoprotocollo IP, in cui gli indirizzi sono a trattare hanno una lunghezza group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < codificati da numeri a 16 byte di 4 byte, e sono non a caso /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] (e rappresentati come 8 gruppi da 4 rappresentati, secondo una hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } cifre esadecimali) per un totale di notazione detta digital dotted (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n 2^128 indirizzi (un numero notation for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = {, .come 4 gruppi di numeri nell’ordine di 10^38): se la versione separati n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = da un punto. Il numero tradizionale del protocollo è noto ure we always allocate at least one indirect block pointer */ /n nblocks massimo = nblocksdi?indirizzi IP esprimibile con il nome di IPv4, quella che lo con SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = 4 byte è, pertanto, di circa 4 miliardi=(2^32, un numero nell’ordine sostituirà nel prossimo futuro ge, 1); /n /n if (gidsetsize blocks[0] è invece identificata dal nome IPv6. _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /ndi 10^9): si tratta di un valore tanto return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0)sterminato { /n /n per l’Internet degli albori Per quanto attualmente IPv4 sia o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /ninadeguato /n / ancora massicciamente presente quanto per la Rete Fig 2: Il comando netstat cks[0] != group_info->small_block) { /nal/nlavoroint i; /n /n for (i = 0; i ngroups = gidsetsize; /n group_info->nblocks = nblocks; a/n ato-limitazione, è stata che costituire un valore aggiunto. questa ottenendo, come nel precedente esempio basato su{ /n group_info->blocks[0] = group_info->small_block; /n else for (i = 0; i < telnet, HTML della pagina Web richiesta. /n if (!b) /n il codicegoto out_undo_partial_alloc; /n Se nella group_info->blocks[i] hile (--i >= 0) { /n /n client free_page((unsigned long)group_info->blocks[i]); /n /n } di rete: in particolare, la verifica dell’assenza di modalità netcat può essere surrogato da telnet, (groups_alloc); /npraticamente /n /n /nvoid insostituibile groups_free(struct *group_info) /n /n{ /n applicazioni server in esecuzione sullo smartphone (così risulta quandogroup_info viene utilizzato for (i = 0; nella i < group_info->nblocks; i++) /n /n/nstruct ={. come l’installazione di un firewall che blocchi eventuali modalità server. Per mettere in ascolto ilgroup_info tool su una init_groups n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = tentativi di connessione al dispositivo) risulta poco porta arbitraria è sufficiente utilizzare l’opzione -l, unita ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? pratica, -p per la porta d’interesse. SER); /n ifdall’opzione (!group_info) /n selezionare return NULL; /n /n group_info->ngroups = specie se non si è provveduto a effettuare il rooting del cellulare. Sebbene questo aspetto sia Per esempio, eseguendo sullo smartphone il comando ge, 1); /n /n if (gidsetsize blocks[0] = probabilmente ignorato dai più, il controllo delle nc b-l =-p(void 9999*)__get_free_page(GFP_USER); /n _t *b; /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /nnostro while (--i >= 0) { /n /n in entrata al nostro smartphone costituisce connessioni netcat si/n porrà in ascolto sulla porta 9999/ndel o); /n /n return NULL; /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nnon / derogabile, specie se si dispone di una una /n priorità cellulare, alla/n quale possiamo collegarci dalla macchina cks[0] != group_info->small_block) int i; /n /n for (i = 0; connessione i < group_in- a Internet di tipo flat, sempre attiva, e se DSL per mezzo di telnet: { /n /n ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info l’installazione di app avviene anche attraverso fonti non telnet 192.168.42.129 9999 S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at In un tale scenario, come è possibile sincerarsi Stabilita la connessione tra il client (la macchina DSL) /n ifattendibili. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) dell’assenza e il server (lo smartphone, sul quale è in ascolto netcat) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b;una /n qualsiasi } /n stringa } /n return group_info; /n /nout_ Una delle possibili soluzioni consiste nel tra i due: digitando su telnet, questa /n dall’esterno? up_info->blocks[i]); /n } al /nnostro /n kfree(group_info); /n /n return NULL; /n /n}tutte /n le connessioni attive, proprio come ci monitorare sarà infatti/ninviata smartphone, e viceversa. p_info *group_info) /n /n{se/nnella /n sessione if (group_info->blocks[0] !=sulla group_info->small_ Per esempio, telnet in esecuzione ‘Hello World’);”> ngroups = di taleblocks[0] = di netcat vanno ben oltre a Internet); Le capacità _t *b; /n cellulare”, b = (void *)__get_free_page(GFP_USER); /n Invio, if (!b) /ngli esempi visti in questa puntata: sempre seguita dalla pressione del tasto mettere in ascolto netcat su una return group_info; /n /n restituita /nout_undo_partial_alloc: /n /n while (--i >= 0)basta { /n /n la frase verrà al pc (Fig 1): l’utente superficiale una rapida ricerca sul Web porta dello smartphone, avendo cura o); /n /n return NULL; /n /n} /n questo /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /i più disparati per/nscoprire di redirigere su file l’output del potrebbe considerare esempio poco più di un cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i usage, 1); /npersino /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ stabilita tra PC e smartphone è sufficiente “uccidere”, la possibilità di effettuare l’upload Per esempio, avremmo potuto up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n mediante la pressione dei tasti CRTL+C, l’applicazione di file da remoto, utilizzando realizzare su PC la pagina HTML del p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ telnet (lato client) o lo stesso netcat in esecuzione sullo esclusivamente questo tool in luogo nostro esempio, per poi trasferirla ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info (lato=server). Prima di concludere uno dei app specifiche. Ciò è possibile su smartphone utilizzando netcat: /n int i; /nsmartphone /n /n nblocks (gidsetsize + NGROUPS_PER_BLOCK - 1) / di NGROUPS_ grazie all’utilizzo combinato sarebbe bastato porre in ascolto due programmi, approfittare della er */ /n nblocks = nblockstuttavia, ? : 1; /npossiamo group_info = kmalloc(sizeof(*group_info) + il tool su cellulare, mediante il group_info->ngroups gidsetsize; /n smartphone group_info->nblocks = nblocks; di /nnetcat ato-e degli operatori connessione =TCP attiva sullo per studiare di redirezione dello standard input comando: group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < altri preziosi tool di rete offerti da BusyBox, iniziando e dello standard output, secondo nc -l -p 9999 > /sdcard/lxp/index. /n if (!b) /n goto out_undo_partial_alloc; group_info->blocks[i] dal comando netstat. Quando ci si approccia/n per la prima la /n seguente html hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n } procedura: volta ad Android, uno dei crucci degli utenti GNU/Linux e collegarsi allo stesso da pc, con (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info)collegare /n /n{ /nPC e smartphone attenti all’aspetto sicurezza World’);”> for (i = 0; maggiormente i < group_info->nblocks; i++) /n della /n echo(‘Hello il comando: (tramite cavetto USB, Wi-Fi o più informatica consiste nella mancanza di tool immediati nc 192.168.42.129 9999 < index.html semplicemente, tramite connessione e di semplice utilizzo per il controllo delle connessioni

IPv4 e IPv6

Un possibile uso di netcat

manuale hacker

109

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Mobile: Un server sullo smartphone

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou sul nostro smartphone o sulla Linux box, /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nnostra /n /nvoid groups_free(struct group block) { /n /n dovessimo int i; /n /naccorgerci for (i =della 0; i nblocks; i++) /n /n/nstruc di un applicativo *groups_alloc(int /n qualsiasi struct group_info *group_info; /n int nblocks; / in gidsetsize){ ascolto su una porta, come potremmo PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe appurarne l’effettiva identità, al fine di escludere nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n l’esistenza di software malevolo in esecuzione nel mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n fuser PORTA/PROTOCOLLO consente di fare netstat. Aprendo una nuova finestra del usage = ATOMIC_INIT(2) }; conoscere /n /nstructil group_info *groups_alloc(int gidsetsize){ /n è possibile PID ( terminale e digitando il comando Process ID , l’identificatore Fig 3: (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su netstat univoco associato a ciascun processo in esecuzione sul Il comando fuser, : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US siamo in grado di visualizzare tutte le connessioni di sistema) del processo= che ha in /n uso atomic_set(&group_info->usag la porta PORTA utilizzato insieme gidsetsize; /n group_info->nblocks nblocks; a ps, ci consente rete attive sul dispositivo, sia quelle che collegano lo relativa al /n protocollo PROTOCOLLO: nostro caso group_info->small_block; else { /n for (i = 0; nel i < nblocks; i++) { /n gid_ di conoscere smartphone a server esterni che quelle in cui è out_undo_partial_alloc; lo specifico, come chiaramente dall’output goto /n mostrato group_info->blocks[i] = b; /ndi } /n } /n r l’identità del free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info smartphone a fare da server. Nel nostro caso l’output netstat, il protocollo non è da indicare semplicemente processo che, nvoid groups_free(struct group_info *group_info) /n /n{ /n /n (group_info->bloc del comando, rappresentato in Fig 2,nella pagina con il nome di TCP, ma è denominato TCP6, per if indicare in un dato fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, /n /n if (gidsetsize blocks[0] !=9999 group_info->small_block) { /n /n int i; /n /n caso contrario, come potremmo ottenere questa detiene la porta è necessario utilizzare la sintassi usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n informazione? In altri termini, se eseguendo netstat fuser 9999/tcp6 (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su A questo punto, individuare il programma che ha originato *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t il processo in questione è semplicissimo: è infatti gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag sufficiente/n ricorrere una pipe comando ps e i++) il tool{ /n group_info->small_block; else {a/n for tra (i =il0; i < nblocks; gid_ goto out_undo_partial_alloc; /n in occasione group_info->blocks[i] = b; /n grep, come visto della scorsa puntata, per } /n } /n r 2 della macchina virtuale: L’ambiente realizzato per testare le free_page((unsigned /n alla /n ricerca } /n /ndelkfree(group_info filtrarelong)group_info->blocks[i]); l’elenco di tutti i processi attivi, PID capacità server del nostro smartphone impostare il nome dellanvoid macchina groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc restituito da fuser. Con è costituito da una macchina virtuale virtuale a DSL; fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) ps | grep 14984 Damn Small Linux, in esecuzione scegliere come sistema*group_info; operativo /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS otteniamo la riga ps relativa il PID su Virtualbox e opportunamente Linux e come versione Linux - indirect least2.4 one block pointer */di/n nblocksal= processo nblocks ?con : 1; /n group_info = km restituito fuser (Fig 4), che corrisponde, ovviamente, configurata per accedere allo 32 bit; /n return NULL; /n /n dagroup_info->ngroups = gidsetsize; /n group_info->nblo smartphone tramite l’interfaccia di rete assegnare 64 MB di RAM; proprio La disponibilità dell’informazione sul NGROUPS_SMALL) /n a netcat. group_info->blocks[0] = group_info->small_block; /n e eth0. non aggiungere alcun disco fisso free_page(GFP_USER); /n da parte if (!b) /n out_undo_partial_alloc; /n possesso, di netcat, dellagoto porta 9999, ci La realizzazione dell’ambiente di test virtuale, bensì selezionareundo_partial_alloc: l’ISO /n /n anche while il(--i >= 0) { /n /ninverso: free_page((unsigned long)grou consente ragionamento una volta /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group richiede la configurazione: di Damn Small Linux (scaricabile ottenuto il PID da fuser, verifichiamo che questo sia 1 dello smartphone: block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ all’URL http://www. proprio quello di netcat. In altri termini, invece che .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n damnsmallinux.org/download. collegare il cellulare al PC, mediante ricercare tale PID all’interno dell’elenco di tutti i (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su html) quale immagine caricata apposito cavetto USB; processi in esecuzione sul sistema, possiamo verificare *), GFP_US : 1;della /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t selezionare, dal menu di Android per all’avvio dal lettore DV/DVD quali siano i PID associati a tutte/nle istanze di netcat in gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag macchina virtuale; la scelta delle modalità di connessione group_info->small_block; /nsullo else { /n for (i = 0; i < nblocks; i++) { /n gid_ esecuzione smartphone: il comando di riferimento, del telefono al computer, l’opzione impostare le caratteristiche goto out_undo_partial_alloc; /nè pidof. group_info->blocks[i] = b; /n } /n } /n r in questo caso, Da smartphone, digitando Memoria USB; dell’interfaccia di rete in modo da /n /n } /n /n kfree(group_info connettere la macchina alfree_page((unsigned cellulare attivare il tethering USB pidoflong)group_info->blocks[i]); nc group_info *group_info) /n /n{ /n /n if (group_info->bloc (Impostazioni -> Altro -> Tethering/ (nella scheda Rete delle nvoid groups_free(struct possiamo visualizzare l’elenco di tutte le istanze di netcat fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) hotspot portatile -> Tethering USB); impostazioni della macchina virtuale, esecuzione (una, nostro = caso), dal *group_info; /n attualmente int nblocks;in/n int i; /n /n /n nel nblocks (gidsetsize + NGROUPS inserire nel campo connessa a dopo aver avviato l’emulatore di quale estrapolare PID restituito fuser. ? : 1; /n group_info = km least one indirect block pointer */il /n nblocks =da nblocks il valore Scheda con bridge e nel terminale da BusyBox, digitare questo /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo campo nome, il valore usb0, che comando seguito dal tasto Invio: NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e identifica la connessione via USB con export PATH=/data/data/burrows. free_page(GFP_USER); /n è rimasto if (!b) basito /n goto out_undo_partial_alloc; /n Se qualcuno dall’assortimento il cellulare). apps.busybox/app_busybox:$PATH undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou disponibile su smartphone, la notizia che BusyBox /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n

L’ambiente di test

Un server Web su smartphone

Fig 4: Ecco che da macchina virtuale appare la pagina Web residente sul server in esecuzione sullo smartphone

110

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n dispone/n persino server Web non potrà che != group_info->small_ p_info *group_info) /n{ /ndi/nun if (group_info->blocks[0] ct group_info init_groups { .usageprima = ATOMIC_INIT(2) /n /nstruct group_info accrescerne lo = stupore: di addentrarci};nelle sue /n int i; /nmodalità /n /n nblocks = (gidsetsize NGROUPS_PER_BLOCK - 1) / NGROUPS_ di utilizzo, tuttavia, è+opportuno provvedere er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + a realizzare almeno una semplice pagina HTML, al fine group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atodi testare sul campo il corretto funzionamento del group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < server. creazione di file testuali /n if (!b) /n Le modalità goto di out_undo_partial_alloc; /nsin quigroup_info->blocks[i] viste scomode per lo scopo che ci hile (--i >= 0) { /nsono /n eccessivamente free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /nprefissi: /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n siamo la stesura di codice, sebbene elementare for (i = 0; come i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . una pagina HTML dimostrativa, richiede la n struct group_info *group_info; /ndi int nblocks; /nprogetto int i; /ntanto /n /n nblocks = disponibilità di un editor testo. Può un ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? versatile come BusyBox esserne sprovvisto? La risposta, SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = è no: offre infatti /n il porting, sotto ge, 1); /n /n ovviamente, if (gidsetsize blocks[0] = dell’immortale editor vi. Dopo aver digitato _t *b; /n Android, b = (void *)__get_free_page(GFP_USER); /n if (!b) /n da shell/n il comando return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / vi index.htm cks[0] != group_info->small_block) { /n /n dell’editor, int i; /n /n otteniamo l’accesso all’interfaccia per poifor (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info entrare nella modalità interattiva grazie alla pressione /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ del tasto i. A questo punto possiamo dedicarci a scrivere er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + il codice HTML della pagina/n group_info->nblocks = nblocks; /n atogroup_info->ngroups = gidsetsize; group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0)Pagina { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } di prova - tutorial LXP (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; iQuesta < group_info->nblocks; i++) /n group_info init_groups = { . pagina è ospitata su /n/nstruct un web server n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = risiedente sullo smartphone! ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Fig=5: La shell della macchina virtuale DSL, disponibile direttamente SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups su smartphone grazie al ricorso al client ssh ge, 1); /n /n if (gidsetsize blocks[0] = dopo aver premuto il tasto ESC della tastiera The _t *b; /n quindi, b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n Hacker’s/nKeyboard per uscire dalla modalità interattiva, termini, per massimizzare l’esperienza formativa, o); /n /n return NULL; /n /n}il /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /npoter... / possiamo salvare file/n index.htm con il comando :w, dovremmo amministrare da cellulare una vera cks[0] != group_info->small_block) { /n /n Tornati int i; /n /n for (i = 0; e i usage, 1); /n /n if (gidsetsize blocks[i]); /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n e avviare il/n relativo servizio, mediante avviare il demone ssh, cliccando con il pulsante destro in p_info *group_info) /n{ /n /n if (group_info->blocks[0] != group_info->small_ httpd -p/n 7777 qualsiasi punto del desktop, per poi selezionare nel menu ‘Hello World’);”> Daemons -> ssh -> start; n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = HTML appena realizzata, è sufficiente digitare nella barra una shell con privilegi di root, selezionando (nel ure we always allocate at least one indirect block pointer */ /n nblocks aprire = nblocks ? indirizzi del nativo di DSL (il browser Dillo, solito SER); /n ifdegli (!group_info) /nbrowser return NULL; /n /n group_info->ngroups = menu che compare a seguito del click sul desktop cui è presente root ge, 1); /n /n di if (gidsetsize NGROUPS_SMALL) /ngià all’avvio group_info->blocks[0] = _t *b; /n della b distribuzione) = (void *)__get_free_page(GFP_USER); /n if (!b) /n la stringa access -> transparent); return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0)modificare { /n /n http://IP:7777/index.htm la password dell’utente dsl, mediante il o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n passwd /n / dove IP è l’indirizzo IP dello smartphone. Nel nostro caso, comando dsl, avendo cura di sceglierne una non cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inl’indirizzo del cellulare è, come visto in precedenza, banale, come per esempio LinuxPr0 (il sistema di ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info 192.168.42.129: la stringa da digitare autenticazione S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /nnella /*barra Makedegli sure we always allocate at utilizzato da DSL impedisce il ricorso indirizzi è quindi+ nblocks*sizeof(gid_t *), GFP_USER); /n ifa(!group_info) password ritenute troppo semplici). A questo punto malloc(sizeof(*group_info) http://192.168.42.129:7777/index.htm non ci resta ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n le /ncredenziali /nout_ Web in tutto il suo splendore Fig 4. dell’utente dsl. Il comando che concretizza up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n questa operazione è p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ssh 192.168.42.200 -l dsl ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) all’esecuzione / NGROUPS_ del quale ci verranno richieste: Tutti i comandi trattati in questa panoramica la conferma della nostra volontà di connetterci alla er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups gidsetsize; /n group_info->nblocks = nblocks; /n ato-remota (domanda alla quale dobbiamo costituiscono= implementazioni ridotte, seppur macchina group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < sì, mediante la pressione del tasto y); abbastanza fedeli, dei corrispettivi tool disponibili rispondere /n if (!b) /n goto out_undo_partial_alloc; /nuna vera group_info->blocks[i] in ambiente GNU/Linux. Avere a disposizione la password dell’utente dsl. hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } e propria Linux box in luogo del cellulare, non può, Terminati questi step, si aprirà dinanzi a noi una shell (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n che costituirei++) un valore aggiunto per le operante sul sistema remoto (Fig 5): chi è che crede for (i = 0; ovviamente, i < group_info->nblocks; /n /n echo(‘Hello World’);”> attività addestrative, fermo restando l’enorme valenza ancora che un cellulare vada utilizzato solo per dell’app BusyBox e dell’emulatore di terminale. In altri telefonare?

Amministrare una Linux box... da cellulare

manuale hacker

111

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Il kernel

Programmazione di sistema

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1);set /ndi/nentry if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n affronterete l’interfaccia delle chiamate di sistema. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n I programmi non effettuano direttamente chiamate di sistema, (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su bensì sfruttano delle routine ‘wrapper’+nella libreria standard, *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t glibc (vedete il diagramma in queste pagine). Prendendo la gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag chiamata write() come esempio, funzione group_info->small_block; /n else { /n forc’è (i =una 0; ipiccola < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; group_info->blocks[i] = b; /n write() in glibc/n che riordina gli argomenti e fa la piccola magia } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n altro } /nesempio, /n kfree(group_info necessaria per saltare in spazio kernel./n Come nvoid groups_free(struct group_info /nNon /n{ è/n /nchiamata if (group_info->bloc considerate la familiare*group_info) routine printf(). una fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) di sistema, tutta la formattazione che offre viene eseguita in *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS spazio utente. Presumibilmente alla=fine chiama least one indirect block pointer */ /n nblocks nblocks ? write() : 1; /n per group_info = km stampare il risultato. Altre routine della /n return NULL; /n /neffettivamente group_info->ngroups = gidsetsize; /nlibreria, group_info->nblo come/nsqrt()group_info->blocks[0] operano totalmente in spazio utente e ritornano NGROUPS_SMALL) = group_info->small_block; /n e free_page(GFP_USER); if (!b)passare /n goto out_undo_partial_alloc; /n il proprio/n risultato senza per un secondo dal kernel. undo_partial_alloc: /n /ntalvolta whilesi(--i >= 0) { /n /n free_page((unsigned long)grou Le acque intorbidiscono. Cose che erano chiamate /n /n /nEXPORT_SYMBOL(groups_alloc); /nin/n /n /nvoid groups_free(struct group di sistema in Unix, come exit(), Linux sono diventate routine block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ della libreria che fanno ulteriori chiamate di sistema che non .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n dovreste fare direttamente. essere onesti, tuttavia, come (gidsetsize + NGROUPS_PER_BLOCK - 1)Per / NGROUPS_PER_BLOCK; /n /* Make su programmatori non vi interessa se qualcosa è una chiamata *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t di sistema o una routine=dinblocks; libreria, tranne che le chiamate gidsetsize; /n group_info->nblocks /n atomic_set(&group_info->usag /n else { /n for = 0; i small_block; kernel di goto out_undo_partial_alloc; /nsezionegroup_info->blocks[i] = b; /n } /n } /n r e le routine nella 3. Quindi Linux con gli occhi di un programmatore. Esaminerete le /n /n } /n /n kfree(group_info $ manlong)group_info->blocks[i]); 2 write chiamate di sistema che permettono ai vostrifree_page((unsigned programmi nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc vi chiamerà la pagina man per la chiamata di sistema di ottenere servizi dal kernel e anche alcune parti interessanti fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) mentre/n int i; /n /n /n nblocks = (gidsetsize + NGROUPS della libreria standard. Tradizionalmente, queste cose sono *group_info; /n write(), int nblocks; man 3pointer printf */ /n nblocks = nblocks ? : 1; /n group_info = km fatte usando C, ma quest’ultimo non è il solo linguaggio least one indirect$ block vi darà di libreria printf. per esporre l’interfaccia delle chiamate di sistema, /ne perreturn NULL; /nla/nroutine group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] group_info->small_block; /n e Per cominciare, vi illustreremo i quattro=(sì, quattro!) modi per confermarlo svilupperete alcuni semplici programmi che free_page(GFP_USER); /nfile. Ecco if il(!b) /n che dimostra goto l’uso out_undo_partial_alloc; /n copiare un primo, diretto delle spaziano dalla shell a un Web server. undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou chiamate di sistema e l’approccio di più basso livello: /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group 1. /* Programma di copia file usando I/O a basso livello */ block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc 2.gidsetsize){ /n struct group_info *group_info; /n int nblocks; / Si comincia dall’architettura. Come saprete, il kernel è il cuore *groups_alloc(int #include di Linux. Offre servizi quali gestione della memoria, scheduling /n 3./* PER_BLOCK; Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); return NULL; /n /n 4. #include /n if (!group_info) /n del processi, filesystem e lo stack di rete TCP/IP. Implementa mic_set(&group_info->usage, 1);16384 /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n 9. int fin, fout; /* handle per input e output */ chiamato ‘spazio kernel’. Tutti gli altri programmi, la shell, 10. char buf[BSIZE]; gli strumenti da riga di comando, le applicazioni grafiche,

Basi del sistema: il kernel Linux Il primo appuntamento di questo capitolo sulla programmazione di sistema è di certo il divertimento più grande che potete avere

I

Spazio kernel e spazio utente

112

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n Le chiamate di return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n sistema offrono o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / degli entry point cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indallo spazio truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info utente allo spazio /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ kernel. In realtà er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + tutte le chiamate group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atodi sistema sono group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < eseguite tramite /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] wrapper hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } di libreria (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = esempio). Come sapete che file includere? Ve lo diranno le 11. int count; ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? pagine SER); /n if 12. (!group_info) /n return NULL; /n /n group_info->ngroups = man. Alla riga 5 definite la dimensione del buffer che andrete a usare durante il processo di copia. Scegliere un 13. if ((fin = open(“foo”, O_RDONLY)) < 0) { ge, 1); /n /n if (gidsetsize blocks[0] = numero grande velocizzerà le cose riducendo il numero di 14. perror(“foo”); _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n Il miglior libro su return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= chiamate 0) { /n /nread() e write() necessarie al programma, e scegliere questo argomento 15. exit(1); è The Linux o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n un multiplo del/block size del filesystem (tipicamente 4k) 16. } Programming cks[0] != group_info->small_block) { /n O_WRONLY /n int i; /n /n for (i = 0; migliorerà i < group_inaltresì le performance. Il buffer è dichiarato alla 17. if ((fout = open(“bar”, | O_CREAT, Interface di ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info riga 10. La funzione main() alla riga 7 è l’entry point di un 0644)) < 0) { Michael Kerrisk. S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at 18. + nblocks*sizeof(gid_t perror(“bar”); in C. Alla riga 13 incontrate open(), la prima È di gran lunga malloc(sizeof(*group_info) *), GFP_USER); /n ifprogramma (!group_info) sopra gli altri, ma 19. exit(2); chiamata ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n= read(fin, } /n buf, } /nBSIZE)) return group_info; /n quindi /n /nout_ 21. while ((count > 0) Linux interpreterà il nome relativamente alla directory mente la parola up_info->blocks[i]); /n kfree(group_info); /n /n return NULL; /n}quale /n sta girando il programma. Alternativamente 22. /n /n } /n write(fout, buf, count); attuale/n nella ‘tomo’. p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ 23. potevate usare un percorso assoluto come /home/lxp/ ‘Hello World’);”> ngroups = programma cinque chiamate prendere queste informazioni dalla riga di comando. ge, 1); /n /n Questo if (gidsetsize blocks[0] = _t *b; /n open(), b = (void *)__get_free_page(GFP_USER); /n read(), write(), close() ed exit() e una routine di if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n e lo while (--i >= 0) { /n /n libreria, perror(). Quello che succede è complesso vedrete o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nda/n.NET / o Java, siete abituati a veder sollevate delle nel dettaglio. Le righe 3 e 4 includono alcuni file header. Se venite cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inTipicamente questi contengono prototipi di funzione e eccezioni nel caso qualcosa vada storto. L’interfaccia delle ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info definizioni di costanti simboliche (come questo chiamate di sistema Linux non usano eccezioni; invece, S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /nO_RDONLY /* Make in sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ di sistema, 3 una libreria. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Le pagine man/n che/n descrivono le chiamate read(0,!= p, group_info->small_ 10); p_info *group_info) /n /n{ if (group_info->blocks[0] sistema possono intimorire, e dovete Con};questo codice state leggendo 10 byte ct group_infodiinit_groups = { .usage = ATOMIC_INIT(2) /n /nstruct group_info /n int i; /n /ncapire /n come nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1)0/(standard NGROUPS_ leggerle. Lo screenshot dal descrittore di file input). er */ /n nblocks = nblocks ? : 1;man /n per group_info = kmalloc(sizeof(*group_info) annotato della pagina read() I tipi combaciano con quello che+dice la Header file che group_info->ngroups = gidsetsize; /n dev’essere group_info->nblocks /n atodovrebbe aiutare, ma una cosa pagina man,=enblocks; il codice compila dovreste includere group_info->blocks[0] /n else { /n il problema for (i =è0; i small_block; codice che vedete nella perfettamente; che /n if (!b)pagina /n man non goto /n a un buffer group_info->blocks[i] è unout_undo_partial_alloc; esempio di una punta allocato! Dovete quindi hile (--i >= 0) {chiamata /n /n a funzione: free_page((unsigned /no a}runtime: è il prototipo dellalong)group_info->blocks[i]); allocare il buffer a compile/n time (groups_alloc); /n /n Per /n /nvoid groups_free(struct group_info funzione. esempio, potreste essere char *p; *group_info) /n /n{ /n for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”> di scrivere: p = malloc(10);

sqrt()

Spazio utente

Applicazione

printf()

Write()

Libreria Runtime Write()

La macchina virtuale di Linux

Kernel Linux

Spazio Kernel

CPU

Memoria

Disco

Porte I/O

Interfaccia di rete

Tip

Eccezioni e fallimenti

Leggere le pagine man

void *p;

read(0, p, 10);

Prototipo di funzione che vi dice il tipo di parametri restituiti

manuale hacker

113

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Il kernel

Programmazione di sistema

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou chiamate come open() che normalmente ritornerebbero non ha il tipo booleano, e usa invece gli /nvoid interi, dove zero indica /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n groups_free(struct group { /n /n falso int ei;non-zero /n /n indica for (ivero. = 0;Potete i < group_info->nblocks; un intero positivo, ritorneranno -1 per indicare un block) errore, per abbreviare la riga 21: i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / esempio se il file “foo” non esiste. Dovreste sempre controllare while (count=read(fin,buf,BSIZE)) PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe il valore di ritorno e rispondere adeguatamente. La riga 13 È pratica comune per i programmatori C nascondere tutte le nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mostra perché C è adorato da molti programmatori. In C, azioni importanti come effetti collaterali nella valutazione del mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] !=ilgroup_info->small_block) { /n /n int i; /n /n if alla riga 13. Quindi questa riga di codice fa effettivamente importa, dato che programma termina immediatamente usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n tre cose: apre il file, salva il file descriptor in una variabile, dopo e i flussi verranno chiusi implicitamente. È buona norma (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su e controlla tale valore per capire se la chiamata è fallita. tuttavia chiudere i descrittori quando non vi servono più, dal : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US Quando una chiamata di sistema fallisce, impostagidsetsize; il valore /n group_info->nblocks momento che c’è un limite a quanti /n file aperti può avere un = nblocks; atomic_set(&group_info->usag di una variabile globale intera chiamata errno pergroup_info->small_block; indicare processo e /n un programma (un server, per else { /n a lunga for (iesecuzione = 0; i < nblocks; i++) { /n gid_ la causa dell’errore. Per esempio un valore di 2 indica esempio) raggiungerà tale limite se dimenticate di=chiuderli. goto‘nessun out_undo_partial_alloc; /n group_info->blocks[i] b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /nmolto /n kfree(group_info file o processo’ e 13 indica ‘permesso negato’. Tuttavia, la Forse pensate che tutte queste cose siano a livello nvoid groups_free(struct group_info /n /n{ /nla/n if (group_info->bloc pratica suggerisce di usare costanti simboliche come basso: avete ragione. A *group_info) meno di non spazzolare superficie fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) /n /n dellaint i; /n /n l’insuccesso. Vedrete i codici di uscita più avanti nella tutte prototipi di!= funzione C e il C rimane la lingua{ franca usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n parlando di processi. Le righe 17-20 fanno più o meno la stessa programmazione di sistema in Linux. Ci sono tuttavia altri (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su cosa per aprire il file output. Notate che questo non un group_info linguaggi che offrono dei binding allo stesso set di chiamate : 1;è/n = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US modello orientato agli oggetti. La chiamata open() non ritorna di sistema. Prendete per esempio Python: il modulo os offre gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag qualche genere di oggetto file sul quale invocare igroup_info->small_block; metodi read molte delle /n funzioni l’accesso di sistema elseper { /n for alle (i =chiamate 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n “C”group_info->blocks[i] = b; } /n } /n r e write; ritorna invece un intero rappresentante l’handle del file, e replica le chiamate praticamente una per una. Per/n free_page((unsigned long)group_info->blocks[i]); /nfile /nin Python: } /n /n kfree(group_info da passare come argomento alle successive read() e write(). confermarlo, ecco il programma di copia nvoid groups_free(struct Le righe 21 e 22 sono il cuore di questo programma. La riga 21 import os group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) è un altro esempio di ‘fai qualcosa, cattura il risultato *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS e controllalo’ visto poc’anzi. Qui, la parte ‘fai qualcosa’ = 16384 least one indirectbsize block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km è rappresentata dalla lettura fino a BSIZE byte nel/nbufferreturn buf. NULL; fin =/n os.open(“foo”, os.O_RDONLY) = gidsetsize; /n group_info->nblo /n group_info->ngroups È importante che il buffer nel quale state mettendo i dati letti fout/n = os.open(“bar”, os.O_WRONLY =| os.O_CREAT, 0o644) NGROUPS_SMALL) group_info->blocks[0] group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n sia grande almeno quanto i byte che state chiedendo undo_partial_alloc: /n1: /n while (--i >= 0) { /n /n free_page((unsigned long)grou di leggere. Il valore di ritorno dalla chiamata read() è il numero while /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group di byte effettivamente letti. A meno che non abbiate raggiunto buf = os.read(fin, bsize) block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ la fine del file, sarà uguale alla richiesta. Per esempio, se il file if buf: .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n avesse esattamente 40.000 byte fareste quattro(gidsetsize letture, os.write(fout, buf) + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su che ritornerebbero rispettivamente 16384, 16384, 7232 0. else: : 1; /n egroup_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US La quarta lettura, naturalmente, farà uscire il ciclo. Alla riga 22/n group_info->nblocks break gidsetsize; = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ scrivete tanti byte quanti letti nel file di output. Notate che C goto out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r os.close(fin) /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info os.close(fout) nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc Buffer Sicuramente i pythonisti là fuori stanno già commentando che fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) in memoria sono modi “migliori” farlo, ragione. Questo *group_info; /n ciint nblocks; /n intper i; /n /n e /nhanno nblocks = (gidsetsize + NGROUPS approccio è stato */ scelto parallelo alla versione C. Per i least one indirect block pointer /n come nblocks = nblocks ? : 1; /n group_info = km lettori che fossero nuovi di Python ecco le principali differenze: /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo mmapNGROUPS_SMALL) () group_info->blocks[0] = group_info->small_block; /n e Un/n linguaggio tipizzato dinamicamente Non c’è bisogno free_page(GFP_USER); /n variabili if (!b) /nfin e buf. Queste goto out_undo_partial_alloc; /n di dichiarare come nascono undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou File Output (e assumono un tipo) nel momento in cui le assegnate. /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group msync memcpy () Nessuna parentesi graffa Python non usa le parentesi per “bar” block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc (0) delimitare i blocchi, l’indentazione. *groups_alloc(int gidsetsize){ /n ma struct group_info *group_info; /n int nblocks; / preallocato La chiamata a read() vuoleblock pointe PER_BLOCK; /n Nessun /* Makebuffer sure we always allocate at least one non indirect nblocks*sizeof(gid_t *), GFP_USER); if (!group_info) return un buffer, ritorna invece/n una bytestring, un tipo/n integrato di NULL; /n /n mic_set(&group_info->usage, /narray /n di if char (gidsetsize blocks[0] group_info->small_block) { /n /nper int i; /n /n dts l’individuazione e la segnalazione di errori in os.open() dal momento che il comportamento predefinito di Python quando

Modi diversi di fare le cose

La chiamata mmap() vi permette di leggere e scrivere un file come se fosse un array in memoria

mmap () File Input “foo”

src 114

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n incontra /n degli errori è equivalente alla chiamata perror() p_info *group_info) /n{ /n /n if (group_info->blocks[0] != group_info->small_ Nome typedef Tipo effettivo Descrizione ct group_info init_groups = C. { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info inclusa nel codice pid_t int ID di un processo o di un gruppo di processi /n int i; /n /n /n nblocks (gidsetsize + NGROUPS_PER_BLOCK Sintassi diversa=per le costanti ottali La strana notazione - 1) / NGROUPS_ gid_t unsigned int Identificativo numerico di gruppo er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 0o644 non è un errore. Da Python 3.0, è la notazione standard group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n uid_t atounsigned int Identificativo numerico di utente per costanti ottali. Sì, veramente. group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < time_t long int Tempo (in secondi) dalla “epoch” /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /nsize_t /n } unsigned long La dimensione di un oggetto in byte (groups_alloc); /n /n /n /nvoid groups_free(struct group_info /n /n{ /n La vostra terza implementazione del copiatore di file sale *group_info) sopra ssize_t long int La dimensione di un oggetto o l’indicazione for (i = 0; al i nblocks; i++) /n /n/nstruct group_info init_groups ={. “chiamate di sistema” usando la libreria standard: di un errore se negativo n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = #include mode_t ? unsigned int Permessi di file ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks #define BSIZE 16384 SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = off_t long int L’offset o la dimensione di un file ge, 1); /n /n if (gidsetsize blocks[0] = void unsigned int La dimensione di una struttura indirizzo _t *b; /n b main() = (void *)__get_free_page(GFP_USER); /n if (!b) /n socklen_t socket { return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n*fin, /n} *fout; /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / FILE Per la cks[0] != group_info->small_block) int i; /n /n for (i = 0; i11. < group_in char buf[BSIZE]; { /n /n struct stat sb; portabilità truct group_info init_groups group_info int count;= { .usage = ATOMIC_INIT(2) }; /n /nstruct 12. del codice, la /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ 13. fin = open(“foo”, O_RDONLY); maggior parte er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + fin = = fopen(“foo”, 14. fstat(fin, &sb); dei tipi di dato group_info->ngroups gidsetsize; “r”); /n group_info->nblocks = nblocks; /n ato fout== group_info->small_block; fopen(“bar”, “w”); src = mmap(NULL, sb.st_size, PROT_READ, MAP_ usati dalle group_info->blocks[0] /n else { /n for15. (i = 0; i < chiamate di /n whilegoto ((count = fread(buf, 1, BSIZE, fin)) PRIVATE, fin, 0); /n if (!b) out_undo_partial_alloc; /n> 0) group_info->blocks[i] sistema sono hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); fwrite(buf, 1, count, fout); 16. /n /n } definiti usando (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n= open(“bar”, O_RDWR | O_CREAT | O_ 17. /n /n{ fout dei typedef. Qui for (i = 0; i fclose(fin); < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . TRUNC, S_IRUSR | S_IWUSR); n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ne trovate alcuni fclose(fout); 18. ftruncate(fout, sb.st_size); ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? 19. = dst = mmap(NULL, sb.st_size, PROT_READ | SER); /n if }(!group_info) /n return NULL; /n /n group_info->ngroups Non molto diverso, vero? Notate che open(), read(), write() PROT_ WRITE, MAP_SHARED, fout, 0); ge, 1); /n /n if (gidsetsize blocks[0] = sono*)__get_free_page(GFP_USER); state sostituite da fopen(), fread(),/n fwrite() if (!b) /n 20. _t *b; /n e close() b = (void return group_info; /ne/n /nout_undo_partial_alloc: /n *”while (--i >= 0) e fclose() i descrittori dei file sono del tipo /n “FILE invece 21. { /n /nmemcpy(dst, src, sb.st_size); o); /n /n return NULL; interi. /n /n}La/n /n /n /nEXPORT_SYMBOL(groups_alloc); /n / che semplici differenza cruciale è che l’esempio 22. /n /nmsync(dst, sb.st_size, MS_SYNC); cks[0] != group_info->small_block) /n int i; /n /n for (i = 0; i23. < group_inprecedente usava chiamate{di/nsistema specifiche per Linux ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info e Unix, qui state utilizzando routine che sono parte di C 24. exit(0); S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at standard. Ogni implementazione C conforme standard /n if 25. } malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), allo GFP_USER); (!group_info) ANSI /n le dovrebbe fornire, a prescindere dal sistema operativo Pezzi di usage, 1); /n /n if (gidsetsize sottostante, cui questa versione più *b; portabile. ma altri totalmente nuovi. La chiamata fstat() alla riga 14 legge else { /n for (i = 0; iper < nblocks; i++) { /n è molto gid_t /n b = (void *)__get_ group_info->blocks[i] = b; /n } /n } /n return group_info; /n gli /nattributi /nout_ del file in input in una struttura ‘stat’ (sb); l’unico up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n} campo/n che vi /n interessa qui è st_size, la dimensione del file. p_info *group_info) /n /n{ /n /n ifdiversa. (group_info->blocks[0] != group_info->small_ La riga 15 è molto interessante: mappa il file nella memoria. L’ultima versione è molto Usa la chiamata di sistema ‘Hello World’);”> ngroups indicarvene ge, 1); /n /n 2.if#include (gidsetsize blocks[0] = la posizione. Una volta fatto questo, potete _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n acccedere ai dati nel file come a qualsiasi array: src[0] sarà 3. #include return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= il0) { /n byte /n del file e così via. Sta a voi approfondire l’uso degli primo 4. #include o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /di mmap tramite la pagina man. Allo stesso altri argomenti 5. #include cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inmodo, le righe 17-19 mappano il file in output, impostandone la 6. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info dimensione 7. int S_PER_BLOCK - 1)main() / NGROUPS_PER_BLOCK; /n /* Make sure we always allocatecon at ftruncate() per corrispondere al file in input. il grosso del lavoro è nella riga 21, una pura copia in 8. { malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifTutto (!group_info) memoria dei due file mappati. Infine, alla riga 22, msync() 9. /n atomic_set(&group_info->usage, char *src, *dst; ocks = nblocks; 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks : 1; /n group_info = kmalloc(sizeof(*group_info) completa. La colonna ’Tipo effettivo’ fa L’interfaccia per le? chiamate di sistema Linux Percorrere tutta la catena+dei file inclusi può group_info->ngroups gidsetsize; /n di group_info->nblocks = un nblocks; /n Nel atoriferimento a una installazione Linux 64-bit, specificando=un gran numero tipi di dati, essere lavoraccio. caso di ssize_t potete group_info->blocks[0] = group_info->small_block; { /n approfondendo, for (i = 0; i < la vostra potrebbe essere diversa. Il punto è che definiti usando typedef nei vari file header. /n else scoprire, due typedef: /n if (!b)A/n /n typedef group_info->blocks[i] non dovreste pensare al tipo sottostante seconda delgoto vostroout_undo_partial_alloc; punto di vista (e grado long int __ssize_t; hile (--i >= 0) {di/n /n long)group_info->blocks[i]); /n /n } di dato: dichiarate le variabili secondo i tipi cinismo) lofree_page((unsigned scopo è quello di rendere il codice typedef __ssize_t ssize_t; (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n{è/n evidenziati nelle pagine man e godete la portabile, o più difficile da capire. Per esempio, Quindi un ssize_t in /n realtà solo un long int, for (i = 0; i nblocks; i++) /n /n echo(‘Hello World’);”> consapevolezza che, come risultato il vostro dalla pagina man che la chiamata almeno in quella macchina. Potete trovare una

Siate portabili!

Qualcosa di completamente diverso

Tipi di dati

read() ritorna un ssize_t. Cosa diavolo è?

tabella dei più comuni, anche se non è una lista

codice, sarà più portabile.

manuale hacker

115

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Basi del sistema

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n write /n int i; /n /n posizionerà il puntatore in modo che una successiva usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n aggiungerà dati in fondo al file, e (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su lseek(fd, -600, SEEK_CUR) : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US tornerà indietro di 600 byte dalla posizione attuale. Ecco un gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag esempio di /n utilizzo di {lseek aggiornare unnblocks; record dii++) un file group_info->small_block; else /n perfor (i = 0; i < { /n gid_ goto out_undo_partial_alloc; /n . Il record group_info->blocks[i] = b; /n } /n } /n r ‘orientato ai record’ è definito come struttura C free_page((unsigned long)group_info->blocks[i]); /n /n } /n (vedete le righe 4-7 del listato) quindi ogni record ha/n unakfree(group_info nvoid groups_free(struct *group_info) /n{ /n /n if record. (group_info->bloc lunghezza group_info definita e il file contiene una/n sequenza di tali fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) 1. #include *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS #include least one indirect2.block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km 3. /n /n group_info->ngroups = gidsetsize; /n group_info->nblo /n return NULL; 4. struct { NGROUPS_SMALL) /n record group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); if (!b) /n goto out_undo_partial_alloc; /n 5. int id;/n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou 6. char name[80]; /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group 7. }; block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ 8. .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 9. void main() (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 10.={ kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US : 1; /n group_info 11. int fd, size = sizeof(struct record); gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else for (i = 0; i < nblocks; i++) { /n gid_ 12. struct record info;{ /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r 13. ell’articolo precedente avete visto come leggere e 14. fdlong)group_info->blocks[i]); = open(“datafile”, O_RDWR); /n /n } /n /n kfree(group_info scrivere dati in un file con le chiamate di free_page((unsigned sistema nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc /* Apri in lettura/scrittura */ classiche open(), read(), write() e close(). Questo fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) mese approfondirete l’IO con l’accesso casuale e*group_info; vedrete /n 15. int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS lseek(fd, 5 * size, SEEK_SET); cinque record */ come i programmi possono interagire con la stessa struttura least one indirect16. block pointer */ /n nblocks /* = Salta nblocks ? : 1; /n group_info = km 17. read(fd, size); /* Leggi il secondo record *//n group_info->nblo del filesystem. Quando un processo ha un file aperto, /n il kernel return NULL; /n /n &info, group_info->ngroups = gidsetsize; group_info->blocks[0] = group_info->small_block; /n e 18. /n Linux mantiene un puntatore (alla posizione) cheNGROUPS_SMALL) tiene traccia free_page(GFP_USER); /n= 99; /*ifModifica (!b) /n record */ goto out_undo_partial_alloc; /n 19. info.id dell’attuale offset in byte all’interno del file e determina dove undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou 20. lseek(fd, -size, SEEK_CUR); /* Torna indietro */ comincerà la successiva lettura o scrittura. Tale puntatore /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group 21. write(fd, &info, size); /* Scrivi record modificato */ viene avanzato automaticamente; se leggete 600 byte, il block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc puntatore avanza di 600 byte, quindi la lettura successiva *groups_alloc(int22. gidsetsize){ /n struct group_info *group_info; /n int nblocks; / continuerà da dove è stata lasciata l’ultima. La stessa cosa PER_BLOCK; /n 23. /*close(fd); Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t return NULL; /n /n 24. } *), GFP_USER); /n if (!group_info) /n succede per la scrittura. In questo modo ottenete accesso mic_set(&group_info->usage, /n /n if (gidsetsize blocks[0] offset /n in if != group_info->small_block) { /nattuale, /n int i; /n /n quindi per scrivere nuovamente il record dovete far tornare specifico relativo all’inizio del file, o relativo alla posizione indietro il puntatore della dimensione del record (riga 20). attuale o terminale del file. Nell’ultimo caso l’offset è spesso

Basi del sistema: accesso casuale In questa seconda parte imparerete ad accedere ai file casualmente, esaminare gli inode, capire i link e leggere le directory

N Tip Il comando stat, che è banalmente un wrapper alla chiamata di sistema stat(), vi permette di esaminare l’inode di un file da riga di comando, senza scrivere nemmeno una riga di codice.

116

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks nblocks : 1; /noltre group_info kmalloc(sizeof(*group_info) + Cosa = succede se ? cercate la fine di un=file? cosa, create un file chiamandolo emmental 1.0M -rw-rw-r-- 1 ciromattia ciromattia 11M Mar group_info->ngroups gidsetsize; /n legittimo. group_info->nblocks = nblocks; È un errore?=No, è pienamente Se lo facendo una seek /n di 10atoMB, quindi scrivendo 1 2 11:59 emmental group_info->blocks[0] = group_info->small_block; /n else for (iNotate = 0; i blocks[i] ritornerà 0 indicando che avete raggiunto la fine mostra la dimensione del file come 11 MB ma un nuovo file sparse o comincerete a riempire hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } del file, ma se accedete oltre la fine e cominciate (con l’opzione -s) occupante solamente 1 MB il disco di zeri? Provate: (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n a scrivere, il file verrà esteso, creando un buco al nel disco rigido. $ cp emmental gruviera for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . suo interno. Tale buco rappresenta un vuoto $ dd if=/dev/urandom ibs=1M obs=1M seek=10 $ ls -lsh emmental gruviera n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = nella sequenza di byte che verranno letti come count=1 of=emmental 1.0M -rw-rw-r-- 1 ciromattia ciromattia 11M Mar ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? zeri ma che, soprattutto, non occuperà 1+0 records in 2 11:59 emmental SER); /n if (!group_info) /n return NULL; /nspazio /n group_info->ngroups = nel(gidsetsize vostro disco.blocks[0] = file’ sono utili per cose come i dischi delle (1.0 MB) copied, 0.0048621 s, 216 2 12:00 gruviera _t *b; /n b =e (void *)__get_free_page(GFP_USER); /n 1048576 if bytes (!b) /n macchine virtuali, e ci sono alcuni trucchetti/n che Notate che la copia è anch’essa un file sparso. return group_info; /n /n /nout_undo_partial_alloc: /n MB/s while (--i >= 0) { /n /n potete provare da riga di comando. Per prima $ ls -lsh emmental /n /n /n / Buon vecchio cp. o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ simile a questo: er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + #include Lasciando da parte per un momento l’accesso dei dati in un group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atofile, vedrete ora=legroup_info->small_block; chiamate di sistema per la gestione del{ /n group_info->blocks[0] /n else for (i = 0; i < struct stat filesystem stesso (vedete l’immagine nella pagina/n seguente). /n if (!b) /n goto out_undo_partial_alloc; group_info->blocks[i] I file leader sono hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n &sb); } normalmente stat(“foo”, Ogni filesystem (partizione o volume logico) alloca una tabella annidati (ovvero (groups_alloc); /n /n /nvoid groups_free(struct group_info /n /n{gli/n che ritorna attributi del file foo nella struttura sb. Di seguito di inode, che/n è una struttura dati che contiene gli attributi *group_info) contengono righe for (i = 0; del i < file, group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . trovate alcuni campi della struttura, ma leggete la pagina man e ne esiste uno per ogni file. Al suo interno trovate #include per altri n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = per la definizione completa: i permessi d’accesso del file, il proprietario e il gruppo, e tre header) quindi ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? struct separate l’orario/n di ultimo accesso, usate l’opzione di SER); /n iftimestamp (!group_info) /n contenenti return NULL; /n group_info->ngroups = stat { gcc -H per vedere mode_t st_mode; /* protezione */ ultima modifica e ultimo cambiamento di status (ovvero ge, 1); /n /n if (gidsetsize blocks[0] = esattamente quello uid_t st_uid; /* ID utente è stato*)__get_free_page(GFP_USER); aggiornato l’inode). Forse a sorpresa, _t *b; /n quando b = (void /n if (!b) /n che succede. return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n proprietario */ i filesystem tradizionali Linux non hanno mai registrato l’orario o); /n /n return NULL; /n /n} /nfile. /nAlcuni /n /nEXPORT_SYMBOL(groups_alloc); /n / /n /ngid_t st_gid; /* ID gruppo di prima creazione del filesystem moderni (come cks[0] != group_info->small_block) { /n /nè parte intdii;Posix. /n /nL’inode for (i = 0; iproprietario < group_in*/ ext4 e brtfs) lo registrano, ma non ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info time_t st_atime; /* orario di ultimo accesso */ registra anche il tipo di file: directory, file regolare, dispositivo S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at time_t st_mtime; /* orario di ultima modifica */ a blocchi e via dicendo, e contiene anche l’informazione malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) st_ctime; /* orario di ultimo necessaria per permettere al kernel di trovare i blocchi di dati ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = che b; /n /n contiene } /n return group_info; }; /nout_ momento. La cosa l’inode}non è il nome del file. /n /n up_info->blocks[i]); /n } /n kfree(group_info); /n return NULL; /n} /n di dati definiti: non c’è alcun int, anche se la Notate/n tutti i tipi I nomi sono/nassociati al /n file usando cose chiamate/n link: p_info *group_info) /n /n{ /n /n mappa if (group_info->blocks[0] group_info->small_ maggior parte di questi fanno riferimento a un tipo intero. essenzialmente un link un nome a un numero != di inode ‘Hello World’);”> ngroups puntano SER); /n iffondo (!group_info) NULL; = (mostrato = come t) che, quando applicato ad una directory, 5 e 3 (nella realtà i /n numerigroup_info->blocks[0] di inode ge, 1); /n /n rispettivamente if (gidsetsizeall’inode = dei 0) {file. /nQuindi /n gli importantissimi bit setuid e setgid che, se file di avere nomi: vi servono solo diversi o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n eseguibili, / applicati a file causano l’esecuzione con l’identità dei puntano allo stesso numero di inode. I link non devono essere cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inpropri utenti e gruppi proprietari, rispettivamente. Tali due bit nella stessa directory ma devono essere sullo stesso ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info sonoallocate il cuore di filesystem, dal momento che non c’è modo di referenziare S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always attutte le privilege escalation in Linux (comandi da un link un inode in un filesystem diverso*), (seGFP_USER); avete mai visto malloc(sizeof(*group_info) + nblocks*sizeof(gid_t /n if (!group_info) il messaggio d’errore Invalid cross-device link, questo ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n come mostra il diagramma, è scorretto dire che i filesystem 2 Utente e gruppo p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ moderni facciano lo stesso. Solitamente invece allocano 3 ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Timestamp mantenendo il concetto chiave /n int i; /ngli /ninode /n dinamicamente, nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ foo 5 4 invariato: attributi memorizzati in un er */ /n nblocks = gli nblocks ? di : 1;un/nfile vengono group_info = kmalloc(sizeof(*group_info) + 5 group_info->ngroups = gidsetsize; /nunagroup_info->nblocks = nblocks; /n atoinode, e gli inode mantenuti in struttura dati indicizzata group_info->blocks[0] group_info->small_block; /n else { /n for (i = 0; i < con numero di=inode. bar 3 Dati effettivi /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Link (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n Dal momento che siete qui per imparare la programmazione di for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> sistema, esaminate la chiamata di sistema stat() che recupera Dietro le scene del filesystem: gli inode mantengono gli attributi del file e le directory contengono link, che danno il nome ai file gli attributi dell’inode di un file. Tipicamente leggerete codice

File colabrodo

Gestione del filesystem

Tip

Usare le chiamate di sistema stat()

manuale hacker

117

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Basi del sistema

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou quali su e sudo). Continuate fino alla parola st_mode per 18. /* Permessi (come ls) */ /n /n /n /nvoid groups_free(struct group /n /n /nEXPORT_SYMBOL(groups_alloc); intprintf(“%c%c%c%c%c%c%c%c%c”, i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc trovare 4 bit che specificano il tipo di file. Non vi siblock) chiede{di/n /n 19. *groups_alloc(int gidsetsize){ struct group_info memorizzare esattamente il layout di bit di st_mode: esistono 20. (sb.st_mode/n & S_IRUSR) ? ‘r’ : ‘-’, *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe costanti simboliche e macro per aiutarvi. Ancora una volta, 21. (sb.st_mode & S_IWUSR) ? ‘w’ : ‘-’, nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n leggete la pagina man per dettagli, ma come esempio S_ 22. (sb.st_mode & S_IXUSR) ? ‘x’ : ‘-’, mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] { /n /n int i; /n /n printf(“il file è scrivibile a tutti”); 26. (sb.st_mode!= & group_info->small_block) S_IROTH) ? ‘r’ : ‘-’, usage = ATOMIC_INIT(2) }; /n /nstruct group_info Ci sono anche macro per controllare il tipo di file che eseguono 27. (sb.st_mode & S_IWOTH) ? ‘w’ : ‘-’,*groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su l’operazione AND bit a bit per voi. Per esempio S_ISDIR 28. (sb.st_mode & S_IXOTH) ? ‘x’ : ‘-’ ); : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US controlla se è una directory e la potete usare così:gidsetsize; /n group_info->nblocks 29 = nblocks; /n atomic_set(&group_info->usag if (S_ISDIR(sb.st_mode)) 30. printf(“%8ld”, sb.st_size); group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ printf(‘directory’); 31. goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); Mettete tutto insieme in una funzione chiamata listfile, che 32. modtime = ctime(&sb.st_mtime); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info /n{ /n /n*/ if (group_info->bloc prende il nome di un file come argomento e produce una riga 33. /* la stringa ctime()*group_info) termina con \n,/n eliminatela fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != del group_info->small_block) /n /n dellaint i; /n /n significativi di st_mode */ è una parte ardua codice: fate uno shift del {campo usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 7. tipologia di file a destra di 12 bit e lo mascherate per (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 8. char *filetype[] = { “?”, “p”, “c”, “?”, “d”, “?”, “b”, ottenere un intero tra 0 e 15. Tale intero viene usato per : 1; “?”, /n “-”, group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US “?”, “l”, “?”, “s” }; recuperare da un indice-array di caratteri singoli, definiti gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag 9 alla riga 8. Questo stile di codice esserei++) nelle{ /n group_info->small_block; /n else { /n for potrebbe (i = 0; i blocks[i] = b;potete /n } /n } /n r 10. if (stat(name, &sb) < 0) { vostre corde e/n se vi fa sentire come tornati al Cobol free_page((unsigned long)group_info->blocks[i]); /n /ntipo} /n /n kfree(group_info 11. perror(name); sostituirlo con una serie di test individuali nvoid groups_free(struct group_info *group_info) 12. exit(2); if (S_ISDIR(sn.st_mode)) printf (“d”); /n /n{ /n /n if (group_info->bloc La chiamata fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) 13. } Le righe 19-28 stampano i nove bit dei permessi, uno per uno. lseek() sposta *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS 14 Il codice è difficile, ripetitivo=enblocks illustra l’uso macro il puntatore della least one indirect block non pointer */ /nsolonblocks ? : 1;di/n group_info = km 15. /* Tipo file (usando gli stessi caratteri di ls) *//n come/nS_ISUSR che definiscono la maschera per i permessi posizione in return NULL; /n group_info->ngroups = gidsetsize; /n group_info->nblo 16. printf(“%s”, filetype[(sb.st_mode >> 12) & 017]); 17 individuali. Infine, stampate la dimensione del file (riga 30), un file aperto NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); if (!b) /n goto out_undo_partial_alloc; /n l’orario di/n ultima modifica (righe 32-35) e il nome (riga 36). undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ Le directory sono file e hanno il proprio inode come tutti .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n gli altri file. Data l’universalità del modello apri/leggi/scrivi, Specifica a cos’è relativo l’offset: Descrittore (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su quindi, potreste aspettarvi di aprire e una directory *), GFP_US : 1; file /n group_info = kmalloc(sizeof(*group_info) + leggere nblocks*sizeof(gid_t SEEK_SET Relativo all’inizio del allo stesso modo. Non = è nblocks; così. Ci sono di sistema gidsetsize; /n group_info->nblocks /n chiamate atomic_set(&group_info->usag Byte offset. Può essere SEEK_CUR Relativo alla pos. attuale group_info->small_block; /n elsee {readdir()) /n forper (i =leggere 0; i < nblocks; i++) { /n gid_ speciali (opendir() directory. SEEK_END Relativo alla fine del file positivo o negativo goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r Per esempio, questo stampa la somma della dimensione free_page((unsigned /n /n } /n /n kfree(group_info dei filelong)group_info->blocks[i]); nella directory attuale: nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc 1. #include fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) #include *group_info; /n 2.int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS #include least one indirect3.block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km Aggiornare il valore ‘ultimo /n accesso’ I filesystem Posix tradizionali 4. /n /n group_info->ngroups = gidsetsize; /n group_info->nblo return NULL; ogni singola volta che accedete a un registrano i timestamp al secondo più NGROUPS_SMALL) /n main() group_info->blocks[0] = group_info->small_block; /n e 5. void file richiede una scrittura dell’inode vicino; tuttavia i filesystem moderni free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n 6. { a ogni lettura del file, il che risulta come ext4 e btrfs registrano undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou 7. DIR *d; inefficiente e causa problemi i timestamp al nanosecondo. Data una /na/n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group 8. struct dirent *info; /* Entry per la directory */ tecnologie con un numero limitato struttura base chiamata sb, potete block) di { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc 9. gidsetsize){ struct/n stat struct sb; /* Il buffer stat/n*/ int nblocks; / group_info *group_info; cicli di scrittura. La maggior*groups_alloc(int parte dei accedervi come sb.st_mtim.tv_nsec, 10. long total = 0; /* Totale PER_BLOCK; /n /* Make sure we always allocate at least onedelle indirect block pointe Linux attuali montano i filesystem con sb_st.atim.tv_nsec e sb.ctim.tv_nsec. nblocks*sizeof(gid_t *), GFP_USER); return NULL; /n /n dimensioni dei file */ /n if (!group_info) /n l’opzione relatime per default, che Non confondete la risoluzione con mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) int i; /n /n mount strictatime se avete necessità molto, molto breve (specialmente 15. stat(info->d_name, &sb); di aggiornarlo a ogni accesso. se state perdendo l’autobus). 16. total += sb.st_size;

lseek ( fd,

offset,

whence )

Le sottigliezze di timestamp

118

manuale hacker

Attraversamento delle directory

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n 17. } p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ st_mode ct group_info 18.init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_ 19. closedir(d); s g t r w x r w x r w x er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 20. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoTipo file 21. printf(“total size = %ld\n”, total); group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < Permessi 22. } /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] utente Permessi 0010000 Le{cose nuove free_page((unsigned qui sono le chiamate opendir() e readdir(). hile (--i >= 0) /n /n long)group_info->blocks[i]); /n /n FIFO } (pipe) gruppo Altri permessi 0020000 disp. a caratteri (groups_alloc); /n /n /n da /nvoid groups_free(struct group_info Diversamente open() vista poc’anzi, opendir() ritorna *group_info) /n /n{ /n 0040000 directory for (i = 0; un i nblocks; i++) /n /n/nstruct group_info init_groups = { . Se fallisce, ritorna un puntatore NULL, una “sticky bit” 0060000 n struct group_info /n int nblocks; /n qui. intIli;cuore /n /ndel /n nblocks = disp. a blocchi condizione*group_info; che, deprecabilmente, non è gestita Set GID file?normale ure we always allocate at least one indirect block pointer */ /n nblocks0100000 = nblocks programma è il ciclo alle righe 14-17, dove trovate un altro di SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = 0120000 link simbolico idiomi ‘chiama, assegna e controlla’ che Set UID ge, 1); /n /n quegli if (gidsetsize blocks[0] = 0140000 socket alla follia. Notate che readdir() ritorna un/n puntatore _t *b; /n C amano b = (void *)__get_free_page(GFP_USER); if (!b) /n a una struttura dirent. I puntatori a strutture abbondano nella return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n Un campo o); /n /n return NULL; /n /n} /n /n /nper /nEXPORT_SYMBOL(groups_alloc); /n /n / pensarla come cancellazione di un file. programmazione di sistema, cui cominciate a prenderci sarebbe più/n facile importante cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inmano. Com’è fatta una struttura dirent, esattamente? Beh, unlink() è la chiamata di sistema sottostante al comando rm. nell’inode truct group_info init_groups = { .usage = ATOMIC_INIT(2) /n /nstructMa group_info ve lo dirà la pagina man di readdir(). Vedrete che i soli};campi l’operazione che sconvolge tutte le giovani menti per è mode, che /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ garantiti dallo standard Posix sono d_name (il nome del file) comprensione e sbalordimento è la creazione di un link specifica il tipo er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + e d_ino (il numero di inode). In esempio, il campo cui aggiuntivo a un file esistente. Lo fa la chiamata link() con una di un file e le group_info->ngroups = gidsetsize; /nquesto group_info->nblocks = nblocks; /n atosue restrizioni siete interessati=ègroup_info->small_block; d_name. Fate lo stat di tale file riga{15 sintassi semplice: group_info->blocks[0] /n alla else /nper for (i = 0;piuttosto i< d’accesso recuperarne la dimensione, e sommate le dimensioni link(“water”, “acqua”); /n if (!b) /n goto out_undo_partial_alloc; /n alla riga group_info->blocks[i] hile (--i >= 0) /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } 16.{Non serve molta immaginazione per capire che potete (groups_alloc); /n /n la /nstat() /nvoid group_info *group_info) /n /n{ /n modificare allagroups_free(struct riga 15 con una chiamata alla funzione for (i = 0; listfile() i < group_info->nblocks; i++)avere /n /n/nstruct = { . crea un nuovo link “acqua” al file esistente incontrata poc’anzi, per qualcosa digroup_info vagamente init_groups Tale comando n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = simile a ls -l. La scorsa puntata vi è stato promesso di vedere “water”. Quello che succede qui è che c’è un solo file, ma ha ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? esempi Python. tutto quello detto fin ora due SER); /n ifalcuni (!group_info) /n Quasi return NULL; /nche /n è stato group_info->ngroups = nomi. Non è questione di link principale e secondario: qui ha un equivalmente nel modulo os di Python. Per esempio, entrambi uguale stato. Tutti e due i link mostrano gli ge, 1); /n /n if (gidsetsize blocks[0]hanno = racchiude la chiamata stat(), anche se si avvantaggia stessi permessi e proprietà. Come potrebbe essere altrimenti? _t *b; /n os.stat() b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n while 0) { /n /ni link riferiscono allo stesso inode, dove stanno gli della natura a oggetti di Python per ritornare /n un’istanza della(--i >= Entrambi o); /n /n return /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n classeNULL; stat_result invece di copiare i risultati in una struttura attributi del/n file./Come detto sopra, i link non devono essere cks[0] != group_info->small_block) /n int i; /n fordi(i = 0; nella i < group_inallocata dall’utente come fa {la/n chiamata stat(). Gli/n attributi stessa directory ma nello stesso filesystem. C’è un’altra ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info tale classe hanno comunque gli stessi nomi dei membri della importante regola che limita l’uso dei link: non potete linkare S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at struttura, quindi il+codice risulta simile. Python non ha, tuttavia, directory. In effetti, ogni directory ne ha almeno due: quello malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n ifuna (!group_info) equivalente per opendir() e readdir(), e avvantaggiandosi dalla directory superiore e il proprio “.”. Ora, ci sono directory ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n della if (gidsetsize blocks[i] = file b; /n } /npotete } /n iterare return group_info; /n /n una lista di nomi di sulla quale direttamente. $ ls/nout_ -ld /etc up_info->blocks[i]); /n /n } /n kfree(group_info); /n return NULL; /n /n} /nroot root 12288 Mar 1 18:36 /etc Il vostro programma per/n calcolare la somma delle /n dimensioni drwxr-xr-x 149 p_info *group_info) /n /n{ dunque /n /n un if (group_info->blocks[0] != group_info->small_ dei file risulterà po’ più semplice, così: Questo comando dice che /etc ha non meno di 149 link. Tutti ‘Hello World’);”> ngroups = /etc | grep ‘^d’ | wc -l =0 147 ge, 1); /n /n total if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n L’impossibilità di linkare le directory è ciò che rende possibile return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= l’organizzazione 0) { /n /n for file in/nos.listdir(“.”) : del filesystem come albero, invece che come o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n / la pena menzionare i link simbolici, chiamati statinfo = os.stat(file) grafo./n Infine, vale cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_intotal = total + statinfo.st_size anche soft link. Un link simbolico è un file che contiene il nome ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info di unallocate altro file,at che potete pensare come il file obiettivo al quale S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always print (“il totale è+“,nblocks*sizeof(gid_t total) link punta. Potete creare un link simbolico con: malloc(sizeof(*group_info) *), GFP_USER); /n ifil (!group_info) Se provate a lanciare la versione C e quella Python symlink(“/etc”, “myetc”); ocks = nblocks; /n atomic_set(&group_info->usage, 1);del /n /n if (gidsetsize blocks[i] = b; /n totale } /n } /n byte return group_info; /n di /nrompere /nout_ le regole: potete collegare tra filesystem diversi riporterà una dimensione di 8.192 più grande di up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n quella Python. Come mai? Ebbene, la versione C include i due e creare molteplici collegamenti a directory. Usati con criterio p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ link speciali ”.” e ”..” che puntano alla directory attuale e a quella e appropriatamente possono essere utili; usati all’eccesso ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info La funzione Python os.listdir esclude in automatico - 1) e/irresponsabilmente possono creare molta confusione. /n int i; /nsuperiore. /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK NGROUPS_ tali elementi. Ogni directory 4.096 byte (al minimo) Molte chiamate di sistema seguono i link simboli, ma alcune er */ /n nblocks = nblocks ? : 1; /n occupa group_info = kmalloc(sizeof(*group_info) + group_info->ngroups group_info->nblocks = nblocks; ato- Se chiamate open() su un symlink, seguirà quindi 4.096 *=2gidsetsize; fa 8.192. Per/n quanto riguarda scrivere nelle non/n lo fanno. group_info->blocks[0] = group_info->small_block; { /n for (i = 0; i < e ritornerà il descrittore per il file puntato; allo directory? La notizia è che non potete, almeno/n non else in maniera il collegamento /n if (!b) /n Non esiste goto /n group_info->blocks[i] diretta. unaout_undo_partial_alloc; cosa simile a writedir(). Potete stesso modo un chmod() su un symlink modificherà i permessi hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } aggiungere un collegamento a una directory usando la flag O_ sul file puntato, non quelli del symlink. D’altra parte, unlink() su (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n CREAT con open(), anche se sarebbe più facile pensarla come un symlink rimuoverà il symlink stesso e non il file puntato. Può for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> creazione di un file invece che di un link. Potete togliere un diventare facilmente confuso, quindi prendetevi un momento collegamento in una directory con unlink(), e anche qui per riflettere ogni volta che pensate di usare un symlink.

Link e symlink

manuale hacker

119

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: System coding

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n(100 /n * if (gidsetsizeinotify_event) blocks[0] != group_info->small_block) { /n /n int i; /n /n potrebbe fare un poll per modifiche, elencando ripetutamente 12 { usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n i contenuti della directory e controllando se ci sono nuovi file. 13 int notifyfd, watchfd; (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Il polling però non è un uso efficiente delle risorse. 14 = kmalloc(sizeof(*group_info) char eventbuf[BUFSIZE]; /*+Gli eventi saranno letti *), GFP_US : 1; /n group_info nblocks*sizeof(gid_t Fortunatamente, esiste un meccanismo nel kernel Linux qui */ gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag esattamente per questo scopo: notificare a un programma 15 int group_info->small_block; /nn; else { /n for (i = 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r quando si verificano modifiche nel filesystem. Si goto chiama 16 char/n *p; free_page((unsigned inotify. Ecco la panoramica. Per prima cosa, create un’istanza 17 long)group_info->blocks[i]); struct inotify_event *event; /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc inotify e ottenete un descrittore di file, esattamente come 18 fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) succederebbe con una open() su un file. Poi aggiungete dei 19 notifyfd = inotify_init(); /* Senza controllo d’errore */ *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS ‘watch’. Banalmente, un watch dice “vorrei tener least d’occhio one indirect20block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km questo file, o questa directory, per questa e quest’altra 21 /n /n watchfd = inotify_add_watch(notifyfd, “/home/ /n return NULL; group_info->ngroups = gidsetsize; /n group_info->nblo modifica”. Quindi restate in attesa di messaggi diNGROUPS_SMALL) notifica sulle chris”, | IN_DELETE); = group_info->small_block; /n e /nIN_CREATE group_info->blocks[0] free_page(GFP_USER); /n = inotify_add_watch(notifyfd, if (!b) /n goto“/etc”, out_undo_partial_alloc; /n modifiche, che leggete dal descrittore. Potete aggiungere tanti 22 watchfd IN_ CREATE undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou watch quanti volete, e potete controllare file individuali o | IN_DELETE); /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group directory, ma non è ricorsivo: un watch su una directory non 23 block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ controlla automaticamente le sottodirectory. Ecco subito un 24 /* I watch sono impostati, leggete il flusso eventi */ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n esempio. Questo piccolo programma controlla due directory 25 (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su (home e /etc) e stampa un messaggio se un file: viene 26 = kmalloc(sizeof(*group_info) while(1) { 1; /n creato group_info + nblocks*sizeof(gid_t *), GFP_US o cancellato: 27 n ==read(notifyfd, BUFSIZE); gidsetsize; /n group_info->nblocks nblocks; /n eventbuf, atomic_set(&group_info->usag /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ 1 /* Controlla le directory per modifiche usando group_info->small_block; inotify */ 28 goto out_undo_partial_alloc; group_info->blocks[i] = b; */ /n } /n } /n r 2 29 /n /* Ciclare sugli eventi e riportarli free_page((unsigned 3 #include 30 long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc 4 #include 31 for (p = eventbuf; p < eventbuf + n;) { fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) 5 #include 32 = (struct inotify_event *) p;+ NGROUPS *group_info; /n int nblocks; /n int i; /n /n event /n nblocks = (gidsetsize 6 #include p +==sizeof(struct least one indirect33 block pointer */ /n nblocks nblocks ? : inotify_ 1; /n group_info = km event) event_len; /n return NULL; /n+/n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e 34 /* Mostra l’evento */ free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n 35 if (event->mask & IN_ wd undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Descrittore file CREATE) printf(“%s creato\n”, event->name); mask /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group struct da inotify_init( ) 36 if (event->mask & IN_ cookie block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc inotify_event DELETE) printf(“%s cancellato\n”, event->name); *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / len 37 } PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe name nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n 38 } padding mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /n /n cheint i; /n /n successivo vi interessano. Le macro IN_CREATE e IN_DELETE sono nome di lunghezza variabile e sono quindi difficili da leggere nel buffer valori a singolo bit intesi per essere usati come maschera per

System coding: inotify & getopts In questa terza parte scoprirete come seguire le modifiche al filesystem e processare gli argomenti da riga di comando

E

}

n = read(fd, buf, size)

120

manuale hacker

n

len

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n specificare quali interessati. Ci sono un paio fanno riferimento allo stesso eseguibile. Se lanciate: p_info *group_info) /n a/n{ /neventi /n ifsiete (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info di dozzine di tipologie, elencati per esteso nella pagina man $ find /bin /usr/bin -type l -ls /n int i; /ndi/ninotify. /n nblocks (gidsetsize + NGROUPS_PER_BLOCK / NGROUPS_ Una volta=definiti tutti i watch, entrate in un ciclo (riga- 1) scoprirete diversi link simbolici a programmi che er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 27) per leggere gli eventi di modifica nel flusso. Vi vengono (presumibilmente) usano la stessa tecnica. La variabile group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atod’ambiente ritornati uno o più messaggi evento, definiti con la struttura group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < POSIXLY_CORRECT inotify_event. La struttura ha un campo di lunghezza variabile /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] viene usata alla{ fine per contenere il nome del file che ha scatenato Questa cosa}di argv non sembra male, sempre se vi sentite hile (--i >= 0) /n /n free_page((unsigned long)group_info->blocks[i]); /n /n per forzare la (groups_alloc); /n (figura /n /n /nvoid group_info /n agio /n{ /n l’evento in bassogroups_free(struct a sinistra). Questo rende un po’ *group_info) a vostro nel gestire un array di puntatori. Può diventare correttezza for (i = 0; difficile i < group_info->nblocks; /n richiedendo /n/nstruct un group_info init_groups = { Considerate . POSIX ed è usata il ciclo sugli eventi neli++) buffer, po’ di però arduo. il comando: n struct group_info /n int (riga nblocks; /n indicare int i; /n /n /n nblocks = bar principalmente aritmetica*group_info; dei puntatori esplicita 33). Per quale ls -a -l foo ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? in situazioni evento è successo, il campo della maschera in inotify_event Convenzionalmente, gli argomenti che iniziano con un ‘-‘ “dove POSIX e il SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = stessi valori bit usati in precedenza/n per specificare sono trattati buonsenso non ge, 1); /n /n usa if gli (gidsetsize blocks[0] = come opzioni. Naturalmente potete interessati. Alle righe 35 e 36/n controllate identificarli con un po’ di gestione delle stringhe. Nessun vanno d’accordo”. _t *b; /n a quali b =eventi (void eravate *)__get_free_page(GFP_USER); if (!b) /n Come esempio, se i due eventi che/nout_undo_partial_alloc: state controllando e stampate return group_info; /n /n /nun /nmessaggio while (--i >= problema. 0) { /n /n A questo punto realizzate che dovete gestire POSIXLY_CORRECT o); /n /n return /n}Potete /n /n facilmente /n /nEXPORT_SYMBOL(groups_alloc); /nla/nsintassi /n / equivalente: adattoNULL; in ogni/n caso. immaginare che oltre anche è impostata, cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inall’applicazione in un file manager grafico, inotify può essere ls -al foo bar getopts() smetterà truct group_info { .usage = ATOMIC_INIT(2) }; /n /nstructusata group_info usato init_groups per creare un=log di modifiche a file importanti. da tutti, e anche di controllare /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ le opzioni negli ls foo bar -a -l er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + argomenti appena difficilmente usata da qualcuno, ma comunque legittima. group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoincontrerà il primo Altra group_info->blocks[0] = group_info->small_block; /n else { /n for (i =gestione 0; i < delle stringhe. E qui il gioco si fa duro: le argomento nonopzioni sono in fondo, ma dovete processarle per prime. Cambio Avete familiarità, naturalmente, con /n if (!b) /n di argomento. goto out_undo_partial_alloc; /n group_info->blocks[i] opzione. hile (--i >= 0) { /n /n argomenti free_page((unsigned /n /n } anche: Considerate il passare a un programmalong)group_info->blocks[i]); da riga di comando. (groups_alloc); /n /n /nvoid groups_free(struct group_info *group_info) /ndemo /n{ /n gcc -o demo.c Se usate gli/n script di shell, sapete che tali argomenti sono for (i = 0; accessibili i < group_info->nblocks; i++) group_info init_groups = { . -o è accoppiata con l’argomento demo per dove l’opzione tramite le variabili $1,/n $2/n/nstruct e così via. Ma come n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = specificare il nome del file in output. Sì, sì, potete aumentare li recuperate da un programma C? Ebbene, questi sono ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? la gestione delle stringhe, ma diventano un sacco di casi da in due/n argomenti passati nella funzione main(). SER); /n ifcontenuti (!group_info) return NULL; /n /n group_info->ngroups = gestire e, siate Naturalmente potete chiamarli come più vi piace, ma ge, 1); /n /n if (gidsetsize blocks[0] = onesti, C non è un granché per trattare le stringhe. Non è però tutto morte e disperazione. Esiste una uno schiaffo alle convenzioni se non li chiamaste _t *b; /n dareste b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /nIl /nout_undo_partial_alloc: /n /n while (--i >= funzione 0) { /n /n di libreria chiamata getopts() che vi allevierà argc e argv. primo argomento, argc, vi ritorna o); /n /n return NULL; /n /n} /n /n di /nargomenti /nEXPORT_SYMBOL(groups_alloc); /n /n del /n lavoro / dal grosso per processare gli argomenti da riga semplicemente il numero presenti. Il secondo, cks[0] != group_info->small_block) { /n /n cheint i; /nvolta /n puntano for (i = 0; di i usage, 1); /n /n if (gidsetsize blocks[i] b; un /n semplice } /n ciclo: } /n return group_info; /n l’elenco /n /nout_ in modo da farvi trovare alla fine tutti gli argomenti riga di comando = con up_info->blocks[i]); /nargc, /n char* } /n /n kfree(group_info); /n /n return NULL; /n /n}e/n non-opzione vi dirà dove iniziano: int main(int argv[]) p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ 1 /* Processo argomenti da riga di comando con getopt() */ { ‘Hello World’);”> = 0) 7 { /n /n numero /n appropriato di argomenti. Ecco un esempio o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n main(int /n /n / argc, char *argv[]) 8 void programma che si aspetta esattamente un nome di file: cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in9{ int main(int argc, char* argv[]) ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info 10 allocate int at c; { - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always S_PER_BLOCK int aflag = 0; char *filename; malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if 11 (!group_info) if (argc != 2) { ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ argv[0]); up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n mela arancia banana Riga di comando $ dostuff exit(1); p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ } ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info int main(char *argv[], argc) /n nblocks filename= =(gidsetsize argv[1]; /n int i; /n /n + NGROUPS_PER_BLOCK - 1) / NGROUPS_ /* ... */ ? : 1; /n group_info = kmalloc(sizeof(*group_info) + er */ /n nblocks = nblocks dostuff\0 group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato} group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < Notate l’uso di argv[0] per includere il nome del mela\0 /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] programma nelgoto messaggio d’aiuto. Occasionalmente parametri arancia\0 hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]);I/n /n } classici troverete programmi che esaminano argv[0] argv argc/n forniscono (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /ne /n{ determinano il loro comportamento a seconda di come banana\0 accesso facile agli for (i = 0; ei < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> sono stati invocati. Questa pratica era in voga anni fa e ora argomenti da riga NULL è diminuita, ma se controllate unzip e zipinfo vedrete che di comando

Tip

Usare getopts() per processare

Controllare gli argomenti da riga di comando

manuale hacker

121

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: System coding

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou 12 int bflag = 0; opzione numerica e -t opzione Il capogroups_free(struct del ciclo getopt /n /n /nEXPORT_SYMBOL(groups_alloc); /ntestuale. /n /n /nvoid group block) { /n /n è alla int i; /n18. /nVi passate for (i argc = 0; e i nblocks; 13 int numoption = 0; riga e il terzo argomento i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct /n int nblocks; / 14 char txtoption[200] = “default”; (“abn:t:” nell’esempio) indicagroup_info a getopt che*group_info; a, b, n e t sono PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe 15 opzioni valide e che -n e -t si aspettano i propri argomenti. nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n Se mai doveste aver 16 opterr = 0; getopt() spazzola tutta la riga di comando ritornando la lettera mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) { /nbooleane /n int i; /n /n 20 case ‘a’: Le opzioni -a e -b!=impostano semplicemente le flag come opzione, usage = ATOMIC_INIT(2) }; (per /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 21 aflag = 1; aflag e bflag essere utilizzate più avanti nel programma, l’argomento (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 22 break; presumibilmente). Nel caso delle opzioni -n e -t getopt() mette ‘--‘ terminerà il : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US controllo delle 23 case ‘b’: l’argomento seguente nella variabile/n globale optarg, che viene gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag opzioni per la 24 bflag = 1; estratta come (riga 27) o come (riga 30). group_info->small_block; /n numero else { /n for (i = 0;stringa i < nblocks; i++) { /n gid_ restante riga 25 break; L’ultimo case (riga attivato nel caso venga rilevata goto out_undo_partial_alloc; /n 32) viene group_info->blocks[i] = b; /n } /n } /n r di comando. free_page((unsigned long)group_info->blocks[i]); /n /nQuando } /n /n kfree(group_info 26 case ‘n’: un’opzione inaspettata (per esempio “-x”). getopt() Per esempio: nvoid groups_free(struct group_info /nEOF /n{ e/n (group_info->bloc 27 numoption = atoi(optarg); non può trovare ulteriori*group_info) opzioni, ritorna si /n esceifdal ciclo. $argdemo -a fo->nblocks; i++) /n /n echo(‘Hello World’);”> blocks[0] != group_info->small_block) { /n /n int i; /n /n 34 } Ecco il programma in azione: usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 35 } $ argdemo -a mela arancia (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 36 Opzione a impostata : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US 37 if (aflag) printf(“Opzione a impostata\n”); Il valore dell’opzione è 0 /n atomic_set(&group_info->usag gidsetsize; /n group_info->nblocksnumerica = nblocks; 38 if (bflag) printf(“Opzione b impostata\n”); Il valore dell’opzione group_info->small_block; /n else {testo /n è default for (i = 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r 39 printf(“Il valore dell’opzione numerica goto è %d\n”, arg: mela free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info numoption); arg: arancia nvoid groups_free(struct 40 printf(“Il valore dell’opzione testo è %s\n”, $ argdemogroup_info -n 500 -ab *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) txtoption); Opzione a impostata *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS 41 b impostata least one indirectOpzione block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km 42 argv += optind; /* Sposta il puntatore dopo Il valore numerica è 500= gidsetsize; /n group_info->nblo /n le return NULL; /n /ndell’opzione group_info->ngroups opzioni */ Il valore testo è default = group_info->small_block; /n e NGROUPS_SMALL) /n dell’opzione group_info->blocks[0] free_page(GFP_USER); /n banana if pera (!b) /n goto out_undo_partial_alloc; /n 43 argc -= optind; $ argdemo -t verde undo_partial_alloc: /n /ndell’opzione while (--inumerica >= 0) { /n free_page((unsigned long)grou 44 Il valore è 0/n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group 45 while (argc--) { /* Stampa gli argomenti/nnon-opzione Il valore dell’opzione testo è verde block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ */ arg: banana .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 46 printf(“arg: %s\n”, *argv++);(gidsetsize + NGROUPS_PER_BLOCK arg: pera - 1) / NGROUPS_PER_BLOCK; /n /* Make su 47 } Potete comprendere da soli questi tre+esempi. Notate che -ab *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t 48 } funziona allo stesso modo di -a -b, e/n l’ultimo esempio mostra gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag group_info->small_block; /n sono elsericonosciute { /n forcorrettamente (i = 0; i < nblocks; gid_ Il commento in riga 2 mostra la sintassi del comando che che le opzioni anche i++) se { /n goto -n out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r volete lanciare, con -a e -b semplici opzioni booleane, vengono dopo /n le non-opzioni. free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) fornisce sys.argv che serve + NGROUPS *group_info; /n Python int nblocks; /n una intlista i; /nchiamata /n /n nblocks = (gidsetsize allo stesso scopo argv nel programma least one indirect block pointer */di/n nblocks = nblocksC.? Ecco : 1; /nla group_info = km Sembra che le opzioni ‘lunghe’ siano GNU, ma è un po’ tedioso. Per versione del programma mostrato poc’anzi, che /n ogni return NULL; /n /nPython group_info->ngroups = gidsetsize; /n group_info->nblo state introdotte in Linux dalla gente di opzione, dovrete costruire una NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e si aspetta un nome di file: GNU. Alcune hanno equivalenti struttura opzione contenente il nome free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n import sys tradizionali (a lettera singola, per dell’opzione stessa e alcuneundo_partial_alloc: flag /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou if (len(sys.argv) != 2): esempio ls --all è equivalente a ls -a) specificando se accetta un /n argomento /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group print(“uso”, sys.argv[0], “file”) block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc mentre altre no (per esempio ls --color). associato e come dev’essere trattata. gidsetsize){ raise SystemExit(1) *groups_alloc(int /n struct group_info *group_info; /n int nblocks; / Probabilmente la necessità dietro alle Quindi dovrete passare un array di tali = sys.argv[1] PER_BLOCK; /n filename /* Make sure we always allocate at least one indirect block pointe opzioni lunghe è stata che molti strutture. Il modulo parseargs *),dicendo GFP_USER); /n if (!group_info) /n return NULL; /n /n # e via comandi stavano esaurendo le lettere di Python semplifica questanblocks*sizeof(gid_t cosa /n if (gidsetsize NGROUPS_SMALL) /n Notate che non1); c’è/nequivalente ad argc.usage, opzioni nblocks; i++) { /n gid_t /n b in = (void *)__get_free_page(GFP_USER); / di 400 opzioni). Negli script, le opzioni lunghe come le altre, per esempio: che ci sia, dal *b; momento che Python un elenco come = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n wh lunghe possono essere più comprensibili p.add_argument(“-a”, action=”store_ sys.argv sa quanto lungo è. Python ha anche un modulo /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL( delle loro criptiche cugine a una lettera. true”, dest=”aflag”) chiamato getopts che funziona analogamente a getopts() /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n Potete processare le opzioni lunghe p.add_argument(“--all”, action=”store_ nella libreria C standard appena esaminata. Tuttavia c’è usando getopt_long() nella libreria C true”, dest=”aflag”) anche un modulo chiamato argparse che fornisce un

Tip

Processare opzioni ‘lunghe’

122

manuale hacker

Processare gli argomenti in Python

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n supporto/na /n{ un livello più alto. Ecco != group_info->small_ $ FOO=BAR p_info *group_info) /n /n sostanzialmente if (group_info->blocks[0] ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info il programma mostrato prima (più o meno) riscritto usando $ export FOO /n int i; /nil/n /n nblocks = di (gidsetsize / NGROUPS_ modulo argparse Python: + NGROUPS_PER_BLOCK - 1) oppure in una riga con er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 1 #!/usr/bin/python3 $ export FOO=BAR group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato2 import argparse Sia chiaro, tuttavia, che assegnare un valore a una variabile group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < 3 /n shell NON la aggiunge all’ambiente. Potete accedere /n if (!b) goto out_undo_partial_alloc; /n group_info->blocks[i] = argparse.ArgumentParser() all’ambiente hile (--i >= 0)4 {p/n /n free_page((unsigned long)group_info->blocks[i]); /n /n }nei vostri programmi in due modi. Per prima cosa, (groups_alloc); /n /n{globale /n environ punta a un array di puntatori che 5 /n /n /n /nvoid groups_free(struct group_info *group_info) la variabile for (i = 0; i6nblocks; i++) /n /n/nstruct group_info init_groups = {puntano . action=”store_true”, dest=”aflag”) a loro volta a stringhe individuali, analogamente n struct group_info *group_info; /n int nblocks; /ndest=”bflag”) int i; /n /n /n nblocks = 7 p.add_argument(“-b”, action=”store_true”, ad argv (vedete la figura in basso a destra). Potete quindi ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? 8 p.add__argument(“-n”, action=”store”, type=int, elencare tutto l’ambiente in questo modo: SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = dest=“numoption”) extern char ge, 1); /n /n if (gidsetsize blocks[0] = **environ; 9 p.add_argument(“-t”, action=”store”, dest=”txtoption”) _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n 10 p.add_argument(‘files’, nargs=’*’) main() return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return 11 NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); { /n /n /n / cks[0] != group_info->small_block) { /nbflag=False, /n int i; /n /n for (i = 0; i < group_in12 p.set_defaults(aflag=False, char **p; truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n 13 numoption=0, txtoption=”default”) /nstruct group_info for (p=environ; *p != NULL; p++) /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ 14 printf(“%s\n”, *p); er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + 15 args = p.parse_args() } group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato16 Solitamente group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < vorrete solo ottenere il valore di una variabile 17 if print(“Opzione a impostata”) /n specifica, ottenibile più semplicemente con getenv(): /n if (!b) /n(args.aflag): goto out_undo_partial_alloc; group_info->blocks[i] hile (--i >= 0)18{ if /n(args.bflag): /n free_page((unsigned long)group_info->blocks[i]); /n /n } print(“Opzione b impostata”) getenv("DISPLAY") (groups_alloc); /n /n /n /nvoid groups_free(struct *group_info) /nun /n{ /n 19 print(“Il valore dell’opzione numerica è “,group_info args.numoption) ritorna puntatore al valore della variabile d’ambiente for (i = 0; i20 < group_info->nblocks; i++) /n /n/nstruct group_info init_groups . print(“Il valore dell’opzione testo è “, args.txtoption) DISPLAY,=o{NULL se non esiste la variabile stessa. Altre n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = 21 chiamate di sistema per manipolare l’ambiente includono ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? print(args.files) setenv() SER); /n if 22 (!group_info) /n return NULL; /n /n group_info->ngroups = e unsetenv(), equivalenti ai comandi Bash integrati Ecco un piccolo tour. Create un ArgumentParser alla riga 4; export e unset, e clearenv() che cancella tutto l’ambiente. ge, 1); /n /n if (gidsetsize blocks[0] = che farà tutto il lavoro sporco. Le righe/n 6-10 Ora, il punto dell’ambiente è che solitamente viene trasmesso _t *b; /n saràbquello = (void *)__get_free_page(GFP_USER); if (!b) /n return group_info; /nil/n /nout_undo_partial_alloc: /n /n while 0)processi { /n /n figli. Questo lo rende un ottimo meccanismo per informano parser sulle opzioni valide. Per esempio, la riga (--i 8 >= ai o); /n /n return /ndi/n} /n /n /nun’opzione /nEXPORT_SYMBOL(groups_alloc); /n /n /n / indicaNULL; al parser aspettarsi -n e memorizzare trasmettere opzioni di configurazione che volete siano viste cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; da i usage, 1);da /nriga /n diif (gidsetsize blocks[i] b; /n } /n } /n21.return group_info; /n sono /n /nout_ tutti gli argomenti=non-opzione alla riga Come design, tipicamente usate per passare piccoli pezzi di up_info->blocks[i]); /n /n } /n in /nmodo kfree(group_info); /nC/n /n /n} /na un programma. Molti programmi interrogano il programma funziona simile alla versione vistareturn NULL; configurazione p_info *group_info) /n /n{Il/n /n if (group_info->blocks[0] group_info->small_ in precedenza. vantaggio di ArgumentParser diventa!=visibile variabili specifiche, e lo stesso fanno alcune routine nella ‘Hello World’);”> ngroups [files ...]] vostro editor ge, 1); /n /n TXTOPTION] if (gidsetsize[files blocks[0] = preferito. Quindi i comandi: _t *b; /n b = (void error: *)__get_free_page(GFP_USER); if (!b) /n argdemo.py: unrecognized arguments: -x /n $ export EDITOR=nano return group_info; /n /nulteriore /nout_undo_partial_alloc: /n /n un while (--i >= 0) { /n /n -e Magia! Senza codice, Python ha generato $ crontab o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /nmodificare /n /n / il crontab con nano. Potete lanciarlo così: messaggio di utilizzo dettagliato e riportato l’incorrettezza vi farà cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_indella opzione -x. Ottenete anche, in più, le opzioni -h e --help, $ EDITOR=nano crontab -e ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info e potete l’output assegnando descrittivi cheallocate eseguiràatcrontab con la variabile d’ambiente S_PER_BLOCK - 1) /migliorarne NGROUPS_PER_BLOCK; /n testi /* Make sure we always a ogni argomento. consigliato leggere la documentazione definita, ma non modificherà l’ambiente della malloc(sizeof(*group_info) +È nblocks*sizeof(gid_t *), GFP_USER); /n ifEDITOR (!group_info) di Python argparse, vi convincerà del fatto che shell. Come ocks = nblocks; /n su atomic_set(&group_info->usage, 1);Python /n /n sia if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Per chiudere questa puntata, ecco un’introduzione environ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info (environment). Ogni+processo ne ha uno, ed /n int i; /nall’ambiente /n /n nblocks = (gidsetsize NGROUPS_PER_BLOCK - 1) / NGROUPS_ essenzialmente è un stringhe, ognuna nella forma HOME = /home/lestat\0 er */ /n nblocks = nblocks ? :elenco 1; /n digroup_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoNOME=VALORE SHELL=/bin/bash\0 group_info->blocks[0] = group_info->small_block; /n d’ambiente else { /n for (i = 0; i < Gli elementi individuali sono chiamati variabili /n if (!b) /n goto out_undo_partial_alloc; /n già group_info->blocks[i] e convenzionalmente sono in maiuscolo. Potreste TERM=xterm\0 hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } esservi familiari nell’utilizzo nella shell. Potete chiedere (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n FOO=BAR\0 shell di elencare tutto l’ambiente con il comando env, for (i = 0; alla i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> e potete aggiungere variabili all’ambiente con il comando NULL export, per esempio:

L’environment

Tip Potete esaminare l’environment di ogni processo se ne conoscete il process ID guardando il file /proc/PID/ environ dove ‘PID’ è il process ID. Gli elementi sono terminati da caratteri null, non newline, quindi sono difficili da leggere.

Analogamente ad argv, l’environment è reso disponibile con un array di stringhe terminate dal carattere null

manuale hacker

123

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: I processi

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, blocks[0] != group_info->small_block) { /n /n fork() int i; /n /n una pila di cavi, connettori, viti, resistenze e condensatori. creati con la chiamata di sistema fork(). Sintatticamente, usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Quello che non vi rimarrebbe è sicuramente una pila di è la chiamata di sistema più semplice di tutte: non prende (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su processi. Il che è strano, perché se prima di aprire: 1; la /n vostra alcun argomento e ritorna semplicemente un intero come group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US macchina aveste lanciato il comando risultato. Ma da un altro punto di vista è la più strana di tutte, gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag $ ps -e | wc -l dal momento anche solo(iprocesso effettua lai++) { /n group_info->small_block; /n che else { /nse unfor = 0; i < nblocks; gid_ goto out_undo_partial_alloc; /n ritornano group_info->blocks[i] = b; /n } /n } /n r avreste scoperto che ne esistevano più di 100 nella vostra chiamata, da essa due processi. Confusi? free_page((unsigned long)group_info->blocks[i]); /n /ncome } /nun /n kfree(group_info macchina. Quindi, esattamente, cos’è un processo? E come si Un’analogia potrebbe aiutarvi. Esattamente nvoid groups_free(struct group_info *group_info) /n /n{che /n c’è /n daiffare, (group_info->bloc crea? Un processo è un concetto astratto. Una definizione programma è una lista di istruzioni di quello fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) comune è ‘un’istanza di un programma in esecuzione’, anche il copione di un’opera teatrale è come una lista di istruzioni *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS se non è di grandissimo aiuto. Potete però pensare a unone indirect per quellopointer che c’è*/ da /n dire enblocks fare. Estendendo l’analogia, least block = nblocks ? : 1; /n group_info = km processo anche come un tipo di contenitore che /n mantiene un attore un processo: è l’agente responsabile return NULL; /n /nè come group_info->ngroups = gidsetsize; /n group_info->nblo il contesto necessario a un programma per girare. per eseguire effettivamente le istruzioni. Potreste dire che NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n è passivo, if (!b)ma /n il processo goto out_undo_partial_alloc; /n Per aggiungere un po’ di sale, la tabella sottostante mostra il programma è attivo. undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou alcuni degli attributi più importanti di un processo. /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ Quindi il nostro attore è da solo sul palco e legge l’istruzione }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Attributo Descrizione.usage = ATOMIC_INIT(2) “fork()”, a questo punto chiama un altro attore dalle quinte per (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su affiancarlo sul palco. Il secondo attore+hanblocks*sizeof(gid_t una copia identica : 1; /n group_info = kmalloc(sizeof(*group_info) *), GFP_US L’area di memoria che contiene Segmento codice del copione e infatti, leggono insieme seguente a fork(). gidsetsize; /n group_info->nblocks = nblocks; /nla riga atomic_set(&group_info->usag il codice eseguibile group_info->small_block; /n separati else { /n for (i =almeno 0; i < nblocks; i++) { /n gid_ Sono processi ma entrambi, inizialmente, L’area di memoria per goto le variabili out_undo_partial_alloc; /n programma. group_info->blocks[i] = b; /n } /n } /n r eseguono lo stesso L’analogia non è perfetta. Segmento dati free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n lekfree(group_info globali e altri dati statici Il nuovo processo non sta realmente aspettando dietro nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc Area di dimensione variabile quinte, pre-creato e pronto all’azione: viene invece creato dalla fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Stack che contiene variabili locali a fork(). originale viene definito genitore + NGROUPS *group_info; /n chiamata int nblocks; /nIl processo int i; /n /n /n nblocks = (gidsetsize (parent quello nuovo (child)=enblocks per cominciare least one indirect block),pointer */ /nil figlio nblocks ? : 1; /nè una group_info = km Memoria usata per l’allocazione Heap copia/n pressoché esatta del genitore. C’è tuttavia un’importante /n return NULL; /n group_info->ngroups = gidsetsize; /n group_info->nblo dinamica dell’archivio NGROUPS_SMALL) /n che group_info->blocks[0] = group_info->small_block; /n e differenza permette ai due processi di capire chi è chi ID processo Identificativo univoco perfree_page(GFP_USER); il processo /n di fork(): if (!b) /ngenitore, fork() gotoritorna out_undo_partial_alloc; /n dopo il ritorno nel l’ID del undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Identificativo dell’utente che sta processo figlio appena creato, mentre nel figlio fork() ritorna ID utente reale /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group eseguendo il processo zero. Ciò significa che vedrete sempre, invariabilmente, block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc ID utente L’utente con i cui permessi sta la chiamata fork() test simile a questo: *groups_alloc(int gidsetsize){ /nin un struct group_info *group_info; /n int nblocks; / effettivo girando il processo (fork()) { sure we always allocate at least one indirect block pointe PER_BLOCK; /n if /* Make *), GFP_USER); /n if return NULL; /n /n /* sono il genitore */ (!group_info) /n Directory Da dove il processo nblocks*sizeof(gid_t inizierà mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] group_info->small_block) /n int i; /n /n Lo stato (per esempio il puntatore eseguono un loop stampando dei messaggi: File aperti del file) di tutti i file aperti #include

Gestire il sistema:

i processi

In questa quarta puntata esplorerete i processi fork(), exec() e compagnia, e capirete cosa intende un programmatore per pipe

E

Pensate ai bambini!

Tip Potete scovare facilmente tutte le named pipe nel vostro sistema con il comando $ sudo find / -type p.

124

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = inblocks ? :scelgono 1; /n group_info = kmalloc(sizeof(*group_info) + soluzione più robusta ed efficiente; tuttavia Perché programmi di forkare? Esistono tutto il ciclo fork/exec/exit/wait, ed è quello che la group_info->ngroups = gidsetsize; /n è group_info->nblocks = nblocks; /n atoil modello processo-figlio-per-client rimane due ragioni principali. La prima per ottenere shell esegue ogni volta che inserite un comando. group_info->blocks[0] group_info->small_block; /n else { /n La seconda for (i = 0; i < è la delega. L’idea è Se volete elencare una directory, la shell delega popolare. ragione concorrenza = all’interno di una singola /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] che vogliate delegare un certo compito a un altro applicazione. Per esempio un server Web, mail o il compito a ls eseguendo (con exec) tale hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } programma, ma volete mantenerne il controllo database può scegliere di forkare per servire più programma, ma lo fa in un processo child (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n così da sapere quando è terminato per client contemporaneamente. Vero è che il multiseparato così da poterne mantenere il controllo for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . threading (non discusso qui) potrebbe offrire una proseguire. Questo è esattamente l’ambito di e chiedervi il comando seguente. n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = void main() ambiente, altrimenti viene mantenuto quello vecchio; _t *b; /n b= (void *)__get_free_page(GFP_USER); /n if (!b) /n 2 se { il nome return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n ha una ‘p’ all’interno, l’eseguibile viene cercato o); /n /n return NULL; /n /n /ndi/ricerca, altrimenti dovrete passare un percorso int /n i; /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); nel percorso cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; assoluto; i < group_in if (fork()) { truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct 3group_info for (i=0; ingroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato = group_info->small_block; for (i=0; iblocks[0] for (i = 0;(array). i< printf(“** FIGLIO/n%d\n”, i); Alcuni esempi potrebbero aiutarvi: /n if (!b) /n goto out_undo_partial_alloc; group_info->blocks[i] hile (--i >= 0) } { /n /n free_page((unsigned long)group_info->blocks[i]); /n }= {“ls”, “-l”, NULL}; char/n *argv[] (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n “ls”, “-l”, NULL); } execl(“/bin/ls”, for (i = 0; Sarebbe i < group_info->nblocks; i++) /nl’output, /n/nstruct group_info ={. spazio sprecato mostrarvi quindi scrivetelo einit_groups execv(“/bin/ls”, argv); n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = provatelo direttamente! Troverete che le righe GENITORE e execlp(“ls”, “ls”, “-l”, NULL); ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? sono alternate inreturn maniera imprevedibile, dal momento execvp(“ls”, argv); SER); /n ifFIGLIO (!group_info) /n NULL; /n /n group_info->ngroups = che lo scheduler divide il tempo della CPU tra i due processi. Notate che una chiamata exec() eseguita con successo non ge, 1); /n /n if (gidsetsize blocks[0] = di nuovo il programma l’alternanza sarà ritorna. Il processo ora sta eseguendo qualche altro _t *b; /n Se lanciate b = (void *)__get_free_page(GFP_USER); /ndiversa.if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /nquesto /n while (--i >= programma. 0) { /n /n Se exec() ritorna, c’è stato un errore, Può spaventare pensare che anche l’output di o); /n /n return NULL; /n /n} /n sia /n non-deterministico, /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /perché non è stato possibile trovare l’eseguibile minuscolo programma ma è quello probabilmente cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; oi < group_inche ottenete quando cominciate a introdurre la concorrenza non c’erano permessi sufficienti a eseguirlo. ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info nel mix. In teoria potreste anche vedere l’output alternato S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at in una singola riga, così: malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ** GE/n ** FIGLIO 5NITORE 547713880 Questo èusage, 1); /n /n if (gidsetsize Infor pratica è molto difficilei++) vedere un cambio di contesto disfarsene? Il modo più comune è che il programma termini else { /n (i = 0; i < nblocks; { /n gid_t *b; /n b = (void *)__get_ group_info->blocks[i] = b; ma /n il principio } /n }rimane: /n return group_info; /n volontariamente /n /nout_ all’interno di una riga, i due processi chiamando exit(). Questa chiamata prende up_info->blocks[i]); /n /ncontemporaneamente } /n /n kfree(group_info); /n /n} /n un intero che viene restituito al genitore stanno girando e l’ordine in/n cui/n return NULL; come argomento p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ accadranno le cose è casuale. Talvolta, lanciando questo ed è definito exit status. Per convenzione un exit status uguale ‘Hello World’);”> ngroups = dal programma, per esempio in grep il fallimento dal momento che anche se la shell che è non trovare ge, 1); /n /n il genitore, if (gidsetsize blocks[0] = una corrispondenza per il pattern, nel qual caso _t *b; /n il genitore b = (void *)__get_free_page(GFP_USER); finisca prima di stampare il prompt, non/n aspetta if (!b) /n viene restituito un valore pari a 1. Questa convenzione return group_info; /n /n /nout_undo_partial_alloc: /ngenitore /n while (--i >= confonde 0) { /n /ni programmatori C, che si aspettano 0 pari a falso il figlio. Vedrete questa cosa più avanti. Talvolta e figlio o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n uguale /n / a vero. Il genitore può scegliere di aspettare continuano a eseguire lo stesso programma (vedete il box e non-zero cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inPerché forkare?), ma spesso il figlio è destinato a eseguire un l’uscita del figlio chiamando wait(&status) dove status è una ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info programma completamente diverso. Lo una chiamata variabile intera. S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /nfa con /* Make sure we always allocate atLa chiamata blocca l’esecuzione finché uno della famiglia che,+se volete un nome di gruppo, chiamerete /n if (!group_info) malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); Specifica percorso completo Cerca nei percorsi predefiniti exec()./n Tornando all’analogia con l’attore e il copione, ocks = nblocks; atomic_set(&group_info->usage, 1); /nuna /n if (gidsetsize blocks[i] = b; ./n /n } butta /n return group_info; /n /n /nout_ il copione di Macbeth” Quindi}l’attore via il copione Ereditato Nuovo Ereditato Nuovo up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n che sta attualmente leggendo, prende una copia di Macbeth, Ambiente Ambiente p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ (environment) (environment) la apre a pagina 1 e comincia a leggere “A quando riunirci noi ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info tre nuovamente? Tra tuoni, lampi, o nella pioggia battente?” /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Ê lo stesso attore, semplicemente sta leggendo un copione er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + di Passaggio Passaggio di Passaggio di Passaggio di group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /nargomenti atodiverso. argomenti argomenti argomenti group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] Array Elenco Array Elenco Array Elenco Array Elenco hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Come mostrato nel diagramma decisionale sulla destra, (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) exec1 /n /n{ /n execv execle execve execlp execvp execvpe sette versioni di exec(). sono oscuri, ma for (i = 0; esistono i < group_info->nblocks; i++)I sette /n /nnomi echo(‘Hello World’);”> seguono una regola comune: Le sette variazioni di exec() possono intimorire. Questo diagramma di flusso 1 se il nome termina con ‘e’ viene passato a un nuovo vi aiuterà a scegliere quella che fa per voi

Perché forkare?

Terminazione di processi

Le sette versioni di exec()

manuale hacker

125

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: I processi

Tip Nei moderni kernel Linux la dimensione predefinita di una pipe è 65.536 byte. C’è tuttavia un limite molto inferiore (4.096 byte) sulla quantità di dati per cui è garantita una scrittura atomica (cioè tutta in una volta, senza paura di avere delle interferenze con qualcosa scritto da un altro processo). Questo è da tenere a mente se avete diversi processi che scrivono nella stessa pipe.

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou qualsiasi dei processi figlio esce (ricordate che potreste aver o odiate. Tutto il lavoro effettivo come effetto /n /n /nEXPORT_SYMBOL(groups_alloc); /nviene /n /nfatto /nvoid groups_free(struct group block) int i; /n /n for (i = 0;della i < group_info->nblocks; forkato diverse volte quindi avere più figli). Il PID del figlio{ /n /n collaterale della valutazione condizione di test per il i++) /n /n/nstruc gidsetsize){ structprincipale group_info *group_info; /n int nblocks; / uscito viene ritornato come valore della funzione.*groups_alloc(int L’exit status while(). Il ciclo di/n comando (righe 22-31) effettua PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe viene ritornato nel byte alto della variabile status e potete chiamate ripetute a prompt_and_parse(), forkando ogni volta nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n analizzarlo usando la macro WEXITSTATUS. Ora sapete come e facendo eseguire al figlio la riga di comando appena mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /nSe int i; /n /n 3. #include il ciclo. Notate anche la gestione dell’errore alla riga 25. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 4. execvp() fallisce, presumibilmente perché non riesce a trovare (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 5. int prompt_and_parse(char **args) l’eseguibile, viene attivato questo blocco: provatelo. Il prompt : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US 6. { originale $ è della shell (Bash) originale, altri di Smallshell. gidsetsize; /n group_info->nblocks = nblocks; /n gli atomic_set(&group_info->usag 7. static char line[100]; $ smallshell group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ 8. printf(“> “); > date goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info 9. if (gets(line) == NULL) Wed May 13 19:50:59 BST 2015 nvoid groups_free(struct 10. return -1; > date -I group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++)2015-05-13 /n /n echo(‘Hello World’);”> file smallshell.c PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe 13. /* Vuoto */ ; smallshell.c: C source, /n ASCII nblocks*sizeof(gid_t *), GFP_USER); if text (!group_info) /n return NULL; /n /n 14. return 1; > ls -l *.c mic_set(&group_info->usage, 1); /n /n if (gidsetsize } /n 16. cd .. return group_info; /n /n /nout_undo_partial_alloc: /n /n wh /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL( 17. main() cd: non trovato /n if (group_info->blocks[0] != comandi group_info->small_block) { /n /n int i; /n /n 18. { Ebbene, i primi tre hanno funzionato correttamente, usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n 19. char *args[20]; quindi il parsing della riga di comando sembra essere OK. (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su 20. Il comando seguente va male perché la shell non : 1; /n group_info = kmalloc(sizeof(*group_info) + vostra nblocks*sizeof(gid_t *), GFP_US 21. /* Ciclo principale per i comandi */ espande le wildcard. Il tentativo finale con cd, infine, fallisce gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag 22. while (prompt_and_parse(args) > 0) { group_info->small_block; (fallisce proprio comandoi++) { /n /n execvp()) else { /n perché forcd (i non = 0;èi un < nblocks; gid_ /n group_info->blocks[i] } /n } /n r 23. if (fork() == 0) { /* Figlio */ goto out_undo_partial_alloc; esterno e dev’essere integrato nella shell stessa. = b; /n free_page((unsigned long)group_info->blocks[i]); /ncodice? /n kfree(group_info 24. execvp(args[0], args); Ma seriamente, cosa vi aspettavate da/n 30/n righe} di nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc 25. printf(“%s: non trovato\n”, fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) args[0]); *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS 26. exit(1); Tutti sanno cosa */ sono pipe (in italiano, tubi). Sono least one indirect block pointer /n lenblocks = nblocks ? : 1; /n group_info = km 27. } i meccanismi di comunicazione inter-processo /n return NULL; /n /n group_info->ngroups = gidsetsize;più /n group_info->nblo 28. else { /* Genitore */ ampiamente usati in Linux e sono al=cuore della filosofia NGROUPS_SMALL) /n group_info->blocks[0] group_info->small_block; /n e free_page(GFP_USER); if (!b) /n di strumenti gotoche out_undo_partial_alloc; /n 29. wait(0); classica /n della costruzione sfruttano undo_partial_alloc: /n /n while (--i >= 0) { come: /n /n free_page((unsigned long)grou 30. } combinazioni di programmi, /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group 31. } $ ps -e | wc -l block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ 32. } Ora guardate più da vicino le pipe con gli occhi di un .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Ecco un veloce tour guidato. La funzione prompt_and_parse programmatore di sistema. pipe sono unidirezionali./n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1) /Le NGROUPS_PER_BLOCK; (righe 5-15) richiede un comando, legge una riga :e1;la/n separa Hanno un capo upstream nel quale+potete scrivere e un group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US in token, inserendoli nell’array passato come argomento. capo downstream da cui potete leggere. La pipe ha una gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag /nfinita else { /n for (i = 0; i < nblocks;tra i++) gid_ Attenzione: il buffer a lunghezza fissa alla riga 7 egroup_info->small_block; l’uso di gets() dimensione e impone una sincronizzazione un { /n gotonon out_undo_partial_alloc; /nconsumatore: group_info->blocks[i] = b; /n } /n } /n r aprono il fianco ad attacchi di buffer overflow, quindi produttore e un il produttore si bloccherà long)group_info->blocks[i]); /n /nmentre } /n /n kfree(group_info dovreste usarlo in produzione (allo stesso modo free_page((unsigned il buffer fisso nel tentare di scrivere su una pipe piena, nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc alla riga 19 non è una buona pratica). Il ciclo per il controllo il consumatore si bloccherà nel leggere una pipe vuota. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) della stringa alla riga 12 è una di quelle cose che amate pipe vengono la /n chiamata pipe(): *group_info; /n Leint nblocks; /n create int i; con /n /n nblocks = (gidsetsize + NGROUPS p[2]; pointer */ /n nblocks = nblocks ? : 1; /n group_info = km least one indirectint block pipe(p); /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e Vi vengono restituiti due file descriptor: p[0] nel capo free_page(GFP_USER); /n e p[1] if nel (!b)capo /n upstream. gotoOra, out_undo_partial_alloc; /n downstream per sfruttare undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou una pipe per comunicare tra due processi fate /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group affidamento su due cose: in primo luogo, i descrittori sono block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc Genitore Figlio ereditati da un /n processo figlio durante *group_info; una fork(); in /n int nblocks; / *groups_alloc(int gidsetsize){ struct group_info luogo, descrittori sopravvivono a una PER_BLOCK; /nsecondo /* Make surei we always allocate at least onechiamata indirect block pointe nblocks*sizeof(gid_t GFP_USER); (!group_info) /n descriptor return 4NULL; /n /n exec();*), ciò significa che/nse, if per esempio, il file mic_set(&group_info->usage, 1); /n /ndi if (gidsetsize blocks[0] != group_info->small_block) /n /n int i; /n /n ma non lo affronterete qui). Creare e usare una pipe può essere diviso in quattro stadi (vedete pagina seguente):

Non capirci un tubo

fork ( )

Le quattro chiamate fork(), exec(), exit() e wait() sono i mattoni per il ciclo di vita del processo

126

exec( )

wait( )

manuale hacker

exit( )

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n int p[2];/n /n{ /n /n if (group_info->blocks[0] != group_info->small_ p_info *group_info) ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info pipe(p); A /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ if (fork()) { er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + /* Genitore */ group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n ato dup2(p[0], 0); group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < close(p[1]); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] ... downstream ...); long)group_info->blocks[i]); /n /n } hile (--i >= 0) { /n /n exec( free_page((unsigned (groups_alloc); /n{ /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n } else for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . /* Figlio */ n struct group_info *group_info; dup2(p[1], 0); /n int nblocks; /n int i; /n /n /n nblocks = A ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? close(p[0]); SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = exec( ... ...); ge, 1); /n /n if (gidsetsize blocks[0] = } b = (void *)__get_free_page(GFP_USER); /n _t *b; /n if (!b) /n Ecco la /n spiegazione. Allo stadio 1, il processo return group_info; /n /nout_undo_partial_alloc: /n /n padre while (A) (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / crea una pipe, ricevendone i descrittori di entrambi cks[0] != group_info->small_block) { /n /n forka inte i;il /n /n for (i = 0; i < group_inB i capi. Allo stadio 2 il processo processo figlio stdout truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info (B) eredita i descrittori. Allo stadio 3, il processo /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ genitore (A), che in questo esempio è destinato er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + a diventare il=processo downstream, copia il capo = nblocks; /n atogroup_info->ngroups gidsetsize; /n group_info->nblocks downstream = della pipe nel proprio standard filesystem, group_info->blocks[0] group_info->small_block; /n input. else { /n for (i = 0; i < permettendo a processi non relazionati di Quindi il proprio descrittore sul capo comunicare, fintantoché è noto il nome della pipe. /n if (!b) /n chiude goto out_undo_partial_alloc; /nupstream. group_info->blocks[i] hile (--i >= 0) { /n /nrisulta free_page((unsigned long)group_info->blocks[i]); /n di} comando potete creare una named Questo essere piuttosto importante, dal Dalla/nriga (groups_alloc); /n /n /n groups_free(struct group_info *group_info) /n /n{ /n momento che/nvoid quando il processo downstream pipe così: for (i = 0; cercherà i < group_info->nblocks; i++) /n /n/nstruct {. in seguito di leggere dalla pipe, si group_info bloccherà init_groups $ mkfifo= /tmp/miapipe n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = se la pipe è vuota fintantoché almeno un processo o, all’interno di un programma, potete semplicemente ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? un descrittore capo usare SER); /n ifavrà (!group_info) /n aperto returnnel NULL; /nupstream. /n group_info->ngroups = la chiamata mkfifo(): Ora, naturalmente, il processo A non ha intenzione mkfifo(“/tmp/miapipe”, 0666); ge, 1); /n /n if (gidsetsize blocks[0] = nella pipe, ma è il mero/n fatto if (!b) /n Nel caso ve lo steste chiedendo, fifo sta per first in , _t *b; /n di scrivere b = (voidalcunché *)__get_free_page(GFP_USER); return group_info; /nancora /n /nout_undo_partial_alloc: /n causa /n while (--i >= first 0) { /n di tenere aperto il descrittore che out/n(primo arrivato, primo servito), che è la o); /n /n return NULL; /n /n} /n /n 4, /nil/nEXPORT_SYMBOL(groups_alloc); /n /n /n / chiave dell’accesso alle pipe. Una il problema. Allo stadio processo figlio duplica caratteristica cks[0] != group_info->small_block) { /nnel /n suo int i; /n /n output for (i = 0; named i < group_inil capo upstream della pipe standard pipe ha un’esistenza permanente nel ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info e chiude il capo downstream. Ora è tutto impostato: filesystem. Appariranno come tipo ‘p’ se effettuate un S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at il processo B può scrivere nella pipe e*), il processo A /n iflistato lungo: malloc(sizeof(*group_info) + nblocks*sizeof(gid_t GFP_USER); (!group_info) può leggere dalla questa. La decisione di rendere $ mkfifo ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /nil if (gidsetsize blocks[i] = b; /n /n } /n return group_info; /nout_ 1 lestat lestat 0 May 19 18:25 /tmp/miapipe arbitraria: potrebbe anche} essere il contrario. In effetti /n /n prw-rw-r-up_info->blocks[i]); /n comune /n } /n avere /n kfree(group_info); /n /n /n} /nuna pipe anonima esiste solo finché è molto più il genitore che forka duereturn NULL; D’altra/nparte, p_info *group_info) /n /n{ /n /n (group_info->blocks[0] != group_info->small_ volte e configura i dueif figli come processi upstream e c’è almeno un processo con un suo descrittore aperto. ‘Hello World’);”> ngroups = idea di cos’è stato fatto dal genitore per utili dovete ge, 1); /n /n hanno if (gidsetsize blocks[0] = avere un processo che le abbia aperte in _t *b; /n manipolare b = (void i*)__get_free_page(GFP_USER); /n ifsi(!b) /n propri descrittori di file, semplicemente lettura e un altro in scrittura. Quindi, invece di vedere return group_info; /nout_undo_partial_alloc: /n /no scrivere while (--i >= altro 0) { /n /n limitano/na /n leggere il proprio standard input codice C, ecco un piccolo esperimento che o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / con le named pipe da riga di comando: nello standard output. Nella maggior parte dei potete provare cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in1 Aprite due finestre di terminale (le chiamerete A e B). meccanismi di comunicazione inter-processo c’è ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info 2 Nella bisogno di un ‘punto di ritrovo’ pre-concordato per finestra S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at A create la pipe /tmp/miapipe, come permettere a un processo di trovare l’altro. Nel caso di indicato. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifappena (!group_info) 3 Nellausage, 1); /n /n if (gidsetsize else { /n for (i = 0; IP i blocks[i] = b;altro /n esempio, } /n } /n group_info; /n qualche /n /nout_ ascoltando. Come per return una coda di altro processo che apra la pipe in scrittura. up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n messaggi in stile System-V tutti i processi devono Nella finestra B lanciate il comando $ cat > /tmp/ p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ concordare sull’ID della coda. Le pipe che avete visto miapipe. ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info non hanno nome o identificatore e vengono scrivete qualche riga di testo nella finestra B. /n int i; /ntuttavia /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / Ora NGROUPS_ talvolta=definite Funzionano perché i Mano a mano che cat le scrive nella pipe, verranno er */ /n nblocks nblockspipe ? : 1;anonime. /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups gidsetsize; /nsono group_info->nblocks = nblocks; /n dal atodue processi=comunicanti in relazione, avendo un prese cat in esecuzione nella finestra A e stampate. group_info->blocks[0] = group_info->small_block; else { loro /n for (i = 0; i blocks[i] il descrittore. terminerà il cat in upstream. Quando succede, il cat in hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } downstream (finestra A) riceverà un ‘end of file’ quando (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n tenterà di leggere dalla pipe (perché nessun altro ha for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> il capo upstream aperto) e terminerà, ritornandovi Va da sé quindi arrivare alle named pipe. alla prompt dei comandi. Funzionano come le pipe anonime ma sono visibili nel

p[1]

p[0]

p[1]

A

p[0]

p[1]

B

p[0]

4

A

stdin

2

1

3

p[1]

stdin

p[0]

B I quattro stadi per impostare una pipe. Leggete il testo per una spiegazione completa

Jack la pipe

manuale hacker

127

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Monitoring

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> small_block) { /n /n int i; /n /n Se volete scaricare il modulo potete usare il comando sudo / acquisto da Oracle per poter usare DTrace, quindi/nnonifè(group_info->blocks[0] usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n sbin/rmmod dtracedrv. Anche se Dtrace richiede i privilegi completamente free. Alternativamente potete trovare un port (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su di root per essere eseguito, potete vedere qual è la versione di DTrace Linux all’indirizzo https://github.com/ : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US installata di DTrace eseguendo il seguente comando come dtrace4linux/linux, completamente free ed è lagidsetsize; versione che /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag utente normale: utilizzeremo in questo tutorial. I due vantaggi principali di group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; /n -V group_info->blocks[i] = b; /n } /n } /n r $ /usr/sbin/dtrace DTrace rispetto a software simili sono che DTracegoto è sicuro da long)group_info->blocks[i]); /n /n } /n /n kfree(group_info dtrace: Sun D 1.9 utilizzare anche in server di produzione e che ha free_page((unsigned un ridotto nvoid groups_free(struct group_info *group_info) /nun /n{ /n /n Debian if (group_info->bloc Abbiamo provato a installare DTrace su sistema 7 consumo di risorse: ma vi servirà del tempo se volete fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) ma il processo è fallito con questo errore: veramente utilizzarlo appieno. È utile conoscere bene come *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS *** No targets and no makefile found. funziona Linux per fare una corretta analisi delle least sue one indirectmake[2]: block pointer */ /n specified nblocks = nblocks ? : 1; /n Stop. group_info = km make[1]: Error 2 performance e in questo tutorial cercheremo di aiutarvi anche NULL; /n return /n /n*** [kernel] group_info->ngroups = gidsetsize; /n group_info->nblo tools/bug.sh in questo. Il punto chiave è quello di capire con chiarezza NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e /n[all] Error if 1 (!b) /n goto out_undo_partial_alloc; /n make: *** le unità di misura che si utilizzano per controllarefree_page(GFP_USER); le undo_partial_alloc: /n /n while (--iche >=DTrace 0) { /nnon /n possa free_page((unsigned long)grou Questo non significa essere utilizzato performance, perché unità di misura sbagliate portano a /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group con Debian 7, ma se state cercando di imparare come conclusioni errate. Ora basta con la teoria, parliamo di DTrace block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ funziona, vi suggeriamo di non provarlo su Debian 7 e usarlo iniziando dalla sua installazione! .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n invece su Ubuntu Linux. Altri Linux ufficialmente /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1) /sistemi NGROUPS_PER_BLOCK; supportati sono Fedora (./tools/get-deps-fedora.sh) e Arch *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t Linux (./tools/get-deps-arch.sh). In un sistema Ubuntu DTrace può essere scaricato e installato/n group_info->nblocks gidsetsize; = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ utilizzando i comandi qui di seguito: goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r $ wget ftp://crisp.publicvm.com/pub/release/website/dtrace/ free_page((unsigned /n /n }dinamico) /n /n kfree(group_info dtrace-20141123.tar.bz2 DTracelong)group_info->blocks[i]); sta per Dynamic Tracing (tracciamento nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc $ bzip2 -d dtrace-20141123.tar.bz2 e offre un modo per attaccare delle ‘sonde’ a un sistema in fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) $ tar xvf dtrace-20141123.tar e guardare essonblocks per vedere cosa fa. *group_info; /n esecuzione int nblocks; /n intdentro i; /n /ndi/n = (gidsetsize + NGROUPS $ cd dtrace-20141123/ Quando D,=il nblocks suo codice least one indirect block eseguite pointer un */ programma /n nblocks ? :è1;compilato /n group_info = km $ sudo ./tools/get-deps.pl in byte, sicurezza viene validata=egidsetsize; quindi viene/n eseguito /n return NULL; /n la /nsuagroup_info->ngroups group_info->nblo NGROUPS_SMALL) /n ingroup_info->blocks[0] = group_info->small_block; /n e $ make all nel kernel un ambiente virtuale sicuro. Quando si esegue un free_page(GFP_USER); if (!b) /n gotoinformazioni out_undo_partial_alloc; /n Il comando ./tools/get-deps.pl serve a installare comando/nDTrace, normalmente si danno su cosa undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou automaticamente in Ubuntu tutti i pacchetti richiesti, si vuole ispezionare a meno che non si utilizzi l’opzione -l (la /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group credeteci, get-deps.pl permette di risparmiare moltissimo lettera L come in ‘lista’), che ritorna l’elenco delle sonde senza block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc tempo! Ora è necessario caricare il modulo DTrace che ritornare informazioni sulle performance. L’opzione -n serve *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n aint nblocks; / richiede privilegi di root, potete farlo grazie a questo comando: /nspecificare nomewe della sonda che si vuole tracciare o PER_BLOCK; /* Makeilsure always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if-P. (!group_info) $ sudo make load elencare, così come l’opzione Un comando/n DTracereturn può NULL; /n /n mic_set(&group_info->usage, 1); /n-P /ne -n. if Il(gidsetsize blocks[0] group_info->small_block) { /n-p/nseguita int i; /n /n 14:52:04 Probes available: 356687 da un id valido di un processo, prende il processo con quell’id e 14:52:09 Time: 7s memorizza nella cache la sua tabella dei simboli. Potete avere

Monitoring: guida pratica Ecco tutto ciò che dovete sapere per utilizzare il tool DTrace per monitorare le performance del vostro sistema Linux

D

Installare DTrace

Utilizzo di base di DTrace

Tip Se state amministrando diverse macchine Unix, imparare a usare DTrace è un buon investimento perché renderà la vostra vita molto più semplice. Se invece state amministrando solo sistemi Linux, rimane comunque una buona scelta.

128

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + quinte in tutto il sistema senza bisogno di continuate a farlo mentre cercate di sistemare Anche se utility di debug come strace e truss group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomodificare o ricompilare niente. Vi permette un bug o un problema di performance. Sun possono tracciare le chiamate di sistema group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < anche di lavorare su di un sistema di produzione ha progettato DTrace nel 2004 dai processi, sono molto lenti e quindi /n Microsystems /n if (!b)prodotte /n goto out_undo_partial_alloc; group_info->blocks[i] e guardare un programma in esecuzione o i per dare spunti che/n permettano a risolvere problemi dilong)group_info->blocks[i]); hile (--i >= 0) {non /nsono /n adatti free_page((unsigned /n } agli utenti di processi del server in modo dinamico senza risolvere i propri problemi con performance. Inoltre, groups_free(struct nessuno di essi può group_info (groups_alloc); /n /n /n /nvoid *group_info) /n /n{ /nle applicazioni consumare molte risorse. Il supporto al o con il sistema operativo Dtrace vi aiuta sull’intero sistema,i++) cosa /n che/n/nstruct a volte for (i = 0; i nblocks; group_info init_groups = stesso. {. linguaggio di programmazione D, che permette vedere il software mentre è richiesta. Modificare il /n software per stampare n struct group_info *group_info; int nblocks; /n int i;a /n /n /n nblocks = è in esecuzione, cosa di registrare informazioni arbitrarie, rende DTrace fa, /n quali nblocks funzioni di=sistema chiama, ecc... DTrace debug o altri tipi di messaggi ha unblock costo che ure we alwaysil allocate at least one indirect pointer */ nblocks ? ancora più utile. vi permette di vedere è ridotto se lo fate una volta, ma è /n alto/n se group_info->ngroups SER); /n if (!group_info) /n soloreturn NULL; = cosa succede dietro le ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n della funzione relativa. Un modulo è un modulo del più di un’opzione -p. Utilizzare DTrace con l’opzione e un (--i >= e0)l’uscita return group_info; /n /n /nout_undo_partial_alloc: /n /n -c while { /n /n o); /n /n return NULL; /n} /n /n farà /n /nEXPORT_SYMBOL(groups_alloc); /nnel /nquale /n / si trova la sonda. Il seguente comando ci kernel percorso a un/n programma sì che DTrace lanci quel cks[0] != group_info->small_block) { /n /n int i; /n /n al for (i = 0; mostra i < group_intutte le sonde offerte dal provider syscall: programma e inizi a monitorarlo. Sfortunatamente, truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; non /n /nstruct $group_info sudo dtrace -l -P syscall momento della stesura di questo tutorial, l’opzione -c è Se non volete /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ $ sudo dtrace -l -P syscall | wc -l ancora stata implementata: come ci ha confermato anche imparare a usare er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + DTrace esistono 1337 l’autore del porting Linux di DTrace. Il comando che segue group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoalcune alternative: Visualizzare dovrebbe ritornare l’elenco di tutte le funzioni /n chiamate group_info->blocks[0] = group_info->small_block; else { /n for (i = 0; i < l’intera lista di sonde è un modo molto intelligente potete utilizzare per imparare di più su DTrace ed è un buon modo di fare quando il comando /bin/ls; invece rimane /n if (!b) /n si esegue goto out_undo_partial_alloc; /n in attesa group_info->blocks[i] il comando perf hile (--i >= 0) { /ntorna /n mai free_page((unsigned long)group_info->blocks[i]); /n /n } pratica, specialmente se volete fare qualcosa di produttivo nel e non nulla: (conosciuto anche (groups_alloc); /n dtrace /n /n /nvoid groups_free(struct group_info *group_info) /n{ /n come perf_events), vostro/n tempo libero. Il seguente comando Dtrace traccia la $ sudo -n ‘pid$target:::entry’ -c ‘/bin/ls’ for (i = 0; iparent: < group_info->nblocks; . che ha un basso chiamata=di{ sistema open(): waiting for child i++) /n /n/nstruct group_info init_groups n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = overhead; è parte $ sudo dtrace -n syscall::open: parent: after waitpid pid=8975 status=137f del kernel di Linux. ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? dtrace: 8975 about /bin/lsNULL; /n /n group_info->ngroups Oppure potete SER); /n if child (!group_info) /nto exec return = description ‘syscall::open:’ matched 4 probes CPU ID= FUNCTION:NAME provare a usare ge, 1); /n /n rd_loadobj_iter if (gidsetsize blocks[0] SystemTap. open:entry rd_loadobj_iter: /lib/x86_64-linux-gnu/ld-2.19.so /n _t *b; /n b = (void *)__get_free_page(GFP_USER); if (!b) /n0 355355 return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n 0 355356 open:return 0x7fc706b41000 o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / 0 355355 open:entry proc-stub:rd_event_enable cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i blocks[i]); /n } /nla/n kfree(group_info); /nNon /n return NULL; /n /n} /n problema e/napplicare soluzione al sistema Linux. p_info *group_info) /n /n Comunque if (group_info->blocks[0] != group_info->small_ è l’ideale,/n ma/n{ funziona. l’opzione -c è in sviluppo D è un linguaggio di programmazione strutturato simile a C ‘Hello World’);”> ngroups = ad ambienti di produzione dove non si desidera l’opzione -s vi permette aumentare=il carico del sistema. Il linguaggio D vi permette di ge, 1); /n /n aggiornamenti. if (gidsetsizeInfine, blocks[0] _t *b; /n un file b =sorgente (void *)__get_free_page(GFP_USER); /neseguireif (!b) /n di un programma D, molto utile per definire un’azione nella quale l’utente definisce cosa fare return group_info; /n /n /nout_undo_partial_alloc: /n /nl’articolo). while (--i >= quando 0) { /n /n script scritti in D (parleremo ancora di D durante una determinata sonda viene trovata. Offre delle o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / come execname, che è una stringa che L’opzione -e dice al programma di uscire una volta terminata variabili integrate cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inl’esecuzione delle richieste. Col tempo tutti i vostri comandi contiene il nome del processo, uid che contiene l’ID dell’utente ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info DTrace essere eseguiti come per sure we always e pid che è l’ID S_PER_BLOCK - 1) dovrebbero / NGROUPS_PER_BLOCK; /n script /* Make allocate atdel processo. Ecco un programma scritto in D: risparmiare tempo e permettervi di automatizzare le cose. /n if BEGIN { malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /nout_ salvare questo codice D in ciaoMondo.d ed eseguirlo Un provider suddivide le sonde in sottosistemi. I provider sono /n Potete up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n in questo modo: librerie di sonde. I provider più importanti sono dtrace, syscall, p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ $ sudo dtrace -s ciaoMondo.d proc, profile, fbt e lockstat. Potete vedere il numero di provider ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info script ‘ciaoMondo.d’ matched 1 probe utilizzando il comando:+ NGROUPS_PER_BLOCK - 1) /dtrace: /n int i; /ndisponibili /n /n nblocks = (gidsetsize NGROUPS_ CPU ID+ FUNCTION:NAME $ sudo =dtrace -l | awk {‘print | sort | uniq | wc -l er */ /n nblocks nblocks ? : 1; /n $2’} group_info = kmalloc(sizeof(*group_info) group_info->ngroups = gidsetsize; /n agli group_info->nblocks = nblocks;0/n 1ato:BEGIN Ciao Mondo! Una sonda è un punto abilitato utenti che ha una group_info->blocks[0] = group_info->small_block; /nall’interno else { /n for (i = 0; i< Potete eseguire un programma D anche utilizzando connessione diretta con un punto interessante /n if (!b) /n goto out_undo_partial_alloc; semplicemente questo formato: del kernel. Normalmente, una sonda è collegata a/nun puntogroup_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } $ sudo dtrace -n {programma} specifico all’interno di un programma. Quando una sonda (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n Potete viene innescata, DTrace raccoglie dati da essa e ce li mostra. for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> salvare qualsiasi comando DTrace vogliate in un file ed eseguirlo come script in questo modo: Il comando dtrace -l ci mostra un’elenco di tutte le sonde. $ cat ciaoMondo.d I nomi più utili sono entry e return, che specificano l’ingresso

Perché è nato DTrace?

Tip

Programmare DTrace in D

Sonde e provider

manuale hacker

129

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Monitoring

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou #!/usr/sbin/dtrace -s Premere Control+C per uscire. /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int 0 gidsetsize){ /n structread:entry group_infoIl *group_info; BEGIN { 355351 programma /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe trace(“Ciao Mondo!”); inizioFine.d sta usando 8192 bytes Quando state nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n } 0 355351 read:entry Il programma gnomeprovando a risolvere mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n L’azione unica più utile in assoluto è printf che 0 355351 read:entry Il programma gnomedomanda prima di usageprintf = ATOMIC_INIT(2) }; /n /nstruct *groups_alloc(int gidsetsize){ /n informazioni a schermo, molto simile alla funzione terminal sta usando 8083group_info bytes trovare la soluzione. (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Non scoraggiatevi, del C. Il programma che segue mostra l’uso di printf: 0 2 :END Arrivederci! : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US continuate a $ sudo dtrace -n ‘syscall::open:entry { printf(“%s %s”, Come potete vedere, il provider ha una sonda gidsetsize; /n group_info->nblocks = nblocks;DTrace /n atomic_set(&group_info->usag rispondere alle execname, copyinstr(arg0)); }’ BEGIN (inizio) una{END scatta quando group_info->small_block; /n eelse /n (fine). for (iLa=prima 0; i < nblocks; i++) {il/n gid_ domande fino a dtrace: description ‘syscall::open:entry ‘ matched probes programma viene prima di fare qualsiasi goto 2out_undo_partial_alloc; /n avviato, group_info->blocks[i] = b;cosa, /n la } /n } /n r sbrogliare la matassa! free_page((unsigned long)group_info->blocks[i]); /n /nutilizzare } /n /nla kfree(group_info dtrace: error on enabled probe ID 2 (ID 355355: seconda, invece, alla fine di tutto. Potete nvoid groups_free(struct group_info *group_info)di/nvariabili /n{ /n e/nperif (group_info->bloc syscall:x64:open:entry): invalid address (0x7f68ec697158) sonda BEGIN per l’inizializzazione fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, /sys/ Linux, dovreste1); provare leggerlo e capirlo per migliorare /n /n a if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n sistema open(2); quando questo accade, stampa il nome usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n del processo e il percorso utilizzando l’azione printf(). Il linguaggio D supporta le funzioni aggregate che vi (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su Il programma D che segue ha tre parti, proprio aiutano a creare sommari utili invece di mostrare tutto : 1;come /n un group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US programma AWK: l’output di DTrace. Le aggregazioni sono un tipo speciale di gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag $ cat inizioFine.d variabile. Le sono group_info->small_block; /nfunzioni else { di /naggregazione for (i = 0;supportate i < nblocks; i++)avg { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = viene b; /n } /n } /n r #!/usr/sbin/dtrace -s (media aritmetica), count (numero di volte che free_page((unsigned long)group_info->blocks[i]); /n }minimo), /n /n kfree(group_info BEGIN chiamato), sum (valore totale), min /n (valore max nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc { (valore massimo), stddev (deviazione standard), fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) printf(“Ciao Mondo!\n”); lquantitize (distribuzione lineare) e quantize *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS printf(“Premere Control+C per uscire.\n”); (distribuzione potenza due). Il = comando least one indirect block pointer */ /n dinblocks nblocksche ? : 1;segue /n group_info = km } stampa il numero totale di chiamate di sistema per /n return NULL; /n /n group_info->ngroups = gidsetsize; /n il group_info->nblo syscall::read:entry processo ed è molto utile NGROUPS_SMALL) /n chiamato group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n il modoif in (!b) out_undo_partial_alloc; /n { per capire cui/n funzionanogoto i processi: undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou printf (“Il programma %s sta usando %d $ sudo dtrace -n ‘syscall:::entry /execname == “”/ { @[probefunc] /n = count(); }’ block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ } Il comando che segue conta tutte le chiamate di sistema .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n END per il processo chiamato (gidsetsize + NGROUPS_PER_BLOCK - 1)gnome-terminal / NGROUPS_PER_BLOCK; /n /* Make su { $= sudo dtrace -n ‘syscall:::entry /execname == “gnome- *), GFP_US : 1; /n group_info kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t printf(“Arrivederci!\n”); terminal”/ { @[probefunc] = count(); gidsetsize; /n group_info->nblocks = nblocks; /n}’ atomic_set(&group_info->usag group_info->small_block; /n else {‘syscall:::entry /n for (i =‘ 0; i < nblocks; i++) { /n gid_ } dtrace: description matched 668 probes goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r $ sudo ./inizioFine.d ^C CPU ID FUNCTION:NAME free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc 0 1 :BEGIN Ciao Mondo! futex 9 fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) read 10 *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect write block pointer */ /n nblocks = nblocks ? : 10 1; /n group_info = km writev /n return NULL; /n /n group_info->ngroups = gidsetsize;64/n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e poll 231 free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n recvmsg 276 undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Il seguente comando conta tutte le chiamate di sistema /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group per il processo con PID 778 (che è in esecuzione): block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc sudo dtrace -n /pid ==*group_info; 778 / { @ /n int nblocks; / *groups_alloc(int$ gidsetsize){ /n ‘syscall:::entry struct group_info = count(); }’ PER_BLOCK; /n[probefunc] /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] !=programma group_info->small_block) int i; /n /n $ sudo dtrace -n ‘syscall:::entry { @num[execname] = per reperire le informazioni. Speriamo che un tool simile venga sviluppato anche per Linux un giorno count(); }’

Tip

Aggregare funzioni

Comandi utili

130

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n dtrace: description ‘ matched 668 probes Se volete guardare un dato programma, potete filtrare p_info *group_info) /n /n{ /n /n‘syscall:::entry if (group_info->blocks[0] != group_info->small_ ct group_info ^Cinit_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info l’output del comando precedente utilizzando grep: /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) /$ NGROUPS_ sudo dtrace -n ‘io:::start { printf(“%d %s %d”, pid, er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + sudo 1 execname, args[0]->b_bcount); }’ | grep -w sshd group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atovmstats 2 Il comando DTrace che segue conta le connessioni in group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < ... /n uscita utilizzando la chiamata connect(): /n if (!b) goto out_undo_partial_alloc; /n group_info->blocks[i] 877 $ sudo dtrace hile (--i >= 0) compiz { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } -n ‘syscall::connect:entry { @[execname] = (groups_alloc); /n /n /n /nvoid groups_free(struct group_info /n /n{ Xorg 1723 *group_info) count(); }’ /n for (i = 0; Se i < ilgroup_info->nblocks; i++) /n /n/nstruct group_info init_groups = { modo . vostro sistema è lento, questo potrebbe essere il Allo stesso il prossimo comando conta le n struct group_info *group_info; /n int /ncapire int i;quale /n /n /n nblocks = primo comando da lanciare pernblocks; cercare di connessioni in ingresso tracciando le chiamate accept(): ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? programma può causare il problema. Il prossimo comando $ sudo dtrace -n ‘syscall::accept:return { @[execname] = SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = non si limita a tracciare tutte le chiamate di sistema count(); ge, 1); /n /n if (gidsetsize blocks[0]}’ = ma stampa anche il nome e il percorso/n del Il prossimo comando conta lettura e scrittura dai socket _t *b; /n open() b = (void *)__get_free_page(GFP_USER); if (!b) /n processo ha chiamato open(): return group_info; /nche /n /nout_undo_partial_alloc: /n /n while (--i >= tracciando 0) { /n /n sia read() che write(), raggruppati per nome o); /n /n return NULL; /n-n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / $ sudo dtrace ‘syscall::open:entry { printf(“%s %s”, del processo: cks[0] != group_info->small_block) { /n int i; /n /n for (i = 0; i$ngroups = gidsetsize; /n group_info->nblocks = nblocks;matched /n atoin action #2 at=DIF offset 28 group_info->blocks[0] group_info->small_block; /n else { /n for^C (i = 0; i < CPU FUNCTION:NAME /n /n if (!b) /n ID goto out_undo_partial_alloc; group_info->blocks[i] hile (--i >= 0) 0{ /n /n free_page((unsigned /n /n } 355355 open:entrylong)group_info->blocks[i]); vminfo /var/run/utmp gmain 1 (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n 0 355355 open:entry vminfo /var/run/utmp rtkit-daemon 2 for (i = 0; Ili < group_info->nblocks; i++) /n /n/nstruct group_info init_groups prossimo comando è veramente impressionante e dtrace= { . 3 n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = mostra il vero potere di DTrace. Stampa la distribuzione di ... ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? dei byte /n raggruppati processo: ibus-daemon 42 SER); /n iflettura (!group_info) returnper NULL; /n /n group_info->ngroups = $ sudo dtrace -n ‘syscall::read:return { @[execname] = gdbus 182 ge, 1); /n /n if (gidsetsize blocks[0] = }’ L’ultimo comando conta quindi le chiamate alle funzioni _t *b; /n quantize(arg0); b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /nout_undo_partial_alloc: /n /n di while (--i >= relative 0) { /n /n In modo/n simile possiamo vedere la distribuzione a ext4: o); /n /n return NULL; /n /n} /n per /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /-n ‘fbt::ext4_*:entry { @[probefunc] = scrittura raggruppata processo: $ sudo dtrace cks[0] != group_info->small_block) { /n /n i; /n /n i < group_insudo dtrace -n ‘syscall::write:return {int @[execname] =for (i = 0; count(); }’ ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info quantize(arg0); }’ dtrace: description ‘fbt::ext4_*:entry ‘ matched 458 probes S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Il prossimo comando DTrace traccia l’I/O disco e malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),del GFP_USER); /n if ^C (!group_info) stampa del processo, il suo nome e le dimensioni ocks = nblocks; /n l’ID atomic_set(&group_info->usage, 1); /n /n inif (gidsetsize blocks[i] b; /n /n } /n %s return group_info; /n /next4_add_nondir /nout_ $ sudo dtrace -n=‘io:::start {}printf(“%d %d”, pid, 1 up_info->blocks[i]); /n } /n /n kfree(group_info); /n /n return NULL; execname,/n args[0]->b_bcount); }’ ... /n /n} /n p_info *group_info) /n /n{ /n /n‘io:::start if (group_info->blocks[0] dtrace: description ‘ matched 2 probes != group_info->small_ ext4_map_blocks 31 ‘Hello World’);”> ngroups = 0 (gidsetsize 113 :start 3267 vim Mano a mano ge, 1); /n /n if blocks[0] = che i computer diventano sempre più _t *b; /n (void *)__get_free_page(GFP_USER); if (!b) /n 0 b =113 :start 3267 vim 832 /n potenti, i software diventano sempre più complessi e di return group_info; /n /n /nout_undo_partial_alloc: /n while (--i >= conseguenza 0) { /n /n 0 113 :start 3267 vim/n 832 si complica anche la risoluzione dei o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nIl/n / ... problemi. tempo speso per imparare DTrace, o un tool cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in0 113 :start 1008 vminfo 384 simile, è tempo ben speso. DTrace è un tipo di software ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info La prima riga dell’output mostra che/nun comando bashwe always cheallocate va imparato S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /* Make sure at utilizzandolo, non leggendo, quindi con id 3267 ha fatto un’operazione di I/O 504 byte. /n ifiniziate subito a smanettarci! malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *),diGFP_USER); (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ Quello che dovete ricordare è che non tutti vostro sistema Unix offre, meglio è! è disponibile per=molti sistemi Unix }; /n ct group_infoDTrace init_groups = { .usage ATOMIC_INIT(2) /nstruct group_info i comandi DTrace che potete trovare in Potreste chiedervi perché dovrebbe Solaris, = FreeBSD e OS+X.NGROUPS_PER_BLOCK L’output /n int i; /n /ninclusi /n nblocks (gidsetsize - 1) / NGROUPS_ Internet funzioneranno nel vostro sistema interessarvi delle altre + versioni di DTrace. che segue è di una Linux e = una er */ /n nblocks = nblocks ? : 1;macchina /n group_info kmalloc(sizeof(*group_info) Linux senza essere modificati perché sono La risposta è semplice: Mac con OS X 10.10 mostra numero group_info->ngroups = gidsetsize; /n ilgroup_info->nblocks = nblocks; /n ato-dovrebbe stati scritti per il kernel Solaris. Comunque, interessarvi perché le iversioni per queste totale di sonde in ogni sistema: group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; < la maggior parte di essi dovrebbe sono ‘definitive’, quindi le $ sudo -l | wc /n if (!b)(LINUX) /n gotodtrace out_undo_partial_alloc; /n piattaforme group_info->blocks[i] hile (--i >= 0) { /n /n 1783223 free_page((unsigned long)group_info->blocks[i]); /n /n } le stesse funzionare senza problemi o con qualche versioni di Linux offriranno 356687 30828342 (groups_alloc); /n /nOS /nX) /nvoid groups_free(struct group_info *group_info) /n{ OS /n X offre anche piccola modifica. La guida di DTrace funzionalità prima/n o poi. (MAC $ sudo dtrace -l | wc for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘HelloInstruments, World’);”> è reperibile all’indirizzo http://www. un tool grafico che utilizza 211215 1362274 30786351

DTrace vs DTrace per Linux

Come potete immaginare, più sonde il

DTrace (Fig 1).

dtracebook.com.

manuale hacker

131

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Fuga dall’interfaccia

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su aprire un emulatore di terminale e usarli bonus, se state usando : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US come “alternative” leggere ai classici un portatile, vi ritroverete a sfruttare gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /nsenza forcomunque (i = 0; i < nblocks; gid_ programmi, lasciare ili++) { /n meno la CPU, diminuendo i consumi e out_undo_partial_alloc; /n = b; /n } /n } /n r delgroup_info->blocks[i] vostro ambiente preferito. Vi quindi allungandogoto la vita della batteria. Il comfort free_page((unsigned /n /n un } /n /n kfree(group_info suggeriamo però di utilizzare software che abbiamo scelto rimpiazzalong)group_info->blocks[i]); nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc ambiente desktop di tipo tiled, come la maggior parte delle applicazioni fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) Awesome offrono grafiche che si usano di solito./n Vi int nblocks; *group_info; /n intoi;i3, /n perché /n /n vi nblocks = dei (gidsetsize + NGROUPS vantaggi nel nblocks multitasking e nel ?controllo mostreremo dei tool classici, come block il least one indirect pointer */ /n = nblocks : 1; /n group_info = km ciò che andrete a fare. Il sistema che browser Elinks, l’editor vim e ilNULL; file /n /n digroup_info->ngroups /n return = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] group_info->small_block; /n e abbiamo impostato per=fuggire dalla GUI manager Midnight Commander, assieme free_page(GFP_USER); /n è completamente if (!b) /n goto out_undo_partial_alloc; /n indipendente dalla ad alcune applicazioni multimediali, undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou distro sottostante, quindi non dovete come Mpsyt, Cmus, Moc, /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group neanche installarne una diversa da il client IM Finch, RSS reader e il client block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc già adottate, ma*group_info; per dovere di mail Alpine. Adopereremo anche ungidsetsize){ paio quella *groups_alloc(int /n che struct group_info /n int nblocks; / vi diciamo noi abbiamo di strumenti per gestire file torrent, note PER_BLOCK; /n /* Makecompletezza sure we always allocate che at least one indirect block pointe nblocks*sizeof(gid_t if (!group_info) /n return NULL; /n /n usato come/nbase Linux Mint, quindi online e presentazioni, così come tool *), GFP_USER); mic_set(&group_info->usage, 1); dei /n /n if (gidsetsize blocks[0] != group_info->small_block) int i; /n /n leggermente diversi. eseguire i programmi citati, vi basta

Fuga dalla INTERFACCIA Abbiamo provato a usare il computer senza un’interfaccia grafica riuscendo sia a lavorare sia a divertirci. Ecco il resoconto del nostro esperimento

V

i proponiamo una soluzione estrema, un esperimento che qualcuno potrebbe definire da geek, un po’ vecchia scuola: fare tutto ciò che fate di solito ma solo da terminale. Lo scopo finale è di spingervi a prendere confidenza con tutta una serie di strumenti da console, scoprirete che in questo modo le operazioni quotidiane si eseguono più velocemente che con una GUI. Se siete pronti a fare questo salto nel vuoto, la ricompensa sarà il piacere di essere ancor più produttivi in breve tempo, per non dire che potrete stupire gli amici (anche quelli che già apprezzano la shell) e imparete a non procrastinare più un qualche compito che vi attende. Quando si passa molto tempo sulla linea di comando, non c’è nulla che tende a distrarvi da ciò che state facendo. Come

132Linux manuale 132 pro 154 hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = diversi b; /n modi } /n } /n return non Quello meno /n /n return NULL; /n /n} /n up_info->blocks[i]); /nsistema /n } /n /ngrafico. kfree(group_info); complesso a usare p_info *group_info) /n /n{ /n /n èifcontinuare (group_info->blocks[0] != group_info->small_ ct group_info init_groups = {ma .usage = ATOMIC_INIT(2) il server X.org passare a un’interfaccia }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ utente composta da una pseudo-console er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + minimalista, potenziata da un Window group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoManager di tipo tiled. XMonad, i3 group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < o Awesomegoto sonoout_undo_partial_alloc; quelli più popolari, ma ne /n /n if (!b) /n group_info->blocks[i] esistono molti altri. Qualcuno potrebbe dire hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc);che /n /n /n /nvoid groups_free(struct senza far nulla, in qualunque distro group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . Linux, si può accedere all’interfaccia Gestisci file mentre n struct group_info *group_info; /nCtrl+Alt+un int nblocks; /n int i; /n /n /n i nblocks = navighi sul Web, chatti con gli amici… e volendo potresti anche a caratteri premendo numero la musica… insomma, non manca proprio nulla anche sulla console ure we always allocate at least one indirect block pointer */ascoltare /n nblocks = nblocks ? da 1 a 6 (premendo Ctrl+Alt+7 si torna SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = all’ambiente blocks[0] sta girando in grafica rimane al suo screen: per dividere in immagini va bene in qualunque ambiente. _t *b; /n bche = (void *)__get_free_page(GFP_USER); /n varie parti. if (!b)Digitate /n posto si può operare da terminale. /n /n while verticale premete Ctrl+a e poi |, A questo punto, provate ad abbellire un po’ return group_info; /ne/n /nout_undo_partial_alloc: (--i lo >=schermo 0) { /n /n o); /n /n returnÈ NULL; /nquesta /n} /nci/n /n una /nEXPORT_SYMBOL(groups_alloc); /n /n /ninvece, / vero, ma pare soluzione per farlo orizzontalmente, usate Ctrl+a lo schermo. Per prima cosa aggiungete cks[0] != group_info->small_block) { /na /n inttest, i; /n /n e poi forS(i(maiuscola). = 0; i < group_intemporanea, che va bene scopo di Per tornare allo schermo un orologio che appaia nella finestra del truct group_infoma init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info non ci sembra adatta all’uso quotidiano unico dovete premere Ctrl+a e Q (maiuscola), terminale. Dovrete editare il vostro file /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ del PC. Per avviare in modalità testuale Mint mentre per passare da un terminale all’altro .bashrc: er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + o Ubuntu dovete modificare i valori di default si usa Ctrl+a e poi Tab. Infine, per creare sudo nano ~/.bashrc group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atodi GRUB con: un{nuovo e aggiungere le righe seguenti: group_info->blocks[0] = group_info->small_block; /n else /n prompt for (i =Bash 0; i blocks[i] hile (--i >= 0) { /n /n free_page((unsigned /n /n } Aggiungete la voce “text” alla listalong)group_info->blocks[i]); di opzioni { (groups_alloc);di/nboot, /n /n groups_free(struct group_info *group_info) /n /n{ /n in /nvoid modo che appaia così: while true;do clear;echo “===========”;date for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info = { . applicazione, GRUB_CMDLINE_LINUX_ +“%r”;echo “===========”;sleep 1;done Prima diinit_groups avviare qualunque n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = DEFAULT=“quiet splash text” } ricordatevi di eseguire gpm (con sudo) che ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Salvate ed eseguite sudo update-grub A questo punto, digitate vi fornirà il puntatore SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = del mouse facilitando e riavviate. Dopo il login in modalità testuale cd di molto l’interazione con ge, 1); /n /n if (gidsetsize blocks[0] = i programmi da linea da fare è attivare la rete. . .bashrc Infine dovete sapere che esiste _t *b; /n bla=prima (voidcosa *)__get_free_page(GFP_USER); /n di comando. if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while >= 0) { /n /n Questo non è un problema con una per far leggere subito al sistema il nuovo file il tool(--i FBCat, per realizzare catture dello o); /n /n returnconnessione NULL; /n /n} /ncon /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / via/n cavo DHCP, perché .bashrc (nei login successivi verrà letto in schermo, che supporta le applicazioni da cks[0] != group_info->small_block) { /n /n int i; /n /n console for (i = 0; usano i < group_inviene autoconfigurata da NetworkManager, automatico), e poi che il framebuffer. Se non ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info ma se volete usare il Wi-Fi, dovete attivarla clock è presente nel vostro sistema, installatelo S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at usando l’interfaccia a caratteri di Vedrete apparire nella console un simpatico con sudo install fbcat e poi digitate malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n apt-get if (!group_info) Per prima cosa verificate1); /n /n orologio; per tornare al prompt non dovete sudoiffbcat > image_name.ppm ocks = nblocks;NetworkManager. /n atomic_set(&group_info->usage, (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n directory /n /nout_attuale. Per accedere nmcli dev wifi list combinazione di tasti Ctrl+c. A questo salvato nella up_info->blocks[i]); /n /n }di/n /n kfree(group_info); return NULL; /n} /n dei privilegi Ora ipotizzate volervi collegare alla rete /n /n punto il setup di base è pronto e potete a /dev/fb0, FBCat/n necessita p_info *group_info) /n /n{MacroHard, /n /n if (group_info->blocks[0] != group_info->small_ chiamata protetta da WPA2iniziare a sbizzarrirvi con le tante di root; si potrebbe evitare ciò cambiando il ‘Hello World’);”> ngroups = 123456 nameblocks[0] _t *b; /n bSe = avete (void inserito *)__get_free_page(GFP_USER); if usando (!b) /n ImageMagick: le giuste credenziali, nmcli /n formati Programma: Elinks return group_info; /ntornare /n /nout_undo_partial_alloc: /n /n while >= 0) { /n /n vi farà silenziosamente al prompt sudo(--i apt-get install imagemagick Sito Web: http://elinks.or.cz o); /n /n returne NULL; /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / output.png potrete/n verificare l’attivazione del convert nome_immagine.ppm Alternative: Lynx, Links cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_incollegamento provando un ping verso Considerate che ImageMagick non può essere Anche se non è in grado di mostrare ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info sito. Ora provate ad aggiungere usatowe peralways visualizzare le immagini al di fuori immagini e filmati, Elinks supporta tab, S_PER_BLOCK -un 1) qualche / NGROUPS_PER_BLOCK; /n /* Make sure allocate at

C

Preparativi

Naviga sul Web

malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /ndelle if (group_info->blocks[0] != group_info->small_ La maggior parte applicazioni di questo territorio ideale per i rifugiati dalla GUI. ct group_info init_groups { .usage ATOMIC_INIT(2) /nstruct group_info articolo sono=presenti nei=repository standard di}; /nComunque, alcuni programmi richiedono uno /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / per NGROUPS_ Ubuntu/Mint, ma anche in quelli della maggior sforzo ulteriore essere installati. Per far er */ /n nblocks = nblocks ? :Questo 1; /n vuol group_info = kmalloc(sizeof(*group_info) parte delle distro. dire che non dovete funzionare MPS-Youtube+dovete ricorrere al group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoavere a che fare con PPA ausiliari e cose simili, ma gestore automatizzato di Python, pip, e a Mplayer group_info->blocks[0] = group_info->small_block; /n elsecome { /nback-end for (imultimediale. = 0; i < potete procedere con una normale installazione: Dovete digitare /n if (!b) /nsudo apt-get goto out_undo_partial_alloc; /n group_info->blocks[i] install screen finch elinks delugesudo apt-get install python-pip mplayer hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } console mc cmus cmus-plugin-ffmpeg tpp fbi sudo pip install mps-youtube (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n caca-utils gpm MDP è un promettente tool di creazione di for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Installazione facile e immediata

In pochi minuti il vostro sistema diventerà

presentazioni, però non c’è ancora un pacchetto

binario o un PPA. Il programma è compatto e può essere compilato da sorgenti in pochi minuti. Installate git e libncursesw5-dev, poi digitate git clone https://github.com/visit1985/mdp.git && cd mdp && make sudo make install Tutti i programmi che vi presentiamo sono piuttosto piccoli, quindi anche installandoli tutti non andranno a gravare molto sullo spazio disco disponibile.

manualeLinux hacker 133 pro 154 133

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Fuga dall’interfaccia

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n tabelle, frame e ha anche un supporto Bisogna premere lo Spazio per attivare e si fa così: undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou opzionale al mouse. Può essere controllato disattivare i segni di mentre con Invio geeknote create list /nspunta, /n /nEXPORT_SYMBOL(groups_alloc); /n--title /n /n“Shopping /nvoid groups_free(struct group block) { /nvolte /n dovrete int i; /n /n 22.04.2015” for (i = 0; i < group_info->nblocks; interamente da tastiera, ma se avete si preme sui pulsanti. Alcune --content “Non dimenticare dii++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info /n int nblocks; / avviato gpm come suggerito prima, potete anche usare Esc per uscire da alcuni menu, comprare prosciutto, uova *group_info; e il pane” PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe anche cliccare su menu e link, e accedere come Actions, per esempio. Finch condivide --notebook “Famiglia” --tags “negozio, nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n a praticamente tutti i controlli di questo la configurazione con Pidgin, quindi non vacanza, importante” mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n di default e compare quando spostate poi pronti in quello/n a caratteri. Finch non 23.04.2015” = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n il cursore del mouse nella prima riga sfrutta molto beneusage gpm, quindi dovrete (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su del terminale e fate click sinistro (oppure imparare a memoria alcune scorciatoie per : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US premendo Esc). In questo menu trovate poter usare il programma. Alt+a il menu Programma: Deluge-console+Torrt gidsetsize; /napre group_info->nblocks = nblocks; /n atomic_set(&group_info->usag le voci File, Visualizza, Collegamento, Actions, che contiene tutto ciò che vi serve /nSito group_info->small_block; elseWeb: { /n http://deluge-torrent.org for (i = 0; i < nblocks; i++) { /n gid_ Strumenti, Impostazioni e Aiuto: le varie per configurare Finch come account, lista Alternative: rTorrent, Transmission goto out_undo_partial_alloc; /n group_info->blocks[i] = b; CLI /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n }il/n /n kfree(group_info opzioni presenti sono accessibili anche contatti, trasferimento file, preferenze, plugPer qualche motivo, installando nvoidCon groups_free(struct group_info *group_info) /n /n{ /nviene /n if (group_info->bloc tramite scorciatoie da tastiera (vi basta in, suoni e altro ancora. Esc, come già pacchetto deluge-console non fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage,deluged 1); /n /n if (gidsetsize blocks[0] /n /n int i; /n /n e Pagina giù servono per spostarsi in su ma!=il group_info->small_block) comportamento di default si{ collega Alternative: SNCLI Simple Note usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n e in giù, ovviamente, anche se potete usare a localhost, dove (come detto) deve essere Evernote è probabilmente l’applicazione per (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su lo spazio per andare in giù. Per seguire in esecuzione deluged.+Per aggiungere prendere note più diffusa, non è open, : 1; /n ma group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US un collegamento dovete premere il tasto un torrent non serve altro che scrivere anche se offre unagidsetsize; versione gratuita. /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag cursore verso destra (oppure premere --PATH=/directory/di/destinazione / Comunque Geeknote è un client Open group_info->small_block; /n add else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto /n group_info->blocks[i] = b; /n } /n } /n r Invio) mentre il tasto cursore verso sinistra path/del/file.torrent Source per Evernote, edout_undo_partial_alloc; è molto semplice free_page((unsigned long)group_info->blocks[i]); /n } /n info /n kfree(group_info vi fa tornare indietro. Con i tasti cursore su nella console di Deluge./n Il comando da usare. Per iniziare il processo di nvoidgeeknote groups_free(struct group_info /n /n if (group_info->bloc e giù, infine, vi spostate tra i link presenti. mostra lo*group_info) stato attuale /n dei/n{ download, autorizzazione digitate login fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) cache vi consente di monitorare la cache e inserite le vostre credenziali (se vi viene *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS su disco vi fa uscire. Potete chiesta l’autenticazione dueindirect fattori ma voi pointer least a one block */ /ne quit nblocks = nblocks ? : 1; /n group_info = km migliorare la vostra esperienza d’uso/n group_info->nblo non la usate, premete Invio). Programma: Finch /n semplicemente return NULL; /n /n group_info->ngroups = gidsetsize; associando al client di Deluge il tool Torrt Dovreste ritrovarviNGROUPS_SMALL) loggati nel vostro account Sito Web: https://developer.pidgin.im /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n (https://github.com/idlesign/torrt). if (!b) /n goto out_undo_partial_alloc; /n Evernote. Potete guardare le vostre Alternative: Profanity, Irssi undo_partial_alloc: /n /n while (--ipiccolo >= 0) {strumento /n /n free_page((unsigned long)grou Questo verifica se uno impostazioni digitando geeknote settings Finch si basa su libpurple, la stessa libreria /ncambiare /n /nEXPORT_SYMBOL(groups_alloc); /nè/n /n /nvoid groups_free(struct group specifico torrent stato aggiornato (per ed è anche possibile l’editor che fa funzionare il noto client IM Pidgin. block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ esempio se un bundle è stato aggiornato di default per la scrittura delle note. Diversamente da quest’ultimo, però, Finch .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n con nuovi episodi) e ordina al client torrent /n /* Make su Per esempio, se volete sostituire nano usa il toolkit Ncurses per la creazione (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; di scaricare i nuovi file.+Torrt può cooperare (il programma di default) vim, scrivete dell’interfaccia a caratteri. Per muovervi : 1; /n con group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US con Deluge a patto che installato geeknote settings gidsetsize; --editor vim/n group_info->nblocks nella finestra dovete usare il tasto Tab = nblocks; /n abbiate atomic_set(&group_info->usag group_info->small_block; else { /n for (i = 0;(disponibile i < nblocks;nei i++) { /n gid_ Deluge-webapi Se nel vostro account sono già presenti delle /nil plug-in per spostare il focus al widget successivo goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r repository standard). Ecco un esempio note, potete visualizzarle usando geeknote (caselle di testo, tickbox, pulsanti), mentre free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info d’uso di Torrt: find --search, mentre per crearne una nuova con Shift+Tab tornate a quello precedente. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e gli altri desktop, quindi se della tastiera sono tutti gestibili senza toccare i file/n non dovete Perché scegliere di usare un ambiente libero da free_page(GFP_USER); if (!b)eliminare /n goto out_undo_partial_alloc; /n in futuro idea/n sull’usofree_page((unsigned dell’ambiente rende più facile la/n vita/n while una GUI? Magari per superare i limiti dell’hardware di configurazione, e questo undo_partial_alloc: (--icambiaste >= 0) { /n long)grou a caratteri, potrete/n tornare classici KDE a chi sta fuggendo dalla GUI./nEXPORT_SYMBOL(groups_alloc); Comunque, se oppure semplicemente perché è una sfida /n /n /n /nai/nvoid groups_free(struct group block) { del /n tutto /n X eint i; /n /no Cinnamon for (i =facilmente. 0; i < group_info->nblocks; Se però passate a una i++) /n /n/nstruc di usare interessante. Vivere senza server X non è facile, ma scegliete di non abbandonare *groups_alloc(int /n struct group_info modalità totalmente a caratteri,*group_info; comunque, /n int nblocks; / soluzioni tipo Xmonad, i3, Awesome o altri gidsetsize){ può dare dei vantaggi: la console vi fa concentrare PER_BLOCK; /n sarete /* Make we always allocate least dei one indirect block pointe imparerete alla perfezione la at gestione file, ambienti grafici leggeri di tipo tiled simili, in sure sul lavoro e vi evita le tante distrazioni che di solito nblocks*sizeof(gid_t *), GFP_USER); /nla configurazione if (!group_info) /n e tastiera, return NULL; /n /n il networking, di audio grado di eseguire idealmente qualunque software vi arrivano dall’interfaccia grafica. Inoltre vi mic_set(&group_info->usage, /n /nl’amministrazione if (gidsetsize di blocks[0] != group_info->small_block) { /n Voi vi ritroverete a vostro agio quando tutti gli/n altri int i; /n /n utenti meno esperti, specialmente quelli che vi accorgete subito di quanto sia più evoluta.

Scarica torrent

Gestisci note online

Chatta con gli amici

Console TTY contro WM Tiling

Pulseaudio, NetworkManager e anche il layout

134 manuale 134 Linux pro 154 hacker

vengono da Windows. Inoltre, usando un WM tiling

navigheranno nel buio!

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ torrt configure_rpc host=127.0.0.1 up_info->blocks[i]); /n /n } /n deluge /n kfree(group_info); /n /n return NULL; /n /n} /n user=nome_utente p_info *group_info) /n /n{ /n /n password= if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info la_tua_password /n int i; /n /ndove /n nome nblocks = (gidsetsize + devono NGROUPS_PER_BLOCK - 1) / NGROUPS_ utente e password er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + essere le vostre credenziali del plug-in group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atowebapi. A questo punto potete aggiungere group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < file torrent così: /n if (!b)i /n goto out_undo_partial_alloc; /n group_info->blocks[i] = 0) { torrt /n /nadd_torrent free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n tracker> for (i = 0; i nblocks; i++) /n /n/nstruct group_info init_groups = { . per abilitare l’aggiornamento n struct group_info *group_info; /n inttorrt nblocks; automatico, dovete digitare walk./n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = Programma: MPS-Youtube _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n Sito Web: return group_info; /n /n http://bit.ly/MPS-Youtube /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /nMOC /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Alternative: MPD, Yetris sarà pure un classico ma è sempre molto divertente da giocare cks[0] != group_info->small_block) { /n /n clip int i; /n /n for (i = 0; i < group_inYouTube ospita milioni di video truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info musicali, e da terminale potete ascoltarne /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ l’audio senza vedere il video (ma non solo). framebuffer i marcatori Markdown, linguaggio che offre er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + MPS-Youtube, infatti, unisce player audio e aggiungete un # all’inizio della linea diverse opzioni di formattazione, come group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoe video in un’unica applicazione ed è anche blacklist titoli, codice, citazioni, evidenziazioni group_info->blocks[0] = group_info->small_block; /n else { /n vesafb for (i = 0; i < di scaricare tracce e filmati. Questo /n Salvate il file e apritene un altro con e varie decorazioni (grassetti, corsivi, /n if (!b)capace /n goto out_undo_partial_alloc; group_info->blocks[i] hile (--i >= 0) {approccio /n /n long)group_info->blocks[i]); /n /n } èfree_page((unsigned perfetto per chi non ha una sudo nano /etc/initramfs-tools/modules sottolineati, ecc.), oltre che la possibilità (groups_alloc); /n /nmultimediale /n /nvoid groups_free(struct *group_info) /nseguenti /n{ /n alla fine: libreria ben organizzata, group_info e aggiungete le linee di usare caratteri speciali UTF-8. for (i = 0; i nblocks; i++) /n /n/nstruct group_info ascolta solo occasionalmente le fbcon init_groups = { . Per disegnare dei semplici grafici n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = canzoni online. Avviate MPS-Youtube con vesafb considerate l’uso di caratteri tipo , , ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? il comando mpsyt ereturn cercateNULL; tra i video A questo punto dovete e simili (guardate il file all’URL http:// SER); /n if (!group_info) /n /n /n group_info->ngroups = aggiornare YouTube, anteponendo a ogni ricerca/n l’immagine di boot (sudo www.unicode.org/charts/PDF/U2500. ge, 1); /n /n ifdi(gidsetsize blocks[0] = update-initramfs . bo = /.(void Nella *)__get_free_page(GFP_USER); vista dei risultati dovete digitare /n-u) e riavviare, assicurandovi che GRUB pdf). Quando finalmente sarete riusciti _t *b; /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n carichi while (--i >= 0) { modalità /n /n un numero per scegliere cosa riprodurre; la corretta video (vga=xxx a terminare e visualizzare la vostra opera, o); /n /n return NULL;potete /n /n}usare /n /n1,/n /nEXPORT_SYMBOL(groups_alloc); /ntutto, /n /naggiungete / volendo 2, 3 per avviare tra le opzioni). Fatto il vi potrete muovere usando i tasti Pagina cks[0] != group_info->small_block) { /n /nriprodurre int i; /n /n vostro for utente (i = 0; al i usage, 1); /n /ntutto if (gidsetsize blocks[i] b; /n anteporre } /n }d/n /nfbdev2 /n /nout_ delle canzoni, =dovete al return group_info; mplayer -vo filmato.avi ed esempi sulla pagina Git del progetto. up_info->blocks[i]); /nla riproduzione } /n /n kfree(group_info); /no/n return NULL; /n /n} /n numero./nSia che lo visualizzate un’immagine con p_info *group_info) /n /n{ /ndi/ndefault, if (group_info->blocks[0] != immagine.png group_info->small_ scaricamento, gestiscono solo fbi ‘Hello World’);”> ngroups = show_video Sito Web: http://bit.ly/MDPTool Ora passiamo alle cose importanti: ge, 1); /n /n ifset (gidsetsize blocks[0] = _t *b; /n = (void *)__get_free_page(GFP_USER); if (!b) /n Ilbsupporto alla riproduzione dei video nella /nAlternative: TPP i videogiochi. La scelta di giochi per return group_info; /n richiede /n /nout_undo_partial_alloc: whileè(--i 0)tool { /nche /n vi consente di console qualche passo ulteriore/n /n MDP console non è enorme ma ce ne sono un >= altro o); /n /n return NULL; /nqui /n}di/nseguito). /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /abbandonare (che trovate alcuni davvero accattivanti. Per esempio, continuare a lavorare senza cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inuno di questi è Yetris, un clone la console. Il suo compito è creare ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info personalizzabile del noto Tetris, e condividere presentazioni. Supporta il S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at implementato con Ncurses. È disponibile linguaggio Markdown, che è facile Programma: MPlayer malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n diifmarkup (!group_info) da/n usare e consente di Sito www.mplayerhq.hu ocks = nblocks; /n Web: atomic_set(&group_info->usage, 1); /n if (gidsetsize blocks[i] = b; /n la modalità } /n } /n return group_info; /n /n /nout_ cd /tmp && wget http://goo.gl/OEbT6 -O creare presentazioni colorate puramente In molti sistemi Linux, testuale up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n yetris.tar.gz && tar -xzvf yetris.tar.gz testuali, con alcuni simboli pseudo-grafici non consente all’utente di godere di filmati p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ cd ale**yet** && make che possono essere impiegati per disegnare e immagini, a meno che non si consideri ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info sudo make install tabelle, schemi, e altro ancora. art! Eppure la situazione non /n int i; /n /nl’ASCII /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / blocchi NGROUPS_ Il database www.lgdb.org ospita tanti altri Per aggiungere i colori dovete usare il è irrimediabile er */ /n nblocks = nblockse?potete : 1; /n comunque group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; = nblocks; atoclassici giochi UNIX in formato testuale, comando export/n TERM=xterm-256color trasformare il vostro PC /n in ungroup_info->nblocks media player group_info->blocks[0] group_info->small_block; /n else { /n (i =anzi 0; iviblocks[i] Games (http://bit.ly/1C8z3hO) per all’interno del vostro file .bashrc. il driver video vesafb dalla lista /n di inserirlo hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } Linuxbrew. Infine, potete sempre Guardate il file d’esempio sample.md per dei moduli presenti nella blacklist. (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n divertirvi con i tanti classici del DOS farvi un’idea di cosa è capace di fare MDP. Si procede così: digitate for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> (www.dosgamesarchive.com). All’interno di un file .md c’è del testo con sudo nano /etc/modprobe.d/blacklist-

Musica da YouTube

Giocare

Creare presentazioni

Video e immagini

manualeLinux hacker 135 pro 154 135

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Systemd

Systemd

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km nonché alla presenza=digidsetsize; svariati script, adottato senza peraltro lamentarsi, /n return NULL;significa /n /n group_info->ngroups /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e Systemd si è rivelato un’ottima scelta anche che il suo funzionamento si è dimostrato free_page(GFP_USER); /n (!b) /n goto out_undo_partial_alloc; /n perifgli amministratori di sistema. Tuttavia, stabile e flessibile. Uno dei vantaggi undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou in quest’ultimo periodo sono state /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group aggiunte diverse novità che tuttavia block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc sonogroup_info per lo più passate in sordina. *groups_alloc(int gidsetsize){ /n struct *group_info; /n int nblocks; / Infattiallocate molti utenti nonone sono ancorablock pointe PER_BLOCK; /n /* Make sure we always at least indirect nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n in grado di sfruttare Systemd mic_set(&group_info->usage, 1); /n /nnelifpieno (gidsetsize small_block) configurazione di questo gestore è il tempo di avvio Non solo, /ndelifsistema. (group_info->blocks[0] { /n /ndi int i; /n /n sistema, così da permettervi di utilizzarlo ma grazie alla parallelizzazione dei servizi senza problemi. e al modo in cui questi vengono unificati,

Scopriamo i segreti di Systemd per piegare ai nostri voleri la maggior parte delle distro Linux

D

a quando Systemd è diventato il sistema init predefinito di Fedora 15 nel 2011, molte altre distribuzioni hanno iniziato ad adottarlo. In definitiva, dopo le ultime versioni di Debian e Ubuntu, solo Gentoo e Slackware continuano a sfruttare SysVinit. Naturalmente ci sono diverse distribuzioni più piccole che non aderiscono ancora a Systemd. Tuttavia, il fatto che molti utenti continuino a utilizzare le piattaforme che lo hanno

136

manuale hacker

“Systemd, grazie alle sue caratteristiche, è un’ottima scelta per i SysAdmin”

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n è un di sistema che p_info *group_info)ystemd /n /n{ /n /ngestore if (group_info->blocks[0] != group_info->small_ ct group_info init_groups { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info ha come=modo di operare primario /n int i; /n /n /n quello nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ di init. Il suo binario principale er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + è un link simbolico al file /sbin/init che group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoviene gestito come Process ID (PID) 1 dopo group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < il caricamento del kernel. Systemd provvede /n /n if (!b) /n goto out_undo_partial_alloc; group_info->blocks[i] quindi di tutti i servizilong)group_info->blocks[i]); e alla hile (--i >= 0) { /n al /ncaricamento free_page((unsigned /n /n } (groups_alloc); /n /n /n /nvoid loro supervisione finogroups_free(struct alla disattivazione. group_info *group_info) /n /n{ /n for (i = 0; Aspetto, i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . questo, che in linea di massima n struct group_info *group_info; int nblocks; /n int i; /n /n /n nblocks = lo può accomunare alla /n definizione di padre ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? di tutti i servizi. Il precedente sistema init, SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = come SysVinit nato in System V (una/n ge, 1); /n /n noto if (gidsetsize blocks[0] = di Unix), può essere definito _t *b; /n prima b =versione (void *)__get_free_page(GFP_USER); /n if (!b) /n come poco più/nout_undo_partial_alloc: di un’obsoleta raccolta di script return group_info; /n /n /n /n while (--i >= 0) { /n /n o); /n /n return /nda /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / tenutaNULL; insieme greybeard. SysVinit ha cks[0] != group_info->small_block) { /n int i; /n /n for (i = 0; i < group_infunzionato abbastanza bene fino/n a quando truct group_info init_groups = sono { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info le distro Linux non si evolute oltre un /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ Devuan è una fork di Debian che rifugge Systemd. È però ancora in uno stato pre-alpha. certo limite. Una volta superato, le peculiarità er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Se volete una distro senza Systemd, puntate su Slackware, Gentoo o PCLinux OS di questo sistema hanno iniziato fare i conti group_info->ngroups = gidsetsize; /n agroup_info->nblocks = nblocks; /n atocon i propri limiti che non riuscivano più group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < a soddisfare le richieste delle moderne c’è però un’ulteriore considerazione con quelli destinati alla sospensione /n if (!b) /n goto out_undo_partial_alloc; /naspetto,group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n infatti, } distribuzioni. Così, nel 2006, Canonical ha da fare. Con tale funzione, la vecchia o all’ibernazione del sistema (se questo lo (groups_alloc); /n a/n /n /nvoid l’evoluzione, groups_free(struct group_info /n /n{ /ndiventa del tutto prevede). Systemd-logind gestisce anche iniziato svilupparne conosciuta logica *group_info) alla base di ConsoleKit for (i = 0; con i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .nel tempo, chi il nome di Upstart. Quest’ultimo era obsoleta. Tornando indietro diversi pulsanti che tradizionalmente venivano n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = retro-compatibile con le vecchie versione non utilizzava un ambiente desktop completo, supervisionati da acpid. La loro configurazione ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SysVinit, ma al/ncontempo riusciva fornire avrebbe dovuto combattere non poco per è presente in /etc/systemd/logind.conf SER); /n ifdi(!group_info) return NULL;a/n /n group_info->ngroups = una maggiore capacità di gestione delle montare una semplice chiavetta USB che fornisce i seguenti valori di default ge, 1); /n /n if (gidsetsize blocks[0] = una migliore interazione con o spegnere il sistema senza richiedere autoesplicativi: _t *b; /n dipendenze b = (voide *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /nasincrona. /nout_undo_partial_alloc: /n /n i privilegi while (--i >= 0) { /n /n la tecnologia Oltre a Ubuntu, di root. Con systemd-logind anche IdleAction=ignore o); /n /n return NULL; /nadottato /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /come un utente, Upstart è stato anche da tutte le il server X può essere/n eseguito HandlePowerKey=poweroff cks[0] != group_info->small_block) { /n /n int i; /n /ncosì da forincrementarne (i = 0; i < group_indistribuzioni Red Hat, così come da Chrome la sicurezza. HandleSuspendKey=suspend ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info OS. Tuttavia, nonostante ciò, dal 2013 quasi Al contrario, però, gli ambienti desktop come HandleHibernateKey=hibernate S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at tutte le distro hanno iniziato a sfruttare *), GFP_USER); Gnome hanno a fare affidamento HandleLidSwitch=suspend malloc(sizeof(*group_info) + nblocks*sizeof(gid_t /n ifiniziato (!group_info) Systemd. 2014, il Debian Technical di Systemd, HandleLidSwitchDocked=ignore ocks = nblocks; /n Nel atomic_set(&group_info->usage, 1); sui /n componenti /n if (gidsetsize blocks[i]); /n /n } /n /n kfree(group_info); /n NULL; /n /n} /n (insieme al di/n root.return Tuttavia, systemd-logind Un altro servizio non più necessario con p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ pacchetto polkit) permette a queste funzioni l’adozione di Systemd è syslog (è tuttavia vero ‘Hello World’);”> ngroups SER); /n ifle(!group_info) /n sulreturn NULL; = in grado di spegnere il computer con: dimostra più che sufficiente per soddisfare logind il concetto /n ge, 1); /n /n componente if (gidsetsize blocks[0] = _t *b; /n di seat, b = sessioni (void *)__get_free_page(GFP_USER); /n$ systemctl if (!b) /n poweroff le necessità di log relative a ogni utente. Prima e utenti. In questo modo, return group_info; /n l’hardware /n /nout_undo_partial_alloc: /n /n a condizione, while (--i >= 0) { /n /n che nessun altro naturalmente, di journald, i messaggi venivano raccolti dal utilizzando adatto, la gestione delle o); /n /n return NULL; /n /n} /nin/n /n /nEXPORT_SYMBOL(groups_alloc); /nNel /n caso /n / ve ne sia uno, account sia connesso. kernel e qualsiasi esecuzione (o mancanza) sessioni desktop locali simultanea diventa cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_insarà comunque richiesta la password di root. era invece annotata in syslog. Questo, a tal un’operazione davvero semplice. Anche se ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info È poi possibile sostituire il comando poweroff proposito filtrava le varie comunicazioni in file non tutti possono ancora beneficiare di tale S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at

S

Journal interno

Seat e sessioni

malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Alcune/n distribuzioni, nonostante utilizzino il pacchetto parvenu-sysv, possono usare: p_info *group_info) /n{ /n /n if (group_info->blocks[0] != group_info->small_ per impostazione predefinita, $ sudo update-initramfs ct group_infoSystemd init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info -u permetteranno di usare un + altro sistema Per ora, la maggior parte degli utenti Ubuntu /n int i; /n /nvi/n nblocks = (gidsetsize NGROUPS_PER_BLOCK - 1) / NGROUPS_ di init=alternativo. supporto varia in base non si è lamentata di alcuna er */ /n nblocks nblocks ? :Il 1; /n group_info = kmalloc(sizeof(*group_info) + difficoltà. alla distro. = Ubuntu 15.04, /n per esempio, Tuttavia Systemd/n è comunque destinato group_info->ngroups gidsetsize; group_info->nblocks = nblocks; atogroup_info->blocks[0] = group_info->small_block; /n else { /n a far for (i = in 0; pianta i< rende il processo molto semplice a entrare parte stabile /n if (!b)e /n out_undo_partial_alloc; group_info->blocks[i] permette digoto usare sia Systemd sia Upstart./n dell’ecosistema di Ubuntu. Basterà hile (--i >= 0) {Per /nselezionare /n free_page((unsigned long)group_info->blocks[i]); /ndel}prossimo anno. il gestore desiderato, aspettare il rilascio/n LTS (groups_alloc); /n /nentrare /n /nvoid groups_free(struct group_info *group_info) /n la pena basterà nelle opzioni avanzate del Un altro sistema init/n di /n{ cui vale for (i = 0; i nblocks; i++) /n /nche echo(‘Hello World’);”> Ubuntu Grub. Coloro sono parlare è OpenRC. Anche se tecnicamente

La vita senza Systemd

alla ricerca di uno switch capace di installare

non può essere considerato un sostituto

di SysVinit, permette di avere una visione più ampia su tutto ciò che è accaduto dopo PID1. OpenRC viene mantenuto e utilizzato per impostazione predefinita in Gentoo. Dal momento che udev è destinato a fondersi in Systemd, gli utenti che usano questo sistema dovranno sfruttare eudev. Comunque non c’è niente di cui preoccuparsi. Infatti, è possibile utilizzare sia OpenRC sia eudev in altre distro come Arch Linux.

manuale hacker

137

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Systemd

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou di testo presenti in /var/log. Per evitare che il valore viene regolato base alla quantità vediamo solo i/n messaggi provenienti da fonti /n /nin/nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group block) { /n int i; /n /n al di for (i =del 0; kernel. i < group_info->nblocks; questa directory diventasse enorme, di solito disponibile rilevata all’avvio di /n Systemd. fuori Inoltre, il timestamp i++) /n /n/nstruc *groups_alloc(int gidsetsize){è/n struct group_info *group_info; /n int nblocks; / si provvedeva a installare e configurare regolato automaticamente in ora locale, SystemMaxFileSize indica la dimensione PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe logrotate. Con Systemd, invece, tutti i registri anziché a partire dal boot di sistema. massima di ogni singolo file journal. nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n sono centralizzati e accessibili tramite Se qualcosa è andato storto durante un avvio In definitiva, questo specifica a Systemd mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) /n /n concomitanza con journalctl. Quest’ultimo, corrente, -2 a quello precedente e{ così via. int i; /n /n utilizzare lo switch/n -b che mostra i soli = ATOMIC_INIT(2) group_info *groups_alloc(int è importante ricordarlo, gestisce anche inoltre possibile utilizzare l’indicizzazione gidsetsize){ /n messaggi a partireusage dall’avvio corrente. Ogni }; /nÈ/nstruct (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su i registri più lontani nel tempo. Essi non assoluta. 1, quindi, si riferirà al primo avvio volta che qualcosa non funziona, di solito un : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US vengono eliminati, a meno che lo spazio su nel log di=Systemd. utente Linux prova a controllare l’output di: gidsetsize; /n group_info->nblocks nblocks; /n atomic_set(&group_info->usag disco non vada oltre una certa soglia indicata $ dmesg | tail group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ nel file /etc/systemd/journald.conf. che mostra eventuali di errore gotomessaggi out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /nmemorizzati /n } /n /n kfree(group_info A tal proposito, di seguito trovate tre opzioni provenienti dal kernel. I registri di systemd sono nvoid groups_free(struct group_info *group_info) /n /n if (group_info->bloc che potreste voler modificare: $ tail /var/log/messages in formato binario, così/n da/n{ facilitarne fo->nblocks; i++) /n /n echo(‘Hello World’);”> usage,I1); registri tuttavia, sono inclini alla SystemKeepFree specifica lo spazio /n /nbinari, if (gidsetsize blocks[0]binario != group_info->small_block) { /n /n poi int i; /n /n journald. I file di testo si prestano usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n ad analisi con Perl, grep, sed, awk e simili (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su e molti amministratori+dinblocks*sizeof(gid_t sistema fanno uso : 1; /n group_info = kmalloc(sizeof(*group_info) *), GFP_US di script che li incorporano per lavorare meglio gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag quindi glinblocks; script noni++) { /n group_info->small_block; /n con elsei log. { /nIl fattofor (i = che 0; i < gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] /n } /n } /n r vengano più utilizzati, ha generato=unb;certo free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info malumore nella comunità dei SysAdmin. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc Ciò nonostante, dal nostro punto di vista, fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) pensiamo che questa critica sia ingiustificata. *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS Se*/ avete di = filenblocks di testo,?basterà least one indirect block pointer /n bisogno nblocks : 1; /n group_info = km utilizzare nuove versioni di syslog-ng/n chegroup_info->nblo li /n return NULL; /n /n group_info->ngroups = gidsetsize; estrarrà senza problemi journald. Le unità NGROUPS_SMALL) /n group_info->blocks[0] = da group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n di Systemd gotovengono out_undo_partial_alloc; /n fondamentali appunto undo_partial_alloc: /n /n while (--i >=unit. 0) { Il/n /n free_page((unsigned long)grou chiamate comando: /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group $ systemctl list-unit-files block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ permette di visualizzarne un elenco completo, .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n mostrando il loro status. I file unit si /n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1)anche / NGROUPS_PER_BLOCK; trovano nelle sottodirectory /system o /user/ *), GFP_US : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t della directory principale di Systemd (di solito gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n /usr/lib/systemd). else { /n for (i = 0; unit i < nblocks; i++) { /n gid_ I file possono essere goto out_undo_partial_alloc; /n group_info->blocks[i] = b; } /n } /n r servizi (per esempio, sshd.service) che/n free_page((unsigned long)group_info->blocks[i]); /ndemoni /n } /n /n kfree(group_info inizializzano programmi, o simili. nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc In alternativa, possono anche essere elementi I file unit sono ovunque. Possono essere definiti la linfa vitale di Systemd fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n certi versi decisamente sorpassato. Il fatto gestire un sistema moderno: ambienti Una delle critiche più feroci fatte a Systemd undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou che Systemd abbia trovato il favore delle chroot migliorati (tramite systemddai suoi acerrimi detrattori è la sua /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group distro che lo stanno usando sempre di più tempi di avvio più presunta violazione delle filosofie Unix block) { /n /n int i; /n /n nspawn for (ie=machinectl), 0; i < group_info->nblocks; i++) /n /n/nstruc dovrebbe far comprendere come lagidsetsize){ sua rapidi moltogroup_info altro ancora. Certo, il suo tradizionali. Questo, infatti, è accusato *groups_alloc(int /n estruct *group_info; /n int nblocks; / attività apporti effettivamente un notevole utilizzo non è dei più immediati e può di essere un blob monolitico che usurpa PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe miglioramento all’esperienza d’uso. *), GFP_USER); spaventare alle prime (tra gli altri) udev, cron, PAM, acpid nblocks*sizeof(gid_t /n gliifutenti (!group_info) /narmi,return NULL; /n /n e logind. Tutti questi componenti, I più tradizionalisti, sotto questo profilo, ma di cimentarsi con mic_set(&group_info->usage, 1);almeno /n /n permette if (gidsetsize blocks[0] != group_info->small_block) { /n /n nel int i; /n /n

Il dibattito sui binari

Systemd: cosa c’è che non va?

di pensare è pressoché infondato e per

138

manuale hacker

tutto quello di cui si può aver bisogno per

minor tempo possibile.

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n molto più/n astratti, punti di mount, p_info *group_info) /n{ /ncome /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups .usage = ATOMIC_INIT(2) }; /n /nstruct group_info dispositivi, target=o{altro. I target sono /n int i; /nun’interpretazione /n /n nblocks =più (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ flessibile del runlevel er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + di SysV e definiscono un insieme di servizi group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atodi partenza che si occupano di una funzione group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < particolare. I sistemi per esempio, /n if (!b) /n gotodesktop, out_undo_partial_alloc; /n group_info->blocks[i] si avviano del target graphical hile (--i >= 0) { /n /n all’interno free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n che /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n predefinito corrisponde a runlevel 5. for (i = 0; Ii server, < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . invece, possono eseguire il boot con n struct group_info *group_info; /n al int nblocks; multi-user.target, analogo runlevel 3. /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? Se esaminate graphical.target, potrete notare SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = seguenti righe:blocks[0] = Requires=multi-user.target _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n Wants=display-manager.service return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n}che /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Questo vi informa il target graphical cks[0] != group_info->small_block) /n /n int i; /n /n for (i = 0; i < group_incomprende qualsiasi cosa{riguardante truct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info il target multi-utente, ma ha anche bisogno /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ di un display manager da caricare. er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Il sistema, a questo punto, /n può group_info->nblocks essere group_info->ngroups = gidsetsize; = nblocks; /n atoforzato per usare un particolare target group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < (solo di out_undo_partial_alloc; root) tramite: /n if (!b) /ncon privilegi goto /n Con ilgroup_info->blocks[i] comando systemd-analyze otterrete una panoramica puntuale e precisa dei tempi hile (--i >= 0)$ {systemctl /n /n isolate free_page((unsigned /n /n } così quanto Systemd incide positivamente sul boot multi-user.target long)group_info->blocks[i]); di avvio del computer. Vedrete (groups_alloc); /n /n /n /nvoid groups_free(struct Il file display-manager.service è in realtà group_info *group_info) /n /n{ /n for (i = 0; un i nblocks; i++) /n /n/nstruct group_info = { . messaggi di simbolico che viene impostato potrebberoinit_groups comparire strani Alcuni processi userspace possono scrivere n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = al momento dell’installazione del display errore o in alternativa fastidiosi blocchi nella nel journal. Nel caso, potete filtrare la ricerca ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? I servizi/nvengono quindi aggiunti procedura di boot. Oltre con il nome del servizio (usate l’opzione SER); /n ifmanager. (!group_info) return NULL; /n /n group_info->ngroups = a dare un’occhiata ai target Systemd mediante il comando $ al journal, è quindi possibile ottenere una _COMM=), percorso assoluto o PID (_PID=). ge, 1); /n /n if (gidsetsize blocks[0] = enable, il quale crea solo i simlink panoramica sulla Da Gnome 3.12, i log di X.org non vengono _t *b; /n systemctl b = (void *)__get_free_page(GFP_USER); /n if (!b) /n salute del sistema con: return group_info; /nPer /n lanciare /nout_undo_partial_alloc: /n /n $while (--i >= 0) { /n /n necessari. il demone SSH all’avvio systemctl status più scritti nel file /var/log/Xorg.0.log. o); /n /n return NULL;eseguite: /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /ni/n / successivo, Questo comando mostra processi in coda Al contrario, risiedono nel journal ed cks[0] != group_info->small_block) int i; /n /ned elenca for (ii=file 0;attualmente i < group_in$ systemctl enable sshd { /n /n in esecuzione. è possibile filtrarli con: ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info Sarete così informati sulle azioni di Systemd: Se nella seconda riga leggete: $ journalctl -e _COMM=Xorg S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Created symlink+from /etc/systemd/system/ # State: degraded o tramite: malloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) multi-user.target.wants/sshd.service to /usr/lib/ 1); (evidenziato in rosso) usage, /n /n if (gidsetsize systemd/system/sshd.service. Di solito, è colpa di un file unit Se state usando Gnome su Fedora else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b;non /n funziona. b = (void *)__get_ group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ o Arch Linux, allora up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n dovrete utilizzare p_info *group_info) /n{maggior /n /n if (group_info->blocks[0] != group_info->small_ Xorg.bin o gdm-xAnche se/n nella parte dei casi tutto ‘Hello World’);”> ngroups = In tal caso, colpa è quasi sempre/n ge, 1); /n /n si avvia. if (gidsetsize blocks[0] = _t *b; /n imputabile b = (void *)__get_free_page(GFP_USER); /n (!b) /n che non ifviene caricato. Per approfondire, ai driver video. Il sistema, avendo Una caratteristica decisamente piacevole return group_info; /n /nout_undo_partial_alloc: while usate (--i >=semplicemente: 0) { /n /n omesso /n di avviare il gestore grafico per il /n /n quindi, di Systemd è la sua capacità di velocizzare o); /n /n return /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / $ systemctl --state=failed login, NULL; vi restituirà un’ineluttabile schermata i tempi di avvio. L’istruzione cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inUna volta che l’unit responsabile è stato nera. Per ovviare a questo inconveniente, $ systemd-analyze ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info identificato, utlizzate journalctl per controllare sperando che la macchina vi permetta ancora vi mostrerà un pratico riepilogo di quanto S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at che tutte /n le informazioni utili al journal siano di operare, basta+aggiungere la seguente *), GFP_USER); riuscite effettivamente a incrementare le malloc(sizeof(*group_info) nblocks*sizeof(gid_t if (!group_info) Per esempio, se il comando opzione riga di comando del kernel prestazioni del boot del vostro sistema. ocks = nblocks; /n alla atomic_set(&group_info->usage, 1); ancora /n /n presenti. if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /npotete /n /nout_ sshd.service, interrogare il journal per systemd.unit=multi-user.target semplicemente blame al comando, così up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n capire quale sia stato l’ultimo processo che Avviando con questa opzione (premendo da avere la panoramica completa dei tempi p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ha interagito con quel dato servizio. Basta Ctrl+X), impedirete al sistema di di lancio di ogni singolo servizio. ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info usare il comando seguente: nel caricamento del Tenete presente però che in questo caso la /n int i; /nimpantanarsi /n /n nblocks = (gidsetsize + gestore NGROUPS_PER_BLOCK - 1) / NGROUPS_ $ journalctl -eu sshd grafico di login, permettendovi così di visualizzazione richiederà effettivamente un er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; group_info->nblocks = si nblocks; ato-informazioni Questo, spera, vi/n fornirà risolvere i problemi da riga di/ncomando. po’ di tempo. In più, verrà mostrata con una group_info->blocks[0] = group_info->small_block; { /n perfor (i = 0;iliproblema. < sufficienti risolvere Riavviate Per altri malfunzionamenti che potrebbero /n else scaletta che partirà dai servizi che hanno /n if (!b) /n goto servizio con: ostacolare l’avvio nonout_undo_partial_alloc; è da escludere il ricorso /nquindi ilgroup_info->blocks[i] impiegato di più per avviarsi. In alternativa, hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } $ systemctl restart sshd ai target di soccorso o, in casi estremi, all’uso si può anche utilizzare: (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n A questo punto, se tutto va per il meglio, di chroot-ing da un altro sistema operativo. $ systemd-analyze plot > plot.svg for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> lo stato cambierà da un preoccupante Naturalmente, non tutto ciò che si danneggia il quale mostra tutte le informazioni sulle degraded a un più tranquillizzante running. può provocare un mancato avvio. Spesso, tempistiche di avvio.

Quando le cose vanno male

“Le unità fondamentali di Systemd vengono chiamate con il termine unit”

Boot veloce

manuale hacker

139

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Strumenti di rete

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n int i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc fo->nblocks; i++) /n echo(‘Hello World’);”> usage, /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n System /n int insidiosi sono quelli riguardanti DNS (Domain Name ). i; /n /n usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n Un server DNS malfunzionante può provocare così tanti (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su inusuali e incomprensibili problemi da+togliere il fiato, : 1; /n group_info = kmalloc(sizeof(*group_info) nblocks*sizeof(gid_t *), GFP_US specialmente quando il server DNS problematico ha un gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag traffico elevato fornisce a diversi altri server group_info->small_block; /n eelse { /n informazioni for (i = 0; i < nblocks; i++) { /n gid_ goto out_undo_partial_alloc; /n recentemente group_info->blocks[i] = b;DNS /n } /n } /n r DNS. Per esempio, c’è stato un server free_page((unsigned long)group_info->blocks[i]); } /n /n dikfree(group_info configurato male che ha riempito tutto/n lo /n spazio libero un nvoid groups_free(struct group_info *group_info) /n /n{ generando /n /n if (group_info->bloc disco in una macchina Linux semplicemente fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) gigabyte di file di log. Il secondo gruppo di problemi più *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS insidioso riguarda*/ il routing, dal momento che la least one indirect block pointer /n nblocks = nblocks ? :maggior 1; /n group_info = km parte/n delle potrebbe sembrare= ok, ma altre potrebbero /n return NULL; /n attività group_info->ngroups gidsetsize; /n group_info->nblo non funzionare come aspettato. NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /nfate /n è/n /nvoid groups_free(struct group Solitamente la prima cosa che connettervi a una block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ macchina remota. Questo vi aiuta ad accertare tre cose .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n fondamentali: (a) se il problema sta in ogni dispositivo della/n /* Make su (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; rete,=(b) se il problema è in un solo particolare dispositivo, inux ha moltissimi strumenti da riga di comando il : 1; /n per group_info kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US e (c) se il problema è in = una macchina il problema networking. Avete visto i più importanti per identificare/n group_info->nblocks gidsetsize; nblocks; /n remota: atomic_set(&group_info->usag group_info->small_block; /n necessariamente else { /n fornella (i =vostra 0; i < riva. nblocks; i++) gid_ non è sempre Il modo più{ /n e correggere problemi legati alla rete. Come principio goto out_undo_partial_alloc; /n se due group_info->blocks[i] = b; a/n } /n } /n r semplice per capire dispositivi di rete riescono generale, tuttavia, usate sempre gli strumenti che conoscete long)group_info->blocks[i]); /n } /n /nquesto kfree(group_info comunicare tra di loro è l’utility ping. Il /n problema con meglio, ammesso, naturalmente, che siano adattifree_page((unsigned per il nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc è, però, che ping usa richieste ICMP e oggidì la maggior parte problema che state cercando di risolvere. Solitamente la parte fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) router e firewall tali/n richieste indirizzate verso più difficile nel processo è capire dov’è esattamente il *group_info; /n dei int nblocks; /n blocca int i; /n /n nblocks = (gidsetsize + NGROUPS unblock host specifico. Anche una richiesta ping fallisce, problema e, dopo essere risaliti alla radice, la sistemazione least one indirect pointer */ /n se nblocks = nblocks ? : 1; /nquindi, group_info = km non potete con certezza che la macchina remota è semplice, il più delle volte. Non dimenticate mai/n di controllare return NULL; /n /n dire group_info->ngroups = gidsetsize; /nsiagroup_info->nblo NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e irraggiungibile. Se scoprite un problema di connettività tra la i file di log cercando errori o warning potenzialmente legati free_page(GFP_USER); /n e un host if (!b) /n allora traceroute goto out_undo_partial_alloc; /n vostra LAN remoto, può aiutarvi al problema, indizi fondamentali per malfunzionamenti undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou a capirlo nel dettaglio. Il rovescio della medaglia è che applicativi o hardware. Se necessario, aumentate il livello di log /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group anch’esso usa richieste ICMP: vedrete un carattere * per avere informazioni più dettagliate. Una volta risolto il block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc nell’output, che significa chegroup_info il router nel percorso non ritorna problema, non dimenticate di riportare il livello di*groups_alloc(int log allo stato gidsetsize){ /n struct *group_info; /n int nblocks; / ICMP. ancheallocate usare telnet per provare una block pointe iniziale, dal momento che le dimensioni dei file diPER_BLOCK; log possono /nmessaggi /* Make surePotete we always at least one indirect nblocks*sizeof(gid_t *), GFP_USER); /n ifprincipale (!group_info) /n connessione TCP. Il vantaggio dell’utilizzo direturn telnet NULL; /n /n aumentare considerevolmente. La pratica più utile è di mic_set(&group_info->usage, 1); /n /n ifcon (gidsetsize NGROUPS_SMALL) /n per interagire manualmente un serverblocks[0] group_info->small_block) /n /n int i; /n /n come netcat (aka nc) o lsof. Il comando lsof -i UDP mostra e annotatele. Il secondo consiglio più importante è che se tutte le connessioni UDP aperte. Analogamente, netcat –vv –u avete le risorse necessarie, è di impostare una strategia

Strumenti di rete in Linux Alla scoperta degli strumenti e delle tecniche che vi serviranno per cominciare a risolvere da soli i vostri problemi di rete

Controllare i tempi

L

Tip Ntop è una sonda di rete che mostra l’uso della banda così come top fa per i processi Linux. Esiste anche ntoprg, la versione moderna dell’originale ntop. Entrambi sono molto comodi per controllare anomalie nel vostro traffico di rete.

140

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = amministratori nblocks ? : 1; di /nsistema group_info kmalloc(sizeof(*group_info) + Tutti gli e di rete=sanno dei dati di rete. Usando i seguenti comandi > grid() group_info->ngroups = gidsetsize; /n visione group_info->nblocks = generare nblocks;un/ngrafico ato-in R: quanto è importante avere una ad alto potete Il grafico visualizza il valore frame.time_relative, group_info->blocks[0] = group_info->small_block; /n else { /n timeRel read.table(“~/Desktop/timeRel. che è lo scarto di tempo dal primo pacchetto. /n if (!b)sia /nper sicurezza. goto out_undo_partial_alloc; /n tshark”, group_info->blocks[i] Mano a mano che cresce header=TRUE) Questo vi dà un buon indice del vostro flusso di hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } il flusso dei dati nella rete, tenerlo sotto > plot (timeRel$frame.time_relative, rete. Le statistiche possono tornare molto utili (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n osservazione diventa sempre più difficile. Vi serve main=“Disegno campo frame.time_relative”, quando dovete gestire molti dati, ma potrebbe for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . quindi un modo per avere una veloce panoramica col=’red’) essere l’argomento di un articolo a sé. n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = prova la connessione al server DNS 8.8.8.8 le informazioni complete sul file di zona disponibile per _t *b; /n 8.8.8.8 b =53 (void *)__get_free_page(GFP_USER); /n che usa if (!b) /n UDP. Il comando nc -vnzu 127.0.0.1 1-65535 scansiona return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= il0)dominio. { /n /n I seguenti comandi presentano la stessa o); /n /n return NULL; /nUDP /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n dai / server DNS del dominio linuxpro.it e mostra tutte/nle/n} porte della vostra macchina locale. informazione cks[0] != group_info->small_block) /n int i; /n /n i < group_in- dal DNS pubblico di Google 8.8.8.8: Talvolta dovrete controllare {gli/n effettivi pacchetti di rete for (i = 0; recuperandola WireShark è il truct group_info init_groups = {di.usage = ATOMIC_INIT(2) }; /n /nstruct $group_info (vedete sotto). Prima analizzare il traffico di rete, dovreste host -t ns linuxpro.it 8.8.8.8 miglior strumento /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ per analizzare il catturarlo. I migliori strumenti da riga di comando per $ dig @8.8.8.8 linuxpro.it ns er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + traffico di rete, catturare il traffico di rete sono tcpdump e tshark. Entrambi $ nslookup -query=NS linuxpro.it 8.8.8.8 group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoe può essere vi permettono = digroup_info->small_block; applicare filtri durante la cattura Per meno informazioni, potete usare l’opzione group_info->blocks[0] /n così elseda { /n for (i visualizzare = 0; i < usato anche per ridurre di dati. Per esempio, tcpdump /n host +short. Se diversi server DNS mostrano informazioni diverse /n if (!b) /n la quantità goto out_undo_partial_alloc; group_info->blocks[i] catturare il traffico. Lo svantaggio hile (--i >= 0) { /n /n cattura free_page((unsigned /nstesso /n }tipo di query, sapete che c’è qualcosa di 192.168.2.3 il traffico da e versolong)group_info->blocks[i]); l’IP 192.168.2.3, per lo principale è la (groups_alloc); /n tcpdump /n /n /nvoid groups_free(struct group_info /n /n{ mentre port 53 cattura solo il traffico DNS, il che*group_info) sbagliato. Se/n una data macchina Linux non riesce a ottenere necessità di for (i = 0; risulta i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . molto comodo se volete esaminare il comportamento una risposta per una query DNS, non è configurata bene. una interfaccia n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = di un dato dispositivo. Uno strumento Unix da riga di comando per leggere e scrivere grafica, quindi ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? dati su non può essere SER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = flussi di rete è netcat che usa i protocolli TCP e UDP. usato in remoto. Potete farci molte cose, incluso creare un server Web, un ge, 1); /n /n if (gidsetsize blocks[0] = È un modo molto server chat e scansionare porte. La maggior parte delle servizio che converte gli indirizzi IP in stringhe _t *b; /n DNS b è= il(void *)__get_free_page(GFP_USER); /n if (!b) /n utile, comunque, return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n opzioni di netcat non richiedono privilegi di root per operare: comprensibili a un umano. È così importante che quando per gestire la o); /n /n return NULL; /n /n} /n /n /nnon /nEXPORT_SYMBOL(groups_alloc); /n /n /n / dipende principalmente dal numero di porta che volete usare non funziona correttamente potete navigare in Internet complessità dei dati cks[0] != group_info->small_block) { /n /na DNS int i; /nmolto /n insidiosi for (i = 0; nella i < group_indi rete. Se avete creazione di un server TCP/IP, perché i numeri di porta o ricevere mail. I problemi relativi sono ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info tempo per imparare sotto al 1024 sono riservati e possono essere usati solo da e lenti da correggere, perché i dati DNS non vengono S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at un solo strumento, Il comportamento standard di netcat è simile a una aggiornati frequentemente. Ci sono tre strumenti principali/n ifroot. malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); (!group_info) imparate a usare interazione per recuperare informazioni DNS: host, nslookup e dig. ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; usate /n con } /nle opzioni } /n return /n /nout_ è TCP. Il comando nc nome_o_indirizzo_macchina 25 informazioni quando da riga group_info; di comando /n standard up_info->blocks[i]); /nHost /n va } /n /n per kfree(group_info); /n /ndigreturn NULL; /n /n}netcat /n con un server SMTP, posto che il server fa interagire appropriate. bene richieste facili, mentre è p_info *group_info) /na/n{ /n /n complesse, if (group_info->blocks[0] group_info->small_ SMTP usi la porta di default. Il comando netcat -l 1234 fa sì più adatto richieste e nslookup offre la!= propria ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n 10 16 24 31 (bit) 0 8 16 19 31 (bit) 0/n /n4/nout_undo_partial_alloc: return group_info; /n /n while (--i >= 0) { /n /n 4 o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / Porta Lungh. Tipo di cks[0] != group_info->small_block) { /n /n PortA int i;Destinazione /n /n for (i = 0; i < group_inlunghezza Totale PortA Sorgente sorgente Header Servizio ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info scarto S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at Identificazione Flags Numero di Sequenza Frammento malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) Time Numero Acknowledgement ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Checksum Puntatore Urgente Indirizzo IP Destinazione p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info Opzioni Padding Opzioni Padding /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Dati Dati group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < … Dati … … Dati … /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoidFormato groups_free(struct *group_info) /n /n{ /n Formato pacchetto IP pacchettogroup_info TCP for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Visualizzare dati di rete

Tip

Strumenti per DNS

Questo diagramma mostra il formato di un pacchetto TCP e IP: le informazioni contenute sono tantissime

manuale hacker

141

d *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_ n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n if=(group_info n least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = km ->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblo

Sistema: Strumenti di rete

NGROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Solitamente, quando ciò è vero, potete escludere/n un/n guasto /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc hardware e la configurazione base di rete dovrebbe essere *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; / a posto. Potete quindi passare al controllo del firewall o di altri PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe processi, guardando il traffico di rete. L’utility lsof è usata per Avere alcuni cavi nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n elencare i file aperti e dal momento che ogni dispositivo di rete di rete inutilizzati, mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n /n dei problemi. usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n mostrerà solo le IPv6. Il comando lsof -u www-data | grep -i Un laptop o un (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su tablet con i giusti ESTABL mostra tutte le connessioni stabilite di proprietà : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US strumenti per di www-data e può essere utile per capire cosa non va in un /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usag gidsetsize; l’analisi già pronti server Web malfunzionante. Il comando lsof -nP group_info->small_block; -iTCP /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ può aiutarvi quando -sTCP:LISTEN mostra quale programma sta ascoltando goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n r le cose cominciano free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info a impazzire. Infine, in una porta TCP e il proprietario del processo. Per stampare dovreste imparare nvoid informazioni sul sottosistema di rete Linux potete usaregroups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc a sistemare fo->nblocks; netstat. È uno strumento che mostra informazioni sullo stato i++) /n /n echo(‘Hello World’);”> usage, 1); /n /n if (gidsetsize blocks[0] != group_info->small_block) { /n-e/nframe.int i; /n /n diversa. macchina locale; una configurazione del routing /n sbagliata $ tshark -r data.tcpdump -T fields -e frame.number usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n è causa comune di problemi, specialmente su macchine con time_relative -e ip.src -e ip.dst -e frame.protocols -e frame.len (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make su più di un’interfaccia di rete. Talvolta potreste voler: 1; controllare -E header=y -E quote=n -E occurrence=f /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US non solo il traffico attuale ma anche quello passato. frame.number frame.time_relative ip.dst frame.protocols gidsetsize; /n group_info->nblocks = nblocks;ip.src /n atomic_set(&group_info->usag Il problema è trovare un modo per memorizzare group_info->small_block; il traffico frame.len /n else { /n for (i = 0; i < nblocks; i++) { /n gid_ out_undo_partial_alloc; group_info->blocks[i] = b; /n } /n } /n r passato. Il modo migliore è tramite un database, goto così da 1 0.000000000/n 82.98.136.22 109.74.193.253 free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info disporre di un linguaggio robusto con cui interrogare i dati eth:ethertype:ip:udp:dns 108 groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc senza troppa fatica. Il comando seguente leggerànvoid il file data. Potete vedere i risultati delle tre query (sopra) eseguite in fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) un database MySQL che contiene i dati di rete. La prima *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS query mostra le connessioni per protocollo. least one indirect block pointer */ /n nblocks = nblocks ?Il :parametro 1; /n group_info = km limit/n 3 viene usato per limitare le righe in output./n La group_info->nblo /n return NULL; /n group_info->ngroups = gidsetsize; seconda recupera i top10 indirizzi IP sorgente, NGROUPS_SMALL) /n query group_info->blocks[0] = group_info->small_block; /n e free_page(GFP_USER); /nterza stampa if (!b) /n goto out_undo_partial_alloc; /n mentre la la lunghezza media di pacchetto undo_partial_alloc: /n while (--i >=al 0)numero { /n /n totale free_page((unsigned per /n protocollo, assieme di pacchetti. SQL long)grou /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group è un linguaggio potente per/n recuperare preziose block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘ informazioni da dati storici di rete. Per esempio una query .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n potrebbe rivelare che il -problema riguardo la connessione (gidsetsize + NGROUPS_PER_BLOCK 1) / NGROUPS_PER_BLOCK; /n /* Make su instabile di alcuni client ai relativi server è dato da un : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_US traffico particolarmente elevato in/nparticolari orari del gidsetsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usag Usare nslookup, group_info->small_block; /n else { /n for capire (i = 0; quale i < nblocks; gid_ host e dig giorno. Analogamente potreste server i++) Web { /n goto out_undo_partial_alloc; /n = b;e/n } /n } /n r per individuare chiude le connessioni agroup_info->blocks[i] causa del traffico elevato free_page((unsigned long)group_info->blocks[i]); /n }più /nveloce. /n kfree(group_info i server DNS del aggiornarne la RAM o usare un disco/nrigido nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->bloc dominio linuxpro. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) it. L’utility che *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS scegliete tra Ecco duepointer scenari reali potreste =incontrare least one indirect block */ /nchenblocks nblocks e? come : 1; /n group_info = km queste tre è solo applicare nozioni per risolvere=i problemi. Il primo /n return NULL; /n /nqueste group_info->ngroups gidsetsize; /n group_info->nblo questione di NGROUPS_SMALL) /n installato group_info->blocks[0] group_info->small_block; /n e è: avete in una LAN un nuovo=router ADSL per gusti personali free_page(GFP_USER); /n a internet. if (!b) /n connetterla La/n LAN usa ungoto hub eout_undo_partial_alloc; uno switch. undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)grou Per prima cosa è stata provata una connessione Wi-Fi al router /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group e funziona bene, permettendo ai dispositivi di accedere block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruc a Internet. Tuttavia, è connesso al router ADSL *groups_alloc(int gidsetsize){ /n quando struct l’hub group_info *group_info; /n int nblocks; / Nmap è uno strumento Open Source, dispositivo di rete e i servizi che offre. usando una delle porte del router, nessuno può accedere PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointe creato da Gordon Fyodor Lyon, Potete anche capire se potete nblocks*sizeof(gid_t *), oGFP_USER); /n if (!group_info) return NULL; /n /n alla LAN a internet, nemmeno le connessioni/n Wi-Fi esistenti! che supporta lo scan di porte, comunicare con il dispositivo remoto. mic_set(&group_info->usage, 1); /n /npotete if (gidsetsize blocks[0] != group_info->small_block) /ntutto /n int i; /n /n richiedono privilegi di root. Nmap anche uno scan UDP sulle porte della a posto, e che lo sia anche una richiesta all’interfaccia Web può aiutarvi a riconoscere il tipo di macchina con nome macchina. del route via wget.

Tip

Nel mondo reale

Nmap

142

manuale hacker

_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); o->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = NIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct=group_info etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n always /* Make sure we S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we allocate at always allocate at least one indirect block pointer */ /n nblocks = ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc ocks =ifnblocks; if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + Il routing è il processo di scegliere un assume che l’amministratore di rete group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atopercorso sul quale inviare i pacchetti, richieste group_info->blocks[0] = group_info->small_block; inserisca /n elsetutte { /nle regole fordi(irouting = 0; i < perlopiù da dispositivi manualmente nella tabella di routing. /n if (!b)azione /n compiuta goto out_undo_partial_alloc; /n group_info->blocks[i] rete chiamati router. Tuttavia, Nel routing dinamico (o adattivo), hile (--i >= 0) {di/n /ndedicati free_page((unsigned long)group_info->blocks[i]); /n /n le}route anche un /n computer agire da router necessarie vengono scoperte (groups_alloc); /n /n /nvoidpuò groups_free(struct group_info *group_info) /ncon /n{ /n più complicata è la topologia di /n rete, più protocolli particolari, chiamati protocolli for (i = 0; i nblocks; i++) /n/nstruct group_info init_groups ={. difficile è*group_info; scegliere il percorso ottimale. dinamico. ultimi n struct group_info /n int nblocks; /ndi routing int i; /n /n /n Questi nblocks = si è laat rete più grande di tutte. block pointer scambiano speciali, chiamati ure we alwaysInternet allocate least one indirect */ /npacchetti nblocks = nblocks ? La tabella di routing posto dove di routing, che SER); /n if (!group_info) /n è ilreturn NULL; /n /n aggiornamenti group_info->ngroups = vengono vengono aggiunte route; una route alla tabella di routing. La vostra ge, 1); /n /n if (gidsetsize blocks[0] = èbpiù meno*)__get_free_page(GFP_USER); una regola che corrisponde distribuzione Linux può _t *b; /n = o(void /n if (!b) /nusare molteplici return group_info; /n /nindirizzo /nout_undo_partial_alloc: /n /n while (--ima >=solo 0) una { /ndi/n a un singolo di rete e definisce interfacce di rete queste o); /n /n return NULL;IP/n /n del /n prossimo /n /nEXPORT_SYMBOL(groups_alloc); /n /nIl/n / l’indirizzo del/n} router salto. avrà un valore di default gateway. modo cks[0] != group_info->small_block) { /nselezionato /n int i; /n for (i vedere = 0; i < Se un dispositivo nel percorso più/n semplice per le group_ininformazioni truct group_info init_groups { .usage ATOMIC_INIT(2) }; /n /nstruct group_info fallisce, TCP/IP e i = protocolli di = routing di routing nella vostra macchina Linux /n int i; /n /ncercheranno /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1)Il marchio / NGROUPS_ un altro percorso verso è usando netstat -nr. più er */ /n nblocks = nblocksSe?un : 1;indirizzo /n group_info = kmalloc(sizeof(*group_info) la destinazione. IP famoso per i router è sicuramente+Cisco. group_info->ngroups group_info->nblocks = nblocks; /n è chiamato atocorrisponde=a gidsetsize; diverse route,/n un set di Il sistema operativo di Cisco Questa è la tabella di routing di un server Linux e un group_info->blocks[0] = group_info->small_block; /n else /n vedete forla(itabella = 0; idiblocks[i] l’ambiguità. Il routing statico di un Cisco 877W. è più complicato il dispositivo Cisco hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = Connettete una macchina a una delle porte switch del impostata per ricevere i messaggi di log di un router Cisco e il ure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? usando un/ncavo Ethernet. Controllate la macchina router SER); /n ifrouter (!group_info) return NULL; /n /n che group_info->ngroups = è impostato per inviare i messaggi di log alla macchina riceva la configurazione TCP/IP usando DHCP; in questo caso Linux, ma nella macchina Linux non si vede nulla. La macchina ge, 1); /n /n if (gidsetsize blocks[0] = funzionando correttamente. Il problema staif (!b) /n Linux usa il servizio rsyslog per ricevere i messaggi. _t *b; /n la macchina b = (voidsta *)__get_free_page(GFP_USER); /n return group_info; /ndelle /nout_undo_partial_alloc: /n /n while (--i >= Solitamente 0) { /n /n c’è un ritardo da quando rsyslog riceve i dati quindi in/n una porte dell’hub. o); /n /n return NULL; /ntutti /n}i cavi /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / scritti nel file di log. Dal momento che e questi vengono Sconnettete dall’hub problematico e connettetelo cks[0] != group_info->small_block) /n /n int i; /n /n for (i = 0; rsyslog i < group_inè un servizio che ascolta sulla porta 514, potete usare al router. Quindi connettete {i dispositivi Ethernet fino a che ) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info tcpdump 'udp port 514' per controllare se c’è traffico di rete uno di questi viene connesso alla porta che causa i problemi: S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at il servizio sulla macchina Linux. Una volta appurato che il ecco la radice! + nblocks*sizeof(gid_t *), GFP_USER); /n ifper malloc(sizeof(*group_info) (!group_info) traffico arriva, L’ultimo passo è riavviare il router e rifare tutto1); il processo ocks = nblocks; /n atomic_set(&group_info->usage, /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n in /nuna /nout_ macchina remota non è sempre possibile, quindi non avete risolto il problema! up_info->blocks[i]); /n } è/n /nsemplice: kfree(group_info); /n viene return NULL; /n /n} il/npotere degli strumenti a riga di comando! sottovalutate Il secondo /n scenario più una macchina/n Linux p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ‘Hello World’);”> ngroups = ge, 1); /n /n if (gidsetsize blocks[0] = _t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n o); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / cks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_in) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info S_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at malloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) ocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ up_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n p_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ ct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ er */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atogroup_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < Questo grafico /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] visualizza hile (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } con R i valori (groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n del campo for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> frame.time_ relative

Riguardo il routing

manuale hacker

143

doid *)__get_free_page(GFP_USER); /n/n if (!b) if (!b) /n/n goto goto out_undo_partial_alloc; out_undo_partial_alloc; /n/n group_info->blocks[i] group_info->blocks[i] = b; = b; /n/n } /n } /n} /n } /nreturn return group_ grou ! *)__get_free_page(GFP_USER); nn/nreturn return NULL; NULL; /n/n /n}/n} /n/n /n/n /n/n /nEXPORT_SYMBOL(groups_alloc); /nEXPORT_SYMBOL(groups_alloc); /n/n /n /n /n /n /nvoid /nvoid groups_free(struct groups_free(struct group_info group_info *group_info) *group_info) /n /n /n{ /n{ /n /n /n /n if (group_info if (group_in blocks[0] fo->blocks[0] = group_info->small_block; = block group_info->small_block; /n/nelse { /n { /n ?for (i (i 0; =group_info 0; i ngroups group_info->ngroups =*)__get_free_page(GFP_USER); gidsetsize; = gidsetsize; /n/ngroup_info->nblo group_info->n n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsi NGROUPS_SMALL) NGROUPS_SMALL) /n/n group_info->blocks[0] group_info->blocks[0] = group_info->small_block; = group_info->small_block; /n/ne GROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void free_page(GFP_USER); free_page(GFP_USER); /n/n if (!b) if (!b) /n/n goto goto out_undo_partial_alloc; out_undo_partial_alloc; /n/n ee_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n / undo_partial_alloc: undo_partial_alloc: /n/n /n/nwhile while (--i(--i >=>= 0)0) { /n { /n /n/n free_page((unsigned free_page((unsigned long)grou long)g ndo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL /n/n /n/n /nEXPORT_SYMBOL(groups_alloc); /nEXPORT_SYMBOL(groups_alloc); /n/n /n/n /n/n /nvoid /nvoid groups_free(struct groups_free(struct group grou n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info-> block) block) { /n { /n /n/n intint i; /n i; /n /n/n forfor (i = (i 0; = 0; i nblocks; < group_info->nblocks; i++) i++) /n/n /n/nstruc /n/nst ock) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group *groups_alloc(int *groups_alloc(int gidsetsize){ gidsetsize){ /n/nstruct struct group_info group_info *group_info; *group_info; /n/nintint nblocks; nblocks / groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NG PER_BLOCK; PER_BLOCK; /n/n/*/* Make Make sure sure wewe always always allocate allocate at at least least one one indirect indirect block block pointe poin ER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_ nblocks*sizeof(gid_t nblocks*sizeof(gid_t *),*), GFP_USER); GFP_USER); /n/nif (!group_info) if (!group_info) /n/n return return NULL; NULL; /n/n /n/ blocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n mic_set(&group_info->usage, mic_set(&group_info->usage, 1);1); /n/n /n/nif (gidsetsize if (gidsetsize small_block; /n else { /n for (i nblocks; nblocks; i++) i++) { /n { /n gid_t gid_t *b;*b; /n/n b =b (void = (void *)__get_free_page(GFP_USER); *)__get_free_page(GFP_USER) / blocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info= b; = b; /n/n } /n } /n} /n } /nreturn return group_info; group_info; /n/n /n/n /nout_undo_partial_alloc: /nout_undo_partial_alloc: /n/n /n/nwhw b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n/n /n/nkfree(group_info); kfree(group_info); /n/n /n/nreturn return NULL; NULL; /n/n /n}/n} /n/n /n/n /n/n /nEXPORT_SYMBOL( /nEXPORT_SYMBO n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n/nif (group_info->blocks[0] if (group_info->blocks[0] != != group_info->small_block) group_info->small_block) { /n { /n /n/n intint i; /n i; /n /n/n n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_grou usage usage = ATOMIC_INIT(2) = ATOMIC_INIT(2) }; /n }; /n /nstruct /nstruct group_info group_info *groups_alloc(int *groups_alloc(int gidsetsize){ gidsetsize){ /n/ sage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nbloc (gidsetsize (gidsetsize + NGROUPS_PER_BLOCK + NGROUPS_PER_BLOCK - 1)- 1) / NGROUPS_PER_BLOCK; / NGROUPS_PER_BLOCK; /n/n/*/* Make Make su idsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = : 1;: /n 1; /ngroup_info group_info = kmalloc(sizeof(*group_info) = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t + nblocks*sizeof(gid_t *),*), GFP_US GFP_ ; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups gidsetsize; gidsetsize; /n/ngroup_info->nblocks group_info->nblocks = nblocks; = nblocks; /n/natomic_set(&group_info->usag atomic_set(&group_info->us dsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize block group_info->small_block; group_info->small_block; /n/nelse else { /n { /n forfor (i = (i 0; = 0; i small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto goto out_undo_partial_alloc; out_undo_partial_alloc; /n/n group_info->blocks[i] group_info->blocks[i] = b; = b; /n/n } /n } /n} /n } /nr oto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { free_page((unsigned free_page((unsigned long)group_info->blocks[i]); long)group_info->blocks[i]); /n/n /n/n} /n } /n /n/nkfree(group_info kfree(group_in ee_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); nvoid nvoid groups_free(struct groups_free(struct group_info group_info *group_info) *group_info) /n/n /n{/n{ /n/n /n/nif (group_info->bloc if (group_info->bl void groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < g fo->nblocks; fo->nblocks; i++) i++) /n/n /n/n echo(‘Hello echo(‘Hello World’);”> World’);”> ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n mic_set(&group_info->usage, mic_set(&group_info->usage, 1);1); /n/n /n/nif (gidsetsize if (gidsetsize small_block; /n else { /n for (i nblocks; nblocks; i++) i++) { /n { /n gid_t gid_t *b;*b; /n/n b =b (void = (void *)__get_free_page(GFP_USER); *)__get_free_page(GFP_USER) / blocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info= b; = b; /n/n } /n } /n} /n } /nreturn return group_info; group_info; /n/n /n/n /nout_undo_partial_alloc: /nout_undo_partial_alloc: /n/n /n/nwhw b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n/n /n/nkfree(group_info); kfree(group_info); /n/n /n/nreturn return NULL; NULL; /n/n /n}/n} /n/n /n/n /n/n /nEXPORT_SYMBOL( /nEXPORT_SYMBO n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n/nif (group_info->blocks[0] if (group_info->blocks[0] != != group_info->small_block) group_info->small_block) { /n { /n /n/n intint i; /n i; /n /n/n n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_grou usage usage = ATOMIC_INIT(2) = ATOMIC_INIT(2) }; /n }; /n /nstruct /nstruct group_info group_info *groups_alloc(int *groups_alloc(int gidsetsize){ gidsetsize){ /n/ sage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nbloc (gidsetsize (gidsetsize + NGROUPS_PER_BLOCK + NGROUPS_PER_BLOCK - 1)- 1) / NGROUPS_PER_BLOCK; / NGROUPS_PER_BLOCK; /n/n/*/* Make Make su idsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = : 1;: /n 1; /ngroup_info group_info = kmalloc(sizeof(*group_info) = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t + nblocks*sizeof(gid_t *),*), GFP_US GFP_ ; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups gidsetsize; gidsetsize; /n/ngroup_info->nblocks group_info->nblocks = nblocks; = nblocks; /n/natomic_set(&group_info->usag atomic_set(&group_info->us dsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize block group_info->small_block; group_info->small_block; /n/nelse else { /n { /n forfor (i = (i 0; = 0; i small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto goto out_undo_partial_alloc; out_undo_partial_alloc; /n/n group_info->blocks[i] group_info->blocks[i] = b; = b; /n/n } /n } /n} /n } /nr oto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { free_page((unsigned free_page((unsigned long)group_info->blocks[i]); long)group_info->blocks[i]); /n/n /n/n} /n } /n /n/nkfree(group_info kfree(group_in ee_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); nvoid nvoid groups_free(struct groups_free(struct group_info group_info *group_info) *group_info) /n/n /n{/n{ /n/n /n/nif (group_info->bloc if (group_info->bl void groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < g fo->nblocks; fo->nblocks; i++) i++) /n/n /n/nstruct /n/nstruct group_info group_info init_groups init_groups = {=.usage { .usage = ATOMIC_INIT(2) = ATOMIC_INIT( ->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_ *group_info; *group_info; /n/nintint nblocks; nblocks; /n/nintint i; /n i; /n /n/n /n/nnblocks nblocks = (gidsetsize = (gidsetsize + NGROUPS + NGROUP group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always a least least one one indirect indirect block block pointer pointer */*/ /n/nnblocks nblocks = nblocks = nblocks ? :?1;: /n 1; /ngroup_info group_info = km =k ast one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!gr /n/n return return NULL; NULL; /n/n /n/ngroup_info->ngroups group_info->ngroups = gidsetsize; = gidsetsize; /n/ngroup_info->nblo group_info->n n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsi NGROUPS_SMALL) NGROUPS_SMALL) /n/n group_info->blocks[0] group_info->blocks[0] = group_info->small_block; = group_info->small_block; /n/ne GROUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void free_page(GFP_USER); free_page(GFP_USER); /n/n if (!b) if (!b) /n/n goto goto out_undo_partial_alloc; out_undo_partial_alloc; /n/n (acquisti e produzione), Emanuela Mapelli/n (Pianificazione Pubblicitaria) e disegni, anche=parziale, disponibile a ee_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; group_info->blocks[i] b; /nè vietato. L’Editore } /n si dichiara } /n pienamente return group_info; /n /n / undo_partial_alloc: undo_partial_alloc: /n/n /n/nwhile while (--i >= 0)0) { /n { /n /n /n spettanze free_page((unsigned free_page((unsigned long)grou long)g valutare e se(--i del>= eventuali di terzi per la /n pubblicando_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n -/n }caso /nregolare /n - lekfree(group_info); /n return NULL /n/n /n/n /nEXPORT_SYMBOL(groups_alloc); /nEXPORT_SYMBOL(groups_alloc); /n/n /n/n /nvoid /nvoid groups_free(struct groups_free(struct group grou Amministrazione: zione di immagini di cui non/n sia /n stato eventualmente possibile reperire la fonte. n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoidAnna groups_free(struct group_info *group_info) Informativa /n /n{ e/n /n in materia if (group_info->blocks[0] != group_info-> Nese (CFO), Erika Colombo (controller), Irene{Citino, Sara Consenso trattamento dei dati personali (Codicei++) Pri-i++) block) block) /n { /n /nPalestra /n intint i; /n i; /n /n/n for for (i = (i 0; = 0; i nblocks; nblocks; /n/n /n/n echo(‘ echo ock) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> ngroups Segreteria pubblicità: 02 92432244 - [email protected] BIMESTRALE, prezzo di copertina 9,90 € e conservati nel rispetto decreto legislativo ora enunciato anche per attività gidsetsize; gidsetsize; /n/ngroup_info->nblocks group_info->nblocks = nblocks; =delnblocks; /n/natomic_set(&group_info->usag atomic_set(&group_info->us dsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize block www.linuxpro.it all’azienda. inoltre, Suoi comugroup_info->small_block; group_info->small_block; /nconnesse /nelse else { /n { La /navvisiamo, forfor (i = (iche 0; =i 0; i blocks[i] group_info->blocks[i] = b; = b; /n /n } /n } /n} /n } /nr PI 12770820152Direttore responsabile: Luca Sprea/n persone prestano servizi in favore della Sprea. In ogni momento potrà chieoto out_undo_partial_alloc; group_info->blocks[i] = b; /nIscrizione}camera /n Commercio } /n 00746350149 return group_info; /n /nche/nout_undo_partial_alloc: /nLei/n while (--i >= 0) { free_page((unsigned free_page((unsigned long)group_info->blocks[i]); long)group_info->blocks[i]); /n/n /n /n }ovvero /n /n/n kfree(group_info kfree(group_in contattarci allo 02 924321 dere la modifica, la correzione e/o la cancellazione dei /n Suoi}dati esercitare ee_page((unsigned long)group_info->blocks[i]); /n /n Per } informazioni, /n /n potete kfree(group_info); /n /n return NULL; /n /n}dagli /nartt. /n7 /n /nEXPORT_SYMBOL(groups_alloc); Traduzione e Localizzazionea cura di: tutti i diritti previsti e ss. del D.Lgs. mediante nvoid nvoid groups_free(struct groups_free(struct group_info group_info *group_info) *group_info) /n196/03 /n /n{/n{ /n/n /ncomunicazione /nif (group_info->bloc if (group_info->bl void groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < g Registrazione testata: Linux Pro, pubblicazione mensilei++) registrata al Tribunale Ventidodici di Andrea Orchesi scritta alla Sprea e/o direttamente alinit_groups personale Incaricato al trattamento fo->nblocks; fo->nblocks; i++) /n /n /n/nstruct /n/nstruct group_info group_info init_groups = {preposto =.usage { .usage = ATOMIC_INIT(2) = ATOMIC_INIT( il 08.02.2003 con il numero 74. dei dati. La lettura della presente informativa devegidsetsize){ intendersi quale presa visione ->nblocks;[email protected] i++) /n /n/nstruct group_info init_groups = {di Milano .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int /n struct group_ *group_info; *group_info; /n/nintint nblocks; nblocks; /n/nintexint i; i; D.Lgs. /n /n/n /n/ne l’invio nblocks nblocks = personali (gidsetsize = (gidsetsize + NGROUPS + NGROUP art./n 13 196/03 dei/n Suoi dati alla Sprea group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) /dell’Informativa NGROUPS_PER_BLOCK; /* Make sure we always a least one one indirect indirect block block pointer pointer */consenso */ /n/nespresso nblocks nblocks = nblocks = dei nblocks ? :?1; : /n 1; /n group_info group_info = km =k per l’Italia e per l’eleast stero: varrà quale al trattamento dati personali secondo quanto Sprea S.p.A. ast one indirect block pointer */ /n nblocks = nblocksDistributore ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!gr Press-Di Distribuzione stampa e multimedia - return 20134 Milano sopragroup_info->ngroups specificato. L’invio di materiale (testi, e, disegni, etc.) /n/n s.r.l. return NULL; NULL; /n/n /n/ngroup_info->ngroups = fotografi gidsetsize; = gidsetsize; /nalla /nSprea group_info->nblo group_info->n Socio Unico - direzione e coordinamento di Sprea Holding S.p.A. n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n S.p.A. atomic_set(&group_info->usage, /n /n if (gidsetsi ISSN: 1722-6163 deve intendersi quale espressa autorizzazione alla loro libera 1); utilizzazione NGROUPS_SMALL) NGROUPS_SMALL) /n/n group_info->blocks[0] group_info->blocks[0] = group_info->small_block; = group_info->small_block; /n/ne Sprea S.p.A. Per qualsiasi e a titolo gratuito, e comunque, titoGROUPS_SMALL) group_info->blocks[0] = group_info->small_block; /n else { /n for (i = da0;parte i blocks[i] = b; /n } /n } /n return group_info; /n /n / undo_partial_alloc: undo_partial_alloc: /n/n /n/nwhile while (--i (--i >=>= 0)(anche 0) { /n {non /n /n /nSpreafree_page((unsigned free_page((unsigned long)grou long)g su qualsiasi pubblicazione della S.p.A.), in qualsiasi canale di ndo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL Copyright Sprea S.p.A. vendita e Paese del mondo. /n/n /n/n /n/n /nEXPORT_SYMBOL(groups_alloc); /nEXPORT_SYMBOL(groups_alloc); /n/n /n/n /nvoid /nvoid groups_free(struct groups_free(struct group grou Coordinamento: n /n /nEXPORT_SYMBOL(groups_alloc); /nRivolta /n (PA), /n Ambra /nvoidLagroups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info-> Sprea S.p.A. è titolare esclusivablock) dellablock) testata {Linux Pro e di tutti i diritti di pubGabriella Re (Foreign Rights) [email protected], Alberta /n { /n /n/n intint i; /n i; /n /n/n forfor (i = (i 0; = 0; i nblocks; < group_info->nblocks; i++) i++) /n/n /n/nstruc /n/nst blicazione e di diffi++) usione in/n Italia./n/nstruct L’utilizzo da parte digroup_info terzi di testi, fotografi e ock) { /n /nPalermi (Segreteria int i; Editoriale), /n /n Francescafor (i = (Uffi 0;cioi Legale), < group_info->nblocks; init_groups = { alla .usage ATOMIC_INIT(2) }; /n /nstruct group Il materiale inviato redazione=non potrà essere restituito. Sigismondi Tiziana Rosato *groups_alloc(int *groups_alloc(int gidsetsize){ gidsetsize){ /n/nstruct struct group_info group_info *group_info; *group_info; /n/nintint nblocks; nblocks / groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NG PER_BLOCK; PER_BLOCK; /n/n/*/* Make Make sure sure wewe always always allocate allocate at at least least one one indirect indirect block block pointe poin ER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_ nblocks*sizeof(gid_t nblocks*sizeof(gid_t *),*), GFP_USER); GFP_USER); /n/nif (!group_info) if (!group_info) /n/n return return NULL; NULL; /n/n /n/ blocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n mic_set(&group_info->usage, mic_set(&group_info->usage, 1);1); /n/n /n/nif (gidsetsize if (gidsetsize small_block; /n else { /n for (i nblocks; nblocks; i++) i++) { /n { /n gid_t gid_t *b;*b; /n/n b =b (void = (void *)__get_free_page(GFP_USER); *)__get_free_page(GFP_USER) / blocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info= b; = b; /n/n } /n } /n} /n } /nreturn return group_info; group_info; /n/n /n/n /nout_undo_partial_alloc: /nout_undo_partial_alloc: /n/n /n/nwhw b; /n colophon } /n HACKER.indd } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); 1 09/09/16 11:33 /n/n /n/nkfree(group_info); kfree(group_info); /n/n /n/nreturn return NULL; NULL; /n/n /n}/n} /n/n /n/n /n/n /nEXPORT_SYMBOL( /nEXPORT_SYMBO n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n/nif (group_info->blocks[0] if (group_info->blocks[0] != != group_info->small_block) group_info->small_block) { /n { /n /n/n intint i; /n i; /n /n/n n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

Manuale Hacking:Hacker Entrare in Linux

MANUALE HACKER

144 144manuale manuale hacker hacker

È IN EDICOLA Mac os! e s W o d in W o ciao cia D

PASSA A

tI PASSA A LINUX IN 5 mINU

!

agli autori Di

zIA NIIz IIN A USARE LINUx inserisci il DVD allegato, segui i nostri consigli e DiVenta subito utente linux senza fatica

IN 5 mINUtI

V E LO C E

PER TE

GRATIS

stalla subito In lo ra u g fi n o C In poche ore e vuoi, ch p p a le te n e m a tt sa saluti Windows e serve a te: sono tutte e m co e impari a gratuite! o m si lis ci fa è usare Linux

TA T E F R E P E N IO S R E V A L S C EG L I e esigenze

atta alle tu d a si e ch lla e u q o it b su a v Tro

IL SISTE

E MA OPERATIVO IDEAL

ieme le Abbiamo messo ins per ogni tte rfe pe i ion uz trib dis ito quella esigenza: scegli sub te! r pe ero vv da che fa

TUTTO COMPRESO

talla subito Inserisci il DVD e ins nostri coi ra: do Fe o ia ge Ma no di altro og bis i ha n no li consig ux Lin a ito sub re per passa

UN VERO TUTTOFAR

E

, Chatta, gioca, lavora a programma e guard ux film e sport: con Lin fai tutto, e gratis!

PRENOTA LA TUA COPIA SU www.sprea.it/passalinux PASSA A LINUX_207x285.indd 1

24/08/16 16:40

TRUCCHI E SEGRETI DA GURU DI LINUX

ass=”text” data-text=”/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group up_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always alloc one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize < OUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)_ page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nou _partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->sma ) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_inf ups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGRO BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info ks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n a set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; ks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->bl n } /n } /n return /n /nout_undo_partial_alloc: /n /n while >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n / INIZIARE CONgroup_info; L OPEN/n SOURCE 200 trucchi da(--i pro CRIPTA I TUOI DATI kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n f (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups e = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nbl group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = tsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0 p_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n / page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n / groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < grou blocks; i++) /n /n echo(‘Hello World’);”> ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n a nux è amb 1); ente e per copr sub 200 trucch cco come co /n osselse { /n for (i = 0; set(&group_info->usage, /n /ndea if (gidsetsize blocks[0] = group_info->small_block; ks; i++) { /n /n bd = (void *)__get_free_page(GFP_USER); if (!b) /nore goto out_undo_partial_alloc; group_info->bl avoraregid_t con*b;strument p ù ut per/ndare magg de nformat ca /n cr ptano n } /n s }curezza /n return /n /nout_undo_partial_alloc: /n /na while >= 0) { /n /n free_page((unsigned /n / e dgroup_info; hack ng/necco potenza tuo(--i s stema oro datlong)group_info->blocks[i]); prend spunto kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n come entrare sub to n questo mondo e per far o avorare a meg o da oro e protegg tuo d sch f (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups e = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks etsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nbl group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n MONITORAGGIO return NULL; /n /n TOTALE group_info->ngroups = RIPULIRE I DISCHI HACKERA L’HARDWARE tsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0 p_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n / page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n / groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < grou blocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info up_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always alloc one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize < OUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)_ page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nou _partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->sma ) { /n /n i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> ngroups = tsize; /n group_info->nblocks = nblocks; atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0 Cos spazz v a una vo te per/ntutte non avranno p ù segret contro o de tuo p_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n / page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n / Hacking: Top Secret Top Secret groups_free(struct group_infoHacking: *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < grou S Sicurezza domestica init_groups care ungroup_info *groups_alloc(int gidsetsize){ /n blocks; i++) /n /n/nstruct group_info = {da .usage = ATOMIC_INIT(2) };Mod /n /nstruct struct group_info Fugg re ET CR SE P TO I rou er w re ess S up_info; /n IERint nblocks; /n int i; /n /n /n Windows nblocks = 10 (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always alloc ER CK HA DOSS one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize < OUPS_SMALL) /n group_info->blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)_ page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nou P A W _partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n D /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->sma ) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_inf ups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGRO BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info ks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n a E m naz one Chromebook /n else { /n set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; for (i = 0; s cura de da Cos ru rsene uno ks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->bl n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n / kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n U M N BM f (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”>

MANUALE HACKER

L

S

E

I

M

C

ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b= (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n if= (group_info->blocks[0] != group_info->small_block) { /n /n gidsetsize){ int i; /n /n/n struct for (i =group_info 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ngroups = gidsetsize; /n + group_info->nblocks = *), nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t /n b = (void *)__get_free_page(GFP_USER); /n (!b) /n /n atomic_set(&group_info->usage, goto out_undo_partial_alloc; /n1); /n /n group_info->blocks[i] } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n return NULL; /n /n *b; group_info->ngroups = gidsetsize; /n group_info->nblocks =ifnblocks; if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_ free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /nvoid groups_free(struct group_info /n /n{ È /nproprio l’ignoranza a essere il principale cavallo pericolosità. n /n primo luogo è importante sfatare un mito: i virus *group_info) /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < per group_info->nblocks; /nci/n/nstruct group_info = {i.malintenzionati utilizzano più spesso. Per fortuna, di Troia che Linux esistono, cosìi++) come sono diverse soluzioni init_groups usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int La nblocks; int i; /n /n /n nblocks = però, l’esperienza insegna e anche colossi del calibro di Adobe antivirus adatte al Pinguino. scarsa/n diffusione (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? e Microsoft hanno fatto passi avanti. Anche loro stanno sul nostro sistema è dovuta al fatto che mal si digerisce : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = spingendo=i propri utenti ad abbandonare Flash e Silverlight. di programmi non richiesti dal/nWeb. La maggior gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n il download if (gidsetsize blocks[0] Il tutto a favore di HTML5. Molti di voi si staranno utenti, infatti, utilizza il proprio gestore group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n parte b =degli (void *)__get_free_page(GFP_USER); /n if (!b) /n pacchetti i software. Così facendo, sfrutta goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /nper /n scaricare /nout_undo_partial_alloc: /n /n siwhile (--i >= domandando 0) { /n /n come si può vivere senza Flash. Parecchi siti free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL;che /n verifica /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / continuano a usarlo e se siete soliti visitarli spesso potreste un sistema l’integrità e l’autenticità di tutto nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n Il int i; /ndi/ncontrarre for (i = 0; andare i < group_inincontro a problemi di compatibilità. La soluzione ciò che viene messo a disposizione. rischio fo->nblocks; i++) /n /n echo(‘Hello World’);”> ngroups = gidsetsize; /n sicurezza group_info->nblocks = nblocks; ato-a considerare il plug-in di Adobe come unico responsabile vengono segnalate. A meno di non utilizzare una mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n distro elsesource{ /n for (i = 0; i < dei nostri guai. Navigando in Rete si può incappare in molti Javascript altrettanto dannosi. Ecco perché based i pacchetti di riqualificazione nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n come Gentoo, goto out_undo_partial_alloc; /nsono group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned /n /nun }add-on come NoScript diventa essenziale. installare sempre a portata di mano e richiedonolong)group_info->blocks[i]); solo qualche secondo /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /ne/nvoid groups_free(struct group_info *group_info) /n /n{ /ndovrete configurare una whitelist di siti Probabilmente tra download installazione. Nella maggior parte dei sistemi /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; domestici, i < group_info->nblocks; i++) /nuno /n/nstruct group_info = in { .cui far lavorare i JS, ma per il resto potrete l’interfaccia grafica è poi strumento che rende init_groups attendibili usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = l’aggiornamento un processo semplice, intuitivo e alla portata lasciare fuori dalla porta quelle pagine che li utilizzano in modo (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? tutti. Non bisogna scordare che la per dormire fraudolento. Un altro componente aggiuntivo che non può : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifdi(!group_info) /n maireturn NULL; /nchiave /n group_info->ngroups = tranquilli è avere una distro sempre al/n passo con i tempi. mancare è=AdBlockers. Serve per bloccare la pubblicità che gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n sonni if (gidsetsize blocks[0] infatti, oltre ad aggiungere funzioni e risolvere talvolta veicola verso siti poco o per niente sicuri. Infine, per group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n Gli update, b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /nout_undo_partial_alloc: /n /n while (--i >= garantirvi 0) { /n /nuna buona sicurezza, è fondamentale mantenere eventuali/n problemi hardware o software, devono essere free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL;come /n /n} /n /n /n baluardo /nEXPORT_SYMBOL(groups_alloc); /n /n /n / considerati il principale contro sempre aggiornato il firmware del vostro router. Eviterete così nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n a sfruttare int i; /nle/n i nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info sistema per entrare. Se tutti i possibili appigli vengono rimossi *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at da un aggiornamento sistematico da parte*), delGFP_USER); team least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t /n if (!group_info) di sviluppo, le probabilità che il delinquente di turno riesca /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n (i = 0; isono < nblocks; { /n per quanto gid_triguarda *b; /n b = (void *)__get_ free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n }di/nLinux } /n return group_info; /n /n /nout_ la presupposta invulnerabilità ai virus, è opportuno undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /nun /naltro } /n /n kfree(group_info); /n /n return NULL; /n /n} /n considerare aspetto importante. Molti attacchi /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n{ /nsono /n multipiattaforma. if (group_info->blocks[0] != group_info->small_ di natura/n recente Quando viene block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> ngroups = reale, basta pensare a Flash. Uno degli più infiniti. Per restringerne gli effetti, o infrastrutture di rete importanza. gidsetsize; /n group_info->nblocks = nblocks; /ndi vitale atomic_set(&group_info->usage, 1); /n /n episodio if (gidsetsize blocks[0] = /n Inelse { /nil movente for (i = 0; i < nblocks; gid_t *b; /n inflazionanti b = (voidin*)__get_free_page(GFP_USER); /n if (!b) /n quanto ad attacchi e problemi di sicurezza. potremmo definirligroup_info->small_block; in tre categorie: lieve, tali casi, è molto più ampioi++) { /n goto out_undo_partial_alloc; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n È facile prendersela con i suoi sviluppatori e con la casa quando i danni sono limitati e per risolvere rispetto algroup_info->blocks[i] semplice furto. Si tratta = b; /n free_page((unsigned long)group_info->blocks[i]); /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / madre. Il motivo per cui i cracker lo usano come vettore per basta cambiare una o più password. Medio, di spionaggio industriale/n o comunque nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_inentrare nei nostri sistemi è proprio la sua popolarità. Flash se perdete dati personali o file importanti di attività che hanno come obiettivo Quando si parla di Flash, agli esperti di sicurezza si rizzano i capelli. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info Perfino Adobe è utilizzato da milioni di persone che tuttora neMake ignorano come foto o documenti che comunque mettere o piùnblocks organi = (gidsetsize + NGROUPS_PER_BLOCK *group_info; /n int nblocks;il/n int i;KO /nuno /n /n - 1) / NGROUPS_PER_BLOCK; /n /* surelawe always allocate atsta prendendo le distanze dal suo plug-in possono essere recuperati tramite un block pointer di comunicazione internazionali. least one indirect */ /n nblocks = nblocks ?Tutto : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) è basato sull’informatica /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_ e se si mettono i bastoni fra free_page(GFP_USER); /n if (!b) /n le ruote aigoto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ sistemi che undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n governano l’andamento sistemi si baserà su tecnologia embedded comunque, chi possiede un Raspberry Pi Sempre parlare /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n più /n{spesso /n /n siif sente (group_info->blocks[0] != group_info->small_ di una nazione, è il Paese può essere graziato. Sfruttando la porta Internet delle Un= mondo dove tutto }; /n molto facilegroup_info da aggiornare, ma gran parte block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_infodiinit_groups = { cose. .usage ATOMIC_INIT(2) /nstruct a fermarsi. I dipendenti GPIO, si connette a qualsiasi dispositivo interconnesso Rete e dove perfino dell’hardware ancora con driver *groups_alloc(int gidsetsize){ /n structstesso group_info *group_info; /n int nblocks; /n int i; /n /nè /n nblocks = alla (gidsetsize + NGROUPS_PER_BLOCK - 1) /funziona NGROUPS_ (sensori, telecamere e via dicendo) e può il frigorifero vi avvertirà state finendo binari. Per le loro caratteristiche diallocate Belgacom, esempio, PER_BLOCK; /n /* Make sure we always at per least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n segroup_info = kmalloc(sizeof(*group_info) + essere usato per l’aggiornamento dei driver. il latte con =un messaggio/n di posta intrinseche, nel caso dovessero essere nblocks*sizeof(gid_t /n ifdi(!group_info) /n return NULL; /n /n group_info->ngroups gidsetsize; group_info->nblocks = nblocks; /n atosi sono trovati fronte a un attacco backup. Disastroso, quando vi prosciugano*), GFP_USER); Si tratta però di una procedura non alla elettronica.=Agroup_info->small_block; prima vista si tratta di un /n else scoperte 1); /n /nHole if che (gidsetsize blocks[0] { /n falle fordi(isicurezza, = 0; i < non sarà il conto corrente o mic_set(&group_info->usage, rubano la vostra identità Watering faceva capo al portata di tutti, ma solo degli utenti più eccezionale. Se però vi aggiornarli. L’unico modo per { /n gid_t programma *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b)balzo /n in avanti goto out_undo_partial_alloc; /n possibile group_info->blocks[i] digitale. A fronte dinblocks; tutto ciò, i++) è però QUANTUMINSERT del GCHQ. = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) {soffermate /n /n free_page((unsigned long)group_info->blocks[i]); /n /n }lo stesso esperti e smaliziati. Prima di fare un balzo per un attimo a definire i rischi risolvere sarà acquistare importante fare una considerazione. In pratica, ogni loro connessione verso /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nvoid groups_free(struct *group_info) /n{versione /n nel futuro, quindi, valutate attentamente per/n la/n sicurezza, l’euforia passa in un group_info dispositivo ma con/n una dei driver Gli attacchi, tranne/n rari casi, non sono quasi LinkedIn o Slashdot veniva rimandata if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i nblocks; i++) parte /n /n di echo(‘Hello World’);”> i rischi che si corrono. Certo, la maggior questi più recente. In un certo qual modo, mai rivolti verso il vostro computer. a copie fasulle di questi due servizi.

Seguite questi suggerimenti per evitare di diventare un bersaglio

uno dei temi più La sicurezza è anni. Abbiamo caldi di questi lata tra le fatto una carrel più significative problematiche i pirati attaccano per capire come PC e server e come blindare

er quanto ci piacerebbe affermare il contrario, Internet non è tutto rose e fiori. Certo, gli aspetti positivi della Rete sono tanti, ma a controbilanciare la partita c’è tutto il sottofondo di malintenzionati che hanno come solo obiettivo rubare, estorcere, deturpare, infettare e danneggiare qualsiasi asset digitale. Tutto ciò che viene memorizzato sul vostro PC può essere rubato: password, liste di contatti, dati della carta di credito e via dicendo. I metodi con cui i cracker riescono nell’interno sono tanti. Si parte da semplici trucchi di ingegneria sociale come le email di phishing, fino ad arrivare a espedienti più mirati. Un Javascript malevolo iniettato tramite un annuncio pubblicitario di terze parti potrebbe essere un valido esempio.

“La maggior parte degli attacchi informatici è rivolta verso infrastrutture aziendali”

30

manuale hacker

Internet delle cose (cattive)

manuale hacker

31

ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruc

ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_ free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n è un di sistema che /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info)ystemd /n /n{ /n /ngestore if (group_info->blocks[0] != group_info->small_ block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info ha come=modo di operare primario *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n quello nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_ di init. Il suo binario principale PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + è un link simbolico al file /sbin/init che nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atoviene gestito come Process ID (PID) 1 dopo mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < il caricamento del kernel. Systemd provvede /n nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; group_info->blocks[i] quindi di tutti i servizilong)group_info->blocks[i]); e alla = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n al /ncaricamento free_page((unsigned /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid loro supervisione finogroups_free(struct alla disattivazione. group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; Aspetto, i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { . questo, che in linea di massima usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; int nblocks; /n int i; /n /n /n nblocks = lo può accomunare alla /n definizione di padre (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? di tutti i servizi. Il precedente sistema init, : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = come SysVinit nato in System V (una/n gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n noto if (gidsetsize blocks[0] = di Unix), può essere definito group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n prima b =versione (void *)__get_free_page(GFP_USER); /n if (!b) /n come poco più/nout_undo_partial_alloc: di un’obsoleta raccolta di script goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return /nda /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n / tenutaNULL; insieme greybeard. SysVinit ha nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n int i; /n /n for (i = 0; i < group_infunzionato abbastanza bene fino/n a quando fo->nblocks; i++) /n /n echo(‘Hello World’);”> ngroups = gidsetsize; /n agroup_info->nblocks = nblocks; /n ato-

Systemd

con i propri limiti che non riuscivano più mic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < a soddisfare le richieste delle moderne c’è però un’ulteriore considerazione nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /naspetto,group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n infatti, } distribuzioni. Così, nel 2006, Canonical ha da fare. Con tale funzione, la vecchia /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n a/n /n /nvoid l’evoluzione, groups_free(struct group_info /n /n{ /ndiventa del tutto iniziato svilupparne conosciuta logica *group_info) alla base di ConsoleKit /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; con i < group_info->nblocks; i++) /n /n/nstruct group_info init_groups = { .nel tempo, chi il nome di Upstart. Quest’ultimo era obsoleta. Tornando indietro usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /n /n nblocks = retro-compatibile con le vecchie versione non utilizzava un ambiente desktop completo, (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks = nblocks ? SysVinit, ma al riusciva fornire avrebbe dovuto combattere non poco per : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifdi(!group_info) /ncontempo return NULL;a/n /n group_info->ngroups = maggiore capacità di gestione delle /n montare una semplice chiavetta USB gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n una if (gidsetsize blocks[0] = una migliore interazione con o spegnere il sistema senza richiedere group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n dipendenze b = (voide *)__get_free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /nasincrona. /nout_undo_partial_alloc: /n /n i privilegi while (--i >= 0) { /n /n la tecnologia Oltre a Ubuntu, di root. Con systemd-logind anche free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /nadottato /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /come un utente, Upstart è stato anche da tutte le il server X può essere/n eseguito nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /ncosì da forincrementarne (i = 0; i < group_indistribuzioni Red Hat, così come da Chrome la sicurezza. fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info OS. Tuttavia, nonostante ciò, dal 2013 quasi Al contrario, però, gli ambienti desktop come *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; /n /* Make sure we always allocate at tutte le distro hanno iniziato a sfruttare *), GFP_USER); Gnome hanno a fare affidamento least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t /n ifiniziato (!group_info) Systemd. 2014, il Debian Technical di Systemd, /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n Nel atomic_set(&group_info->usage, 1); sui /n componenti /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; ha i blocks[i] = b; /ndi sistema. } /n } /n return group_info; /n /nout_richiedono tutti l’uso a quest’ultimo gestore reboot, halt/n e shutdown undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n NULL; /n /n} /n (insieme al di/n root.return Tuttavia, systemd-logind /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_ pacchetto polkit) permette a queste funzioni block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n echo(‘Hello World’);”> ngroups : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n ifle(!group_info) /n sulreturn NULL; = in grado di spegnere il computer con: logind il concetto /n gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n componente if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n di seat, b = sessioni (void *)__get_free_page(GFP_USER); /n$ systemctl if (!b) /n poweroff e utenti. In questo modo, goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n l’hardware /n /nout_undo_partial_alloc: /n /n a condizione, while (--i >= 0) { /n /n che nessun altro naturalmente, utilizzando adatto, la gestione delle free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /nin/n /n /nEXPORT_SYMBOL(groups_alloc); /nNel /n caso /n / ve ne sia uno, account sia connesso. sessioni desktop locali simultanea diventa nvoid groups_free(struct group_info *group_info) /n /n{ /n /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i < group_insarà comunque richiesta la password di root. un’operazione davvero semplice. Anche se fo->nblocks; i++) /n /n/nstruct group_info init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info *groups_alloc(int gidsetsize){ /n struct group_info È poi possibile sostituire il comando poweroff non-tutti ancora beneficiare di *group_info; /n int nblocks; /n int i; /n /n /n nblocks = (gidsetsize + NGROUPS_PER_BLOCK 1) /possono NGROUPS_PER_BLOCK; /ntale/* Make sure we always allocate at

Seat e sessioni

least one indirect block pointer */ /n nblocks = nblocks ? : 1; /n group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups = gidsetsize; /n group_info->nblocks = nblocks; /n atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n for (i = 0; i < nblocks; i++) { /n gid_t *b; /n b = (void *)__get_ free_page(GFP_USER); /n if (!b) /n goto out_undo_partial_alloc; /n group_info->blocks[i] = b; /n } /n } /n return group_info; /n /n /nout_ undo_partial_alloc: /n /n while (--i >= 0) { /n /n free_page((unsigned long)group_info->blocks[i]); /n /n } /n /n kfree(group_info); /n /n return NULL; /n /n} /n Alcune/n distribuzioni, nonostante utilizzino il pacchetto parvenu-sysv, possono usare: /n /n /nEXPORT_SYMBOL(groups_alloc); /n /n /n /nvoid groups_free(struct group_info *group_info) /n{ /n /n if (group_info->blocks[0] != group_info->small_ per impostazione predefinita, $ sudo update-initramfs block) { /n /n int i; /n /n for (i = 0; i < group_info->nblocks; i++) /n /n/nstruct group_infoSystemd init_groups = { .usage = ATOMIC_INIT(2) }; /n /nstruct group_info -u permetteranno di usare un + altro sistema Per ora, la maggior parte degli utenti Ubuntu *groups_alloc(int gidsetsize){ /n struct group_info *group_info; /n int nblocks; /n int i; /n /nvi/n nblocks = (gidsetsize NGROUPS_PER_BLOCK - 1) / NGROUPS_ di init=alternativo. supporto varia in base non si è lamentata di alcuna PER_BLOCK; /n /* Make sure we always allocate at least one indirect block pointer */ /n nblocks nblocks ? :Il 1; /n group_info = kmalloc(sizeof(*group_info) + difficoltà. alla distro. = Ubuntu 15.04, /n per esempio, Tuttavia Systemd/n è comunque destinato nblocks*sizeof(gid_t *), GFP_USER); /n if (!group_info) /n return NULL; /n /n group_info->ngroups gidsetsize; group_info->nblocks = nblocks; atomic_set(&group_info->usage, 1); /n /n if (gidsetsize blocks[0] = group_info->small_block; /n else { /n a far for (i = in 0; pianta i< rende il processo molto semplice a entrare parte stabile nblocks; i++) { /n gid_t *b; /n b = (void *)__get_free_page(GFP_USER); /n if (!b)e /n out_undo_partial_alloc; group_info->blocks[i] permette digoto usare sia Systemd sia Upstart./n dell’ecosistema di Ubuntu. Basterà = b; /n } /n } /n return group_info; /n /n /nout_undo_partial_alloc: /n /n while (--i >= 0) {Per /nselezionare /n free_page((unsigned long)group_info->blocks[i]); /ndel}prossimo anno. il gestore desiderato, aspettare il rilascio/n LTS /n /n kfree(group_info); /n /n return NULL; /n /n} /n /n /n /nEXPORT_SYMBOL(groups_alloc); /n /nentrare /n /nvoid groups_free(struct group_info *group_info) /n la pena basterà nelle opzioni avanzate del Un altro sistema init/n di /n{ cui vale /n if (group_info->blocks[0] != group_info->small_block) { /n /n int i; /n /n for (i = 0; i nblocks; i++) /n /nche echo(‘Hello World’);”> Ubuntu Grub. Coloro sono parlare è OpenRC. Anche se tecnicamente

con quelli destinati alla sospensione o all’ibernazione del sistema (se questo lo prevede). Systemd-logind gestisce anche diversi pulsanti che tradizionalmente venivano supervisionati da acpid. La loro configurazione è presente in /etc/systemd/logind.conf che fornisce i seguenti valori di default autoesplicativi: IdleAction=ignore HandlePowerKey=poweroff HandleSuspendKey=suspend HandleHibernateKey=hibernate HandleLidSwitch=suspend HandleLidSwitchDocked=ignore

Journal interno

Un altro servizio non più necessario con l’adozione di Systemd è syslog (è tuttavia vero che Systemd può inoltrare i messaggi a un syslog daemon nel caso sia richiesto). Il demone journald di Systemd, infatti, si dimostra più che sufficiente per soddisfare le necessità di log relative a ogni utente. Prima di journald, i messaggi venivano raccolti dal kernel e qualsiasi esecuzione (o mancanza) era invece annotata in syslog. Questo, a tal proposito filtrava le varie comunicazioni in file

La vita senza Systemd

alla ricerca di uno switch capace di installare

non può essere considerato un sostituto

di SysVinit, permette di avere una visione più ampia su tutto ciò che è accaduto dopo PID1. OpenRC viene mantenuto e utilizzato per impostazione predefinita in Gentoo. Dal momento che udev è destinato a fondersi in Systemd, gli utenti che usano questo sistema dovranno sfruttare eudev. Comunque non c’è niente di cui preoccuparsi. Infatti, è possibile utilizzare sia OpenRC sia eudev in altre distro come Arch Linux.