Fixed or not Fixed ? this is the question…

Dopo un lungo periodo di indecisione su colore e in particolare manubrio ecco finalmente il gioiellino prodotto da Cicli Frugeri.

L’indecisione sul colore era fra un grigio antracite ed un verde british, per cui la scelta non poteva che ricadere su di un bellissimo “fumo di Londra”, una spettacolare via di mezzo proprio fra il grigio antracite ed il verde!

Essendo un bici da “passeggio” alla fine ho scelto una sella comoda, non poteva non essere una Brooks modello Flyer.

Il manubrio, anche qui, indecisione fra dritto e corsa vintage, alla fine ha vinto un dritto… ma non troppo

Ultima ma non ultima, scatto fisso o meno, anche qui in barba alla moda, non ho scelto un fisso, e come aggiunta ho messo un comodissimo contropedale in modo da eliminare un gruppo freno dal manubrio a beneficio dell’estetica generale.

Ora basta con le parole e spazio alle foto!!!

Nikon D300S

Componenti

  • Telaio su misura in acciaio alleggerito, color fumo di Londra
  • Cerchi ambrosio
  • Pneumatici CST ULTRA SPEED
  • Freno anteriore TEKTRO
  • Freno posteriore contropedale
  • Manubrio acciaio lucidato
  • Sella Brooks FLYER
  • Serie sterzo su cuscinetti
  • Guarnitura URBAN ProWheel
  • Pedali in alluminio su cuscinetti
  • Mozzi pista

Nikon D300S

Nikon D300S

contropedale
contropedale

Nikon D300S

RSA, Cypher & Cyphers

INTRO

Partendo dal presupposto che la sicurezza totale in ambito informatico e’ un obiettivo quasi irraggiungibile, potremmo dire un’Isola che non C’e’, si possono tuttavia adottare tecniche che ci consentano di scambiare dati in maniera sicura!

Scambiare dati in maniera SICURA non e’ cosa semplice e sopratutto molti magari non avranno idea di come farlo, quindi sia per l’utente curioso sia per l’utente che vuole capire meglio cosa sta dietro a programmi blasonati come PGP o simili vi propongo una interessante lezione di sicurezza con un utile e concreto esempio, che vi fara’ avere piu’ confidenza con il terminale ( cosa che non fa mai male dal mio punto di vista ovviamente ), ma piu’ che altro vi consentira’ di imparare le basi della crittografia simmetrica e pubblica.

Piccola premessa teorica per consentirvi di apprendere al meglio.

CIFRATURA

Per cifrare file lunghi la maniera piu’ sicura e performante e’ utilizzare algoritmi di cifratura simmetrica come AES ( Advanced Encryption Standard ) a 128 bit se si vuole essere veloci oppure a 256 bit se si vuole essere maggiormente sicuri ( ma piu’ lenti in fase di crypt/decrypt ), infatti la forza dell’algoritmo dipende dalla lunghezza della chiave ed e’ inversamente proporzionale alle prestazioni, ovvero chiave lunga e sicura, prestazioni piu’ lente! Gli algoritmi simmetrici sono utilizzati per cifrare messaggi anche di grosse dimensioni ( sono stati creati apposta! ) e sono molto rapidi nell’esecuzione dell’algoritmo sia in fase di cifratura che in decifratura.

Al contrario gli algoritmi a chiave pubblica eseguono pesanti e complesse funzioni matematiche, in particolare esponenziali e aritmetica modulare, e per questo motivo sono computazionalmente molto piu’ pesanti e quindi lenti, per questo motivo e’ meglio usarli per cifrare file di piccole dimensioni, infatti uno dei loro principali scopi e’ quello di cifrare le chiavi di algoritmi simmetrici per essere scambiate in maniera sicura. Per la loro particolarita’ di avere due chiavi, una pubblica e una privata essi sono molto sicuri in quanto anche se le chiavi sono in funzione una dell’altra non c’e’ modo di ricavare la chiave privata conoscendo la pubblica.

N.B. Modi di attacco a questi sistemi ce ne sarebbero, come l’attacco Man in the Middle, ma utilizzando le dovute precauzioni che dopo elenchero’ starete tranquilli che i vostri dati saranno ‘abbastanza’ sicuri!!

