Dokumentation

Allgemein Javadoc/APIDOC Artikel Beispiele Android

Allgemein

Überprüfen Sie Ihre Lizenz

Das SDK enthält ein einfaches Batch-/Shell-Skript print_version, das Ihnen mitteilt, ob Ihre Bibliotheksdatei lizenziert oder eine Testversion ist.

Javadoc/APIDOC

Sie können die API-Dokumentation hier durchsuchen: CrococryptLib Online APIDOC (Englisch).

Sie können die API-Dokumentation mit dem SDK für das Offline-Durchsuchen herunterladen.

Artikel

Wir haben begonnen, Anleitungen zu spezifischen Themen zu schreiben und werden dies weiterhin tun - um mehr Menschen zu ermöglichen, kryptobezogenen Code für Anwendungen zu schreiben:

Beispiele

Die folgenden Beispiele aus dem SDK enthalten Demos und typische Anwendungsfälle, die auch als Muster für eigene Anwendungen verwendet werden können.

Beispieldatei	Beschreibung
SimplePBEEncryptionExample.java	Einfachste Möglichkeit, eine Nachricht oder einen Binärcode sicher mit einem Passwort zu verschlüsseln
CompactEncryptionExamples.java	Symmetrische Verschlüsselung mit einem Rohschlüssel, automatische Generierung und Speicherung aller Verschlüsselungsparameter
PasswordBasedKeyExample.java	Speichern der Parameter eines Schlüssels, der sicher aus einem Passwort abgeleitet wurde
SimplePasswordHashExample.java	Wenn Sie keine Verschlüsselung benötigen, zeigt dieses Beispiel, wie Sie stattdessen einfach einen sicheren Passwort-Hash in Ihrer Anwendung speichern können
SimplePBEFileEncryptionExample.java	Dieses Beispiel demonstriert ein sehr einfaches, aber sicheres passwortbasiertes Datei-Verschlüsselungstool unter Verwendung des effizienten kompakten Stream-Formats
SimplePBEFileEncryptionExampleShort.java	Dasselbe Beispiel, aber ohne Kommentare
PBEFileEncryption_CustomSettings.java	Alle Standard-Krypto-Einstellungen können geändert werden - aus Leistungs- oder Geschmacksgründen
PasswordHash_WithCustomSettings.java	Sicheres Hashing mit benutzerdefinierten Einstellungen
PasswordKeyWrapping_PlusPasswordChange.java	Ein vollständiges Beispiel für die Schlüsselverschlüsselung. Das bedeutet, jeder Benutzer erhält einen Verschlüsselungsschlüssel, der sicher mit einem Schlüsselverschlüsselungsschlüssel umwickelt wird, der auf dem Passwort des Benutzers basiert.
AndroidSetupExample.java	Beispiel einer `Activity` einer Android-App

Einfache Beispiele

Es sind keine weiteren Kryptokenntnisse erforderlich, um diese Muster in Ihrer Software zu verwenden.

SimplePBEEncryptionExample

Verwendet die folgenden Standardwerte: PBKDF2-Schlüsselableitung mit einem SHA512-HMAC, 100000 Iterationen, 512 Bit Salz und AES-256 im CBC-Modus.

public class SimplePBEEncryptionExample {
    public static void main(String[] args) throws Exception{
        String password = "Demo Passwort!";
        String textToencrypt = "Geheimer Text, der verschlüsselt werden soll, könnte auch beliebige Binärdaten sein";
        CompactPasswordKey key = CompactPasswordKey.generateKey(new Secret(password));
        String encryptedMessage = new CompactEncryption(key).encryptToBase64(new StringData(textToencrypt));
        System.out.println("\nVerschlüsselte Nachricht: " + encryptedMessage);
        System.out.println("\nEntschlüsselte Nachricht: " + new CompactEncryption(key).decryptFromBase64(encryptedMessage));
    }
}

Erzeugt diese Ausgabe:

