Zuletzt aktualisiert: 11. September

Sichere Dateiverifizierung mit Ruby und SHA384

Tim Koschützki

Mitgründer · Berlin, Deutschland ·

Die Sicherstellung der Dateiintegrität ist für Entwicklerinnen und Entwickler entscheidend, insbesondere beim Umgang mit sensiblen Daten oder bei der Verteilung von Software. SHA384-Hashing bietet eine robuste Methode, um zu überprüfen, ob Dateien verändert oder beschädigt wurden. Sehen wir uns an, wie Sie SHA384-Hashing in Ruby mithilfe der OpenSSL-Bibliothek umsetzen können.

Warum SHA384?

SHA384 gehört zur SHA-2-Familie und bietet einen sicheren Hash-Algorithmus, der einen eindeutigen 384-Bit-Hash (48 Byte) erzeugt. Er wird häufig zur Überprüfung der Dateiintegrität eingesetzt und stellt sicher, dass Daten während der Übertragung oder Speicherung nicht manipuliert wurden.

SHA384-Hashing verbessert die Dateisicherheit, indem es:

Beschädigungen von Dateien oder unbefugte Änderungen erkennt.
für jede Datei einen eindeutigen Fingerabdruck bereitstellt.
die Datenintegrität während der Übertragung sicherstellt.
bei minimalen Leistungseinbußen eine stärkere Sicherheit als SHA256 bietet.

Ihre Ruby-Umgebung einrichten

Die OpenSSL-Integration von Ruby ist bereits eingebaut, Sie benötigen jedoch eine ordentliche Ruby-Installation. So richten Sie diese mit rbenv ein:

Unter macOS oder Linux mit Homebrew

brew install rbenv
rbenv init
# Follow the printed Instructions to update your shell configuration

Unter Linux ohne Homebrew

git clone https://github.com/rbenv/rbenv.git ~/.rbenv
cd ~/.rbenv && src/configure && make -C src
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
~/.rbenv/bin/rbenv init
# Follow the printed Instructions to update your shell configuration

Installieren Sie anschließend Ruby:

rbenv install 3.2.2  # or latest stable version
rbenv global 3.2.2
ruby -v  # Verify installation

Dateien mit Ruby und OpenSSL hashen

Hier ist eine robuste Implementierung zum Hashen von Dateien mithilfe der in Ruby integrierten OpenSSL-Bibliothek:

require 'openssl'

def sha384_hash(file_path)
  digest = OpenSSL::Digest.new('SHA384')
  File.open(file_path, 'rb') do |file|
    buffer = ""
    # Read file in chunks to handle large files efficiently
    digest.update(buffer) while file.read(8192, buffer)
  end
  digest.hexdigest
end

# Usage example with error handling
begin
  hash = sha384_hash('example.txt')
  puts "SHA384 hash: #{hash}"
rescue Errno::ENOENT
  puts "Error: File not found"
rescue => e
  puts "Error: #{e.message}"
end

Diese Implementierung:

liest die Datei in Blöcken (jeweils 8 KB) und verarbeitet große Dateien effizient, ohne sie vollständig in den Arbeitsspeicher zu laden.
verwendet zum Lesen der Dateien den Binärmodus ('rb'), um plattformübergreifend konsistente Ergebnisse zu gewährleisten.
enthält eine ordentliche Fehlerbehandlung für häufige Probleme wie fehlende Dateien.

Dateiintegrität überprüfen

Um die Dateiintegrität zu überprüfen, vergleichen Sie den erzeugten Hash mit einem bekannten, korrekten Hash. Dabei ist es entscheidend, eine Vergleichsfunktion mit konstanter Laufzeit zu verwenden, um Timing-Angriffe zu verhindern, bei denen Angreifer aus der Dauer des Vergleichs Informationen über den Hash ableiten könnten.

require 'openssl'

# Constant-time comparison function
def secure_compare(a, b)
  # Ensure strings are of the same type and encoding for accurate byte comparison
  a = a.b unless a.encoding == Encoding::BINARY
  b = b.b unless b.encoding == Encoding::BINARY

  return false unless a.bytesize == b.bytesize

  l = a.unpack "C*"

  res = 0
  b.each_byte { |byte| res |= byte ^ l.shift }
  res == 0
end

# Assume sha384_hash function from previous example is defined
expected_hash = "your_known_good_hash_here" # Replace with the actual expected hash

begin
  file_hash = sha384_hash('example.txt')

  if secure_compare(file_hash, expected_hash)
    puts "File integrity verified."
  else
    puts "File integrity compromised!"
  end
rescue Errno::ENOENT
  puts "Error: File not found"
rescue => e
  puts "Error verifying file: #{e.message}"
end

Plattformübergreifende Überlegungen

Wenn Sie Dateien über verschiedene Betriebssysteme hinweg überprüfen, achten Sie auf mögliche Unterschiede bei den Zeilenenden (CRLF unter Windows gegenüber LF unter macOS/Linux), die die Hash-Werte beeinflussen können, wenn Dateien im Textmodus gelesen werden. Lesen Sie Dateien zum Hashen immer im Binärmodus, um konsistente Ergebnisse zu erhalten:

# Always use binary mode ('rb') for consistent cross-platform results
File.open(file_path, 'rb') do |file|
  # Hashing logic here...
end

Wenn Sie unbedingt Hashes von Textdateien vergleichen müssen, die auf unterschiedlichen Plattformen erzeugt wurden, und nicht garantieren können, dass ursprünglich der Binärmodus verwendet wurde, können Sie erwägen, die Zeilenenden vor dem Hashen zu normalisieren. Bewährte Praxis ist es jedoch, die Datei stets Byte für Byte im Binärmodus zu hashen.

