In realtà loro conoscono benissimo la sicurezza ma spesso non vogliono
affrontare analisi, fuzzing, pentest e altro per paura di dover rivoluzionare
progetti interi che risalgono anche a piu’ di 10anni fa!!

Non faccio nomi, ma la situazione, anche per noi “clienti” che ci fidiamo
non è per niente sicura e non certo io ma la cronaca parla abbastanza
chiara: ogni anno milioni di normali utenti vengono inculati per colpa di
qualche azienda che non li tutela come dovrebbe..

vorrei pero’ abbandonare, almeno per il momento, quello che avviene negli
ambiti enterprise e parlare piu da vicino al privato: cosa deve fare un
normale utente per avere un minimo di sicurezza?

L’argomento è davvero grande già solo per questo ambito “casalingo” non
basterà sicuramente un post, ma cominciamo qui dalle basi, questo primo
appunto sarà di facile fruizione e dedicato a utenti alle prime armi, diciamo,
per intenderci meglio, un post aranzulliano :p

Una delle prime cose che dobbiamo analizzare per capire quanto il nostro
pc è sicuro è il “giro” che i pacchetti in uscita fanno verso internet e
sopratutto se tali pacchetti vengono trasmessi in chiaro..
un altra cosa poi, che riguarda forse più i portatili e i device destinati
ad “uscire da casa” è analizzare anche quanto sono fruibili i dati nostri
sul filesystem e quindi in primis se il nostro profilo è coperto da una
password robusta e consistente e in secundis se il nostro filesystem è
cifrato o meno..l’idea è quella di astrarre il piu possibile, di allontanare
le nostre informazioni da tutti tranne che da noi in maniera decisa e radicale..
più ci riusciamo, più diventa difficile raggiungere i nostri dati personali.

In questo post vi daro’ qualche idea, più avanti, appena trovero’ il tempo
giusto, scrivero’ anche qualche breve tutorial per spiegare come “tirarla su”
(l’idea) senza troppi problemi.

Cominciamo dal/i nostro/i hard-disk, prima di formattarli, se sono stati usati,
andrebbero sempre skretchati con dati randomici, per esempio con un bel:
dd if=/dev/urandom of=/dev/ bs=1M (/dev/drive è il device da sovrascrivere ovviamente)

..ci starà tanto quanto è grande il nostro device..se vogliamo una stima
possiamo dare un:
kill -USR1 $(pidof dd) durante l’operazione..

fatto questo possiamo decidere in base al tipo di partizione (bootabile o meno)
se utilizzare LUKS, truecrypt o altro.. piu avanti, in un altro post, entreremo
nel dettaglio su questo.

Avendo dei device crittati saremo sicuri che se dovessimo perdere il nostro
laptop piangeremo solo (con un occhio?) per lui e non per i nostri dati…
ovviamente questo vale anche per un hd esterno, una usbkey etc etc.

Passiamo adesso al network, come renderci davvero anonimi in rete?

Dicevo che innanzitutto bisogna analizzare quale sarà il giro che i pacchetti
faranno prima di raggiungere internet: il giro in parole povere è
NostroPC—->ROUTER—->In(f)ernet
e scrivo Infernet non a caso… già perchè è proprio cosi’ che dobbiamo
concepirlo per difenderci e renderci invisibili quanto piu’ possibile…

Nella rete oltre i piu’ comuni virus e worm girano tanti spider, parecchi robot
in grado di reperire informazioni dai più ingenui ute(o)nti..e non parlo delle
pratiche più stupide e facilmente sgamabili tipo il Phishing ma parlo di tanto
altro, di sniffer, trojan, massbots, rootkit etc etc tutte robe che giornalmente
vengono piazzate e utilizzate facilmente su milioni di pc a insaputa di utenti e
(pseudo)sistemisti…l’approccio è sempre lo stesso, il robot dapprima individua
un servizio buggato tramite uno scanport, successivamente sfrutta la vulne
per bindare un proprio socket o cmq avere accesso al target..

Dobbiamo allora rendere invisibili i nostri servizi, o cmq renderli almeno più
sicuri: per far cio’ mi viene in mente iptables, ipfw o anche il nostro router
casalingo, router che nel migliore dei casi è anche un firewall, in questa
maniera sapremo cosa rendere accessibile all’esterno e cosa no e sopratutto
sapremo che tutto cio’ che è accessibile deve essere prima ancora PATCHATO..