Verschlüsselte Nachricht: AAAAAAIAAAAQ1SHBVLPfXMbOOV7rvSnrcgAAAGBwEOiB9h3H-KtVW1-1XPFi7H2dm61_0-DWaiCUafgzFuUaelB46X1pmijNCWd92BkqLlJ0F2NLbzFFGYvJGJgVztFf49WnAJ_J8B0OXLWgYuLkPdygH57CAHTnhSN9pP8

Decrypted message: Geheimer Text, der verschlüsselt werden soll, könnte auch beliebige Binärdaten sein

Sie werden nicht in der Lage sein, die gleiche Ausgabe zu reproduzieren, da: a) jeder neue CompactPasswordKey ein neues Salt haben wird und b) jeder Aufruf einer der CompactEncryption.encrypt*-Methoden automatisch einen neuen IV erstellt.

CompactEncryptionExamples

public class CompactEncryptionExamples {
    public static void main(String[] args) {
        //Sicheres Generieren eines rohen symmetrischen Schlüssels (z.B. für AES-256)
        EncryptionKey key = EncryptionKey.generateNewKey();
        
        System.out.println("Standard-Schlüssellänge:     " + key.getKeyInBytes().length);
        System.out.println("Base64-codiertes Format: " + key.writeToBase64());
        System.out.println("Standardverschlüsselung:    " + new CompactEncryption(key).getAlgorithm());
        System.out.println();

        String message = "Klartextnachricht. Könnte auch binär sein.";
        
        //Die Verschlüsselung beinhaltet alle notwendigen Parameter,
        //einschließlich eines sicher generierten IV für den CBC-Blockchiffriermodus
        String encryptedMessage = new CompactEncryption(key).encryptToBase64(new StringData(message));
        System.out.println("Verschlüsselte Nachricht:     " + encryptedMessage);
        System.out.println("Entschlüsselte Nachricht:     " + ((StringData)new CompactEncryption(key)
                            .decryptFromBase64(encryptedMessage)).getDataString());
        System.out.println();
        
        //Jeder symmetrische Blockchiffre, der im JCE verfügbar ist, kann verwendet werden
        String encryptedMessage2 = new CompactEncryption(key, "Blowfish").encryptToBase64(new StringData(message));
        System.out.println("Verschlüsselte Nachricht:     " + encryptedMessage2);
        System.out.println("Entschlüsselte Nachricht:     " + ((StringData)new CompactEncryption(key)
                            .decryptFromBase64(encryptedMessage2)).getDataString());

    }
}

PasswordBasedKeyExample

public class PasswordBasedKeyExample {
    public static void main(String[] args) {
        //Ein Passwort über die Befehlszeile bereitstellen oder stattdessen das Demo-Passwort verwenden
        if(args == null || args.length == 0 || args[0] == null)
            args = new String[]{"Demo-Passwort!"};
        
        //Erstellen einer PBKDF2-basierten Schlüsselableitung
        CompactPasswordKey key = CompactPasswordKey.generateKey(new Secret(args[0]));
        
        //Speichern Sie das kompakte Schlüsselableitungsformat in verschiedenen Ausgabeformaten. Dies umfasst alle
        //notwendigen Parameter (Algorithmus, Salz, Iterationsanzahl) plus eine Verschlüsselungsprüfsumme, die
        //uns sagt, ob das Passwort korrekt ist
        System.out.println("Hash (Hex): " + key.writeToHex());
        System.out.println("Hash (B64): " + key.writeToBase64());
        
        byte[] binaryObject = key.writeToBytes();
        
        //Nehmen wir an, 'binaryObject' wurde in eine Datenbank geschrieben und wird neu geladen.
        CompactPasswordKey theKey = CompactPasswordKey.newInstance(new Secret(args[0]));
        theKey.readFromBytes(binaryObject);
        
        //Führen Sie eine Validierungsprüfung des neu bereitgestellten Passworts durch
        System.out.println(theKey.isPasswordValid());
        
        //Führen Sie eine Validierungsprüfung durch, die fehlschlagen muss
        theKey = CompactPasswordKey.newInstance(new Secret("falsches Passwort"));
        theKey.readFromBytes(binaryObject);
        System.out.println(theKey.isPasswordValid());
    }
}