Detto questo una volta cifrato il nostro messaggio dobbiamo trasmetterlo al destinatario con la relativa chiave, per consentirgli di decifrarlo e quindi leggerlo. Come e’ noto internet non e’ un mezzo sicuro, i dati possono essere letti e spiati in centinaia di modi diversi, per questo accorre in nostro aiuto la crittografia a chiave pubblica, la quale ci consente di trasmettere un segreto, in questo caso la chiave di AES, in maniera sicura e veloce.

Apriamo quindi il terminale del nostro Mac e utilizziamo il comando openssl, il quale ci mette a disposizione una vasta scelta di algoritmi che possiamo utilizzare. Non ricordo il comando per vedere la lista dei comandi ma e’ sufficiente digitare un comando non valido come “?” o “help” per vederne il listato:

comandi OpenSSL

Da un rapido sguardo notiamo che e’ diviso in tre sezioni: Standard commands, Message Digest commands e Cipher commands. Il primo comprende comandi per generare certificati, firme digitale, numeri primi, e per utilizzare algoritmi a chiave pubblica come RSA, il secondo comprende comandi per la generazione di hash utilizzando alcuni fra i piu’ famosi algoritmi, il terzo racchiude i comandi per cifrare con algoritmi simmetrici, come AES, DES, RC4, con diversi tipi di lunghezze di chiavi.

Una breve panoramica di quello che dovrebbe essere il modus operandi per scambiare un messaggio fra due utenti A e B coniugando i vantaggi della crittografia a chiave privata e a chiave pubblica:

A e B devono generare entrambi una chiave privata ed una pubblica ( punti 1-2-3-4 ) e poi scambiarsi l’output del punto 4 ovvero la loro chiave pubblica. La chiave pubblica puo’ essere scambiata normalmente senza precauzioni particolari in quanto per i principi di questa tecnica e’ computazionalmente impossibile ricavare la chiave privata associata sapendo la pubblica.

A questo punto se A vuole scambiare un messaggio sicuro con B deve:

  1. creare una chiave per AES
  2. cifrare il messaggio in questione con tale chiave
  3. inviare il messaggio cifrato a B
  4. cifrare la chiave di AES con la chiave pubblica di B ( in modo che solo B con la sua privata la possa leggere ) ed inviargliela

B ha quindi a disposizione un messaggio cifrato con AES e la relativa chiave cifrata con la sua pubblica, e deve:

  1. decifrare la chiave di AES usando la sua privata
  2. decifrare il messaggio cifrato con AES con la chiave ricavata al punto precedente

Perdonatemi la lunga introduzione ma questo e’ un argomento delicato e di non facilissima trattazione per cui e’ meglio spiegare bene le cose che scriverle in maniera troppo concisa risultando di difficile comprensione.

Detto questo, voglio aggiungere che e’ piu’ semplice a farsi che a dirsi, procediamo quindi con il mostrare passo a passo nel dettaglio la procedura.

Abbiamo a disposizione un file da cifrare che chiamiamo per stare sul classico plaintext.txt.

Per cifrare un file ci vuole la chiave, generiamo quindi una chiave random per AES con dimensione 128, 192 o 256: (ribadisco che piu’ e’ grande la chiave piu’ e’ forte l’algoritmo ma lenta l’operazione di crypt/decrypt)

rand -out aespwd.txt 256

Ora possiamo cifrare con AES e la chiave ( aespwd.txt ) il nostro file:

enc -aes-256-cbc -salt -in video.html -out video.aes

per decifrarlo in ricezione il comando e’ il seguente:

enc -d -aes-256-cbc -in video.aes -out video1.html

A questo punto dobbiamo scambiare in maniera sicura la password con il destinatario.

Creiamo la chiave privata per RSA salvandola in un file di testo:

1. genrsa -out rsapr.txt : il quale comando creera’ il suddetto file nella vostra home ( in /Users/nome_utente )