io spesso vado anche a cambiare il version sui sorgenti dei servizi prima di
compilarli, e cambio anche le porte di default..questa pratica è inutile se il
servizio è buggato ma è cmq un livello piccolo in piu’ di astrazione, diciamo che
è quel poco che basta per non rendere il servizio localizzabile almeno ai bot
piu’ stupidi che basano le proprie scansioni sulle porte in ascolto e il version
(la rete ne è satura!)..

Se patchati i nostri servizi sono più sicuri di prima (salvo 0day ovviamente).

Vediamo di analizzare adesso quello che “trasmettiamo” su internet:
i nostri pacchetti in uscita, le nostre navigazioni sul web per esempio..

Le pagine web navigate e altro (anche le password!) sappiamo che vengono
raccolte, quando abilitata, nell’history del browser…possiamo stare
sicuri almeno adesso sul fatto che queste siano più sicure visto che
prima abbiamo cifrato il nostro disco.. se volessimo astrarre ancora di
piu’ potremmo usare per le navigazioni più a rischio una macchina
virtuale opportunamente configurata, magari una VM che risieda su un
virtualdisk cifrato con truecrypt e che bootiamo solo all’occorrenza
(per esempio quando dobbiamo utilizzare carte di credito o accedere al
sito della nostra banca).. in questa maniera il file contenente la vm
(vmdk, vdi etc.) viene crittato e a sua volta risiede su un filesystem
crittato: livello di astrazione = +2

..il giro dei dati sarà pero’ sempre lo stesso: anche usando una VM i dati
verranno trasmessi in chiaro dal nostro gateway a Infernet..(e lo stesso
vale per le chiamate al DNS) l’idea sarebbe quella di trovare un nodo, un
relay al quale trasmettere i dati (magari crittati) e che provveda lui
stesso a girare tali dati cifrati in rete: per far cio’ potremmo utilizzare
una VPN in UDP utilizzando una nostra macchina in rete (io uso una vps per
esempio) oppure un qualche servizio su internet (cercate VPN services la
rete è piena, solitamente i migliori sono a pagamento ma assicurano la
cancellazione addirittura dei logs di accesso!).
Esiste anche l’opzione TOR, io la uso sempre come secondaria, nel senso che
arrivo a tor sempre dopo una vpn esterna perchè non mi fido al 100%..

I maniaci come me, inoltre, creano proprio delle sottoreti virtuali sul quale
girare i pacchetti, in particolare io potrei tirare su due o piu macchine
virtuali impostandole una come gw dell’altra e facendole viaggiare su vpn
diverse:

VM1—(vpn udp)—> 1GW/Relay VM2—-(vpn2 udp)—>2GW VM3

I miei dati praticamente “escono” dalla prima macchina virtuale incapsulati e
cifrati tramite la prima vpn instaurata con la seconda VM che a sua volta li
cifra nuovamente e li gira su internet sfruttando un’altra vpn e cosi via…

(PS: è indubbio che più è il numero delle vpn pubbliche più sarà lenta la
navigazione)

in questa maniera siamo sicuri che anche i nostri pacchetti
diventano per lo meno inleggibili (o quasi) per provarlo si puo’ utilizzare
un qualsiasi sniffer (tcpdump, ethereal, ettercap) e mettersi ai bordi e
catturare il traffico.
Infine dicevamo delle interrogazioni ai DNS, solitamente queste vengono fatte
dirette dal host (cosa che in molti dimenticano) quindi per completare il nostro
giro dovremmo provvedere a crittarle, un consiglio è quello di cominciare
usando unbound+dnscrypt-proxy oppure nameserver pubblici con zerolog
garantiti…
ma per oggi mi fermo qui.
Amen!

Nel mio caso ho dapprima bindato sshd sulla 1022 e http ssl sulla 4433 e successivamente configurato il file di configurazione
di sshd (su archlinux /etc/conf.d/sslh ) in questo modo:

LISTEN=178.79.135.237:443
SSH=localhost:1022
SSL=localhost:4433

Il demone sslh praticamente si mette in ascolto sulla 443 analizza il pacchetto, se questo è http lo forwarda sulla 4433 altrimenti sulla 1022 se è una connessione ssh.
Amen

eccovi l’esempio:
# cat /var/log/dmesg.log |sprunge
http://sprunge.us/rtsNw
ciao!