SimplePasswordHashExample

public class SimplePasswordHashExample {
    public static void main(String[] args) {
        //Geben Sie ein Passwort über die Befehlszeile ein oder verwenden Sie stattdessen das Demo-Passwort
        if(args == null || args.length == 0 || args[0] == null)
            args = new String[]{"Demo Passwort!"};
        
        //Erstellen eines sicheren Passwort-Hashes auf PBKDF2-Basis mit Standardeinstellungen
        CompactPasswordHash cph = CompactPasswordHash.generateHash(new Secret(args[0]));
        
        //Speichern Sie das kompakte Hash-Format in verschiedenen Ausgabeformaten. Dies umfasst den vollständigen Hash einschließlich
        //aller notwendigen Parameter (Algorithmus, Salz, Iterationsanzahl).
        System.out.println("Hash (Hex): " + cph.writeToHex());
        System.out.println("Hash (B64): " + cph.writeToBase64());
        
        byte[] raw = cph.writeToBytes();
        
        //Nehmen wir an, 'raw' wurde in eine Datenbank geschrieben und wird neu geladen.
        CompactPasswordHash cph_loaded = CompactPasswordHash.newInstance();
        cph_loaded.readFromBytes(raw);
        
        //Führen Sie eine Validierungsprüfung des neu bereitgestellten Passworts gegen den gespeicherten Hash durch
        System.out.println(cph_loaded.verifyPassword(new Secret(args[0])));

        //Führen Sie eine Validierungsprüfung durch, die fehlschlagen muss
        System.out.println(cph_loaded.verifyPassword(new Secret("wrongPassword")));
    }
}

Einfaches Beispiel für Datei-Verschlüsselung mit PBE

public class SimplePBEFileEncryptionExample {

public static void main(String[] args) throws Exception{
String password = "Demo Passwort!";

//Erstellen einer PBKDF2-basierten Schlüsselableitung
//STANDARDWERTE:
//+ HmacSHA512
//+ 100000 Iterationen
//+ AES-256
//+ 256bit Schlüssellänge
//+ 512bit Salz
CompactPasswordKey key = CompactPasswordKey.generateKey(new Secret(password));

//Erstellen einer temporären Datei zur Demonstration mit etwas Inhalt, Initialisierung der Streams
File inputFile = createDemoFile();
File outputFile = File.createTempFile("crococryptlibdemo-ENCRYPTEDFILE-", ".data");
FileInputStream fis = new FileInputStream(inputFile);
FileOutputStream fos = new FileOutputStream(outputFile);

//Schreiben der PBE/PBKDF2-Parameter in die Datei
key.writeToStream(fos);

//VERSCHLÜSSELUNG
//STANDARDWERTE:
//+ AES-256
//+ 256bit Schlüssellänge
//+ CBC-Modus
//+ 16byte Initialisierungsvektor (IV)

//HINWEIS: Diese Klasse kann jeden Stream nutzen, ein Dateistream ist nur ein Beispiel!
CompactBinarystreamEncryption cbe = new CompactBinarystreamEncryption(key);
cbe.encrypt(fis, fos);
fis.close();
fos.close();

//---VERSCHLÜSSELUNG ABGESCHLOSSEN---

System.out.println("Geschrieben von " + inputFile + " zu " + outputFile);

//ENTSCHLÜSSELUNG
File tmp = outputFile;
outputFile = File.createTempFile("crococryptlibdemo-DECRYPTEDFILE-", ".txt");
inputFile = tmp;
fis = new FileInputStream(inputFile);
fos = new FileOutputStream(outputFile);

//Lesen der PBE/PBKDF2 aus dem Stream
key = CompactPasswordKey.newInstance(new Secret(password));
key.readFromStream(fis);

//Tatsächliche Entschlüsselung
cbe = new CompactBinarystreamEncryption(key);
cbe.decrypt(fis, fos);
fis.close();
fos.close();

        System.out.println("Geschrieben von " + inputFile + " zu " + outputFile);

        //---DECRYPTION DONE---
}

