Sto sviluppando un'applicazione per proteggere le comunicazioni tra un client e un server linux incorporato. Sono molto nuovo nel campo della crittografia, quindi in questa fase cerco più indicazioni, soprattutto quando si tratta di vulnerabilità nel mio approccio.
Il server non sarà connesso a Internet. Sto cercando un modo per implementare un'autenticazione con password one time - (presumibilmente l'OTP verrebbe generato tramite qualche scambio segreto condiviso tra client e server). Non voglio archiviare chiavi statiche sul server, quindi stavo pensando che qualcosa di simile all'uso dello scambio di chiavi effimero di Diffie-Hellman potesse essere usato per scambiare queste chiavi o qualcosa del genere. Qualcuno potrebbe darmi qualche suggerimento su come potrei approcciarmi a risolvere questo problema - o meglio ancora se questo è già stato fatto. Stavo pensando di usare OpenSSL per mettere insieme i pezzi del server e il client ha bisogno di essere più aperto - agnostico Java / C ++ / Platform. Forse ci sono alcuni esempi OpenSSL che fanno qualcosa di simile a questo, in caso affermativo, per favore mandali insieme.
EDIT: Quindi ho fatto un po 'di sperimentazione dopo aver postato la domanda ieri. Sono stato in grado di verificare che posso creare con successo un segreto condiviso utilizzando uno scambio temporaneo di Diffie-Hellman effimero. Ho ottenuto un proof of concept in C ++ usando la libreria OpenSSL, come mostrato nel blocco di codice qui sotto (che ho adattato da vari frammenti che ho trovato online, mi spiace di aver perso i link). Da quello che posso dire, questo dovrebbe essere sufficiente per far funzionare le password One Time tra il client e il server. Per quest'ultima soluzione, stavo pensando di collegare alla OATH Toolkit libreria per HOTP o TOTP Supporto dell'algoritmo.
L'idea sarebbe che una volta scambiato il segreto condiviso, il server potesse creare un OTP con sia il segreto condiviso che alcuni dati casuali del server. Una volta che il client conosce questo OTP, lo fornirebbe per accedere e autenticarsi. Non sono sicuro di aver sbagliato completamente se ciò che sto proponendo non è possibile (o più probabilmente pieno di buchi).
Il seguente blocco di codice mostra come i Diffie-Hellman segreti condivisi sono identici (dato un generatore comune e primo che viene stabilito tramite DH_generate_parameters_ex .... e clonato per il client e server che utilizza l'API DHparams_dup le chiavi DH sostituite tramite la chiamata EVP_PKEY_set1_DH)
auto dhparams = DH_new();
if ( DH_generate_parameters_ex(dhparams, 512, DH_GENERATOR_5, nullptr) != 0 ) {
// duplicate the existing parameters for alice
auto dhparams_alice = DHparams_dup(dhparams);
// generate Alice's private and public key values
// should return 1 for success
auto res = DH_generate_key(dhparams_alice);
// Use the same generator and bitlength parameters
auto dhparams_bob = DHparams_dup(dhparams);
// generate Bob's private and public key values
// should return 1 for success
res = DH_generate_key(dhparams_bob);
auto key_alice = EVP_PKEY_new();
// should return 1 for success
res = EVP_PKEY_set1_DH(key_alice, dhparams_alice);
auto key_bob = EVP_PKEY_new();
// should return 1 for success
res = EVP_PKEY_set1_DH(key_bob, dhparams_bob);
// Compute the shared secret using Alice's private key and Bob's public key.
// unique pointer, so automatically destroyed.
size_t keyLen1 = 0;
auto key1 = dh_derive(key_alice, key_bob, keyLen1);
// Compute the shared secret using Bob's private key and Alice's public key.
// unique pointer, so automatically destroyed.
size_t keyLen2 = 0;
auto key2 = dh_derive(key_bob, key_alice, keyLen2);
// Prove correctness by showing Alicia and Beth derived the same secret
if (keyLen1 != keyLen2 || memcmp(key1.get(), key2.get(), keyLen1) != 0) {
std::cout << "Shared Secret different" << std::endl;
}
EVP_PKEY_free(key_alice);
EVP_PKEY_free(key_bob);
DH_free(dhparams_alice);
DH_free(dhparams_bob);
DH_free(dhparams);