e’ possibile specificare la lunghezza in bit della chiave che si vuole generare in un range da 32 bit a 4096 bit, ovviamente per le operazioni matematiche di elevamenti di potenza, che si effettuano per il calcolo di RSA piu’ corta e’ la chiave, piu’ e’ veloce la cifratura e decifratura ma e’ anche piu’ soggetta ad attacchi di tipo Brute Force per scovare la chiave. Con lunghezze di chiave a partire da 512 bit diventa gia’ computazionalmente impossibile effettuare attacchi di tipo brute force pero’ come svantaggio si ha un notevole incremento, per l’appunto esponenziale, di calcolo impiegandoci molto tempo per cifrare e decifrare lo stesso messaggio.

2. rsa -in rsapr.txt -text -out espkey.txt

il quale comando genera un file contenente i parametri utilizzati per generare la chiave privata di RSA, i quali parametri verranno utilizzati per generare la seconda chiave, quella pubblica, la quale e’ in funzione della privata.
-text : consente appunto questa esplicitazione, andando a scrivere nel file indicato i valori del modulo, gli esponenti, i numeri primi, e tutto il resto.

contenuto di espkey.txt

Private-Key: (512 bit)
modulus:
00:e6:de:78:a5:bd:b4:9e:e1:20:e1:ee:a3:f9:04:
9c:a4:5b:f9:e0:be:1d:5d:f0:57:7d:e9:e3:11:dd:
9d:99:c3:bc:60:f1:0b:8d:6b:cf:27:49:de:01:81:
81:9b:8e:8b:65:f7:41:1f:5e:98:e1:0a:10:9f:9b:
b4:a8:5a:f8:d7
publicExponent: 65537 (0x10001)
privateExponent:
00:b6:2a:d5:07:f2:a8:92:b5:11:3d:35:10:2d:6d:
76:2c:3a:66:f0:ef:12:3d:0d:67:fb:f2:91:39:87:
a4:d3:ae:1f:4c:90:3b:92:18:ce:13:5f:87:a9:74:
0c:9b:4e:e4:a0:b6:ee:e9:28:d7:43:6d:ee:4a:f4:
be:67:37:01
prime1:
00:f4:65:81:3d:17:e8:02:23:ba:2e:a2:54:82:d3:
25:2f:68:69:cc:6b:4a:08:95:a3:da:37:4d:1b:ef:
79:a8:41
prime2:
00:f1:d4:8c:47:f3:d4:6f:03:55:e3:49:a7:06:4f:
90:03:5b:d4:fb:83:cd:e8:78:ae:34:39:8f:2f:14:
2e:1b:17
exponent1:
0b:46:e3:bf:bd:ea:a6:ae:9f:58:a7:84:de:c4:7f:
62:c0:9e:a1:20:12:3a:73:2d:2c:54:80:ea:59:12:
74:01
exponent2:
43:55:b3:59:b5:82:c9:06:5c:bb:d4:9e:35:1b:a2:
35:cd:34:18:74:32:b9:30:21:11:59:95:8c:be:49:
b8:31
coefficient:
29:59:6c:bb:c0:38:a5:a7:f2:9d:ea:01:ba:1c:99:
30:4f:94:e3:5f:44:34:5d:9a:9f:35:6c:37:02:e4:
c9:21
—–BEGIN RSA PRIVATE KEY—–
MIIBOQIBAAJBAObeeKW9tJ7hIOHuo/kEnKRb+eC+HV3wV33p4xHdnZnDvGDxC41r
zydJ3gGBgZuOi2X3QR9emOEKEJ+btKha+NcCAwEAAQJAALYq1QfyqJK1ET01EC1t
diw6ZvDvEj0NZ/vykTmHpNOuH0yQO5IYzhNfh6l0DJtO5KC27uko10Nt7kr0vmc3
AQIhAPRlgT0X6AIjui6iVILTJS9oacxrSgiVo9o3TRvveahBAiEA8dSMR/PUbwNV
40mnBk+QA1vU+4PN6HiuNDmPLxQuGxcCIAtG47+96qaun1inhN7Ef2LAnqEgEjpz
LSxUgOpZEnQBAiBDVbNZtYLJBly71J41G6I1zTQYdDK5MCERWZWMvkm4MQIgKVls
u8A4pafyneoBuhyZME+U419ENF2anzVsNwLkySE=
—–END RSA PRIVATE KEY—–