    private static final File createDemoFile() throws Exception{
        File tmp = File.createTempFile("crococryptlibdemo-ORIGINALFILE-", ".txt");
        FileOutputStream fos = new FileOutputStream(tmp);
        fos.write("Kleine Demodatei".getBytes());
        fos.flush();
        fos.close();
        return tmp;
    }

}

SimplePBEFileEncryptionExampleShort

public class SimplePBEFileEncryptionExampleShort {

public static void main(String[] args) throws Exception{
    String password = "Demo Passwort!";
    FileInputStream fis = new FileInputStream(createDemoFile());
    File outputFile = File.createTempFile("crococryptlibdemo-ENCRYPTEDFILE-", ".data");
    FileOutputStream fos = new FileOutputStream(outputFile);
    CompactPasswordKey key = CompactPasswordKey.generateKey(new Secret(password));
    key.writeToStream(fos);
    new CompactBinarystreamEncryption(key).encrypt(fis, fos);
    fis.close();
    fos.close();
    System.out.println("Verschlüsselung erfolgreich abgeschlossen: " + outputFile.getAbsolutePath());

    fis = new FileInputStream(outputFile);
    fos = new FileOutputStream(File.createTempFile("crococryptlibdemo-DECRYPTEDFILE-", ".txt"));
    key = CompactPasswordKey.newInstance(new Secret(password));
    key.readFromStream(fis);
    new CompactBinarystreamEncryption(key).decrypt(fis, fos);
    fis.close();
    fos.close();
    System.out.println("Entschlüsselung erfolgreich abgeschlossen: " + outputFile.getParent());
}

private static final File createDemoFile() throws Exception{
    File tmp = File.createTempFile("crococryptlibdemo-ORIGINALFILE-", ".txt");
    FileOutputStream fos = new FileOutputStream(tmp);
    fos.write("Kleine Demodatei".getBytes());
    fos.flush();
    fos.close();
    return tmp;
}

}

Komplexe Beispiele

Sie können alle Kryptoparameter ändern. Sie sollten jedoch wissen, was Sie tun, wenn Sie diesen Weg gehen, da schwache Algorithmen oder Betriebsparameter die Sicherheit der Daten Ihrer Anwendung schwächen können.

PBEFileEncryption_CustomSettings

public class PBEFileEncryption_CustomSettings {

public static void main(String[] args) throws Exception{
    String password = "Demo-Passwort!";
    
    //Erstellen einer PBKDF2-basierten Schlüsselableitung
    
    //Jeder einzelne Parameter kann geändert oder auf Standard belassen werden
    GenerationParametersCPK parameters = CompactPasswordKey.createParameters();
    parameters.hmacAlgorithm = "HmacWhirlpool";
    parameters.iterationCount = 10000;
    parameters.keyLengthInBytes = 24;
    parameters.saltLengthInBytes = 20;
    parameters.checksumEncryptionAlgorithm = "Twofish";
    CompactPasswordKey key = CompactPasswordKey.generateKey(new Secret(password), parameters);
    
    //Erstellen einer temporären Datei zur Demonstration mit etwas Inhalt, Initialisierung der Streams
    File inputFile = createDemoFile();
    File outputFile = File.createTempFile("crococryptlibdemo-ENCRYPTEDFILE-", ".data");
    FileInputStream fis = new FileInputStream(inputFile);
    FileOutputStream fos = new FileOutputStream(outputFile);

    //Schreiben der PBE/PBKDF2-Parameter in die Datei
    key.writeToStream(fos);
    
    //VERSCHLÜSSELUNG
    
    //Verwendung des CBC-Modus (Standard) mit Twofish anstelle von AES. Schlüssellänge wird 192bit sein (siehe oben)
    CompactBinarystreamEncryption cbe = new CompactBinarystreamEncryption(key, "Twofish");
    cbe.encrypt(fis, fos);
    fis.close();
    fos.close();
    
    System.out.println("Geschrieben von " + inputFile + " nach " + outputFile);
    
    //ENTSCHLÜSSELUNG
    File tmp = outputFile;
    outputFile = File.createTempFile("crococryptlibdemo-DECRYPTEDFILE-", ".txt");
    inputFile = tmp;
    fis = new FileInputStream(inputFile);
    fos = new FileOutputStream(outputFile);
    
    //Lesen der PBE/PBKDF2 aus dem Stream
    key = CompactPasswordKey.newInstance(new Secret(password));
    key.readFromStream(fis);
    
    //Tatsächliche Entschlüsselung
    cbe = new CompactBinarystreamEncryption(key);
    cbe.decrypt(fis, fos);
    fis.close();
    fos.close();
    
    System.out.println("Geschrieben von " + inputFile + " nach " + outputFile);
}

