Piero V.

Audio Alfabeto Telefonico Italiano

L’alfabeto telefonico è quello che di solito si usa quando si devono dettare codice fiscale e simili.

Personalmente avevo l’esigenza di creare un sistema di sintesi audio dei CAPTCHA, una cosa simile a quella che fa il mio plugin DokuCaptcha, però volevo che il tutto fosse più accessibili alle utenze di lingua italiana.

Visto che può essere utile anche ad altre persone, lo condivido.

Poiché non avevo una bella voce narrante disponibile, l’ho generato con IT-FLite, una vecchissima versione italiana del motore di sintesi vocale FLite (Festival Lite). Sono rimasto stupito che GCC 6 sia riuscito a compilare un software di 13 anni fa senza intoppi.

Purtroppo non sono riuscito ad addolcire i picchi dei file generati, quindi allego direttamente i file come sono stati generati.

Li rilascio nel pubblico dominio o, in alternativa, se proprio vi occorre una licenza, fate riferimento alla CC0 di Creative Commons. Il software generatore è software libero, quindi non dovrebbe imporre vincoli sui file prodotti, ma in caso di problemi vi invito a contattarmi.

Download: alfabeto_telefonico.zip (zip contenente i vari WAV a 16KHz).

Scansioni... veloci

Purtroppo a casa non ho uno scanner che faccia da solo le scansioni di più fogli, devo accontentarmi del mio Epson Perfection.

Però ecco qui uno script bash utile che permette di fare velocemente le scansioni:

i=0; s=''; while [ "$s" != "e" ]; do scanimage --resolution 200 > image$i.pnm; convert image$i.pnm image$i.jpg; rm image$i.pnm; echo -n 'Immagine '; echo $i; let "i=i+1"; read s; done

In pratica prima dovete mettere un foglio, poi avviate lo script e farà il primo foglio. Continuate a premere invio per scannerizzare le pagine successive o “e” per uscire dal loop.

Ovviamente è uno script di pubblico dominio 😉

Brute force in PHP

Attenzione: lo scopo di questo articolo è solamente didattico e l’autore non si assume nessuna responsabilità di ogni suo uso illecito.

Il brute force è una tecnica per trovare una password tentando tutte le combinazioni possibili di certi caratteri.

Ne avevo già parlato di come scriverne uno ma non era fatto molto bene.

Questo qui invece è completamente personalizzabile, ma vi lascio il codice che parla da sé:

<?php
/**
 * Questa funzione è eseguita quando hai una password completa.
 * Ovvero è un collback di esempio, nonché quello di default.
 *
 * @param string $stringa: La password
 * @return boolean: La password va bene?
 **/
function callback($stringa) {
}

/**
 * Questa funzione serve per annidare dei cicli for che provano le
 * varie possibilità di caratteri.
 *
 * @param string $stringa: La stringa di partenza
 * @param array $chars: I caratteri da provare
 * @param integer $lunghezza: Lunghezza a cui si vuole arrivare
 * @param mixed $callback: Il callback per verificare la password
 * @return string: La password, altrimenti se fallisce il booleano false
 */
function for_annidato($stringa, $chars, $lunghezza=1, $callback='callback') {
	$stringa_originale=$stringa;
	$found=false;

	for($i=0; $i<count($chars); $i++) {
		$stringa=$stringa_originale.$chars[$i];

		if(strlen($stringa)==$lunghezza) {
			$found=call_user_func($callback, $stringa) ? $stringa : false;
		} else {
			$found=for_annidato($stringa, $chars, $lunghezza, $callback);
		}

		if($found!==false) {
			break;
		}

	}

	return $found===false ? false : $found;

}

Creare tutte le possibili combinazioni di un array di caratteri

Non so se avete letto il mio post di prima…

Comunque lo sfizio di creare un generatore di dizionario per brute-force me lo volevo togliere…

Ed eccolo qua:

<?php
$z=explode(' ',microtime());
$z=$z[0]+$z[1];
$l=8;
$a=array('a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',0,1,2,3,4,5,6,7,8,9);
$b=count($a);
$u=fopen("dizionario.txt", "w+");
for($c=0; $c<$b; $c++) {  ## 1
	$m=$a[$c];
	for($d=0; $d<$b; $d++) { ## 2
		$n=$a[$d];
		for($e=0; $e<$b; $e++) { ## 3
			$o=$a[$e];
			for($f=0; $f<$b; $f++) { ## 4
				$p=$a[$f];
				for($g=0; $g<$b; $g++) { ## 5
					$q=$a[$g];
					for($h=0; $h<$b; $h++) { ## 6
						$r=$a[$h];
						for($i=0; $i<$b; $i++) { ## 7
							$s=$a[$i];
							for($j=0; $j<$b; $j++) { ## 8
								$w=$m.$n.$o.$p.$q.$r.$s.$a[$j];
								fwrite($u, $w."n");
							}
						}
					}
				}
			}
		}
	}
}
$x="#";
$y=explode(' ',microtime());
$y=$y[0]+$y[1];
$v=$y-$z;
fwrite($u, "$x Generated in $v");
fclose($u);

Se non siete pazzi come me non fatelo girare, a meno che non abbiate 23,092060626TiB di spazio libero e tanto tempo da sprecare…

Infatti, questo script crea un documento di testo con tutte le combinazioni alfanumeriche (caratteri latini minuscoli solo, per fortuna) di 8 caratteri…

Ma facciamo un po’ di calcoli alla mano…

Numero di combinazioni: 368=2821109907456
Vale a dire 22568879259648 caratteri senza gli a capo
Quindi 25389989167104 byte il file con gli a capo
Ovvero 24794911296 KiB
Perciò 24213780,5625 MiB
Che equivale a 23646,270080566GiB
Come dire 23,092060626TiB

In pratica, è impossibile farlo…

Se prima finiva la memoria, adesso uno dei due processori è sempre al 100%…

Io dopo un bel po’ di minuti di elaborazione sono arrivato a aacou58n e a 1,2GiB.

Più precisamente a 1308793590byte…

Vedete un po’ voi…