# Example of normalizing line endings (use with caution)
def normalize_and_hash(file_path)
  content = File.read(file_path, mode: 'rb')
  # Normalize to LF line endings
  normalized = content.gsub(/\r\n?/, "\n")

  digest = OpenSSL::Digest.new('SHA384')
  digest.update(normalized)
  digest.hexdigest
end

Dateiüberprüfung automatisieren

Die Automatisierung der Dateiüberprüfung kann Ihren Workflow straffen, insbesondere bei einer Vielzahl von Dateien, etwa bei der Softwareverteilung oder in Pipelines zur Datenvalidierung. Hier ist ein Skript, das die Überprüfung mehrerer Dateien anhand einer Liste bekannter Hashes automatisiert:

require 'openssl'

# Assume sha384_hash and secure_compare functions are defined as above

files_to_verify = {
  'example.txt' => 'known_good_hash_for_example_txt',
  'another_file.dat' => 'known_good_hash_for_another_file'
  # Add more files and their expected hashes here
}

files_to_verify.each do |file, expected_hash|
  begin
    actual_hash = sha384_hash(file)
    if secure_compare(actual_hash, expected_hash)
      puts "#{file}: Verified ✅"
    else
      puts "#{file}: Verification failed ❌ (Hash mismatch)"
    end
  rescue Errno::ENOENT
    puts "#{file}: Verification failed ❌ (File not found)"
  rescue => e
    puts "#{file}: Error - #{e.message} ❌"
  end
end

Häufige Probleme beheben

Beim Arbeiten mit SHA384-Hashing in Ruby können Ihnen diese häufigen Probleme begegnen:

Inkonsistente Hashes auf verschiedenen Plattformen: Stellen Sie sicher, dass Sie Dateien zum Hashen im Binärmodus ('rb') öffnen. Unterschiede bei den Zeilenenden im Textmodus verändern den Hash.
Speicherprobleme bei großen Dateien: Vergewissern Sie sich, dass Sie wie im Beispiel sha384_hash blockweise lesen (die Datei also Stück für Stück), anstatt die gesamte Datei in den Arbeitsspeicher zu laden.
Fehlerhafte Hash-Vergleiche: Verwenden Sie eine Vergleichsfunktion mit konstanter Laufzeit (secure_compare), um Timing-Seitenkanalangriffe zu verhindern. Ein einfacher Zeichenkettenvergleich (==) kann angreifbar sein.
Probleme mit der Zeichencodierung: Der Binärmodus entschärft zwar die meisten Codierungsprobleme beim Hashen, achten Sie jedoch darauf, wenn Sie Dateiinhalte vor dem Hashen als Zeichenketten bearbeiten. Sorgen Sie für eine einheitliche Zeichencodierung.
Leistungsbedenken: Bei extrem großen Dateien oder Szenarien mit hohem Durchsatz bieten native Erweiterungen oder externe Werkzeuge möglicherweise eine bessere Leistung, auch wenn die OpenSSL-Anbindung von Ruby im Allgemeinen effizient ist.

Bewährte Verfahren für den sicheren Umgang mit Dateien und ihre Überprüfung

Verwenden Sie immer den Binärmodus: Lesen Sie Dateien zum Hashen im Binärmodus (File.open(file_path, 'rb')), um plattformübergreifende Konsistenz zu gewährleisten und Probleme mit Zeilenenden oder Zeichencodierungen zu vermeiden.
Verarbeiten Sie große Dateien blockweise: Lesen Sie große Dateien nicht vollständig in den Arbeitsspeicher ein. Nutzen Sie gepuffertes Lesen (z. B. file.read(chunk_size, buffer)), um den Speicher effizient zu verwalten.
Implementieren Sie eine ordentliche Fehlerbehandlung: Rechnen Sie mit Problemen wie nicht gefundenen Dateien (Errno::ENOENT), Berechtigungsfehlern oder E/A-Fehlern und fangen Sie diese sauber ab.
Speichern Sie Hashes sicher: Bewahren Sie die bekannten, korrekten Hashes getrennt von den Dateien auf, die sie überprüfen. Legen Sie sie in einer sicheren Datenbank, einer Konfigurationsdatei oder einem signierten Manifest ab.
Verwenden Sie Vergleiche mit konstanter Laufzeit: Nutzen Sie beim Überprüfen von Hashes immer eine Zeichenketten-Vergleichsfunktion mit konstanter Laufzeit, um Timing-Angriffe zu verhindern.
Halten Sie Bibliotheken aktuell: Sorgen Sie dafür, dass Ihre Ruby-Installation und deren OpenSSL-Bibliothek auf dem neuesten Stand sind, damit Sie von den aktuellsten Sicherheitspatches profitieren.
Berücksichtigen Sie die Quelle der Wahrheit: Etablieren Sie einen sicheren Prozess zum Erzeugen und Verteilen der anfänglichen „bekannt guten“ Hashes.

SHA384 mit Transloadit verwenden

Das Robot-Ökosystem von Transloadit umfasst den 🤖 /file/hash Robot als Teil unseres Medienkatalogisierungs-Services. Dieser Robot unterstützt verschiedene Hash-Algorithmen, darunter SHA384, sodass Sie Hashes als Teil Ihrer Workflows zur Dateiverarbeitung erzeugen können. Hier ist eine beispielhafte Assembly Instruction:

{
  "steps": {
    "hash": {
      "robot": "/file/hash",
      "use": ":original",
      "algorithm": "sha384"
    }
  }
}

Indem Sie SHA384-Hashing in Ihre Ruby-Anwendungen integrieren, fügen Sie eine starke Sicherheitsebene hinzu und stellen sicher, dass Ihre Dateien während ihres gesamten Lebenszyklus unversehrt und manipulationssicher bleiben.