Salve sto utilizzando l'ethernet shield per un progetto. Ho un problema, siccome un server invia dei comandi ad arduino che li esegui avrei bisogno che la comunicazione sia sicura visto che il progetto si trova all'interno della rete lan. Ho scoperto che arduino non supporta il protocollo https, avete qualche soluzione da propormi?
Grazie...
Ad esempio, potresti implementare una cifratura dei comandi passati ad Arduino.
--> http://avrcryptolib.das-labor.org/trac
Se passa Leo72 da queste parti, chiedi a lui. 
@antonio:
Avr-crypto va benissimo come libreria. Ma la domanda è: da quanta "sicurezza" ti serve? Cosa vuoi proteggere?
Se si tratta di poche stringhe e la rete è mediamente sicura, potresti pensare ad un algoritmo a chiave privata. Lunghezza della chiave su 80 o 128 bit.
Se vuoi maggior sicurezza adotta un algoritmo a chiave pubblica, anche se poi i calcoli si appesantiscono e non poco.
@Paolo:
Ma va' dai XD XD
La sicurezza migliore è non inviare dati vitali. Puoi cifrare quanto vuoi ma captare la maggior quantità possibile di pacchetti dalla rete e farla analizzare da appositi programmi si trova la chiave. Bombardare l'ip della ethernet shield con pacchetti astrusi, voglio vedere quanto regge prima di crashare non essendo in grado di buttare fuori gli ip indesiderati 
Un po' di anni fa mi divertivo a fare il piccolo hacker e dentro la rete fastweb c'era veramente da ridere
Ora non puntiamo il dito.
Chi ha smanettato con i computer da anni non hai mai fatto ste cose?
chi non ha mai crakkato TELE+?
Scagli la prima pietra
Si trova la chiave se si usano algoritmi provatamente deboli oppure chiavi "a bischero" 
Se una chiave deve essere lunga 128 bit e per 128 bit intendo 128 bit casuali, se trovi "aaaaaaaaaaa" tu capisci come il gioco sia facile. Ma trova caratteri veramente a caso e poi ne riparliamo 
128 bit in un cifrario a scorrimento o a blocchi garantiscono 20 anni minimo di resistenza ad un attacco a forza bruta, ammesso che l'algoritmo sia serio e la chiave sicura. Se poi prendiamo una chiave pubblica allora dobbiamo addirittura salire a 2048 bit per avere la sicurezza di una chiave privata di 128 bit.
Se poi passiamo a 256 bit tenendo fermi i punti suddetti (chiave veramente casuale e algoritmo sicuro) abbiamo la certezza che, allo stato attuale, finirà molto prima l'universo che una rete composta da tutti i computer attualmente sulla Terra riesca a violare un dato cifrato a 256 bit XD
eeeeeee ho capito, parliamo di arduino uno sputo e si inchioda eheh
pablos:
Tu mi facevi un discorso sui generis, io parlavo quindi di sicurezza in generale. Tornando all'Arduino, io vedo bene per questo genere di micro i cifrari a scorrimento. Anche l'RC4, tanto bistrattato, va bene per proteggere i dati ammesso di usare una buona chiave. Ed è molto veloce, nonostante la sua semplicità.
leo72:
128 bit in un cifrario a scorrimento o a blocchi garantiscono 20 anni minimo di resistenza ad un attacco a forza bruta, ammesso che l'algoritmo sia serio e la chiave sicura.
uhhhh un pò come l'MD5. usando la potenza di una GPU ormai li cracchi in 5 minuti
lesto:
leo72:
128 bit in un cifrario a scorrimento o a blocchi garantiscono 20 anni minimo di resistenza ad un attacco a forza bruta, ammesso che l'algoritmo sia serio e la chiave sicura.uhhhh un pò come l'MD5. usando la potenza di una GPU ormai li cracchi in 5 minuti
Ma l'MD5 è tanto che si sa che non è sicuro. Ma è un problema diverso rispetto ai cifrari. Gli hash sono insicuri quando generano delle collisioni, ossia con testo differente possono generare lo stesso risultato. Sfruttando questo difetto insito nella loro struttura si può creare del testo "ad hoc" affinché restituisca valori prestabiliti, in questo modo si può ingannare un utente presentando un file contraffatto ma che ha un MD5 uguale a quello di un file "buono" oppure si può risalire al dato protetto generando hash preconfezionati e controllando che siano uguali a quelli memorizzati.
Gli hash infatti sono comunemente usati anche per memorizzare delle password, o per meglio dire si memorizza l'hash della password. Al login di un utente, il software esegue l'hash della password immessa dall'utente: se corrisponde all'hash memorizzato, la password è identica a quella stabilita dal programmatore o dall'amministratore del sistema. Usando l'MD5 si può trovare la password forzando le collisioni di questo algoritmo.
leo72:
Se poi passiamo a 256 bit tenendo fermi i punti suddetti (chiave veramente casuale e algoritmo sicuro) abbiamo la certezza che, allo stato attuale, finirà molto prima l'universo che una rete composta da tutti i computer attualmente sulla Terra riesca a violare un dato cifrato a 256 bit XD
affermazione "un po" troppo ottimistica
Gli algorimti attuali di crittografia potranno resistere per un altro decennio o poco più.
daddeTr:
affermazione "un po" troppo ottimistica
Gli algorimti attuali di crittografia potranno resistere per un altro decennio o poco più.
Io parlo di complessità della password misurata in bit e non in caratteri e parlo di attacchi compiuti da computer digitali. I computer quantistici hanno da venire e quindi forse fra 50 ann ne sapremo di più.
Intanto per violare una semplice password da 72 bit, nonostante lo sforzo aggregato di migliaia di computer, ad oggi ci vogliono ancora più di 160 anni:
http://stats.distributed.net/projects.php?project_id=8
Suggerisco anche:
Crypto-gram: February 15, 1999 - Schneier on Security (il Warning Sign #5)
Password size does matter | InfoWorld
forse mi sono espresso male.... mi sono semplicemente soffermato sulla tua certezza
leo72:
Se poi passiamo a 256 bit tenendo fermi i punti suddetti (chiave veramente casuale e algoritmo sicuro) abbiamo la certezza che, allo stato attuale, finirà molto prima l'universo che una rete composta da tutti i computer attualmente sulla Terra riesca a violare un dato cifrato a 256 bit XD
sto semplicemente dicendo che oltre alla complessità della password, gli algoritmi di crittografia hanno un ciclo di vita con una data di inizio ed una di fine... e la data di fine non è la fine del mondo (maya permettendo!) ma un data dipende da molti fattori tra cui la crescita dell'HW.
Se attualmente, parlando di computer digitali, i computer aggregati impiegano circa 160 anni per bucare una pwd da 72 bit dell'RC5,
tra 10 anni forse saremo nella condizione in cui i computer aggregati impiegheranno 20 anni per burare una pwd dell'RC5 a 256 bit.
abbiamo la certezza che, allo stato attuale,
Se tra 50 anni avremo i computer quantici, allora ne riparleremo. Fino ad allora, gli attuali computer non permettono di forzare una chiave "sicura" a 256 bit in un tempo ragionevole, neanche aggregando la potenza di calcolo.
salvo trovare un algoritmo che sia in grado di abbattere il tempo computazionale. mica esiste solo il brute-force. 
I tempi di crack sono calcolati sulla forza bruta, generalmente, che è tra gli attacchi peggiori. Esistono tantissime altre tecniche di crittanalisi ma se io devo vedere nel peggiore dei casi quanto mi costa infrangere un algoritmo, devo fare un paragone sulla forza bruta. Poi posso trovare la combinazione anche al 1° tentativo, mica è detto
Grazie per tutte queste informazioni. La rete dovrebbe essere mediamente sicura però non si sa mai! Quindi vorrei utilizzare la libreria avr-crypto-lib c'è qualche tutorial che mi spieghi come fare?
Grazie ancora...
Purtroppo poca documentazione. Quella libreria ha veramente poca documentazione. Anzi, la poca che trovi sul loro sito è anche non aggiornata. Ti conviene aprire la libreria che pensi di usare e ricostruire, guardando il file .h, i metodi ed i parametri da usare.
Salve ragazzi, ho provato a utilizzare la libreria avr che mi avete suggerite e per la quale vi ringrazio. Purtroppo ho dei problemi in fase di compilazione che non riesco a risolvere. Ho bisogno del vostro aiuto. Ecco il semplice codice che ho trovato da un esempio nel sito di avr-crypto-lib:
#include <stdint.h>
#include "aes.h"
void setup(){
Serial.begin(9600);
/* a sample key, key must be located in RAM */
/* generating the round keys from the 128 bit key */
}
boolean risp=false;
void loop(){
if(risp==false){
uint8_t key[] = { 0x01, 0x23, 0x45, 0x67,
0x89, 0xAB, 0xCD, 0xEF,
0x01, 0x23, 0x45, 0x67,
0x89, 0xAB, 0xCD, 0xEF };
uint8_t data[] = { 0x01, 0x02, 0x03, 0x04,
0x05, 0x06, 0x07, 0x08,
0x09, 0x0A, 0x0B, 0x0C,
0x0D, 0x0E, 0x0F, 0x00 };
aes128_ctx_t ctx;
aes128_init(key, &ctx);
//aes128_enc(data, &ctx);
risp=true;
}
}
Nel file ho commentato riga per riga ed ho scoperto che l'errore proviene dalla riga "aes128_init(key,&ctx);". Questo è il testo che mi restituisce il tool di arduino:
C:\arduino-1.0\libraries\aes\aes128_dec.cpp: In function 'void aes128_dec(void*, aes128_ctx_t*)':
C:\arduino-1.0\libraries\aes\aes128_dec.cpp:32: error: invalid conversion from 'void*' to 'const aes_cipher_state_t*'
C:\arduino-1.0\libraries\aes\aes128_dec.cpp:32: error: initializing argument 1 of 'void aes_decrypt_core(const aes_cipher_state_t*, const aes_genctx_t*, uint8_t)'
Forse potrei risolvere con un cast? Aspetto un vostro aiuto e intanto provo a risolvere...
Grazie...
Uhm... ho paura che non siano compatibili con l'IDE di Arduino. Le avevo provate ad usare tempo fa queste librerie, non mi ricordo però se con o senza successo.
Questa è una implementazione dell'AES-256 per l'Arduino.
EDIT:
e qui:
trovi un paio di hash.