Bene ho scritto “Tablespace problematici” e non Tablespace.. già perchè spesso il comando da manuale per il resize:
ALTER DATABASE DATAFILE ‘/home/oracle/oradata/tbmaledetto.dbf’ size 10G
indovinate? Non funziona…
i motivi sono tanti e a volte basta semplicemente un PURGE RECYCLEBIN per risolvere
altre volte invece, quando siete tanto ma taanto ma proprio taaaanto sfigatti il vostro db proviene da svariati
porting e durante il suo percorso, di release in release, il tablespace in questione ha sempre più frammentato i suoi dati all’interno fino a rendere praticamente impossibile perdere tempo tra i blocks liberi e fantomatici recuperi “standard”…

Quindi la soluzione è:

1> Create un TS NUOVO con le dimensioni/datafiles utili a contenere il vecchio..dategli un nome PROVVISORIO
(io ho spostato USERS, e mi sono bastati due DATAFILE da 20Gb ciascuno)
create tablespace USERS2 datafile ‘/home/oracle/oradata/user1.dbf’ size 20G autoextend on,’/home/oracle/oradata/user2.dbf’ size 20G autoextend on;
2> muovete tutti gli oggetti del TS “vecchio” spoolando ed eseguendo questo script:
(io l’ho usato per spostare tutti gli oggetti di USERS dentro USERS2.. modificatelo voi stessi secondo quello
che vi serve oppure se siete fighi sostituite USERS e USERS2 con &VARIABILE1 e &VARIABILE2

set pagesize 2000
set linesize 200
set echo off
set heading off
select ‘Transporting tablespace ‘ || ‘USERS’ || ‘ to tablespace ‘ || ‘USERS2′ from dual;
select ‘Size: ‘ || to_char((sum(ext.bytes) / 1048576), ’9,990.00′) || ‘ MB’
from dba_objects ob
inner join (
select ta.owner, ta.table_name as nom, ta.tablespace_name as tbs, ‘TABLE’ as tipo from dba_tables ta
union
select ind.owner, ind.index_name as nom, ind.tablespace_name as tbs, ‘INDEX’ as tipo from dba_indexes ind
) tb on tb.owner=ob.owner and tb.nom=ob.object_name and tb.tipo=ob.object_type
inner join dba_extents ext on ext.segment_name = ob.object_name
where ob.object_type in (‘INDEX’, ‘TABLE’, ‘LOB’) and (tb.tbs = ‘USERS’);
select ‘alter user ‘ || ob.owner || ‘ quota unlimited on ‘ || ‘USERS2′ || ‘ default tablespace ‘ || ‘USERS2′ || ‘;’
from dba_objects ob
inner join (
select ta.owner, ta.table_name as nom, ta.tablespace_name as tbs, ‘TABLE’ as tipo from dba_tables ta
union
select ind.owner, ind.index_name as nom, ind.tablespace_name as tbs, ‘INDEX’ as tipo from dba_indexes ind
) tb on tb.owner=ob.owner and tb.nom=ob.object_name and tb.tipo=ob.object_type
where ob.object_type in (‘INDEX’, ‘TABLE’, ‘LOB’) and (tb.tbs = ‘USERS’)
group by ob.owner;
select
decode(ob.object_type,
‘TABLE’,
‘alter table “‘ || ob.owner || ‘”.”‘ || ob.object_name || ‘” move tablespace ‘ || ‘USERS2′ || ‘;’,
‘alter index “‘ || ob.owner || ‘”.”‘ || ob.object_name || ‘” rebuild tablespace ‘ || ‘USERS2′ || ‘;’
)
from dba_objects ob
inner join (
select ta.owner, ta.table_name as nom, ta.tablespace_name as tbs, ‘TABLE’ as tipo from dba_tables ta
union
select ind.owner, ind.index_name as nom, ind.tablespace_name as tbs, ‘INDEX’ as tipo from dba_indexes ind
) tb on tb.owner=ob.owner and tb.nom=ob.object_name and tb.tipo=ob.object_type
where ob.object_type in (‘TABLE’) and (tb.tbs = ‘USERS’);
select
‘alter table “‘ || lo.owner || ‘”.”‘ || lo.table_name ||
‘” move lob (“‘ || lo.column_name || ‘”) store as (tablespace ‘ || ‘USERS2′ || ‘);’
from dba_lobs lo
inner join dba_segments se on se.segment_name = lo.segment_name
where se.tablespace_name = ‘USERS’;
select
decode(ob.object_type,
‘TABLE’,
‘alter table “‘ || ob.owner || ‘”.”‘ || ob.object_name || ‘” move tablespace ‘ || ‘USERS2′ || ‘;’,
‘alter index “‘ || ob.owner || ‘”.”‘ || ob.object_name || ‘” rebuild tablespace ‘ || ‘USERS2′ || ‘;’
)
from dba_objects ob
inner join (
select ta.owner, ta.table_name as nom, ta.tablespace_name as tbs, ‘TABLE’ as tipo from dba_tables ta
union
select ind.owner, ind.index_name as nom, ind.tablespace_name as tbs, ‘INDEX’ as tipo from dba_indexes ind
) tb on tb.owner=ob.owner and tb.nom=ob.object_name and tb.tipo=ob.object_type
where ob.object_type in (‘INDEX’) and (tb.tbs = ‘USERS’);

Adesso il vecchio TS è vuoto… cancellatelo e insultatelo quanto volete:
DROP TABLESPACE users INCLUDING CONTENTS AND DATAFILES;
(PS: se il TS è il DEFAULT USER settate come DEFAULT USERS quello nuovo così:
ALTER database default tablespace users2; )
e rinominate il nuovo con:
ALTER TABLESPACE users2 RENAME TO users;
Finalmente avete risparmiato lo spazio che desideravate e in più avete il vostro bel TS
con i dati frammetati e quindi resizzabile quando e quanto credete.
Amen

PROPERTY_VALUE
——————————————————————————–
TEMP
E ovviamente se proviamo a fare la cosa più normale in questi casi, e cioè dropparla e rigenerarla, essendo la TEMP globale del db otterremo un errore ORA-12906:
SQL> drop tablespace temp;
drop tablespace temp
*
ERROR at line 1:
ORA-12906: cannot drop default temporary tablespace
Per risolvere il problema dobbiamo quindi creare una nuova TS temporanea provvisoria così:
SQL> create temporary tablespace temp2 tempfile ‘/oradata2/temp2.dbf’ size 10M;
Tablespace created.
Definirla come temporanea principale:
SQL> alter database default temporary tablespace temp2;
Database altered.
Per confermare che sia la TS che vogliamo diamo un:
SQL> select username, temporary_tablespace from dba_users where username in (‘utente1′,’SCOTT’,'utente2′);

USERNAME TEMPORARY_TABLESPACE
—————————— ——————————
utente1 TEMP2
PROD TEMP2
utente2 TEMP2

A questo punto finalmente cancelliamo la TS temporanea ex-di-default
SQL> drop tablespace temp;
Tablespace dropped.

Cancelliamo il datafile corrispondente nel filesystem mi raccomando e infine riprocediamo come sopra
ma stavolta per la TS TEMP definitiva.
Amen

————————————————-

Il secondo metodo come vi dicevo è piu complesso e lungo, consiste nel rifare la procedura a mano x la creazione del controlfile:
Bisogna innanzitutto ricordarsi il PATH settato x files di trace del db:
* SQL> show parameter USER_DUMP_DEST ;
Questo PATH ci servirà a prendere il trace generato dal comando:
* SQL> alter database backup controlfile to trace;
Come vedete dal comando in questa maniera avremmo il ddl per la creazione del cf all’interno del file trace
appena creato.
* Spegniamo il db appena ripristinato:
SQL> shutdown immediate ;
e dalla directory DUMPDEST preleviamo il trc-file corrispondente al controlfileToTrace;
* Editiamolo cominciando a eliminare tutte le righe prima della fase 2 ( Set #2. RESETLOGS case )
* Aggiungiamo un “REUSE” davanti il “SET” della riga: “create controlfile….” modificando il SID vecchio col nuovo, otterremo: “CREATE CONTROLFILE REUSE SET DATABASE “NUOVOSID” ……..
* Cancelliamo tutto quello che viene dopo “CHARACTER SET…”
* Salviamo il nostro file come script sql (.sql)
* Rinominiamo adesso il file initVECCHIOSID.ora in initNUOVOSID.ora (e modifichiamo all’interno i riferimenti al vecchio SID);
* Settiamo l’enviroment x l’ utenza unix e carichiamola.
* SQL> startup nomount ;
* lanciamo il file precedentemente modificato per la creazione del nuovo controlfile ;
* SQL> alter database open resetlogs (occhio alle dir nuove per i logs, il nome sarà il nuovo SID, ci sono già?)
* SQL> alter database rename global_name to
* SQL> alter database open;
* Ricreiamo la TABLESPACE temporanea.

- compilare dentro $HOME/.juniper_networks/network_connect/ l’eseguibile ncui così:
gcc -m32 -Wl,-rpath,`pwd` -o ncui libncui.so

- prendiamo adesso il certificato ssl dal host con:
echo | openssl s_client -connect extranet.dominio.net:443 2>&1 |sed -ne ‘/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p’ |openssl x509 -outform der > ssl.crt

CONNESSIONE
- Da questo momento per ogni connessione alla VPN faremo il login sul frontend web del network connect https://extranet.dominio.net e preleveremo il DSID cookie tramite il browser con il comando:

javascript:alert(document.cookie)

in questa maniera successivamente potremmo far partire il client con:
(cd /root/.juniper_networks/network_connect; )
./ncui -h extranet.sace.it -c “DSID=733f7719f6f92672b63bea541f24c73b” -f ssl.crt

cd /etc/ssl/certs & openssl req -new -x509 -newkey rsa:1024 -days 3650 -keyout mail.key -out mail.crt
openssl rsa -in mail.key -out mail.key & mv mail.key /etc/ssl/private

Assicuriamoci che l’utenza di sistema che mapperemo con quella per l’email appartenga al gruppo “mail” e cominciamo con le installazioni:

pacman -S postfix procmail dovecot spamassassin
configuriamo spamassassin:
groupadd -g 5001 spamd
useradd -u 5001 -g spamd -s /sbin/nologin -d /var/lib/spamassassin -m spamd
chown spamd:spamd /var/lib/spamassassin

tuniamo un po’ abbassando ad 1 il valore del parametro max-children (default=5), cio’ ci fara risparmiare parecchia ram:
vi /etc/conf.d/spamd

SAHOME=”/var/lib/spamassassin/”
SPAMD_OPTS=”-c –max-children 1 –username spamd -H ${SAHOME} -s ${SAHOME}spamd.log –pidfile /var/run/spamd.pid”

Configuriamo adesso DOVECOT per l’ IMAPssl e il pop3dssl con:
vim /etc/dovecot/dovecot.conf

protocols = imaps pop3s

disable_plaintext_auth = yes
log_timestamp = “%b %d %H:%M:%S ”

#ssl_disable = no

#i nostri certificati precedentemente creati
ssl_cert_file = /etc/ssl/certs/mail.crt
ssl_key_file = /etc/ssl/private/mail.key

mail_location = maildir:~/Maildir
mail_access_groups = mail
auth_username_chars = abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890.-_@

protocol imap {
imap_client_workarounds = delay-newmail tb-extra-mailbox-sep
}

protocol pop3 {
pop3_uidl_format = %08Xu%08Xv
#pop3_client_workarounds =
}

auth default {
mechanisms = plain login
passdb pam {
}
userdb passwd {
}
user = root
socket listen {
client {
path = /var/run/dovecot/auth-client
user = postfix
group = postfix
mode = 0660
}
}
}

Passiamo adesso alla configurazione di POSTFIX, (

cd /etc/postfix/

) cominciamo dal file principale:
vi main.cf

# Paths
queue_directory = /var/spool/postfix
daemon_directory = /usr/lib/postfix
command_directory = /usr/sbin
mail_owner = postfix
# Domain settings
myhostname = mail.nostrodominio.com
myorigin = nostrodominio.com
mydestination = $myhostname, localhost.$mydomain, localhost
# Timeout settings and other limits
delay_warning_time = 4h
unknown_local_recipient_reject_code = 450
minimal_backoff_time = 300s
maximal_backoff_time = 1200s
maximal_queue_lifetime = 1d
bounce_queue_lifetime = 1d
smtp_helo_timeout = 60s
smtpd_soft_error_limit = 3
smtpd_hard_error_limit = 12
# SMTP settings
smtpd_tls_cert_file=/etc/ssl/certs/mail.crt
smtpd_tls_key_file=/etc/ssl/private/mail.key
smtpd_use_tls=yes
smtpd_tls_session_cache_database = btree:/var/lib/postfix/smtpd_scache
smtp_tls_session_cache_database = btree:/var/lib/postfix/smtp_scache
smtpd_tls_loglevel = 1
smtpd_sasl_auth_enable = yes
smtpd_recipient_restrictions = permit_sasl_authenticated, permit_mynetworks, reject_unauth_destination,
#postgrey
check_policy_service inet:127.0.0.1:10030
smtpd_sender_restrictions = permit_sasl_authenticated, permit_mynetworks
smtpd_sasl_security_options = noanonymous
# SASL
smtpd_sasl_type = dovecot
smtpd_sasl_path = /var/run/dovecot/auth-client

# Network settings
inet_interfaces = all
inet_protocols = ipv4
mynetworks = 127.0.0.0/8
relayhost =
# Email and mailbox settings
alias_maps = hash:/etc/postfix/aliases
alias_database = $alias_maps
home_mailbox = Maildir/
virtual_alias_domains = miodominio.com eventualealtrodominio.org
virtual_alias_maps = hash:/etc/postfix/virtual
mailbox_size_limit = 0

# Misc
mailbox_command = /usr/bin/procmail
smtpd_banner = $myhostname ESMTP banner_che_vogliamo
biff = no
append_dot_mydomain = no
debug_peer_level = 2
sendmail_path = /usr/sbin/sendmail
newaliases_path = /usr/bin/newaliases
mailq_path = /usr/bin/mailq
setgid_group = postdrop
html_directory = no
manpage_directory = /usr/man
sample_directory = /etc/postfix/sample
readme_directory = no
recipient_delimiter = +

Mappiamo adesso utenza sys/utenza email inserendo le informazioni opportune con:
vi /etc/postfix/virtual

utenteemail@dominiomio.com utentesistema@localhost
utente2mail@altrodominio.org utentesistema2@localhost
#etc.

lanciamo adesso il comando:

postmap /etc/postfix/virtual

alliniamo adesso a spamassassin postfix configurando il suo vero motore principale:
vi master.cf e aggiungiamo/modifichiamo

smtp inet n – n – – smtpd
-o content_filter=spamassassin
spamassassin unix – n n – – pipe
user=spamd argv=/usr/bin/perlbin/vendor/spamc -f -e
/usr/sbin/sendmail -oi -f ${sender} ${recipient}

Configuriamo spamassassin:
vi /etc/mail/spamassassin/local.cf

rewrite_header Subject *****SPAM*****
required_score 3
report_safe 0 #1
use_bayes 1
use_bayes_rules 1
bayes_auto_learn 1

Diciamo adesso a procmail come istruire le emails marchiate da spamassassin:
vi /etc/procmailrc

DROPPRIVS=yes
DEFAULT=$HOME/Maildir/
MAILDIR=$HOME/Maildir/
:0:
* ^X-Spam-Status: Yes
.Junk/

Postgrey:
yaourt -S postgrey
configuriamo con
vi /etc/conf.d/postgrey

POSTGREY_TYPE=”inet”
POSTGREY_HOST=”127.0.0.1″
POSTGREY_PORT=”10030″
POSTGREY_SOCKET=”/var/spool/postfix/private/postgrey”
POSTGREY_OPTS=”–delay=60″

Infine creiamo la Maildir per l’utente:

cd ~utente
umask 077
mkdir -p Maildir/{cur,new,tmp}
mkdir -p Maildir/.Drafts/{cur,new,tmp}
mkdir -p Maildir/.Sent/{cur,new,tmp}
mkdir -p Maildir/.Trash/{cur,new,tmp}
chmod -R 0700 Maildir
chown -R utente:users *

Riavviamo adesso tutti i servizi legati al mail server

/etc/rc.d/postgrey start
/etc/rc.d/spamd start
/etc/rc.d/dovecot start
/etc/rc.d/postfix start

..e configuriamoci i nostri clients di posta.

SQL> CREATE OR REPLACE TRIGGER trace_logon
2 after logon on database
3 begin
4 if ( sys_context(‘USERENV’, ‘SESSION_USER’) in (‘N00b1′, ‘Noob2′))
5 then
6 execute immediate ‘alter session set timed_statistics=true’;
7 execute immediate ‘alter session set max_dump_file_size=10000′;
8 execute immediate ‘alter session set tracefile_identifier=”Noobs”;
9 execute immediate ‘alter session set events ”10046 trace name context forever, level 12”’;
10 end if;
11 end;
12 /

SQL> CREATE OR REPLACE TRIGGER trace_logoff before logoff on database
2 begin
3 if ( sys_context(‘USERENV’, ‘SESSION_USER’) in (‘N00b1′,’Noob2′))
4 then
5 execute immediate ‘alter session set events ”10046 trace name context off”’;
6 end if;
7 end;
8

PS:
tkprof $ORACLE_BASE/diag/rdbms/prod/prod/trace/*Noobs….* $ORACLE_HOME/*Noob….*.out sys=no print=10 sort=fchela