    private static final File createDemoFile() throws Exception{
        File tmp = File.createTempFile("crococryptlibdemo-ORIGINALFILE-", ".txt");
        FileOutputStream fos = new FileOutputStream(tmp);
        fos.write("Kleine Demodatei".getBytes());
        fos.flush();
        fos.close();
        return tmp;
    }
    
}

PasswordHash_MitBenutzerdefiniertenEinstellungen

public class PasswordHash_MitBenutzerdefiniertenEinstellungen {
    public static void main(String[] args) {
        //Geben Sie ein Passwort über die Befehlszeile ein oder verwenden Sie stattdessen das Demo-Passwort
        if(args == null || args.length == 0 || args[0] == null)
            args = new String[]{"Demo Passwort!"};
        
        //Erstellen eines PBKDF2-basierten sicheren Passwort-Hashes mit benutzerdefinierten Einstellungen
        GenerationParametersCPH parameters = CompactPasswordHash.createParameters();
        parameters.hmacAlgorithm = "HmacWhirlpool";
        parameters.hashLengthInBytes = 16;
        parameters.iterationCount = 5000;
        
        CompactPasswordHash compactHash = CompactPasswordHash.generateHash(new Secret(args[0]), parameters);
        
        //Speichern des kompakten Hash-Formats in verschiedenen Ausgabeformaten. Dies umfasst den vollständigen Hash einschließlich
        //aller notwendigen Parameter (Algorithmus, Salt, Iterationsanzahl).
        System.out.println("\nHash (Hex): " + compactHash.writeToHex());
        System.out.println("\nHash (B64): " + compactHash.writeToBase64());
        
        byte[] raw = compactHash.writeToBytes();
        
        //Nehmen wir an, 'raw' wurde in eine Datenbank geschrieben und wird neu geladen.
        CompactPasswordHash theHash = CompactPasswordHash.newInstance();
        theHash.readFromBytes(raw);
        
        //Führen Sie eine Validierungsprüfung des neu bereitgestellten Passworts gegen den gespeicherten Hash durch
        System.out.println(theHash.verifyPassword(new Secret(args[0])));
        
        //Führen Sie eine Validierungsprüfung durch, die fehlschlagen muss
        System.out.println(theHash.verifyPassword(new Secret("falschesPasswort")));
    }
}

PasswordKeyWrapping_PlusPasswortÄnderung

