ABAP Cloud - Hashes
Du möchtest einen Hash in ABAP Cloud erstellen? Welche Klassen gibt es eigentlich dafür und wie kannst du sie sinnvoll nutzen?
Inhaltsverzeichnis
In diesem Artikel schauen wir uns zwei Klassen zur Erstellung von Hashes an und wie wir diese in unserer Entwicklung einfacher einsetzen können.
Einleitung
Hashes werden in der Informatik eingesetzt, um zum Beispiel zu prüfen, ob sich ein Text, eine Datei oder andere Inhalte verändert haben. So kannst du aus einer Zeichenkette einen eindeutigen Hash errechnen der Eindeutig ist. Ändert sich ein Zeichen in der Kette, dann erhältst du einen komplett anderen Hash. Damit können Manipulationen von Inhalten verhindert werden. Oft wird dieses Verfahren auch verwendet, um Passwörter sicher abzulegen, da du aus einem Hash nicht mehr den originalen Wert ableiten kannst, aber zwei Inhalte immer noch vergleichen kannst, ob diese gleich sind.
Bibliotheken
In ABAP Cloud gibt es dafür verschiedene freigegebene Klassen, die du verwenden kannst, um einen Hash zu ermitteln. In diesem Kapitel schauen wir uns einmal drei Varianten an.
CL_ABAP_MESSAGE_DIGEST
Die erste freigegebene Klasse, die wir verwenden ist für die Konvertierung von Strings und XStrings zu Hash. Dabei werden verschiedene Ausgabeformate zur Verfügung gestellt. Über den Algorithmus führen wir dann eine Konvertierung durch.
TRY.
cl_abap_message_digest=>calculate_hash_for_char( EXPORTING if_algorithm = 'SHA256'
if_data = value
IMPORTING ef_hashstring = result
ef_hashxstring = DATA(hashxstring)
ef_hashb64string = DATA(hashb64string) ).
CATCH cx_abap_message_digest.
ENDTRY.
Neben den Konvertierungsmethoden sind auch verschiedene Hilfsmethoden in der Klasse vorhanden, wie String nach XString, die Erzeugung von Digest über eine Instanz. Die Klasse verwendet dabei zusätzlich eine Factory Methode und du kannst teilweise mit Instanzmethoden arbeiten.
CL_ABAP_HMAC
Die zweite Klasse ist sehr ähnlich zur ersten Klasse aufgebaut. Die Hauptmethoden haben kleine Namensunterschiede, die Hilfsmethoden sind hier aber ebenso vorhanden. Der Unterschied ist allerdings, dass wir neben dem reinen Hash, auch einen HMAC erzeugen können. Dazu verwenden wir einen Schlüssel, um den String zu verschlüsseln. Die Gegenseite hat den gleichen Schlüssel und kann damit überprüfen, ob der String manipuliert wurde. Wird oft bei der Übertragung von Nachrichten verwendet.
TRY.
DATA(converted_key) = cl_abap_hmac=>string_to_xstring( key ).
cl_abap_hmac=>calculate_hmac_for_char( EXPORTING if_algorithm = 'SHA256'
if_data = value
if_key = converted_key
IMPORTING ef_hmacstring = result
ef_hmacxstring = DATA(hmacxstring)
ef_hmacb64string = DATA(hmacb64string) ).
CATCH cx_abap_message_digest.
ENDTRY.
XCO_CP_STRING
Im Bereich XCO gibt es ebenfalls die Möglichkeit einen Hash über verschiedene Algorithmen zu erzeugen. Dabei gehen wir über ein String Objekt, konvertieren es zuerst nach XString und verwenden dabei ein Format aus der Klasse XCO_CP_HASH. Leider gibt es hier nur für SHA1 ein Objekt, für die anderen Algorithmen, müssen wir wieder auf eine magische Konstante zurückgreifen.
xco_cp=>string( value )->as_xstring( xco_cp_hash=>algorithm->for( 'SHA256' ) )->value.
Vergleich
Führen wir einmal die verschiedenen Methoden zur Überprüfung mit den gleichen Strings aus. Dabei erzeugen wir erst einen Hash, dann ein HMAC ohne Passwort, mit Passwort und verwenden zum Abschluss die XCO Klasse.
Alle errechneten SHA256 sind so weit gleich, bis auf den, wo wir einen eigenen Schlüssel verwendet haben. Damit können wir auch über die Klasse CL_ABAP_HMAC normal Hashes erzeugen, wenn wir den Schlüssel einfach leer lassen.
Algorithmen
Was ist eigentlich der Unterschied zwischen den verschiedenen Algorithmen? Aktuell unterstützten die Klassen verschiedene Berechnungsalgorithmen, wie MD5, SHA1, SHA256, SHA384 und SH512. Früher wurde oft MD5 verwendet und teilweise auch noch heute, ist aber aus Security Aspekten veraltet und nicht mehr als sicher zu betrachten. Mit der Länge an Zeichen kann nicht mehr ein eindeutiger Hash sichergestellt werden. Zwei unterschiedliche Strings können den gleichen Hash ergeben, was für verschiedene Attacken genutzt werden kann. Das Gleiche gilt mittlerweile auch für SHA1. Daher sollte einer der anderen Algorithmen verwendet werden, um Hashes zu erstellen.
Was ist der Unterschied zwischen SHA256, SHA384 und SH512? Die Verfahren nutzen unterschiedliche Längen und die Verschlüsslung ist rechenintensiver, weil mehr Runden durch den Algorithmus durchgeführt werden und das mit der entsprechenden Länge.
| MD5 | SHA-1 | SHA-256 | SHA-384 | SHA-512 | |
|---|---|---|---|---|---|
| Hash-Länge | 128 Bit | 160 Bit | 256 Bit | 384 Bit | 512 Bit |
| Zeichenlänge | 16 | 20 | 32 | 48 | 64 |
| Sicherheit | Sehr Niedrig | Niedrig | Hoch | Sehr Hoch | Extrem Hoch |
| Blockgröße | 512 Bit | 512 Bit | 512 Bit | 1024 Bit | 1024 Bit |
| Runden | 64 | 80 | 64 | 80 | 80 |
Open Source
Im Moment haben die beiden Klassen einige kleine Designschwächen, die wir aber mit einer neuen Fassade korrigieren können. Aktuell fehlende und/oder unklare Punkte wären:
- Magic Constants - Die verwendeten und unterstützten Hash Algorithmen sind nicht klar und definiert. Es gibt keinen Hinweis auf zu vermeidende Algorithmen (MD5, SHA1).
- Instanziierung - Die Methode GET_INSTANCE nimmt den Algorithmus entgegen, dieser wird aber nur bei einem Teil der Methoden verwendet, andere müssen manuell befüllt werden.
- Methoden - Es werden zahlreiche Import und Export Parameter verwendet. Ebenso ist ein Fehlerhandling nötig, was den Code stark aufbläht.
- Testbarkeit - Die Testbarkeit mit den Klassen ist nicht ohne zusätzlichen Aufwand möglich.
Fassade
Die Fassade ist ein Pattern in der Entwicklung, die bestehende Funktionalitäten nimmt, bündelt und über eine einheitliche Schnittstelle nach außen bringt. Damit können wir den bestehenden Code nehmen und noch einmal verbessert zur Verfügung stellen.
Konstanten
Für die unterstützten Algorithmen legen wir ein ENUM an. Dieses nimmt uns eine Prüfung der unterstützen Formate ab und gibt zur Laufzeit eine Fehlermeldung, wenn keine korrekten Werte übergeben werden. In diesem Fall haben wir auch die Möglichkeit MD5 und SHA1 rauszunehmen, da sie schon lange nicht mehr als sicher und kollisionsfrei gelten.
TYPES: BEGIN OF ENUM algorithms STRUCTURE algorithm,
sha256,
sha384,
sha512,
END OF ENUM algorithms STRUCTURE algorithm.
Testbarkeit
Um die Testbarkeit herzustellen, erzeugen wir eine Factory und einen Injector. Die Factory erlaubt uns unter anderem auch verschiedene Instanzen des Interfaces zu definieren. In diesem Fall können wir den Algorithmus und einen Schlüssel übergeben. Ist der Schlüssel leer, dann erzeugen wir nur Hashes, ansonsten verwenden wir die HMAC Klasse intern.
Design
Um nicht in beiden Implementierungen die gleichen Funktionen auszuprägen, verwenden wir eine abstrakte Klasse. Somit können wir einen Teil der Funktionen, wie den Algorithmus oder die String Konvertierung in der abstrakten Klasse abbilden und später einfach verwenden.
Verwendung
Für die Verwendung erzeugen wir über die Factory eine neue Instanz und wählen einen Algorithmus. Als Standard wird SHA512 verwendet, falls keine Angabe gemacht wird. Den Schlüssel können wir als String oder XString übergeben. Intern wird grundsätzlich der XString verwendet und es erfolgt direkt eine Konvertierung.
DATA(hash) = zcl_hash_factory=>create_hash( algorithm = zif_hash=>algorithm-sha256
key_plain = key ).
Über die Methode GET_HASH_FOR_STRING lassen wir uns dann einen Hash erzeugen und erhalten verschiedene Typen zurück. Hier verwenden wir das Feld HASHSTRING als Ergebnis und geben es an den Aufrufer zurück oder verwenden es direkt.
hash->get_hash_for_string( value )-hashstring.
Vollständiges Beispiel
Hier findest du das Beispiel von oben, um es bei dir im System nachzustellen. Das Open Source Projekt findest du ganz normal bei uns in GitHub, wenn du weitere Inspiration benötigst oder die Klassen ebenfalls verwenden willst.
CLASS zcl_bs_demo_hash DEFINITION
PUBLIC FINAL
CREATE PUBLIC.
PUBLIC SECTION.
INTERFACES if_oo_adt_classrun.
PRIVATE SECTION.
METHODS create_hash
IMPORTING !value TYPE string
RETURNING VALUE(result) TYPE string.
METHODS create_hmac
IMPORTING !value TYPE string
!key TYPE string
RETURNING VALUE(result) TYPE string.
METHODS create_xco
IMPORTING !value TYPE string
RETURNING VALUE(result) TYPE string.
METHODS create_open_source
IMPORTING !value TYPE string
!key TYPE string
RETURNING VALUE(result) TYPE string.
ENDCLASS.
CLASS zcl_bs_demo_hash IMPLEMENTATION.
METHOD if_oo_adt_classrun~main.
DATA(hash) = create_hash( '123456' ).
out->write( hash ).
DATA(hmac_without) = create_hmac( value = '123456'
key = `` ).
out->write( hmac_without ).
DATA(hmac_with) = create_hmac( value = '123456'
key = `ABC` ).
out->write( hmac_with ).
DATA(xco_hash) = create_xco( '123456' ).
out->write( xco_hash ).
ENDMETHOD.
METHOD create_hash.
TRY.
cl_abap_message_digest=>calculate_hash_for_char( EXPORTING if_algorithm = 'SHA256'
if_data = value
IMPORTING ef_hashstring = result
ef_hashxstring = DATA(hashxstring)
ef_hashb64string = DATA(hashb64string) ).
CATCH cx_abap_message_digest.
CLEAR result.
ENDTRY.
ENDMETHOD.
METHOD create_hmac.
TRY.
DATA(converted_key) = cl_abap_hmac=>string_to_xstring( key ).
cl_abap_hmac=>calculate_hmac_for_char( EXPORTING if_algorithm = 'SHA256'
if_data = value
if_key = converted_key
IMPORTING ef_hmacstring = result
ef_hmacxstring = DATA(hmacxstring)
ef_hmacb64string = DATA(hmacb64string) ).
CATCH cx_abap_message_digest.
CLEAR result.
ENDTRY.
ENDMETHOD.
METHOD create_xco.
RETURN xco_cp=>string( value )->as_xstring( xco_cp_hash=>algorithm->for( 'SHA256' ) )->value.
ENDMETHOD.
METHOD create_open_source.
DATA(hash) = zcl_hash_factory=>create_hash( algorithm = zif_hash=>algorithm-sha256
key_plain = key ).
RETURN hash->get_hash_for_string( value )-hashstring.
ENDMETHOD.
ENDCLASS.
Fazit
Die Erzeugung von Hashes ist für die Kontrolle und Sicherstellung von Manipulationen entscheidend. Möchtest du Informationen sicher ablegen, um diese später vergleichen zu können, dann kannst du ebenfalls Hashes verwenden. Möchtest du die Informationen später wieder in einem lesbaren Format haben, ist dies allerdings der falsche Weg zur sicheren Ablage.
