Come si fa a controllare l'identity framework; di file enormi se ha hashing legato alla CPU?

Per i file di piccole size è solo ok, ma con quelli enormi si può facilmente trovare md5sum è CPU legato. C'è un algorithm di hashing in grado di scalare su più core? Qualsiasi soluzione? Idee? Qualsiasi cosa? 🙂

  • Percorso hyperthreading di esempio di AWS EC2
  • Esegui le richieste curl in parallelo in bash
  • Generazione di una CSR SHA256 SSL su CentOS / RHEL utilizzando genkey
  • Php: Come abilitare il hashing di blowfish su un server debian
  • Import un file csv da 260 GB in MySQL
  • Perché il mio Windows 7 VM in esecuzione sotto KVM di Linux non utilizza tutti i processri virtuali?
  • L'unità SATA a 4 TB HGST mostra solo 1,62 TB in Windows Server 2012
  • Quanto male è Network Attached Storage per alcune applicazioni cloud?
  • Tomcat Denial of Service dovuta a grandi pacchetti
  • Import un file csv da 260 GB in MySQL
  • 24TB RAID 6 configuration
  • Rsync è un buon candidato per l'implementazione di failover (set di dati molto grandi)?
  • 6 Solutions collect form web for “Come si fa a controllare l'identity framework; di file enormi se ha hashing legato alla CPU?”

    La mia miniera proprio al momento soluzione è:

    parallel --block=512M --pipepart -a …HUGEFILE… --progress --recend '' \ -k -j …NUMofProcessesSay4… md5sum | md5sum

    – Si dovrebbe notare che:

    1. L'hash md5 risultante non è del file ma piuttosto dei md5s delle sue parti, ma consente comunque di confrontare se la replica è identica all'origine
    2. Inoltre non funziona molto bene, specialmente quando si utilizza pipe e non file come input
    3. parallel --pipepart come ho scoperto non support le partizioni del disco

    Quindi mi piacerebbe sentire anche altri modi.

    Purtroppo, MD5 è un process lineare where il suo stato dipende da tutti gli input precedenti. In altre parole, non si può veramente parallelizzare. Inoltre, non sono a conoscenza di un vero e proprio hash alg che non funziona in questo modo.

    Quello che puoi fare (e, in base alla tua risposta, stai facendo) è quello di dividere i file di origine e calcolare contemporaneamente md5sum di ciascun pezzo.

    Se non è ansible / non farlo, è necessario utilizzare una function di hash più veloce come xxHash , CityHash o SpookyHash

    Altra idea (forse è applicabile al tuo utilizzo intenzionale): se hai bisogno di qualcosa di più veloce di MD5 (seppure singolo thread), puoi utilizzare CRC32 (che è accelerato dall'hardware dalle ultime CPU) per un primo passo veloce, ricorrendo a MD5 / SHA1 per un secondo passaggio su file apparentemente identici.

    Non c'è molto da fare per elaborare l'integer file. MD4 o CRC32 sono probabilmente le tue scommesse migliori per un algorithm ampiamente implementato e veloce (anche se CRC32 sarà molto less efficace di MD4).

    Verifica di varie implementazioni del vostro algorithm di scelta. Se riesci a trovare un'applicazione asm ben testata, probabilmente migliorerà la performance dei suoi cugini C / C ++.

    Se non ti interessa veramente l'integerperabilità, la ricerca di hashing su più core è facilmente fattibile dividendo il file in blocchi (non è necessario eseguire sul disco, si avrebbe appena iniziato a leggere da offset specifici) e elaborando ciascun pezzo separatamente (questo provocherà gravi danni a disco, degradando le performance, soprattutto per i dischi meccanici). Si finirà con hashes separati per each pezzo (anche se questo ha altri vantaggi, come quello di puntare verso il pezzo rotto) ma potresti sempre farli insieme per un valore finale.

    Questo Gist potrebbe essere un buon inizio per qualcosa in Python.

    La maggior parte delle risposte qui hanno affrontato la natura lineare degli algoritmi di hashing più. Anche se sono sicuro che esistono alcuni veri algoritmi di hashing scalabili, una soluzione più semplice è dividere semplicemente i dati in piccoli pezzi, e farlo each singolo.

    Considerate l'approccio BitTorrent: quando viene creato un Torrent, tutti i file sono suddivisi in 'blocchi', ciascun block viene separato singolarmente e ognuno di quei hash registrato nel file .torrent. Questo è ciò che consente a un peer di verificare in modo incrementale i dati in entrata, senza wherer attendere che l'integer file finisca il download. Gli errori possono anche essere corretti in base al block, anziché richiedere la re-trasmissione dell'integer file. Oltre ai vantaggi logistici, questo approccio consente inoltre di scorporare gli hash su più core – se sono disponibili 8 core, è ansible estrarre contemporaneamente 8 blocchi.

    Se si ingegnerizza il process di verifica per lavorare su alcuni sottoinsieme dei dati, ad esempio blocchi di size fisse, è ansible estrarre each block su un nucleo separato eliminando così una grande quantità di ritardi nella pipeline. Ovviamente, questo approccio ha un piccolo compromesso di tempo / memory: each ulteriore istanza di hashing è associata ad una sovrapposizione, soprattutto nella forma di memory, anche se questo è minimo a less che non esegui centinaia di istanze.

    È ansible utilizzare md5deep per questo e hashdeep per altri hash. Support il multi threading con la -j flag. Per impostazione predefinita creerà un thread di hashing per ciascun nucleo. Inoltre ha una bandiera per rompere i file in pezzi prima di hashing, ma non utilizzerà più thread su un singolo file. Ho usato questo per get sha256 di mezzo milione di file e ha funzionato ottimamente. Ha anche un flash ricorsivo che rende più facile la gestione di grandi alberi di directory.

    Ecco il manpage per esso http://md5deep.sourceforge.net/md5deep.html e git repo https://github.com/jessek/hashdeep

    Il nome del pacchetto in ubuntu e debian è md5deep e include includehdeep.

    È facile progettare un algorithm di hashing che sia scalabile su più core, è che gli algoritmi di hashing più conosciuti tendono a essere progettati specificamente per prevenire questo, in modo che i compiti come trovare collisioni di hash si fanno il più lento ansible.

    Le funzioni di cancellazione che non impongono l'elaborazione seriale potrebbero essere adatti a voi, ma ciò dipende dalle properties; che si aspetta dalla function di hashing. In quanto tale, non credo di aver fornito informazioni sufficienti per fare una buona raccomandazione.

    Come altri hanno suggerito, è ansible build una function di hashing come hash degli hash concatenati di ciascuno dei blocchi di una certa dimensione nell'originale. Finché la dimensione del block è abbastanza grande per rendere difficile invertire gli hash di singoli blocchi, questo è probabile che funziona abbastanza bene per la maggior parte degli scopi. Quanto grande dovrebbe dipendere dipende da quanto prevedibile sia il contenuto di quei blocchi. Se è in grado di stimare l'entropia e scegliere una dimensione di block in modo tale che si ottengono 128 bit di entropia per block, dovrebbe essere sufficiente per la maggior parte degli scopi (e overkill per molti in cui la sicurezza non è la preoccupazione principale).

    Dal punto di vista della sicurezza, sei preoccupato del grado di entropia a livello di block, in quanto altrimenti trovare una collisione per un singolo block è sufficiente per consentire a un attore maligno di sostituire una parte del contenuto e di get lo stesso hash finale.

    È forse degno di notare che avere un block fisso di size significa che la principale debolezza di MD5 è irrilevante – l'hacker non può aggiungere dati aggiuntivi al block.

    Se le vostre esigenze stanno prevenendo le collisioni di hash che si verificano in natura, a differenza di quelle maligne, allora è senza dubbio permesso di utilizzare una function di checksum molto più veloce. Gli hash crittografati sono tipicamente progettati per essere lenti da calcolare.

    Una function del gruppo function di scorrimento che utilizza la modalità tree di hash può essere adatta. Poi di nuovo, CRC32 potrebbe essere tutto il necessario.

    Suggerimenti per Linux e Windows Server, quali Ubuntu, Centos, Apache, Nginx, Debian e argomenti di rete.