Copy Link
Add to Bookmark
Report
SystemDown 02
*********************************************************************
* *
* Chiunque venisse in possesso di questa rivista e' pregato di NON *
* postarla su NESSUN TIPO di newsgroup. Gli autori di questo testo *
* non si prendono nessuna responsabilita' per l'uso che ne verra' *
* fatto poiche' e' stata espressamente concepita per puri scopi *
* informativi. *
* *
*********************************************************************
Introduzione
Siamo cosi' giunti al secondo numero di SystemDown.
Vi diro' la verita': abbiamo ricevuto diverse mails di ragazzi contenti del
lavoro che e' stato svolto il mese scorso e cio' non puo' che farci piacere.
Sono felice che tutto questo sia piaciuto; vuol dire che le notti passate
ha dialogare in chat per scoprire se si poteva realizzare questo progetto
sono servite, in fondo, a qualcosa.
D'ora in avanti, comunque, abbiamo deciso di pubblicare SystemDown ogni
2 mesi per poter migliorare ( si spera! ) la qualita' degli articoli
qui riportati e per dare piu' tempo a chi scrive di reperire le informazioni
piu' interessanti.
Vista la quantita' di mails arrivate alla mia casella di posta abbiamo
deciso di aprire una piccola mailbox per poter rispondere, come
meglio possiamo, alle vostre domande e/o curiosita'.
Se volete scrivere potete farlo al Dr.Creker a dr.creker@deathsdoor.com.
E' inutile pero' che domandiate come entrare dentro un sistema o i
metodi per non pagare gli scatti del telefono perche' non possiamo
rispondervi per semplici motivi legali. Il nostro aiuto sara' limitato
solamente a darvi spiegazioni sugli articoli contenuti in questo testo.
Ci sono stati alcuni problemi con un articolo ( scritto da Ramlin ) nello
scorso numero della rivista poiche' quest'ultima e' andata online senza il
suddetto articolo.
Riporto quindi in questo numero il testo citato chiedendo scusa a Ramlin
per non essere riuscito a pubblicarlo in tempo per il numero precedente.
Un'ultima cosa: alcune persone ci hanno criticato per errori di ortografia
che, a quanto dicevano loro, erano praticamente ORRORI di ortografia,
illeggibili ed "elementari".
Possiamo anche capire il fatto di aver commesso qualche errore ma il testo
era ugualmente comprensibile e quindi penso che nessuno di voi si sia troppo
scandalizzato per un accento posto male su una parola.
Cio' che conta, penso, e' la sostanza; quindi non ce ne vogliate se per
caso, un giorno, incappaste in qualche strana parola mal accentata
all'interno di questa rivista...
By InfectedMachine ( Infected@community.co.uk )
Indice
Introduzione
1) VAX/VMS ( by InfectedMachine )
2) Sniffi tu che sniffo anche io ( by IceNice )
3) Firewall: concetti base (Parte I) ( by Ramlin )
4) Blue box: teoria dell'utilizzo ( by Jester )
5) Psicologia Costrittiva ( by Jack McKrak )
6) The Xoanon's Guide to Cracking ( by Xoanon ) Iø Parte
7) I siti del Dr.Creker ( by Dr.Creker )
Ringraziamenti
Conclusioni
Purtroppo RaggedRobin non e' riuscito a completare il suo nuovo e direi
interessante virus in tempo e quindi abbiamo pubblicato senza il suddetto
pezzo che comparira' nel terzo numero di questa rivista.
VAX/VMS ( by InfectedMachine )
Da questo numero vorrei trattare la descrizione ( piu' approfondita che
posso ) dei sistemi operativi sparsi in giro per la rete e che magari vi e'
capitato piu' volte di incontrare.
Vedro' di spiegare quanto meglio posso il sistema e la sua storia. Le nozioni
sul suo uso ed infine le tecniche per potervi accedere.
Allora partiamo subito col dire una cosa:
Se volete hackerare un VAX o siete veramente bravi ( e quindi non credo che
vi interessi questo mio articolo ) oppure avete un forte motivo per farlo.
Se siete alle prime armi NON avvicinatevi a questo tipo di sistema poiche'
e' considerato il piu' sicuro che ci sia in giro.
Detto questo, inizio con un breve accenno di storia sul VAX/VMS.
Il computer VAX, la cui sigla significa Virtual Address eXtension e' stato
creato dai tecnici della Digital Equipment Corporation ( DEC ).
Ci sono vari modelli di questo computer: dal piu' vecchio MicroVax, alla
serie 11/7XX per finire alla serie 6000.
Purtroppo sono rimasto a questa serie e non so' se ne e' uscita una nuova.
Perdonatemi.
Il computer VAX usa, solitamente, un sistema operativo chiamato VMS.
VMS sta per Virtual Memory System. Sempre creato dalla DEC questo sistema
e' molto pratico per quanto riguarda la sicurezza di un terminale in quanto
e' molto piu' flessibile di sistemi come lo unix o il dos.
Il VMS utilizza un linguaggio chiamato DCL, ovvero Digital Command Language
ed e' stato creato utilizzando due linguaggi di programmazione cioe' il
BLISS-32 e il FORTRAN.
Per fare un esempio lo si puo' paragonare al linguaggio batch del dos o allo
script dello unix ma con alcune differenze.
Una di queste e' che quando si vuole far partire un programma dal prompt
bisogna mettere un $ davanti al comando.
In genere i programmi del DCL sono comunemente chiamati COM file.
Tutte le procedure di login su questo sistema possono essere eseguite in
una di queste due modalita':
1) Interattiva;
2) Non interattiva.
Il primo metodo significa che lo user deve eseguire alcune istruzioni
( login, password ) che il terminale gli invia per poter cosi' accedere
alle sue funzioni.
Esempio di questo primo metodo sono l'accesso locale ( quando si e'
connessi direttamente al processore del computer ); attraverso linee
telefoniche o da un nodo remoto di una rete.
Il secondo metodo, ovviamente, significa che lo user deve solo attendere
che il software lo colleghi senza dover far nulla poiche' a tutte le
procedure pensa il computer.
Alcuni esempi possono essere attraverso network; tramite un batch login
che e' un processo iniziato da uno user e che sta attualmente girando
sulla macchina oppure tramite un sottoprocesso che e' fatto partire da
uno user ed e' il risultato di un comando del sistema o di un servizio
di quest'ultimo.
Qui di seguito riporto ( presi da varie riviste sparse per la rete, prima
di queste la LOD ) le password e gli account piu' comuni per questo
tipo di sistema:
ACCOUNT PASSWORD
RJE RJE
HOST HOST
LINK LINK
INFO INFO
BACKUP BACKUP
NETWORK NETWORK
DECMAIL DECMAIL
HELPDESK HELPDESK
REPORT REPORT
REPORTS REPORTS
DECNET DECNET
DEFAULT DEFAULT
DEMO DEMO ( o privo di password )
FIELD FIELD, SERVICE
GUEST GUEST ( o privo di password )
OPERATOR OPERATOR
OPERATIONS OPERATIONS
SYSMAINT SYSMAINT, SERVICE, DIGITAL
SYSTEM SYSTEM, MANAGER, OPERATOR, SYSLIB
SYSTEST UETP, SYSTEST
SYSTEST_CLIG CLIG, SYSTEST, TEST
SUPPORT SUPPORT, DEC
Una possibile schermata di login puo' essere questa:
*********************************************************************
WELCOME TO THE
AT&T MICROVAX II SYSTEM
Username:
Password:
Dopo averli inseriti puo' apparire:
Last interactive login on Wednesday, 01-JUN-1996 10:20.11
Last noninteractive login on Friday, 30-MAY-1996 15:38.27
2 failures since last successful login
You have 1 new mail messagge
$ ( questo e' il simbolo del prompt dei comandi )
Come si puo' benissimo vedere dallo schema che ho riportato sopra, il
VAX registra i tentativi falliti di login e li comunica all'utente
quando effettua il primo login corretto ( comunque ne parlaremo anche
dopo ).
Comandi del VAX/VMS:
Di seguito riporto i comandi piu' utilizzati in questo sistema.
@: Esegue un programma. Se si vuole eseguire un file .com bisogna mettere
davanti ad esso un @. Ad esempio: @LOGIN.COM;3
ACCOUNTING: Questo comando fa' partire il programma accounting che serve
per vedere quanto sei stato online.
CREATE: Compilatore Pascal. Usare: CREATE nomefile.pas
CREATE/DIR: Crea sottodirectory.
DELETE: Questo comando e' usato per cancellare file o per cancellare
directory vuote e non protette. Per cancellare un file usa il comando
DEL filename.ext;x. Per cancellare una directory prima bisogna
cancellare tutti i file presenti in essa ( DEL/LOG *.*:* ) poi
bisogna settare la protezione ( SET PROTECTION ):
SET PROTECTION=OWNER:D nomedirectory.DIR poi cancellare la
directory DEL nomedirectory.DIR.
DIR ( DIRECTORY ): Questo comando ti permette di vedere quali file sono
contenuti in una directory ( vedi dir per dos o ls per unix ).
Con /BRIEF si otterra' una piccola lista mentre con /FULL si
vedra' il contenuto completo della directory.
Esempio: DIR/FULL PIPPO-%%.*;%
Il carattere % serve ad indicare un qualsiasi carattere mentre * indica
una qualsiasi cosa.
EDIT: editor VMS.
HELP: Ti fornisce il programma degli aiuti ( che tra l'altro sono
tra i migliori esistenti al mondo ).
LIBRARY: Usato per scopi di archiviazione.
LOGOUT: Disconnette dal sistema.
MAIL: Carica il programma per la posta elettronica.
$PASSWORD: Cambia la propria password. Esempio: $PASSWORD nuovapassword.
PHONE: Usato per parlare con un altro utente. Per parlare con uno user
bisogna digitare il suo nome.
PHOTO: Registra una sessione.
RUN: Lancia un eseguibile.
SET: Vedi oltre.
SHOW: Show puo' mostrare molte cose e la sintassi e' come in questo
esempio: SHOW USERS DAV ( SHOW qualcosa qualcuno ).
-CLUSTER: Mostra i cluster del VAX se ci sono
-DEFAULT: Percorso della directory.
-DEVICES: Mostra i device del sistema.
-INTRUSION: Dice se ci sono degli account che sono stati hackerati.
-MEMORY: Memoria.
-NETWORK: Mostra il network e dove il VAX e' connesso.
-PROCESS: Mostra lo stato di un processo in corso.
-PROTECTION: Mostra le protezioni di un file.
-QUOTA: Mostra lo spazio sul disco permesso per il tuo account.
-SYSTEM: Varie informazioni sul sistema.
-DAY: Giorno e data.
-TIME: Ora.
-USERS: Mostra gli user online sul sistema.
Piccola spiegazione del comando SET:
SET FILE/PROTECTION: settare i permessi nei file o nelle directory.
La stringa da utilizzare e': SET FILE/PROTECTION=OWNER[RWED]
nomefile.estensione ( RWED: permessi dei file, spiegato oltre ).
Al posto di OWNER ( possessore ) si possono mettere le seguenti opzioni:
-WORLD: per tutti gli users connessi al sistema;
-GROUP: per tutti gli users nello stesso gruppo del possessore;
-SYSTEM: per tutti quelli che hanno privilegi di SysOp.
SET TERMINAL:
Il comando da utilizzare e': SET TERMINAL/opzioni.
Le opzioni sono le seguenti:
WIDTH=80: 80 colonne di ampiezza;
ADVANCE_VIDEO: seleziona 124 x 24 linee;
NOADVANCE_VIDEo: deseleziona 124 x 24 linee;
ANSI_CRT: seleziona la sequenza di uscita ANSI;
NOANSI_CRT: deseleziona la ANSI_CRT;
AUTOBAUD: permette al computer di selezionare la velocita' piu' alta
possibile per il collegamento;
NOAUTOBAUD: deseleziona la voce sopra;
BROADCAST: permette il ricevimento di SEND, MAIL e PHONE;
NOBROADCAST: previene dalla ricezione di SEND, MAIL e PHONE;
DEVICE_TYPE=VT220: setta il terminale come VT220;
ECHO: abilita l'echo dalle linee di comando del DCL;
NOECHO: disabilita la funzione ECHO;
FULLDUP: abilita il full duplex;
NOFULLDUP: disabilita il full duplex;
HANGUP: esegue il log off se non c'e' portata;
Vi sono altri comandi ma non li riporto...se li volete proprio sapere
tutti vi consiglio di ricercare con l'altavista la parola VAX o VMS e
cercare un po' tra i risultati i vari manuali dei comandi di questo sistema.
SET DEFAULT:
Avete presente il comando cd.. o cd .. ( rispettivamente dos e unix )?
Nel VAX/VMS per cambiare le directory o per entrare in esse e'
necessario conoscere questo comando.
La sintassi per entrare in una directory e':
SET DEFAULT [.SOTTODIRECTORY] mentre per andare nella directory
"superiore" il comando e': SET DEFAULT [-].
SICUREZZA DEL VAX:
Il VAX come ho gia' detto e' il sistema piu' sicuro che ci sia in
circolazione e questo per una serie di motivi:
1) Password;
2) Barriere interne;
3) Monitoraggio;
PASSWORD
Ci sono ( come in ogni altro sistema ) due tipi di accessi, quello
dello user normale e quello del root ( o amministratore di sistema ).
Per il primo in genere il sistema richiede l'inserimento di un nome
( login ) seguito poi da una password.
Per il secondo puo' sia chiedere le stesse cose che ha richiesto ad
uno user sia richiedere l'inserimento di una seconda password
dopo aver inserito la prima...diciamo una successiva barriera di
sicurezza.
Raramente un amministratore di sistema mette due password per accedere
ad una directory ma tenete bene a mente che LO PUO' fare.
BARRIERE INTERNE
Su alcuni sistemi, dopo esserci inseriti con una giusta combinazione
di user e password, potrebbe apparirci un messaggio nel quale ci si
richiedono successive informazioni e cio' potrebbe farci "saltare" ad
un'applicazione supplementare o addirittura ad un errore di sistema.
Per superare questo tipo di protezione si puo' provare a premere
control-c e/o control-y dopo aver inserito correttamente login e pass.
Questo puo' ( e ripeto puo' ) far saltare al sistema l'esecuzione di
programmi di sicurezza, applicazioni o altri tipi di eseguibili che
indicherebbero al computer che non siamo veramente lo user in questione.
Alle volte, pero', gli amministratori di sistemi settano
il comando SET in modo da non poter usare control-y all'inizio della
fase di login ( set nocontrol=y ) impedendo cosi' che intrusi penetrino
nel sistema in questo semplice modo.
MONITORAGGIO
L'intera sicurezza del sistema VMS e' basata su un concetto di monitoraggio
di tutto il terminale.
Un amministratore di sistema puo' controllare:
1) Ogni informazione su di uno user, dalle info personali ai comandi che
lancia sul sistema;
2) Ogni tipo di applicazione e documento presenti sul sistema come, ad
esempio, mailbox, file o terminali;
3) Tutte le possibili forme di sicurezza sui files come diritti su di essi
o le liste di accesso a un dato programma;
4) I cosiddetti avvisi di allarme.
Questo tipo di monitoraggio rende capace il system-operator di seguire
passo passo ogni procedura di autenticazione che si verifica all'interno
del sistema.
Il VMS e' molto flessibile come sistema poiche' un root puo' decidere
praticamente tutto sul terminale...potrebbero mettere una password
sopra un dato file oppure metterne una su tutti quelli presenti.
Potrebbero restringere l'accesso a certi tipi di utenti oppure
lasciare libero accesso a tutti.
Tanto per fare una panoramica generale sulle sicurezze del VMS:
1) Il sistema permette di controllare tutti i tipi di accesso nonche' le
password per un dato documento o per una directory nel sistema
permettendo una maggiore sicurezza rispetto agli altri sistemi esistenti;
2) Registra ogni tipo di interazione tra user e macchina per motivi
di sicurezza e di documentazione;
3) Supporta un sistema di encriptazione che permette all'amministratore
del sistema di creare una particolare chiave per poter accedere ad
una certa zona del computer;
4) Come se non bastassero tutte le sicurezze sopra riportate, possono
essere aggiunti allarmi che "scattano" quando si verificano particolari
condizioni preimpostate come ad esempio un login errato o un accesso a
file del sistema nei quali non potevamo sbirciare.
Tutte queste funzioni di sicurezza si controllano attraverso due
meccanismi:
ACL = Access Control List;
UIC = User Identification Codes.
L'ACL usa alcuni indentificatori per controllare gli user:
1) Gli identificatori UIC dipendono dal codice di identificazione di
uno user e sono UNICI per ogni user nel sistema ( ogni user ne ha uno );
2) Le identificazioni generali sono definite dal root nei diritti del
sistema per identificare gruppi di user nel sistema;
3) Gli identificatori a definizione di sistema descrivono certi tipi di user
basati sul loro uso del sistema.
Una ACL consiste in una o piu' ACE ( Action Control list Entries ):
1) Identificatori ACE: Controllano i privilegi di accesso ad un dato o ad
una directory. I privilegi sono READ, WRITE, EXECUTE, DELETE, CONTROL
e NONE ( R, W, E, D, C, N );
2) Protezione di default ACE: Definisce la protezione di default per
le sole directory;
3) Allarme di sicurezza ACE: Manda un messaggio di allarme quando si
accede ( o si prova ad accedere ) a qualcosa in cui non si poteva
entrare. Le allarmi possono essere generate quando lo user "rompe"
uno di questi privilegi di accesso: READ, WRITE, EXECUTE, DELETE o
CONTROL. L'allarme puo' scattare sia se ci riuscite sia se NON ci
riuscite.
UIC ovvero User Identification Code:
Ogni utente sul sistema ( come ho gia' detto prima ) ha un proprio UIC.
Ogni dato sul sistema ha un UIC associato che gli consente di capire
chi puo' e chi non puo' avere accesso a tale dato ed e' anche il
tipo di identificatore posto sui quattro gruppi principali cioe'
System, Owner, Group, World ( sistema, proprietario, gruppo, altri ).
In base a questo il sistema concede o no l'accesso a uno user a
qualsiasi cosa presente sul terminale. Praticamente in fase di login
ci viene preso il codice di identificazione personale dal database
dei diritti nel sistema e viene poi copiato in una lista di diritti
dalla quale verra' informato il terminale sui tipi di privilegi che
possediamo ogni volta che si cerchera' di accedere ad un certo dato.
Di seguito riporto i principali privilegi di un VAX:
ACNT: Puo' sopprimere i messaggi di accounting.
OPER: Fornisce privilegi da operatore.
GROUP: Puo' prendere altri processi nello stesso gruppo.
WORLD: Come GROUP solo valido per la categoria WORLD.
SHMEM: Puo' creare/cancellare dati nella shared memory.
ALTPRI: Puo' settare qualsiasi livello di priorita'.
BYPASS: Evita le procedure di controllo.
SETPRV: Puo' settare qualsiasi bit di privilegi.
SYSLCK: Blocca le risorse del sistema.
SYSPRV: Puo' accedere a dati attraverso la protezione del sistema.
VOLPRO: Puo' passare sopra alla protezione dei volumi sul sistema.
READALL: Puo' leggere qualsiasi cosa come il possessore.
SECURITY: Puo' far eseguire le funzioni di sicurezza.
Per vedere i propri privilegi all'interno del sistema dovete digitare:
$ SET PROCESS /PRIVS
Se nella lista che compare alla fine della descrizione di tutti i
privilegi e' presente anche quello chiamato SETPRV, ci si puo' dare
qualsiasi tipo di privilegio con il comando:
$ SET PROCESS /PRIVS=ALL
Hacking The VAX
Allora innazitutto direi che ci sono due metodi principali per entrare
in un VAX:
1) Attraverso l'hack di un account & similar;
2) Attraverso una rete;
1) Hack di un Account & Similar
Quando vi loggate ad un account e questo vi da' problemi iniziali
potete provare ad inserire al fianco del login anche un comando:
Username: NOME /NOCOMMAND
Password:
Ci sono 4 comandi fondamentali utilizzabili accanto al login e cioe':
1) /NOCOMMAND: Se il login dell'account che abbiamo hackerato non
permette l'ingresso al sistema operativo, possiamo provare ad inserire,
come nell'esempio sopra, l'opzione /NOCOMMAND che, se abilitata,
potrebbe concedere l'ingresso al sistema evitando ulteriori procedure
di identificazione.
Tutto questo viene mandato in fumo se si tratta di un account particolare
chiamato CAPTIVE.
Gli accounts chiamati Captive permettono un uso e un accesso MOLTO
limitati.
In genere "spediscono" la connessione che abbiamo effettuato ad un altro
programma o ad un'altra applicazione che permettono scarse possibilita' di
poter penetrare all'interno del terminale soprattutto se anche il comando
control-y e' disabiltiato.
2) /CLI ( Command Line Interpreter ): Permette di specificare il DCL
( Digital Command Language ) o il MCR ( Monitor Control Routine ).
3) /DISK: Permette di specificare un disco diverso da quello di default.
4) /TABLES: Specifica il nome di un'altra tabella CLI per poter scavalcare
quella di default specificata nell'UAF ( User Authorization File ).
Il file passwd sotto un VMS e' situato nella directory
SYS$SYSTEM:SYSUAF.DAT; ricordate pero' che il VAX/VMS come ho gia
detto prima, puo' fare in modo che questo file non possa venir
letto da normali utenti.
Se riuscite a scaricarlo e volete confrontarlo con una lista
gia preparata di password ( vedi CrackerJack o Brute per win )
potete usare uno di questi due programmi:
CHECK_PASSWORD
GUESS_PASSWORD
In poche parole dovete riuscire ( se non trovate i programmi
che ho scritto sopra ) a scrivere un programma che, utilizzando
le funzioni SYS$GETUAF, confronti le parole criptate con i dati
sempre criptati in SYSUAF.DAT
Ritornando al discorso di prima, dopo esserci inseriti con successo
all'interno del sistema in questione, ci sono una serie di utili
comandi per capire bene cio' che ci circonda:
SHOW USER, SHOW PROCESS/PRIVS, SHOW AUDIT e SHOW INTRUSION.
SHOW USER
Se, all'interno del sistema, incontriamo un altro user dobbiamo prendere
nota del suo nome e questo per la semplicissima ragione che avere gia'
il nome di un utente faciliterebbe il compito di dover ricercare la sua
password per poter penetrare nel sistema attraverso il suo account.
SHOW PROCESS/PRIVS
Per poterlo usare senza scatenare il finimondo sul terminale in questione
bisogna avere il permesso di usare SHOW AUDIT e SHOW INTRUSION.
Comunque si puo' sempre tentare:
$ SET PROCESS/PRIVS=GROUP
Iniziate con GROUP e se funziona, continuate fino ad arrivare a ALL.
Comunque per lanciare programmi, vedere file o altre interessanti cosucce
NON bisogna avere tutti i privilegi ( ALL )... bastano solo quelli giusti.
SHOW AUDIT
Puo' mostrare due schermate:
La prima potrebbe dare come risultato qualcosa tipo:"Security alarms
currently disabled" ( Allarmi di sicurezza attualmente disabilitate ).
Oppure potrebbe indicare dove si trovano le allarmi:
ACL
BREAKIN: ( DIALUP, LOCAL, REMOTE, NETWORK )
FILE ACCESS:
FAILURE: ( READ, WRITE, EXECUTE, DELETE, CONTROL )
BYPASS : ( READ, WRITE, EXECUTE, DELETE, CONTROL )
LOGIN: ( DIALUP )
LOGOUT: ( DIALUP )
Sarebbe molto importante vedere questa schermata in modo da non far
scattare allarmi cercando un modo per aggirarle senza
correre rischi.
Tanto per rinfrescarvi la memoria un SysOp puo' ricevere un allarme
quando:
1) Una ACL ( Access Control List ) "richiede" un allarme; se si vuole
accedere ad un file e non si e' sicuri di cosa si ha davanti potete
provare a fare un SHOW ACL e vedere cosa salta fuori.
2) Il sistema individua una possibile intrusione. Il computer ha,
nella sua configurazione, indicato un numero che, una volta raggiunto
fa' scattare l'allarme.
Potrebbe essere dopo tre tentativi falliti di connessione o dopo venti;
dipende tutto da come e' stato configurato il sistema.
Quindi il mio consiglio e' quello di tentare una o due password al giorno
perche' credo che nessuno setti questo valore al di sotto dei due tentativi
e anche perche' cosi' si desterebbero meno sospetti.
3) Si accede ad un file "rompendo" i vari accessi ( read, write, ecc. ).
4) Si accede ad un file attraverso il privilegio BYPASS.
Molto probabilmente, se si entra in un sistema e si ha il BYPASS si
hanno anche tutti ( ALL ) i privilegi. Non credo che qualche amministratore
di sistema concederebbe a chiunque l'uso del BYPASS se non per un errore
di impostazioni.
SHOW INSTRUSION
$ SHOW INTRUSION/TYPE=ALL
Intrusion Type Count Expiration Source
TERMINAL INTRUDER 9 08:34:24.56 TTA0
NETWORK SUSPECT 2 09:03:33.39 COINS::NSAUSER1
Il comando impostato sopra mostra le informazioni contenute nel database
del sistema.
Dopo TYPE si possono inserire le seguenti parole:
ALL: E' di default e mostra TUTTI i tentativi di hack del terminale.
SUSPECT: Tutte quelle che non sono identificate come INTRUDER.
INTRUDER: Tentativi di penetrazione del sistema nei quali c'erano molte
azioni evasive nei confronti del computer stesso.
2) Hackerare attraverso una rete.
Secondo me questo e' sicuramente il metodo piu' "facile" poiche' il VAX
ha molte debolezze sui computer collegati via rete.
Una volta che sia e'entrati con successo in un sistema come DECnet, si puo'
accedere tranquillamente a file, directory e dati contenuti nel VAX senza
che neppure quest'ultimo richieda password.
Faro' tre esempi citati dalla Lod:
1) $ TYPE PLOVER::SYS$SYSROOT:<SYSEXE>SYSUAF.LIS;*
2) $ DIR DOCWHO::SYS$SYSROOT:<000000...>
3) $ RUN LEGION::SYS$SYSROOT:<SYSEXE>AUTHORIZEUAF>
La sintassi e':
NOME-COMANDO NOME-NODO::DEVICE:<DIRECTORY>FILE-OPPURE-NOME-PROGRAMMA
Il NOME-NODO deve essere seguito dalle due "colonne" ( :: ).
Nel primo esempio abbiamo scaricato a video il contenuto del file
SYSUAF.LIS che contiene tante tante informazioni importanti.
Nel secondo esempio stavamo dando un'occhiata a quali erano TUTTI
i file presenti in TUTTE le directory del sistema.
Nel terzo esempio, stavano lanciando AUTHORIZE e cosi' facendo possiamo
per esempio avere la lista degli user sul sistema oppure crearci un
account...tanto per citarne solo due.
Qui, per concludere questo ( forse troppo ) lungo articolo riporto
le estensioni dei file che si trovano su un VAX/VMS:
ADA File compilati con Ada;
BAS File compilati con il BASIC;
B32 File compilati con il BLISS-32;
C File compilati con il C;
COB File compilati con il COBAL;
FOR File compilati con il FORTRAN;
MAR File compilati con il MACRO;
PAS File compilati con il PASCAL;
PLI File compilati con il PL/I;
CLD File di descrizione dei comandi DCL;
COM DCL batch o file di procedure di comando;
DAT Data file;
DIS File di distribuzione ( come quelli della mail );
DIR Directory;
EDT File di comando per l'editor EDT;
EXE Eseguibili;
HLP File di aiuto;
JOU "Giornale" di aiuto dell'editor EDT quando si verifica un problema;
LIS System Listing File ( ovvero come per il comando TYPE );
LOG Batch Job Output File;
MAI File di posta;
MEM DSR output file;
OBJ File creati da un compilatore prima di LINKarli;
RNO File di sorgente per DSR;
SIXEL File per la grafica SIXEL;
SYS File di sistema;
TJL "Giornale" creato quando accade qualcosa di insolito;
TMP File temporanei;
TPU File di comando dell'editor;
TXT File di testo e file di uscita del programma MAIL;
UAF User Authorization File ( file di autorizzazione di un utente )
I piu' importanti sul sistema direi...
Il VAX e' un gran bel sistema ma, come ogni altro sistema, ha le sue
debolezze e, in questo caso, risiedono nel network.
Quindi perche' fondersi il cervello per entrare in un VAX senza lasciare
traccia quando possiamo farlo benissimo da un nodo di una rete e senza
troppi problemi?
By InfectedMachine
Sniffi tu che sniffo anche io ( By IceNice )
No, non preoccupatevi non faccio e non faro mai uso di stupefacenti.
Questo non e' altro che un articolo riguardante lo sniff che e' l'arte
di intercettamento di una comunicazione via internet.
Esistono in giro sulla rete vari software per poter sniffare; il piu'
famoso nel mondo UNIX e' il TCPDUMP (e gia il nome dice tutto). Esiste
anche software per DOS ed NT che pero' ha il problema dell'accesso
diretto da parte di un task alla scheda di rete.
Tutto il traffico che passa su un cavo in cui noi abbiamo accesso
puo' essere sniffato, l'utilizzo migliore dello sniff avviene con la
rete ethernet. Ethernet non e' altro che un protocollo che lavora
spedendo i pacchetti con le informazioni a tutti i computer collegati
a tale rete, l'intestazione del pacchetto contiene il proprio indirizzo
e l'indirizzo di destinazione.
Gli sniffer funzionano in maniera molto semplice non fanno altro che
dire alla scheda di rete di raccogliere tutti i pacchetti che passano
sul cavo di rete invece che solo quelli che sono destinati all'indirizzo
della scheda, questo avviene settando quest'ultima in modalita' PROMISCUE
MODE in modo da potergli dire di ricevere tutti i pacchetti che transitano
sulla sua scheda. Questo succede perche' la scheda quando riceve i
pacchetti ethernet prende solo quelli destinati al suo MAC address.
Se la macchina da noi utilizzata e' collegata con un cavo coassiale
abbiamo la possibilita' di utilizzare lo sniff in modo piu' approfondito
che utilizzando solo il doppino telefonico dato che su quest'ultimo
passano solo i pacchetti destinati alla mia macchina.
Come gia' molti di voi sapranno che il cavo coassiale e' gia' di per se
un mezzo BROADCAST quindi abbiamo la possibilita' di sentire tutto quello
che gli altri dicono sul filo elettrico.
Se avete anche la possibilita' di avere accesso al cavo che collega i
vari router al MIX (che e' il nodo di interscambio di traffico
tra i vari provider) allora occorre delimitare lo spezzone della
rete, dobbiamo, cioe', selezionare quello che ci interessa indicando
gli indirizzi di arrivo e di partenza in modo da non sovraccaricare
il SO.
Chiaramente uno sniffer va' su qualsiasi macchina della nostra rete:
sulla macchina remota, sul server locale o su una terza macchina,
il tutto dipende dal tipo di rete che collega i nodi presi in
questione.
Un esempio pratico: io mi trovo in una universita' e quindi ho molte piu'
possibilita' di sniffare del traffico che passa sui miei cavi rispetto
a quello che passa in Finlandia.
Ci sono vari prodotti di sniff in giro ma per ora ve ne lascio uno
da compilare :
/* [JOIN THE POSSE!] */
/* Esniff.c */
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/stropts.h>
#include <sys/signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <net/nit_if.h>
#include <net/nit_buf.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <netinet/ip_var.h>
#include <netinet/udp_var.h>
#include <netinet/in_systm.h>
#include <netinet/tcp.h>
#include <netinet/ip_icmp.h>
#include <netdb.h>
#include <arpa/inet.h>
#define ERR stderr
char *malloc();
char *device,
*ProgName,
*LogName;
FILE *LOG;
int debug=0;
#define NIT_DEV "/dev/nit"
#define CHUNKSIZE 4096 /* device buffer size */
int if_fd = -1;
int Packet[CHUNKSIZE+32];
void Pexit(err,msg)
int err; char *msg;
{ perror(msg);
exit(err); }
void Zexit(err,msg)
int err; char *msg;
{ fprintf(ERR,msg);
exit(err); }
#define IP ((struct ip *)Packet)
#define IP_OFFSET (0x1FFF)
#define SZETH (sizeof(struct ether_header))
#define IPLEN (ntohs(ip->ip_len))
#define IPHLEN (ip->ip_hl)
#define TCPOFF (tcph->th_off)
#define IPS (ip->ip_src)
#define IPD (ip->ip_dst)
#define TCPS (tcph->th_sport)
#define TCPD (tcph->th_dport)
#define IPeq(s,t) ((s).s_addr == (t).s_addr)
#define TCPFL(FLAGS) (tcph->th_flags & (FLAGS))
#define MAXBUFLEN (128)
time_t LastTIME = 0;
struct CREC {
struct CREC *Next,
*Last;
time_t Time; /* start time */
struct in_addr SRCip,
DSTip;
u_int SRCport, /* src/dst ports */
DSTport;
u_char Data[MAXBUFLEN+2]; /* important stuff :-) */
u_int Length; /* current data length */
u_int PKcnt; /* # pkts */
u_long LASTseq;
};
struct CREC *CLroot = NULL;
char *Symaddr(ip)
register struct in_addr ip;
{ register struct hostent *he =
gethostbyaddr((char *)&ip.s_addr, sizeof(struct in_addr),AF_INET);
return( (he)?(he->h_name):(inet_ntoa(ip)) );
}
char *TCPflags(flgs)
register u_char flgs;
{ static char iobuf[8];
#define SFL(P,THF,C) iobuf[P]=((flgs & THF)?C:'-')
SFL(0,TH_FIN, 'F');
SFL(1,TH_SYN, 'S');
SFL(2,TH_RST, 'R');
SFL(3,TH_PUSH,'P');
SFL(4,TH_ACK, 'A');
SFL(5,TH_URG, 'U');
iobuf[6]=0;
return(iobuf);
}
char *SERVp(port)
register u_int port;
{ static char buf[10];
register char *p;
switch(port) {
case IPPORT_LOGINSERVER: p="rlogin"; break;
case IPPORT_TELNET: p="telnet"; break;
case IPPORT_SMTP: p="smtp"; break;
case IPPORT_FTP: p="ftp"; break;
default: sprintf(buf,"%u",port); p=buf; break;
}
return(p);
}
char *Ptm(t)
register time_t *t;
{ register char *p = ctime(t);
p[strlen(p)-6]=0; /* strip " YYYY\n" */
return(p);
}
char *NOWtm()
{ time_t tm;
time(&tm);
return( Ptm(&tm) );
}
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
/* add an item */
#define ADD_NODE(SIP,DIP,SPORT,DPORT,DATA,LEN) { \
register struct CREC *CLtmp = \
(struct CREC *)malloc(sizeof(struct CREC)); \
time( &(CLtmp->Time) ); \
CLtmp->SRCip.s_addr = SIP.s_addr; \
CLtmp->DSTip.s_addr = DIP.s_addr; \
CLtmp->SRCport = SPORT; \
CLtmp->DSTport = DPORT; \
CLtmp->Length = MIN(LEN,MAXBUFLEN); \
bcopy( (u_char *)DATA, (u_char *)CLtmp->Data, CLtmp->Length); \
CLtmp->PKcnt = 1; \
CLtmp->Next = CLroot; \
CLtmp->Last = NULL; \
CLroot = CLtmp; \
}
register struct CREC *GET_NODE(Sip,SP,Dip,DP)
register struct in_addr Sip,Dip;
register u_int SP,DP;
{ register struct CREC *CLr = CLroot;
while(CLr != NULL) {
if( (CLr->SRCport == SP) && (CLr->DSTport == DP) &&
IPeq(CLr->SRCip,Sip) && IPeq(CLr->DSTip,Dip) )
break;
CLr = CLr->Next;
}
return(CLr);
}
#define ADDDATA_NODE(CL,DATA,LEN) { \
bcopy((u_char *)DATA, (u_char *)&CL->Data[CL->Length],LEN); \
CL->Length += LEN; \
}
#define PR_DATA(dp,ln) { \
register u_char lastc=0; \
while(ln-- >0) { \
if(*dp < 32) { \
switch(*dp) { \
case '\0': if((lastc=='\r') || (lastc=='\n') || lastc=='\0') \
break; \
case '\r': \
case '\n': fprintf(LOG,"\n : "); \
break; \
default : fprintf(LOG,"^%c", (*dp + 64)); \
break; \
} \
} else { \
if(isprint(*dp)) fputc(*dp,LOG); \
else fprintf(LOG,"(%d)",*dp); \
} \
lastc = *dp++; \
} \
fflush(LOG); \
}
void END_NODE(CLe,d,dl,msg)
register struct CREC *CLe;
register u_char *d;
register int dl;
register char *msg;
{
fprintf(LOG,"\n-- TCP/IP LOG -- TM: %s --\n", Ptm(&CLe->Time));
fprintf(LOG," PATH: %s(%s) =>", Symaddr(CLe->SRCip),SERVp(CLe->SRCport));
fprintf(LOG," %s(%s)\n", Symaddr(CLe->DSTip),SERVp(CLe->DSTport));
fprintf(LOG," STAT: %s, %d pkts, %d bytes [%s]\n",
NOWtm(),CLe->PKcnt,(CLe->Length+dl),msg);
fprintf(LOG," DATA: ");
{ register u_int i = CLe->Length;
register u_char *p = CLe->Data;
PR_DATA(p,i);
PR_DATA(d,dl);
}
fprintf(LOG,"\n-- \n");
fflush(LOG);
if(CLe->Next != NULL)
CLe->Next->Last = CLe->Last;
if(CLe->Last != NULL)
CLe->Last->Next = CLe->Next;
else
CLroot = CLe->Next;
free(CLe);
}
/* 30 mins (x 60 seconds) */
#define IDLE_TIMEOUT 1800
#define IDLE_NODE() { \
time_t tm; \
time(&tm); \
if(LastTIME<tm) { \
register struct CREC *CLe,*CLt = CLroot; \
LastTIME=(tm+IDLE_TIMEOUT); tm-=IDLE_TIMEOUT; \
while(CLe=CLt) { \
CLt=CLe->Next; \
if(CLe->Time <tm) \
END_NODE(CLe,(u_char *)NULL,0,"IDLE TIMEOUT"); \
} \
} \
}
void filter(cp, pktlen)
register char *cp;
register u_int pktlen;
{
register struct ip *ip;
register struct tcphdr *tcph;
{ register u_short EtherType=ntohs(((struct ether_header *)cp)->ether_type);
if(EtherType < 0x600) {
EtherType = *(u_short *)(cp + SZETH + 6);
cp+=8; pktlen-=8;
}
if(EtherType != ETHERTYPE_IP) /* chuk it if its not IP */
return;
}
/* ugh, gotta do an alignment :-( */
bcopy(cp + SZETH, (char *)Packet,(int)(pktlen - SZETH));
ip = (struct ip *)Packet;
if( ip->ip_p != IPPROTO_TCP) /* chuk non tcp pkts */
return;
tcph = (struct tcphdr *)(Packet + IPHLEN);
if(!( (TCPD == IPPORT_TELNET) ||
(TCPD == IPPORT_LOGINSERVER) ||
(TCPD == IPPORT_FTP)
)) return;
{ register struct CREC *CLm;
register int length = ((IPLEN - (IPHLEN * 4)) - (TCPOFF * 4));
register u_char *p = (u_char *)Packet;
p += ((IPHLEN * 4) + (TCPOFF * 4));
if(debug) {
fprintf(LOG,"PKT: (%s %04X) ", TCPflags(tcph->th_flags),length);
fprintf(LOG,"%s[%s] => ", inet_ntoa(IPS),SERVp(TCPS));
fprintf(LOG,"%s[%s]\n", inet_ntoa(IPD),SERVp(TCPD));
}
if( CLm = GET_NODE(IPS, TCPS, IPD, TCPD) ) {
CLm->PKcnt++;
if(length>0)
if( (CLm->Length + length) < MAXBUFLEN ) {
ADDDATA_NODE( CLm, p,length);
} else {
END_NODE( CLm, p,length, "DATA LIMIT");
}
if(TCPFL(TH_FIN|TH_RST)) {
END_NODE( CLm, (u_char *)NULL,0,TCPFL(TH_FIN)?"TH_FIN":"TH_RST" );
}
} else {
if(TCPFL(TH_SYN)) {
ADD_NODE(IPS,IPD,TCPS,TCPD,p,length);
}
}
IDLE_NODE();
}
}
/* signal handler
*/
void death()
{ register struct CREC *CLe;
while(CLe=CLroot)
END_NODE( CLe, (u_char *)NULL,0, "SIGNAL");
fprintf(LOG,"\nLog ended at => %s\n",NOWtm());
fflush(LOG);
if(LOG != stdout)
fclose(LOG);
exit(1);
}
/* opens network interface, performs ioctls and reads from it,
* passing data to filter function
*/
void do_it()
{
int cc;
char *buf;
u_short sp_ts_len;
if(!(buf=malloc(CHUNKSIZE)))
Pexit(1,"Eth: malloc");
/* this /dev/nit initialization code pinched from etherfind */
{
struct strioctl si;
struct ifreq ifr;
struct timeval timeout;
u_int chunksize = CHUNKSIZE;
u_long if_flags = NI_PROMISC;
if((if_fd = open(NIT_DEV, O_RDONLY)) < 0)
Pexit(1,"Eth: nit open");
if(ioctl(if_fd, I_SRDOPT, (char *)RMSGD) < 0)
Pexit(1,"Eth: ioctl (I_SRDOPT)");
si.ic_timout = INFTIM;
if(ioctl(if_fd, I_PUSH, "nbuf") < 0)
Pexit(1,"Eth: ioctl (I_PUSH \"nbuf\")");
timeout.tv_sec = 1;
timeout.tv_usec = 0;
si.ic_cmd = NIOCSTIME;
si.ic_len = sizeof(timeout);
si.ic_dp = (char *)&timeout;
if(ioctl(if_fd, I_STR, (char *)&si) < 0)
Pexit(1,"Eth: ioctl (I_STR: NIOCSTIME)");
si.ic_cmd = NIOCSCHUNK;
si.ic_len = sizeof(chunksize);
si.ic_dp = (char *)&chunksize;
if(ioctl(if_fd, I_STR, (char *)&si) < 0)
Pexit(1,"Eth: ioctl (I_STR: NIOCSCHUNK)");
strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
si.ic_cmd = NIOCBIND;
si.ic_len = sizeof(ifr);
si.ic_dp = (char *)𝔦
if(ioctl(if_fd, I_STR, (char *)&si) < 0)
Pexit(1,"Eth: ioctl (I_STR: NIOCBIND)");
si.ic_cmd = NIOCSFLAGS;
si.ic_len = sizeof(if_flags);
si.ic_dp = (char *)&if_flags;
if(ioctl(if_fd, I_STR, (char *)&si) < 0)
Pexit(1,"Eth: ioctl (I_STR: NIOCSFLAGS)");
if(ioctl(if_fd, I_FLUSH, (char *)FLUSHR) < 0)
Pexit(1,"Eth: ioctl (I_FLUSH)");
}
while ((cc = read(if_fd, buf, CHUNKSIZE)) >= 0) {
register char *bp = buf,
*bufstop = (buf + cc);
while (bp < bufstop) {
register char *cp = bp;
register struct nit_bufhdr *hdrp;
hdrp = (struct nit_bufhdr *)cp;
cp += sizeof(struct nit_bufhdr);
bp += hdrp->nhb_totlen;
filter(cp, (u_long)hdrp->nhb_msglen);
}
}
Pexit((-1),"Eth: read");
}
/* Authorize your proogie,generate your own password and uncomment here */
/* #define AUTHPASSWD "EloiZgZejWyms" */
void getauth()
{ char *buf,*getpass(),*crypt();
char pwd[21],prmpt[81];
strcpy(pwd,AUTHPASSWD);
sprintf(prmpt,"(%s)UP? ",ProgName);
buf=getpass(prmpt);
if(strcmp(pwd,crypt(buf,pwd)))
exit(1);
}
*/
void main(argc, argv)
int argc;
char **argv;
{
char cbuf[BUFSIZ];
struct ifconf ifc;
int s,
ac=1,
backg=0;
ProgName=argv[0];
/* getauth(); */
LOG=NULL;
device=NULL;
while((ac<argc) && (argv[ac][0] == '-')) {
register char ch = argv[ac++][1];
switch(toupper(ch)) {
case 'I': device=argv[ac++];
break;
case 'F': if(!(LOG=fopen((LogName=argv[ac++]),"a")))
Zexit(1,"Output file cant be opened\n");
break;
case 'B': backg=1;
break;
case 'D': debug=1;
break;
default : fprintf(ERR,
"Usage: %s [-b] [-d] [-i interface] [-f file]\n",
ProgName);
exit(1);
}
}
if(!device) {
if((s=socket(AF_INET, SOCK_DGRAM, 0)) < 0)
Pexit(1,"Eth: socket");
ifc.ifc_len = sizeof(cbuf);
ifc.ifc_buf = cbuf;
if(ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0)
Pexit(1,"Eth: ioctl");
close(s);
device = ifc.ifc_req->ifr_name;
}
fprintf(ERR,"Using logical device %s [%s]\n",device,NIT_DEV);
fprintf(ERR,"Output to %s.%s%s",(LOG)?LogName:"stdout",
(debug)?" (debug)":"",(backg)?" Backgrounding ":"\n");
if(!LOG)
LOG=stdout;
signal(SIGINT, death);
signal(SIGTERM,death);
signal(SIGKILL,death);
signal(SIGQUIT,death);
if(backg && debug) {
fprintf(ERR,"[Cannot bg with debug on]\n");
backg=0;
}
if(backg) {
register int s;
if((s=fork())>0) {
fprintf(ERR,"[pid %d]\n",s);
exit(0);
} else if(s<0)
Pexit(1,"fork");
if( (s=open("/dev/tty",O_RDWR))>0 ) {
ioctl(s,TIOCNOTTY,(char *)NULL);
close(s);
}
}
fprintf(LOG,"\nLog started at => %s [pid %d]\n",NOWtm(),getpid());
fflush(LOG);
do_it();
}
Buon lavoro da IceNice.
Firewall: concetti base (Parte I) ( by Ramlin )
Per Firewall si intende un sistema o un gruppo di sistemi il cui scopo
e' quello di filtrare il traffico tra due reti differenti, cioe'
implementare una politica di controllo degli accessi. I Firewall sono
ormai molto diffusi nelle grandi corporation e nei vari centri di
ricerca, soprattutto quelli di tipo governativo...dovunque ci sia
qualcosa di riservato state sicuri di trovare un firewall..:-)). E'
pratica molto comune utilizzare i Firewall come "vetrine" in cui
mettere materiale che debba essere reso pubblico (basti pensare alle
varie patch e upgrade resi disponibili dalle varie corporation): il
lato "positivo" di questa pratica e' data dal fatto che tutti i vari
ospiti del sistema rimangono fuori dalla rete interna vera e propria,
visto che il Firewall crea una sorta di compartimento a tenuta stagna
con il mondo esterno. Un Firewall puo' essere configurato diversamente
a seconda delle esigenze di sicurezza a cui deve fare capo: alcuni
Firewall lasciano passare in entrambi i sensi solo messaggi di posta
elettronica, altri, piu' sofisticati bloccano il traffico proveniente
dall'esterno ma non pongono nessuna limitazione a quello proveniente
dall'interno. Questi simpatici gingilli sono utili anche nel caso in
cui il sistema e' attaccato via modem; in questo caso il Firewall puo'
ricoprire il ruolo di investigatore, nel senso che se opportunamente
configuato puo' implementare delle funzioni di logging (e fin qui
nulla di speciale) e soprattutto delle funzioni di tracciamento della
chiamata, cosa abbastanza improbabile nel caso di un Firewall made in
Italy ma MOLTO piu' probabile nel caso di uno made in USA, in quanto
il sistema telefonico USA permette agevolmente di sapere il numero del
chiamante (tramite la funzione CALLER ID); in Italia questo e'
possibile solo nel caso di linee ISDN e sistemi GSM (anche se non in
maniera uniforme, ma qui svicoliamo in un altro argomento..). Un altro
aspetto da tenere in considerazione riguarda il livello di sicurezza
globale della rete "target": e' inutile acquistare un Firewall
costosissimo e poi ignorare tutte le altre possibile back-doors:
un Firewall dovrebbe rispecchiare il livello globale della rete.
Questa banale regola nella maggior parte dei casi fortunatamente non
viene presa in considerazione...:-9 Se poi esistono particolari
esigenze di riservatezza e sicurezza la prima regola da seguire
dovrebbe essere questa: NON collegarsi in Rete!!:) Sembra banale ma e'
l'unico modo per garantire una sicurezza prossima al 100%..se poi uno
accede alla rete fisicamente...beh..chiamate un fabbro e fate mettere
un paio di serrature in piu'..8-)) Fondamentalmente esistono due tipi
di Firewall:
* Network Level
* Application Level
Le differenze tra i due sono molto meno marcate di quanto si potrebbe
pensare, ed anche in termini di giudizio non e' possibile affermare in
senso assoluto "quel tipo e' meglio di quell'altro"..tutto dipende
dalle necessita' di sicurezza della rete.
Un Firewall di tipo Network Level prende le sue decisioni basandosi
sull'indirizzo sorgente, quello di destinazione e la porta di un
singolo pacchetto IP, per il resto si comporta come un router normale.
Generalmente i Firewall di questa categoria risultano molto veloci
trasparenti all'utente.
I Firewall di tipo Application Level invece, sono macchine in cui
viene fatto girare un Proxy server, la cui caratteristica piu'
evidente e' data dal fatto di non permettere il passaggio di dati
**direttamente** tra le due reti, ma al contrario permette a questa
operazione una serie di sofisticati controlli di tracciamento e di
logging dei pacchetti. Inizialmente questi Firewall erano abbastanza
pensantucci dal lato client, ma ora la situazione sta
cambiando. La caratteristica piu' importante di questa
tipologia di Firewall e' la possibilita' di avere dei dettagliati
report su tutto il traffico transitato attraverso esso.
Concludo questa prima parte con un'osservazione di carattere pratico
apparentemente banale; un Firewall puo' essere un ottimo aiuto ai
Sysadmin per garantire l'integrita' degli accessi alla propria rete,
ma non bisogna dimenticarsi una cosa: "lui" mette il naso e controlla
tutto quello che gli passa attraverso..ma SOLO quello..nel caso in cui
per qualche fortuito motivo ci sia un'altra via di accesso,
il suo compito decade immediatamente, quindi prima di provare a fare
fesso un Firewall conviene cercare in maniera quanto piu' approfondita
possibile un'altra via di accesso.
SeE Ya!!:)
Il prossimo articolo che leggerete non riguarda uno strano metodo di
infiltrazione ne' l'ultima scoperta in campo telefonico.
Sono semplicemente alcune considerazioni del nostro Jack McKrak su tema
della liberta' in Internet.
Lo abbiamo voluto pubblicare ugualmente sebbene non sia del tutto attinente
ai temi trattati in questa rivista...sebbene la liberta' e' un po' dentro
ad ogni hacker...
Psicologia Costrittiva (Jack McKrak)
Liberta': la capacita' di poter scegliere qualcosa, senza essere
condizionati da agenti esterni...
Una definizione semplice ma ragionevole, sono libero se voglio fare qualcosa
e nessuno me lo impedisce, tranne ovviamente, quando interferisco con la
liberta' di qualcun altro...Trasportando questa definizione nel mondo di
Internet, la nostra liberta' si esprime nella possibilita' di visitare
qualsiasi sito o accedere a tutte le informazioni sparse nella rete, senza
che qualcuno mi dica cosa sia lecito vedere o ignorare...
Chiariamo subito il discorso: io non ho il diritto di usufruire di
informazioni che qualcuno immette sulla rete e che non vuole rendere
pubbliche, come dati personali o servizi offerti a pagamento... chi si
intrufola in database privati lo fa a proprio rischio e pericolo...
Ho pero' il diritto di poter ascoltare le idee e le opinioni di chiunque
abbia qualcosa da dire, senza che queste vengano filtrate o modificate; ho
anche il diritto di conoscere notizie che potrebbero essere utili a me
stesso o alla comunita', ma che vengono tenute segrete per proprio comodo...
Ogni tanto, nel mondo, c'e' qualcuno che si sveglia con la voglia di
migliorare la propria vita, a discapito di quella di qualche altra persona.
Pensiamo di essere il classico conquistatore pazzo che ha del potere e vuole
allargare il suo consenso, Internet rappresenterebbe un grosso problema:
se milioni di persone si scambiano delle idee e' difficile evitare che si
uniscano in gruppi che non la pensano come me, anzi, magari fanno cambiare
idea a quelli che avevo gia' convinto...come si puo' sfruttare la rete a
proprio comodo? Un impatto affrettato porterebbe a un approccio violento,
censurare i siti non allineati all'ideologia ed escudere le persone non
desiderate... una logica vecchia e controproducente. E' facile fermare
qualcuno quando le sue intenzioni sono chiare...oggi i sistemi per persuadere
gli altri sono molto piu' astuti e potenti, le pubblicita' ne sono un esempio
ridotto ma significativo. Esistono anche materie di studio che si occupano di
questo problema, come la Psicologia Costrittiva... in questa disciplina si
definisce "persuasione" la capacita' di fare credere ad una persona che il
proprio bene si raggiunga seguendo le istruzioni impartite; in questo modo
non si e' costretti a sceglire qualcosa contro la propria volonta', ma la
nostra liberta' ci porta sulla strada sbagliata pensando che sia quella
giusta.
Sono stati studiati gli effetti di droge e torture per potenziare
procedimenti di questo tipo (vedi lavaggio del cervello), solo per citare
i metodi piu' invasivi...infatti fra quelli piu' sottili possiamo citare i
messagi subliminali, l'effetto ipnotico dei flash ( chi fa comizi a volte si
mette addosso oggetti luccicanti, tipo spille d'oro, in modo che questi
riflettano negli occhi la luce dei fari e inducano il cervello in uno stato
ipnotico ), suoni a particolare frequenza che provocano un senso di "sballo"
(si dice che in alcune discoteche modificavano la musica aggiungendo questo
effetto per aumentare il rincoglionimento prodotto dalle pasticche & co.),
messaggi ripetuti in continuazione (effetto pubblicitario) e infine,
l'ultimo ritrovato : l'effetto sondaggio. Ovvero se ti dicono che il 90 %
degli italiani la pensa in un certo modo sei portato a pensare che
effettivamente quella sia l'idea migliore... nonostante non sia vero....
Concentrando il discorso su Internet, bisogna tenere anche in considerazione
il fattore "dipendenza da Software". Lo sviluppo delle interfacce
user-friendly, dove mouse e menu' a tendina sono all'ordine del giorno, sta
portando al totale annullamento delle conoscenze necessarie per utilizzare
il computer e Internet senza usufruire delle comodita' a cui siamo soliti...
la normalizzazione del software porta al completo rincoglionimento
informatico, ovvero non si e' in grado di far niente se non si usa il solito
sistema operativo, con il solito programma di interfaccia... anzi la cosa
peggiore e' che questa dipendenza dai programmi porta internet a dipendere
da chi produce questi software (i migliori amici del nostro dittatore pazzo),
che sono in grado di imporci le loro scelte senza che noi possiamo dire una
parola. In questo modo Internet non e' piu' un ostacolo, anzi, diviene la
vera incarnzaione del Grande Fratello, in grado di condizionare tutti e tutto.
Ancora la situazione e' normale, ma bisogna stare all'erta, essere
in grado di scavalcare i muri che ci troviamo davanti ed evitare che qualcuno
ci espropri delle liberta' di cui godiamo oggi... state informati, e con gli
occhi aperti.. finche' potete leggere giornali come questo c'e' sempre della
speranza....
Jack McKrak
Blue box: teoria dell'utilizzo ( by Jester )
Dunque, prima di iniziare vorrei sottolineare il carattere puramente
teorico e speculativo del modo in cui e' stato trattato l'argomento;
questo articolo discutera' infatti solo il modo in cui TEORICAMENTE
operano le blue box senza tuttavia spiegare come utilizzarle praticamente.
INTRODUZIONE
L'origine delle blue box si fa' risalire comunemente all'inizio degli
anni 60 quando, in college americani, si iniziavano a diffondere i
primi movimenti di contestazione di pari passo con il fenomeno hippy.
C'erano individui ( i cosiddetti phreaks = fenomeni da baraccone ) i
quali erano capaci di emulare i segnali delle compagnie telefoniche
straniere per intrufolarsi nella rete telefonica senza pagare. Costoro
mantenevano un atteggiamento di aperta sfida nei confronti dell'autorita'
e si servivano di "apparecchi" per emulare i toni. Nel corso di una retata
ad un raduno hippy fu' sequestrato uno di questi "apparecchi" dalla
polizia: era in una scatola blu; da qui il nome blue box.
Per chi non lo sapesse anche Steve Wozniak e Steve Jobbs ( i fondatori
della Apple computer ) in quel periodo vendevano blue box nel loro ateneo!
FUNZIONAMENTO DELLE BLUE BOX
Usare blue box ha rappresentato per un certo tempo il miglior modo per
fare phreaking. Esso consiste nell'utilizzare le linee telefoniche che
mettono in comunicazione le centrali telefoniche tra di loro che in gergo
vengono chiamate "trunks", da non confondere con le linee che uniscono gli
apparecchi domestici con le centrali telefoniche stesse ( queste, infatti,
sono le linee telefoniche standard ). Ora, quando la linea ( "trunk" ) non
e' in uso ( cornetta abbassata ) c'e' una frequenza da 2600Hz applicata ad
essa in entrambi i sensi. Quando la linea e' in uso ( cornetta alzata ) la
frequenza da 2600Hz viene rimossa dal lato che viene usato: quindi possiamo
dire che la freq. da 2600hz viene usata per indicare lo stato della linea
( in uso/non in uso ) e, a questo proposito, bisogna rilevare due cose.
Primo: per emettere questo "suono" la centrale sfrutta una singola frequenza
( single frequency signalling = SF ).
Secondo: questa frequenza e' "in banda" nel senso che e' in quel campo di
frequenze che possono essere trasportate da una normale linea telefonica.
Come vedremo in seguito ci sono anche segnali che non possono essere
portati lungo normali linee telefoniche perche' non rientrano nella gamma
delle frequenze trasportabili. Detto in poche parole: sapete perche' il
web e' cosi lento da casa eppure quando andate a navigare al bowling o
vi connettete dall' universita' e' una scheggia? Perche' la linea
telefonica normale puo' trasportare una serie ridotta di frequenze e quindi
tutte le informazioni devono essere convertite in modo da rientrare nella
banda di frequenze trasportabili, con una discreta perdita di tempo...
Al contrario una linea ISDN o una bella 2Mbit ( quella che hanno le
universita' affiliate alla rete GARR o JANET ) possono trasportare una gamma
piu' ampia di frequenze e quindi un maggior volume di dati per unita' di
tempo...( per la precisione le cose non stanno esattamente cosi' ma questo
era un esempio per farvi capire meglio ).
Immaginiamo che voi facciate una chiamata e vediamo che cosa accade.
Diciamo, ad esempio, che volete chiamare il Papa a Roma il cui numero e'
06-6982 e che siete in un distretto diverso da quello di Roma. Una volta
composto il numero la vostra centrale telefonica riconoscerebbe il prefisso
appartenente ad un altro distretto e indirizzerebbe la chiamata verso la
centrale telefonica di quel distretto ( per la precisione supponiamo anche
che la vostra centrale telefonica usi segnali di controllo al di fuori
delle frequenze trasportabili; su questo punto ritornero' in seguito ).
A seconda di dove siete all'interno della rete telefonica la chiamata
lascera' la vostra centrale e, attraverso piu' trunks, raggiungera' la
centrale telefonica del distretto chiamato.
Quindi:
A------CT1--------CT2--------B
A=il chiamante ( voi )
CT1=la vostra centrale telefonica
CT2=la centrale del distretto ricevente la chiamata
B=il ricevente della vostra chiamata
E' da notare che per trunk, in pratica, si intende il tratto di linea
telefonica compreso tra CT1 e CT2; inoltre la chiamata per arrivare alla
CT2 partendo da CT1 puo' anche passare per altre centrali telefoniche.
Ora quello che e' importante capire e' che tutti i trunks non hanno la
frequenza da 2600Hz per segnalare che una chiamata e' in corso e che le
linee sono in uso.
Immaginiamo che nel corso di questa chiamata mandiate un tono da 2600 Hz
attraverso la linea. Questo tono verrebbe ricevuto dalla seconda centrale
telefonica ( CT2 ) che si comporterebbe come se avesse ricevuto quel tono
da un'altra centrale lungo il percorso A - B. Tutto cio' starebbe ad
indicare che voi avreste abbassato il ricevitore e, alle linee, non essendo
piu' in uso, verrebbe applicata la 2600. Ma in realta' non avete
agganciato e avete ingannato la CT2 facendogli pensare questo. Quindi la
CT2 disconnette B e si prepara a ricevere una nuova chiamata. Tutto questo
avviene molto velocemente.
Quando smettete di mandare la freq. da 2600 ( dopo circa 1 secondo ) la
centrale pensa che un'altra chiamata stia venendo verso di essa ( in effetti
questo e' dovuto al fatto che, essendo stata tolta la freq. da 2600 e' come
se qualcuno avesse alzato la cornetta per chiamare.
In questo momento accadono diverse cose:
1) un altro trunk viene impegnato;
2) viene mandato un segnale al chiamante dalla centrale (CT2) per indicare
che questa non e' ancora pronta a ricevere comandi;
3) un registro viene associato al trunk in uso entro due secondi;
4) un segnale e' inviato al chiamante da parte della centralina per indicare
che questa e' pronta per ricevere i toni.
Di questo, chi usa blue box, non sente quasi niente ad eccezione di qualche
rumore di fondo.
Cosi' chi volesse impegnare un trunk dovrebbe mandare una 2600 attraverso
la linea per qualche secondo e qualche rumore dovrebbe comunicargli la
riuscita dell'operazione.
Fatto questo avete impegnato un trunk pronto ad obbedire ai vostri ordini.
A questo punto dovete inviare i segnali per fare un'altra chiamata: per
ottenere questo simulate i segnali utilizzati dalle centrali per comunicare
tra loro sui trunks.
Ecco perche' non e' possibile agire con una frequenza da 2600 appena alziamo
la cornetta: solo le centrali usano la 2600 per comunicare tra loro lungo
i trunks mentre lungo le linee che uniscono gli apparecchi telefonici
domestici con le centrali telefoniche vengono usate frequenze da 3700 Hz
che non possono essere trasportate dalle linee telefoniche normali e
quindi non si possono emulare. Di solito, il metodo piu' usato e' quello del
MF ( multi frequency ), impiegato anche nelle telecomunicazioni
internazionali ( standard CCITT n.5).
I toni MF sono costituiti ognuno da due frequenze diverse; a partire da 700Hz
con una progressione aritmetica di ragione 200Hz, si hanno sette frequenze
accoppiate due a due che servono per i toni che rappresentano i numeri da 0 a
9.
Altre combinazione servono per 5 tasti con funzioni speciali.
Le frequenze sono qui di seguito:
Frequenze (Hz) Toni
--------------------------------------
700+900 1
700+1100 2
900+1100 3
700+1300 4
900+1300 5
1100+1300 6
700+1500 7
900+1500 8
1100+1500 9
1300+1500 0
2400+2600 Cornetta abbassata ( la famosa 2600! )
2400+0 Impegno di un trunk
700+1700 Codice 11
900+1700 Codice 12
1100+1700 KP1 ( Key pulse 1 )
1300+1700 KP2 ( Key pulse 2 )
1500+1700 ST ( Send tones )
La durata delle segnalazioni MF e' di solito 60Ms, eccetto per i KP, 120Ms;
per la "2600", 100MS e per l'impegno di un trunk, 240Ms. Oltre agli usi
standard elencati qui sopra, la segnalazione MF ha anche altre funzioni
conosciute come "segnalazione espansa in banda". Per esempio il KP2, il
codice 11 e il codice 12 che saranno solo menzionati brevemente qui.
Per completare una chiamata una volta che si e' impegnato un trunk usando
la 2600Hz e dopo avere aspettato un paio di secondi affinche' avvengano le
operazioni di cui sopra, bisogna inviare un key pulse ( KP ).
Questo prepara il registro per i toni che verranno inviati.
Per una chiamata domestica standard, il KP deve essere seguito da sei o
sette cifre ( se chiamiamo lo stesso distretto della chiamata originaria ) o
da nove o dieci cifre ( se vogliamo chiamare un distretto diverso e quindi
dobbiamo aggiungere le cifre del prefisso ); esattamente come se dovessimo
fare una chiamata normale. Dopo il KP e i toni bisogna inviare l'ST ( STart)
che e' inviato per comunicare che non seguono altre cifre.
Esempio di una chiamata completa:
1) Chiamare un numero:06-6584235;
2) Aspettare un segno di chiamata in corso ( occupato, libero... );
3) Mandare la 2600 per un secondo circa;
4) Aspettare un paio di secondi per impegnare un trunk;
5) Mandare KP+prefisso+numero+SP ( per chiamare in un distretto diverso da
Roma ) oppure KP+numero+SP ( per chiamare nel distretto di Roma ).
Quindi la chiamata dovrebbe riuscire se tutto e' stato fatto correttamente.
Nelle segnalazioni internazionali per richiedere certi tipi di operatori
vengono usati il Code 11 o il Code 12. KP2 e' usato nelle comunicazioni
internazionali per instradare le comunicazioni su un circuito diverso dal
solito, o per ragioni economiche o di equipaggiamento.
Perche' tutto questo non e' possibile attualmente?
Purtroppo quanto ho detto sarebbe valido se Telekom non usasse il
protocollo CCIS che e' il principale responsabile della impossibilita' di
usare una blue box.
CCIS significa Common Channel Interoffice Signalling.
E' il metodo di segnalazione che viene usato tra le centrali telefoniche
che ha eliminato l'uso delle frequenze da 2600Hz e da 3700H
z per segnalare
lo stato delle linee telefoniche.
In molti posti come l'Italia le blue box non funzionano perche' vengono
usate segnalazioni CCIS, segnalazioni fuori della banda delle frequenze
trasportabili dalle linee telefoniche e che quindi non possono essere emulate
in alcun modo.
Ovviamente il passaggio a questo standard ha comportato l'upgrade o la
sostituzione di tutte le apparecchiature abilitate alla comunicazione
telefonica.
Come sarebbe possibile sfruttare questa situazione?
Ammesso che vi troviate in un paese dove il paleolitico non e' mai passato,
potreste usare proficuamente una blue box nel modo che descrivero' qui di
seguito.
Dunque ritornando a quanto ho detto prima, quando impegnate un trunk mandando
una freq da 2600Hz, la linea telefonica aggancia per un attimo ( linea non in
uso - 2600) per tutta la durata del segnale, poi, riaggancia di nuovo quando
il segnale finisce ( linea in uso - NO 2600 ).
La centralina in questione capisce che un'altra chiamata sta arrivando e
prepara un registro per interpretare i toni che seguiranno.
Ora e' bene capire che nonostante la vostra linea telefonica sia stata per un
momento non in uso ( proprio come se aveste abbassato la cornetta ), l'altro
capo della connessione NON ha riagganciato.
Quindi, mentre dal vostro lato ( che chiamero' per comodita' CHIAMANTE )
verso l'altro estremo della linea ( RICEVENTE ) non c'e' alcuna frequenza da
2600 in quanto la linea e' in uso, si verifica la situazione opposta sul lato
del ricevente. Infatti dall'estremo ricevente verso di voi e' presente una
frequenza da 2600Hz per indicare all'equipaggiamento che la linea
telefonica non e' in uso e il ricevente non ha ancora risposto, quindi non
dovete pagare niente.
A questo punto e' lecito chiedersi perche' voi non udiate questa frequenza:
questo accade perche' lungo i trunk sono presenti dei filtri che impediscono
all'utente di udire queste comunicazioni di servizio. Ritornando a quanto
stavamo dicendo prima una volta effettuata la chiamata con la blue box,
quando il numero boxato risponde, la 2600 verso di voi viene tolta ed
iniziate a pagare la telefonata.
La vostra centrale telefonica pensa che vi siate connessi al numero che
avevate chiamato in origine e non al numero che avete chiamato tramite la
blue box.
Cosi voi pagate la tariffa telefonica come se aveste chiamato il primo numero
e non quello boxato.
A questo punto i piu' furbi di voi si staranno chiedendo perche' ho scritto
tutta sta roba solo per pagare una tariffa ridotta... perche' basterebbe
chiamare un numero verde per telefonare gratis in tutto il mondo......
Chi volesse contattarmi puo' farlo a:
Jester@cryogen.com
PS: oggigiorno c'e' ancora qualcuno che se ne sbatte del protocollo CCIS
e fa' lavorare gli extender come piu' gli aggrada...
The Xoanon's Guide to Cracking
..............................
Aspirante guida per gli aspiranti crackers
..........................................
Piccola nota a proposito di questo testo:
Vista l'incredibile ampiezza del suddetto articolo, abbiamo deciso di
mandarlo online in tre parti distinte.
La prima parte riguardera' l'assembler e i programmi necessari in questo
tipo di "lavoro".
La seconda parte trattera' il cracking in dos mentre la terza trattera'
il crack in dos4gw piu' altri piccoli trucchi.
Mi dispiace per questo taglio ma si e' rivelato necessario vista la
grande quantita' di informazioni che Xoanon ci ha mandato.
Per ultimo vorrei dire che non abbiamo pubblicato questa guida per
scopi illegali ma per approfondire la conoscenza su questo interessante
argomento. Quindi se, come dice Xoanon, vi distruggete i programmi
non protestate con noi.
LE INFORMAZIONI CHE TROVATE ALL'INTERNO DI QUESTO FILE SONO PER PURO SCOPO
DIDATTICO. L'AUTORE NON INCORAGGIA CHI VOLESSE SERVIRSENE PER SCOPI ILLEGALI.
INOLTRE, NON MI ASSUMO NESSUNA RESPONSABILITA' SE VI DISTRUGGETE I PROGRAMMI.
UPDATE 10/4/97 PART 1:
CAUSA UN MONGOLOIDE CHE SI ERA SCANDALIZZATO PER IL CONTENUTO PRETTAMENTE
OFFENSIVO E PERICOLOSO DI QUESTO SIMPATICO MANUALETTO, IL PRESENTE NON
APPARIRA' PIU' SU SCREAM (ALMENO NELLE VERSIONI .EXE). QUINDI, SE LO
TROVATE SUL PROSSIMO NUMERO DI "SYSTEMDOWN" VUOL DIRE CHE NON L'HO SCRITTO
PER NULLA.....
UPDATE 10/4/97 PART 2:
.DOS4GW CRACKING *REVEALED* ... VEDERE A QUESTA SEZIONE
.PICCOLE AGGIUNTE ALLA PARTE WINDOWS
UPDATE 18/4/97
.DOS4GW .ALTRI TRUCCHETTI.
----------------------------------------------------------------------------
INTRODUZIONE: SCREAM SUPPORTA LA PIRATERIA. SUPPORTATE SCREAM! (SCHERZO EH?!)
----------------------------------------------------------------------------
Dunque dunque dunque..... era tanto che pensavo di scrivere un qualcosa del
genere, e ora finalmente ( grazie a SCREAM ) ne ho la possibilita'.
Sinceramente, quando ho chiesto a Swan se potevo collaborare scrivendo un
manuale di cracking, pensavo che mi avrebbe immediatamente kickato fuori dal
canale ( eravamo su IRC )...... ma fortunatamente cio' non e' avvenuto, anzi...
Quindi eccomi qua !!! Premetto che di tutorial come questo, su internet, se
ne trovano a bizzeffe ( io si puo' dire che ho imparato leggendo quelli ),
tutti pero' con un basilare difetto: sono in INGLESE! Anche se ormai quasi
tutti conoscono questa lingua, penso che una versione italiana non dispiaccia
a nessuno. Naturalmente, sempre che questa mia versione venga su decentemente..
... Speriamo bene! ( sento gia' che scrivero' una caterva di stronzate...
Bah... )
Accendiamoci una sigaretta...... via, si parte!
Il manuale e' strutturato in 4 parti, trattanti i seguenti argomenti:
1) NOZIONI GENERALI E USO DEL DEBUGGER
2) DOS, DOS EXTENDERS (DOS4GW e simili)
3) WINDOWS 3.1/95/NT
4) Appendice: Patchers,TSR,Trainers
In ognuna di queste, cerchero' di spiegarvi le tecniche da usare nei vari
tipi di sprotezione, nei limiti delle mie possibilita'. Per semplificare le
cose non saro' troppo specifico, e tentero' di rendere il tutto capibile
anche da chi di assembler non ci capisce un accidente (io stesso non e' che
sia una cima nel campo!). L'importante infatti e' sapere il significato di
una manciata di istruzioni, oltre alle funzioni di alcuni dei registri AX,DX,
CX,ecc...
Per ogni sezione ci sara' una guida passo passo nella sprotezione di un
programma (gioco o utility) in maniera da rendere le cose piu' chiare.
----------------------------------------------------------------------------
CAPITOLO 1: NOZIONI GENERALI E USO DEL DEBUGGER
----------------------------------------------------------------------------
Dunque, innanzitutto partiamo con le 3 doti principali dell'aspirante (e
anche del provetto) cracker:
1) Conoscenza media dell'assembler, in particolare le funzioni di JMP
(nelle sue varie forme), MOV, CALL e CMP (il vostro intervento sui
programmi "vittima" si risolvera' nel 99% dei casi nella
disattivazione/modifica di queste funzioni) e della funzione dei
registri principali della CPU.
2) Conoscenza dell'uso delle funzioni del debugger (SOFTICE,GAMETOOLS,
WATCOM,ecc.) necessarie alla sprotezione (STEP,TRACE,come si settano e
cosa sono i BREAKPOINT; di solito queste 3 funzioni sono le principali
che userete, il resto e' utile ma non indispensabile).
3) Una dose spropositata di CULO sapientemente miscelata con intuito.
Difatti, molte volte il crack avviene per caso, magari NOPPANDO (poi vi
spiego) un'istruzione che apparentemente non c'entra nulla, oppure
forzando un JMP proprio quando si pensa che non serva a niente.
Quindi, se siete iellati tipo Paperino, meglio lasciar perdere
(scherzo eh?!)
1.1........MINI CORSO CRACKING-ORIENTED DI ASSEMBLER (ORA SI RIDE!)
Partiamo con la parte sull'assembler. Premetto che all'inizio avevo in mente
di fare solo un breve excursus (senti che paroloni!), ma cio' penso che
vi avrebbe lasciato con parecchi punti interrogativi. Quindi, per evitare di
essere sommerso da e-mail sull'argomento (che se il server-administrator me
le becca, probabilmente mi manda alle Sughere, rinomato carcere livornese)
ho pensato di farmi dare una mano da MoonShadow (lui parla in assembler!)...
quindi, se un giorno andrete in galera per aver formato un cracking-group
dopo esservi esaltati a leggere questo manualino, ringraziate anche lui!
Allora...iniziamo con il funzionamento dei registri principali:
[AX].... registro accumulatore, utilizzato per le operazioni matematiche e
di I/O. Tutto passa da questo registro, le funzioni di COMPARE (CMP) di
solito avvengono confrontando un valore inserito da voi (es. un numero del
serial number, una lettera della password, il numero riferito ad una icona
da scegliere) con quello contenuto in AH, AL o in tutto il registro
(non e' pero' una regola generale, voglio dire cioe' che questi valori
possono essere anche contenuti in un'altro registro, es.BX, pero' nel 99%
dei casi e' cosi').
Questo valore e' qui precedentemente mosso dalla routine che vi trasferisce
uno ad uno i valori (naturalmente, in HEX o in DEC) della password o del
serial number.
[BX].... Viene utilizzato di solito come base o puntatore ad una locazione.
[CX].... Il contatore. Viene usato per i loops (cicli) e viene decrementato
o incrementato secondo le esigenze. Di solito contiene un numero (ad es. il
numero delle volte che potete provare ad inserire la password prima che il
tutto si blocchi) che viene poi decrementato (con l'istruzione DEC CX oppure
SUB CX,AX) ogni volta che sbagliate. Utile in questo caso eliminare queste
istruzioni per poter lavorare con piu' tranquillita'.
[DX].... Funzioni simili a BX.
Da notare che ognuno di questi registri puo' essere suddiviso ulteriormente
in 2 parti, ossia parte alta (es. AH,BH,ecc.) e parte bassa (AL,BL,ecc.).
Quindi in questa maniera ogni "parte" del registro puo' contenere un valore
da 00 a FF (mentre il registro "intero" contiene valori da 0000 a FFFF).
Facciamo un esempio: se muoviamo un valore in AX (MOV AX, 01AFh), il registro
AL conterra' il valore AFh ed il registro AH conterra' invece 01h. Tutto qua!
Ora, i segment-registers:
[CS].... Il code-segment, cioe' l'area di memoria nella quale si trova il
codice del programma che state sodomizzando. L'indirizzo CS:IP serve ad
identificare proprio l'istruzione che state per eseguire.
[DS].... Data-segment, l'area di memoria alla quale la CPU accede in lettura.
I dati.
[ES].... Extra-segment, altra area di memoria alla quale la CPU accede, ma
questa volta in scrittura. In pratica, la CPU legge da DS:SI e va' a scrivere
il byte (o la word) letta in ES:SI.
[IP]..... Istruction Pointer. Cos'e'? Semplice, l'indirizzo dell'istruzione
che state per eseguire nel code segment attuale. Io di solito, durante il
crakkaggio nel debugger, modifico questo registro invece del jump, in maniera
da non danneggiare per il momento il programma. Ma e' solo una mia abitudine.
[SS].... Stack-segment, area di memoria di "parcheggio" nella quale la CPU
tiene nota di tutti i return-address dalle subroutines. Usando l'istruzione
PUSH o POP, lo stack viene riempito o svuotato (questa ci sta' che sia una
stronzata, comunque se non e' proprio cosi' la funzione di queste istruzioni
e' simile..... chiedero' a MoonShadow!).
Altri registri, ma questi li potete anche tralasciare, sono:
[SI]..... Source-index, usato insieme all'istruzione MOV. E' un puntatore
all'interno di un segment (di solito DS) che viene letto dalla CPU.
[DI]..... Destination-index, anche questo usato insieme a MOV. E' un
puntatore all'interno di un segment (di solito ES) dove la CPU va' a
scrivere. Andando a vedere all'indirizzo ES:DI, se vedete che ci viene mosso
qualcosa, potreste anche capitare in locazioni interessanti... (potreste
trovarci addirittura la password che cercate.... boh, voi provate!)
[BP]..... Base-pointer, usato insieme allo Stack-segment.
[SP]..... Stack-pointer, altro pointer usato insieme allo Stack-segment
Una particolare nota merita il seguente registro:
[FLAG].. Nel vostro debugger, vedrete (di solito in cima) un'insieme di
lettere maiuscole e minuscole (oppure illuminate o no, oppure con sotto dei
numeri 0 e 1). Questi sono i flag, che servono ad indicare se un particolare
jump deve avvenire o no. Logicamente, flag=0=spento flag=1=acceso.
Agevoliamo un esempio (Agevoliamo TM of Enzino Iachetti)
CMP AL,2A......... confronta il valore di AL con 2A.
Il risultato e' un cambiamento dello stato del flag
Z. Cioe', se e' vero, il flag viene attivato (1)
senno' viene disattivato (0).
JZ 8EDF........... salta -SE- il flag Z=1 (quindi se AL=2A)
Comunque, io di solito non li guardo mai, anche perche' tutti i debugger
(di solito) ti dicono con una freccetta se il jump avviene o no..... ma e'
una mia abitudine.
Piaciuti i registri? Ganzi eh? (comunque non preoccupatevi, si puo' crakkare
bene anche senza conoscerli molto... io stesso di solito, a meno che il
programma non sia una brutta bestia, non li guardo nemmeno..... poi vi
spiego).
Ora, qualcosa sulle istruzioni (altra sigaretta.... Ulp! Le ho quasi finite!)
[MOV]..... E' un'istruzione le cui funzioni sono fondamentali nel cracking.
Difatti, molte volte vi ritroverete a dover magari muovere un valore giusto
in una locazione semplicemente cambiando un CMP in un MOV (poi vi spiego....
non temete). La sua sintassi e': MOV [destination],[source]
es 1. MOV AX,BX ------> muove il valore di BX in AX
es 2. MOV CX,[0400] ------> muove i due bytes contenuti all'indirizzo
specificato (DS:0400) in CX. In questo caso
se dumpate a DS:0400 trovate lo stesso
valore di CX, solo rovesciato (es. se in CX
c'e' 002Ah, troverete 2A00h); non so' perche',
stasera non ho fame), ma e' cosi'....
es 3. MOV AL,DL ------> muove la parte bassa di DX nella parte bassa
di AX
es 4. MOV [ES:300],AX ----> muove il valore di AX nella locazione
specificata. Notare che se ES non e'
menzionato, si usa DS. Se prima di una
istruzione del genere si muove un valore
in BX (es. 03) questo viene usato come base
da aggiungere all'indirizzo specificato.
Quindi, in questo caso, il valore di AX
verrebbe mosso in ES:300+BX = ES:303.
[CMP]..... Semplicemente, confronta due valori in memoria, siano essi
registri oppure bytes, cambiando di conseguenza il flag relativo. La
intassi, secondo i casi, puo' essere:
es 1. CMP AX,01 -----> confronta AX con 01
es 2. CMP AX,BX -----> confronta AX con BX
es 3. CMP AX,[0550] -----> confronta AX con i 2 bytes a DS:0550
(eccetera eccetera...)
Questa funzione funziona (bello!) come una sottrazione source-destination,
cioe':
ponendo AX=20 e BX=21, il risultato del CMP AX,BX sara' 20-21=-1. Il
risultato di questa sottrazione attivera' il flag CARRY (C), attivato quando
si sottrae un valore piu' grande da uno piu' piccolo; se invece la
sottrazione non da' risultato negativo, il flag rimane 0 (disattivato).
Dal punto di vista crakkistico, le istruzioni CMP sono usate *SEMPRE* per
verificare il vostro input, oppure per far sapere al programma se e'
registrato o meno. Quindi, truffando il CMP si puo' benissimo far credere al
tapino una cosa per un'altra!
[JMP].... Lo troverete *SEMPRE* dopo il CMP, nelle varie forme.
La piu' semplice, e ovvia, e' la forma JMP <indirizzo>, che naturalmente
provoca un salto all'indirizzo desiderato, quali che siano i valori dei
flags dati dal CMP. Per quanto riguarda l'indirizzo, questo puo' essere
nello stesso CS (JMP 0AF4) oppure in un'altro (JMP 2000:18A0 oppure JMP
DWORD PTR ES:[DI], che vi spedira' alla locazione contenuta in ES:DI. Ma
sono solo alcuni esempi).
Questa comunque e' l'istruzione che userete piu' spesso (anzi, mi sbilancio:
nel 99% dei casi) nei vostri scopi pirateschi. Difatti, se la vostra
protezione, ad esempio, controlla una locazione e poi fa' un JNZ che riporta
il programma all'inserimento della password/serialnumber, basta che
sostituiate il jump condizionale con un JMP, e..... et voila'! Comunque, se
ne riparla dopo!
Ora, vi agevolo la lista dei vari jump condizionali, spudoratamente copiata
dal Cracking Manual di The Cyborg (quindi, grazie tante, leggetelo che e'
bellino, ma il mio e' meglio perche' e' piu' aggiornato!).
Dunque, supponendo un CMP AX,BX, si possono avere i seguenti casi:
(Z,O,S,C,P sono i flags che i jump vanno a controllare)
Istruzione Definizione, condizione, flag
JNZ 030A (Jump if not zero, AX diverso da BX, Z=0)
JNE 030A (Jump if not equal, identico a JNZ)
JZ 030A (Jump if zero, AX=BX, Z=1)
JE 030A (Jump if equal, identico a JNZ)
JB 030A (Jump if below, AX<BX, C=1)
JA 030A (Jump if above, AX>BX, C=0)
JL 030A (Jump if less, AX<BX, S diverso da O)
JNGE 030A (Jump if not greater or equal, AX<=BX, S diverso da O)
JGE 030A (Jump if greater or equal, AX>=BX, S=O)
JNL 030A (Jump if not less, in pratica uguale a JGE)
JLE 030A (Jump if less or equal, AX<=BX Z=1 oppure S=F)
JNG 030A (Jump if not greater, come JLE)
JG 030A (Jump if greater, AX>BX Z=0 oppure S=O)
JNLE 030A (Jump if not less or equal, AX>=BX Z=0 oppure S=O)
JS 030A (Jump if sign, /, S=1)
JNS 030A (Jump if not sign, /, S=0)
JC 030A (Jump if carry, /, C=1)
JNC 030A (Jump if not carry, /, C=0)
JO 030A (Jump if overflow, /, O=1)
JNO 030A (Jump if not overflow, /, O=0)
JP 030A (Jump if parity, /, P=1)
JPE 030A (Jump if parity even, come JP)
JNP 030A (Jump if no parity, /, P=0)
JPO 030A (Jump if no parity odd, come JNP)
(ce ne sarebbero altri, ma nella lista da cui li ho copiati non venivano
menzionati.)
Puff,Puff..... spero di non aver scritto minchiate! (tanto poi lo riguarda
MoonShadow!). E comunque, non fatevici tante seghe mentali....
Il funzionamento dei jump lo imparerete strada facendo.... nemmeno io mi
ricordo a memoria il funzionamento di tutti questi jmp (anzi, a dire il vero
non vado oltre le prime 5/6 righe!).
[LOOP]..... Indica un ciclo, che si ripete per CX volte (naturalmente, CX
decrementa ogni volta che trova questa istruzione). Per quanto riguarda il
formato, e' LOOP <indirizzo>, che indica appunto l'inizio del LOOP dove
questo ogni volta ritorna finche' CX non diventa 0. Istruzione piuttosto
pallosa da debuggare, utile in questo caso la funzione "Breakpoint Here" dei
debugger, che permette di settare un breakpoint all'istruzione successiva e
ripartire direttamente da li' senza sorbirsi tutto il ciclo (sempre che
funzioni, senno' ve lo dovete puppare tutto).
[REP]..... Repeat. Stesso discorso del loop per quanto riguarda la pallosita'
e l'uso della funzione "Here". Indica il ripetersi di istruzioni MOVS, LODS,
STOS (quindi si trovera' nel formato REP MOVS, REP LODS, REP STOS). Le
istruzioni suddette vengono ripetute CX volte.
[MOVSB]..... Muove un byte dall'indirizzo DS:SI all'indirizzo ES:SI.
[MOVSW]..... Stesso discorso, ma per una word (4 bytes)
[LODSB/LODSW]..... Con queste istruzioni, viene letto un byte o una word
residenti in memoria all'indirizzo DS:SI. Il byte o la word in questione
viene messo in AL (o in tutto AX, naturalmente, se e' una word)
[STOSB/STOSW]..... Se le istruzioni prima leggevano, questa cosa fa'?
mah..... forse scrive! Difatti, scrive il byte (o la word) in AL (o AX se
word) all'indirizzo ES:SI.
[CALL]...... Richiama una subroutine, e dopo l'esecuzione di questa torna
all'indirizzo successivo alla CALL stessa (tramite un RET/RETF).
Esempio:
CALL 68AB ----> esegue la subroutine a CS:68AB
subroutine:
CS:68AB ......
68AE ......
68B0 ......
68B3 RET ----> torna all'istruzione successiva a CALL 68AB
Una call puo' essere anche nel formato CALL FAR (come anche il JMP),cioe'
viene eseguita una subroutine ad un'indirizzo in un altro CS.
Nei vostri primi approcci crakkistici, se avete la fortuna di trovare la
CALL che salta *DIRETTAMENTE E SOLO* alla protezione, potete benissimo
togliere quella. Piu' in la' sara' meglio che impariate a districarvi con i
jump e i compare, identificando e modificando quelli relativi al solo
controllo della protezione. Difatti, se per caso quella CALL chiamasse una
subroutine che contiene la protezione ma anche istruzioni necessarie al buon
funzionamento del programma, eliminandola siete fottuti.... (cosa che ho
imparato dopo mooooooooooooooolto tempo e moooooooooooolte figure penose
distribuendo crack che si' sproteggevano il programma, ma che avevano anche
"alcuni" effetti collaterali!)
[INT]...... Chiama un interrupt (tipo una CALL ma non relativa al programma)
con una specifica funzione assegnata da un valore, di solito mosso in AX.
E' utile ad esempio monitorare l'interrupt 13 con il debugger (nel caso si
voglia sproteggere un programma che accede al floppy), oppure l'interrupt 16
con funzione 10 (AX=10) nel caso il programma attenda la pressione di un
tasto.... Utile ma non indispensabile, si crakka anche senza usare questa
funzione del debugger.....
FFFFFFFFFFFFIIIIIIIIIIIIINNNNNNNNNEEEEEEEEE!!!!!!!!!!!!!
Finalmente, che palle!!! Non ne potevo piu'. Non vedo l'ora di cominciare la
parte sul cracking vero e proprio. Comunque, a parte gli scherzi, un mini
corsino di assembler (MOOOOOOOLTTTOOOOO MIIIIIINIIIII!) ci voleva proprio,
senno' probabilmente non capireste niente nelle parti successive. Comunque
non e' detto che se capite poco in questa sezione non andrete avanti.......
anzi! Io stesso non conosco troppo bene l'assembler, ma vi assicuro che se
vi imparate ben bene le cose scritte sopra non avrete problemi. Quello che
conta e' l'intuito, la perseveranza, e ancora una volta.....il CULO! Magari,
se l'argomento vi interessa, puo' essere una buona scusa per impararsi
l'assembler un po' piu' a fondo (cosa che sto' cercando di fare anch'io!).
1.2...... USO DEI VARI DEBUGGERS
Vi dico subito che qui non mi dilunghero' poi tanto, visto che anche se i
programmi sono diversi, le funzioni sono sempre le stesse, e ben deducibili
dal programma stesso. Comunque, in questo tutorial faro' uso di:
1) GameTools 3.2 (G3X).... MITICO e INEGUAGLIABILE debugger DOS
(purtroppo solo in modo reale) che potete usare anche per
fare dei trainers.
2) SoftICE 2.0 for Windows95 ..... Praticamente, il GameTools per
Windows, con le stesse doti di ineguagliabilita' e miticita' (che
discorso a culo!). A parte gli scherzi, indispensabile, anche
perche' e' l'unico debugger (almeno credo) che permette di
debuggare (bel discorso, complimenti...) i programmi con
DOS4GW. Se volete potete anche usare il SoftICE x DOS al posto
del G3X.
3) Watcom Debugger..... Odiosissimo debugger indispensabile per
il cracking in DOS4GW. Fortunatamente, lo dovete usare solo
per questo..... il resto si fa' con gli altri due! Dato che
questa parte l'ho aggiunta dopo, i comandi li trovate direttamente
nel paragrafo sul DOS4GW.
Beh, andiamo al dunque.....
i comandi del debugger che userete piu' spesso sono:
[STEP] ....... Esegue le istruzioni una alla volta, eseguendo direttamente
le CALL e i LOOP.
[TRACE] ...... Come sopra, ma permette di eseguire le istruzioni all'interno
delle CALL e dei LOOP una alla volta. Utile se dovete utilizzare la famosa
tecnica "Cynar, fino al cuore del carciofo", ossia spulciare all'interno di
una serie di CALL nidificate fino a trovare quella che chiama *SOLO* la
routine di protezione
[BREAKPOINT]..... Esegue un INT 3 al posto dell'istruzione presente all'
indirizzo da voi specificato, causando un ritorno al debugger quando questa
viene eseguita. (se pero' c'e' la famosa trappola per il debugger...... son
cazzi! dovete individuare le istruzioni che vi impiantano il debugger e
levarle.). I breakpoint sono di vari tipi, ognuno con una funzione specifica.
Ad esempio, un breakpoint molto usato e' quello che torna al debugger ogni
qualvolta si accede in lettura e/o scrittura alla locazione indicata
(utilissimo per trovare proprio le istruzioni che esaminano il vostro input).
Un altro ancora e' quello che torna al debugger quando viene eseguita
l'istruzione all'indirizzo indicato (ad esempio, per stoppare il programma
in un certo punto che sappiamo essere proprio prima del controllo dell'input).
Questi sono solo 2 esempi di breakpoint.... nel G3X vi appare la lista
di quelli che potete usare, nel SoftICE dovete settarveli a mano.
La sintassi per il SoftICE non sto' a scriverla,in quanto e' spiegata nell'
help stesso del programma. Direte voi, dove lo trovo l'help ?
Semplice: se digitate ? <invio>, vi appare una lista di tutti i comandi
disponibili; ora, andate a vedere quelli relativi ai breakpoint, scegliete
quello che vi interessa e inserite ? <nome breakpoint (BPR,BPX,ecc.). Vi
apparira' quindi la sintassi del comando. Questo procedimento e' valido anche
per tutto il resto dei comandi del SoftICE (cosi' lo spiego una volta sola!)
[HERE]..... La funzione cui accennavo prima nel tutorial assembler, permette
di settare un breakpoint BPX (break on execution) in un punto particolare
(es. subito dopo un loop) causando il ritorno al debugger quando il programma
arriva a quel punto. In questo modo, si saltano fastidiose attese.....
Giustamente, voi mi direte: ma non e' lo stesso mettere un breakpoint come
spiegato prima ? No, cioe' si (la funzione e' la stessa), ma cosi' fate
prima.
Mi spiego: col G3X, ad esempio, scorrete il listato assembler, e
all'indirizzo dove volete che il programma si fermi premete "H", in modo da
mandarlo in esecuzione fino a quando non raggiunge quel punto. Per il SoftICE
stesso discorso, ma prima dovete entrare nella CodeWindow (la finestra sopra
a quella dove inserite i comandi, quella dove vedete il disassemblato del
codice) digitando "ec". Quindi, scorrete con alt+frecce e premete F7 dove
volete il breakpoint. L'unica differenza e' che questo tipo di BP vale una
volta sola, ossia tutte le volte lo dovete risettare. Capito mi avete ?
[INTERRUPT MONITOR]..... Non e' una vera e propria funzione, bensi' un
breakpoint (nel SoftICE comando BPINT) ad uno specificato interrupt, che
causa il ritorno al debugger ogni qualvolta questo interrupt e' chiamato.
Utile nel caso di protezioni che accedono al floppy, o alla porta parallela
(se se ne conoscono gli interrupt relativi, quello del floppy e' il 13)....
ma come ho detto piu' indietro non indispensabile, serve solo a sveltire un
po' la procedura. Non vi intrippate quindi troppo a mettere breakpoint
sull'interrupt 21 o 10, chiamati per funzioni dos e apertura schermo, perche'
rischiate di perdervi nei meandri del programma. Usate questa funzione solo
nei casi in cui conoscete *ESATTAMENTE* il numero dell'interrupt e la
funzione richiesta (es. per la pressione di un tasto, INT16 con funzione 10
in AX).
Dal G3X, accedendo al menu interrupt monitor, potete settare questi
breakpoint in maniera molto semplice..... nel SoftICE dovete fare a mano.
Vabbe', le funzioni che andrete maggiormente (anzi,diciamo pure e
sclusivamente) a usare nei debuggers trattati sono queste. Vi faccio ora una
panoramica sui tasti da usare nel SoftICE per accedere a queste funzioni
(cosi' evitate di battere 200 volte "p" <return>, "p" <return> mentre
debuggate). Quelli del G3X non li metto, dato che tutto e' spiegato su
schermo e anche un deficiente quale ero (e sono) io lo saprebbe far
funzionare.....
F6...... EC (enter/exit code window)
F7...... H (here) [dovete prima andare nella code window con F6 (ec)]
F8...... T (trace)
F10..... P (step)
Da notare che questi tasti possono anche essere cambiati, basta andare a
modificare il file WINICE.DAT nella directory del SoftICE.
FINE PRIMA PARTE ( by Xoanon )
I siti del Dr.Creker ( by Dr.Creker )
Apro questa piccolissima parte della rivista cercando di aiutare tutti quelli
che sono stufi di girovagare per la rete senza una meta proponendo ad
ogni numero siti piu' o meno interessanti e piu' o meno nuovi.
In questo numero ve ne propongo sei; molti di voi sicuramente li
conosceranno certamente ma comunque voglio ugualmente ricordarveli.
http://195.32.61.1:80/zo
Sito chiamato "Zona D'Ombra" del nostro amico Jader, che ci ha dato e ci
continua a dare l'opportunita' di mettere online questa rivista.
Ci sono link verso i piu' conosciuti siti hack della rete oltre ad una
pagina dedicata alle riviste ( come Phrack ad esempio ) e altro
materiale utile incluse alcune guide tradotte in italiano.
http://www.silitoad.org
Infinity Void Silicon Toad.
Carico di roba...forse un po' lenta l'apertura iniziale della pagina.
http://dspace.dial.pipex.com/town/terrace/oz49/hp.htm
Hacking and Phreaking.
Pagina priva, ad eccezione dello sfondo, di immagini; ci sono diversi
argomenti che spaziano un po' tutti i vari campi che trattiamo in
questa rivista. Un salto lo farei.
http://hack.box.sk
Hack Box. Contiene un motore di ricerca chiamato "astalavista".
Ci sono diverse cose che vale la pena vedere anche se,
rispetto ad altri, e' meno ricco di grafica ( quasi esclusivamente bianco
e nero ) e contiene meno materiale.
http://home1.swipnet.se/~w-12285
Jam Industries. Ci sono diverse cose in questo sito che riguardano warez
et similar. Un po' lento perche' carico di scritte 3d e menate varie.
http://www.vicon.net/~bhoover/frames
Brian's Hacking Page. Sito abbastanza interessante se non sapete dove
sbattere la testa mentre dialogate in irc.
Per ora vi ho citato alcuni dei siti che ho incontrato durante i miei
lunghi vagabondaggi su Internet; ho cercato di citare ( tranne Silicon
Toad e Zona D'Ombra ) luoghi poco conosciuti o almeno interessanti per
fare qualcosa in attesa che si scarichi la posta o che l'amico in irc
finisca di rispondere ad una vostra domanda.
Ho aggiunto piccoli commenti prettamente personali e quindi se non vi
trovate d'accordo sul mio giudizio non arrabbiatevi con la mia mail!
;)
Arrivederci alla prossima!
Dr.Creker
Ringraziamenti
Vorrei ringraziare alcune persone che ci hanno scritto:
Max, Donato, End, Dr Brujo, DukeLuke e tutti gli altri che ci hanno mandato
i loro consigli e suggerimenti per migliorare questa rivista.
Il Dr.Creker, cioe' il curatore della nostra zona posta ( che detto cosi'
puo' anche sembrare una cosa molto stupida ), ci teneva a ringraziare
un nostro amico e cosi' mi e' sembrato giusto dedicare a lui queste
righe:
Un saluto particolare a Ravestar...contento? ;)
Un ultimo saluto e ringraziamento va' a tutti i ragazzi che, tutte le
sere, incrocio in chat: Cliffipip, |CancerM|, Franco21, Kio, _Guyver_,
e a tutti gli altri che stanno continuando a sostenere questa nostra
rivista.
Grazie a tutti voi!
Conclusioni ( by InfectedMachine )
Stiamo ultimando la homepage "ufficiale" ( grossa parola, forse troppo )
di SystemDown ovvero stiamo ritoccando alcune immagini e sistemando piccoli
dettagli ( e per questo devo ringraziare MainMan che ha gestito fin
dall'inizio la grafica della nostra pagina ); comunicheremo nel prossimo
numero l'url della suddetta paginetta.
Per ora, come sempre, questa rivista apparira' su Zona D'Ombra ( per chi
non sapesse l'indirizzo esatto, vi rimando all'angolo del Dr.Creker ) e
continuera' ad apparire sul sito di Jader anche dopo che la nostra
homepage sara' in linea.
Pregherei ancora una volta tutti voi di NON postare SystemDown sui
newsgroups; questo non perche' vogliamo andare contro alle cose che avevamo
scritto nel primo numero, cioe':"...se avete qualche persona a cui volete
dare questo testo lo potete fare tranquillamente ( e, anzi, ne saremmo
molto felici :)) ) senza pero' alterarne il contenuto..." ma perche' i
newsgroups possono essere letti da cani e porci quindi vorrei evitare,
almeno per ora, lo spargimento del testo che state leggendo ovunque.
Se, comunque, vi venisse qualche dubbio gradiremmo molto che comunicaste
PRIMA le vostre intenzioni a qualcuno della rivista in modo da poterne
discutere un po' tra noi.
Le parole che avevo scritto nel numero scorso volevano dire:
1) Spargete in giro la rivista in modo che tutti la possano leggere e
questo per il semplice fatto che ancora MOLTE persone non sanno nemmeno
che esiste una cosa del genere, e mi riferisco anche a chi sta leggendo
questa rivista solamente per proteggere meglio il suo server da eventuali
attacchi "nocivi" come diceva una lettera che mi e' arrivata.
2) Spargetela in giro si, ma alle persone che conoscete e di cui vi fidate.
Postarla sui Newsgroup non e' proprio darla alle persone che conosciamo...
Grazie a tutti.
Un ultima cosa:
Qua di seguito riporto le mail alle quali potete scrivere se avete dubbi o
se vi serve un semplice consiglio:
InfectedMachine: infected@community.co.uk
Dr.Creker: dr.creker@deathsdoor.com
Jester: Jester@cryogen.com
Vi lascio con una frase che mi e' rimasta impressa dopo aver visto il
film "pantere nere ( Panthers )":
"...potete fermare i rivoluzionari, non la rivoluzione... ".