public class PasswordKeyWrapping_PlusPasswortÄnderung {
    public static void main(String[] args) {
        String password = "passwort";
        Secret secret = new Secret(password);

        //---VERSCHLÜSSELUNG UND SCHLÜSSELUMHÜLLUNG---
        
        //Sicheres Generieren eines neuen Standard-256-Bit-Schlüssels, z.B. für AES
        EncryptionKey encKey = EncryptionKey.generateNewKey();
        //Erstellen eines passwortbasierten Schlüssels, z.B. für einen Anwendungsbenutzer
CompactPasswordKey pwKey = CompactPasswordKey.generateKey(secret);
        WrapUtil wrapper = new WrapUtil(pwKey);
        
        byte[] pwKey_atStorage = pwKey.writeToBytes();
        byte[] wrappedEncKey_atStorage = wrapper.wrapToBytes(encKey);
        
        String message = "Eine Textnachricht, Datei, Binärdatei oder Stream";
        String encryptedMessage = new CompactEncryption(encKey).encryptToBase64(new StringData(message));
        
        //---ENTSCHLÜSSELUNG---
        
        //Laden des Schlüsselmaterals
        pwKey = CompactPasswordKey.newInstance(secret).readFromBytes(pwKey_atStorage);
        wrapper = new WrapUtil(pwKey);
        encKey = wrapper.unwrapFromBytes(wrappedEncKey_atStorage);
        
        //Durchführen der Entschlüsselung
        System.out.println("Entschlüsselte Nachricht:                " +
                            new CompactEncryption(encKey).decryptFromBase64(encryptedMessage));
        
        //---NEUVERPACKEN EINES SCHLÜSSELS FÜR EINEN PASSWORTWECHSEL (altes und neues Passwort erforderlich)---
        
        String newPassword = "neues Passwort";
        CompactPasswordKey newPwKey = CompactPasswordKey.generateKey(new Secret(newPassword));
        //Hinweis: Der eigentliche Verschlüsselungsschlüssel bleibt derselbe, obwohl das Passwort geändert wurde.
        //         Daher können alle verschlüsselten Daten weiterhin entschlüsselt werden! Deshalb gibt es den eigentlichen
        //         Verschlüsselungsschlüssel und einen Schlüsselverschlüsselungsschlüssel (in diesem Fall passwortbasiert).
        wrappedEncKey_atStorage = wrapper.rewrapFromBytes(wrappedEncKey_atStorage, newPwKey);
        pwKey_atStorage = newPwKey.writeToBytes();
        
        //---WIEDERHOLEN DER ENTSCHLÜSSELUNG MIT DEM NEUVERPACKTEN SCHLÜSSEL NUR ZUR DEMONSTRATION---
        encKey = new WrapUtil(newPwKey).unwrapFromBytes(wrappedEncKey_atStorage);
        System.out.println("Entschlüsselte Nachricht (neues Passwort): " +
                            new CompactEncryption(encKey).decryptFromBase64(encryptedMessage));
    }
}

Android

Beispiele

AndroidSetupExample

Dies ist eines der einfachen Beispiele oben, das auch die grundlegenden Setup-Informationen für eine Android-Aktivität enthält:

public class AndroidSetupExample extends Activity {

    static{
        //Grundlegendes Setup: Kopieren Sie die croco.jar in den 'lib'-Ordner Ihres Android-Projekts,
        //die bcprov.jar ist NICHT(!) erforderlich. 
        
        //Dieser Schritt ist ERFORDERLICH, um den Android-Modus zu aktivieren
        CryptoMain.setAndroidMode();

        //Der folgende Code gilt NICHT(!) für die voraktivierte Testversion noch die lizenzierte Bibliothek!
        //Wenn Sie die Online-Testversion verwenden,
        //müssen Sie die folgenden Berechtigungen zu Ihrer AndroidManifest.xml hinzufügen:
        //<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
        //<uses-permission android:name="android.permission.INTERNET" />
        //Die folgenden Zeilen sind nur für die Online-Aktivierung erforderlich:
        /*
        StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
        StrictMode.setThreadPolicy(policy);
        */ 
    }

    /**
     * Dies ist eine Demo, die innerhalb einer Android-Aktivität verwendet werden kann.
     * Es erfordert ein einfaches TextView mit der View-ID 'text' für die Ausgabe
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        TextView tv = (TextView) findViewById(R.id.text);
        
        String password = "Demo-Passwort!";
        String textToencrypt = "Geheimer Text, der verschlüsselt werden soll, könnte auch beliebige Binärdaten sein";
        CompactPasswordKey key = CompactPasswordKey.generateKey(new Secret(password));
        String encryptedMessage = new CompactEncryption(key).encryptToBase64(new StringData(textToencrypt));
        
        String tmp = ("\nVerschlüsselte Nachricht:\n" + encryptedMessage);
        tmp += ("\n\nEntschlüsselte Nachricht:\n" + new CompactEncryption(key).decryptFromBase64(encryptedMessage));
        
        tv.setText(tmp);
    }
}

crococryptlib

zurück zu Produkte