3. rsa -in rsapr.txt -pubout -out pubkey.pem

con questo comando generiamo la chiave pubblica associata.

4. rsa -in pubkey.pem -text -pubin -out pubblica.txt

con questo comando generiamo un file contenente, la chiave pubblica, il modulo e l’esponente utilizzati, necessari al destinatario per decifrare il file.

Modulus (512 bit):
00:e6:de:78:a5:bd:b4:9e:e1:20:e1:ee:a3:f9:04:
9c:a4:5b:f9:e0:be:1d:5d:f0:57:7d:e9:e3:11:dd:
9d:99:c3:bc:60:f1:0b:8d:6b:cf:27:49:de:01:81:
81:9b:8e:8b:65:f7:41:1f:5e:98:e1:0a:10:9f:9b:
b4:a8:5a:f8:d7
Exponent: 65537 (0x10001)
—–BEGIN PUBLIC KEY—–
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAObeeKW9tJ7hIOHuo/kEnKRb+eC+HV3w
V33p4xHdnZnDvGDxC41rzydJ3gGBgZuOi2X3QR9emOEKEJ+btKha+NcCAwEAAQ==
—–END PUBLIC KEY—–

Cifriamo con la chiave pubblica del destinatario la chiave di AES, in questo modo solo egli con la sua chiave privata sara’ in grado di leggere il contenuto e quindi di decifrare il messaggio:

rsautl -encrypt -in aes_pwd.txt -inkey pubkey.pem -pubin -out cifrato.txt

il risultato:

5¿≈p@#©##g«Ë˘4}ì#˙flhËÁ~#pÍ=J˚¡ÙD$˛1≥Rê≤ˇhÜÙwúé´#s#-~Qôé(DÌfÃΩc

se lo voglio inviare via mail o dettare al telefono devo convertirlo in base64 a causa dei sistemi di inoltro mail che consentono solo caratteri ASCII oppure nel secondo caso… vi vorrei sentire a pronunciare certe lettere 🙂

Per cui, perconvertire la chiave in base64 procediamo nel seguente modo:

base64 -in cifrato.txt -e -out cifrato64.txt

ottenendo il seguente output:

NcDFcEABqRgdZ8fo+TR9kxT632jo534DcOo9Svvl//RE8CT+MbNSkLL/aIb0d5yO
qxlzGC1+UZmOKETtZsy9Yw==

Per riconvertirla da base64 il comando e’ il seguente:

base64 -in cifrato64.txt -d -out cifrato-.txt

riottenendo la chiave AES cifrata (con la pubblica del destinatario):

5¿≈p@#©##g«Ë˘4}ì#˙flhËÁ~#pÍ=J˚¡ÙD$˛1≥Rê≤ˇhÜÙwúé´#s#-~Qôé(DÌfÃΩc

ora procediamo con il ripristinare dalla chiave qui sopra, con la privata del destinatario, la chiave AES:

e applichiamo la chiave al messaggio per poterlo leggere…

lungo ma efficace e molto molto sicuro!

Ruby, esercizio 1, statistiche.

Piccolo esercizio in Ruby che tramite la scansione di un file testuale crea alcune statistiche.

Da fare:

  1. leggere il file di testo;
  2. creare un metodo parole_frequenti, che ritorni un insieme delle parole piu’ lunghe di 3 caratteri che compaiono piu’ di 20 volte;
  3. ceare un secondo metodo coppie_frequenti, che ritorni l’insieme delle coppie con almeno 10 occorrenze.

vi do la struttura iniziale e il metodo per effettuare il punto 1.

N.B. il metodo leggi ritorna un array contenente tutte le parole del file specificato.

def leggi()
  testo=IO.read("costituzione.txt").downcase!
  return testo.split(" ")
end

def parole_frequenti
  #metodo da implementare
end

def coppie_frequenti
  #metodo da implementare
end

#MAIN
z=leggi
p z

a=parole_frequenti()
puts a

b=coppie_frequenti()
puts b

Nota: il file costituzione.txt lo potete scaricare qui.

ovviamente essendo un esercizio le soluzioni sono rimandate a settimana prossima 😛

Buona Programmazione!!

Fonte: esercizio universitario.