# String signieren und verifizieren



## uz (7. Aug 2006)

Hallo,

ich haette einige Fragen bezueglich Java und Signaturen. 
Was muss ich am einfachsten benutzen bzw tun, wenn ich ein pub/priv-Schluesselpaar generieren moechte, diese Schluessel in Dateien speichern moechte und dann einfache Texte (strings) signieren bzw verifizieren moechte. 
Hat hierfuer vielleicht jemand ein Beispiel? Oder gibt es irgendwo ein brauchbares Tutorial? Ich konnte leider bisher nichts brauchbares finden.

Des Weiteren: Sind die erzeugten Schluessel standardisiert? Koennen die dann ohne weiteres von anderen Anwendungen in anderen Programmiersprachen verwendet werden?

Vielen Dank.
ciao
uz


----------



## Anmeldeboykottierer (7. Aug 2006)

Hi,
Schlüssel als Strings sind nicht standardisiert, dazu unterscheiden sich Strings zu stark. So sind das in Java Klassen, die mit 2 Byte pro Zeichen codiert werden (Unicode), Delphi würde dazu z.B. WideString sagen, ein normaler Delphi String besteht aus 8 Bit Zeichen. 
C kennt (soweit ich weiß) nicht einmal direkt Strings. Hier hast du eher ein PChar (ein Zeiger auf ein Character Array). 
Da die verfahren für's signieren und verifizieren aber bekannt sind, solltest du ohne Probleme auch Plattform/Programmiersprachen übergreifend arbeiten können. Dazu solltest du die Schlüssel dann nicht als String sondern als Byte-Array auffassen. Das Byte ist auf den gängigen Architekturen die kleinste direkt addressierbare Einheit. Ein Byte lässt sich zu dem in jeder Sprache (irgendwie) auslesen.
Das signieren eine Nachricht besteht dann einfach darin, dass jmd. mit seinem privaten Schlüssel die Nachricht verschlüsselt. Hier kann die Nachricht dann nur mit dem dazu gehörigen öffentlichen Schlüssel entschlüsselt werden.
Ok, genaugenommen ist nicht garantiert, dass es nur eine Möglichkeit gibt, aber die Wahrscheinlichkeit zufällig eine zweite passende zu finden ist nun ja, gering.
was du also eigentlich machst ist eine asynchrone Verschlüsselung anwenden (nur diesmal umgekehrt). Welche Verschlüsselung du verwendest bleibt dir überlassen (schau einfach nach asynchroner Verschlüsselung). 
Ob ein anderes System die Nachricht entschlüsseln kann hängt dann nur vom System ab. Ist hier ein entsprechender Algorithmus implementiert, gibt es keine Gründe warum dies nicht klappen sollte

Gruß Der Anmeldeboykottierer


----------



## Gast (7. Aug 2006)

Oh, gerade noch gesehen, dass du ja fragst was du am einfachsten benutzen kannst. Schau dich mal im package java.security um, da solltest du schon mal eine Basis für Verschlüsselungsalgorithmen finden.


----------



## Leroy42 (8. Aug 2006)

@Anmeldeboykottierer-Gast

Deine Beiträge sind qualifiziert und eine Bereicherung dieses Forums.

Wann gedenkst du den Boykott aufzugeben?   

(wie man gerade gesehen hat, ist dir die andauernde Eingabe
deines Nicks nicht wirklich angenehm.  :bae: )


----------



## uz (15. Aug 2006)

Ok  soweit erstmal danke fuer Eure Antworten.
Ich bin jetzt an der Stelle dass ich Schluessel in PEM-Dateien von einem in Python geschriebenen Programm erhalte.
Diese möchte ich jetzt in Java einlesen und z.B. den public key zum entschluesseln verwenden.
Ich habe keine genauen Informationen zu den PEM-Files nur dass sie RSA Keys in dieser Form sind:


```
-----BEGIN PUBLIC KEY-----
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBANQNY7RD9BarYRsmMazM1hd7a+u3QeMP
FZQ7Ic+BmmeWHvvVP4Yjyu1t6vAut7mKkaDeKbT3yiGVUgAEUaWMXqECAwEAAQ==
-----END PUBLIC KEY-----
```

Kann Java hieraus erkennen um welchen Key es sich handelt und diesen dann dementsprechend verwenden?

Kann mir vielleicht jemand mit ein paar Zeilen Code zum Importieren eines solchen Schluessels helfen?

Danke!


----------



## tekknokrat (11. Mai 2008)

Hallo,

Hatte irgendwann irgendjemand ansatzweise eine Antwort zu diesem Problem?

Ich habe auch einen Public Key und die Signatur vom private Key und möchte einen verifySignature ausführen.

Es kommt jedoch immer die Meldung:


```
java.security.spec.InvalidKeySpecException: java.security.InvalidKeyException: invalid key format
```

Ich kann's nicht mehr sehen  :autsch: 

Der Code sieht so aus:


```
public static PublicKey getPublicKeyFromPEMFile(String fn) {		
      File pubKeyFile = null;
      PublicKey pubKey = null;
	try {
		// read public key DER file
        pubKeyFile = new File(fn);
        DataInputStream dis = new DataInputStream(new FileInputStream(pubKeyFile));
        byte[] pubKeyBytes = new byte[(int)pubKeyFile.length()];
        dis.readFully(pubKeyBytes);       
        dis.close();
	KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        X509EncodedKeySpec pubSpec = new X509EncodedKeySpec(pubKeyBytes);
        pubKey = keyFactory.generatePublic(pubSpec);
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (NoSuchAlgorithmException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (InvalidKeySpecException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
      	return pubKey;
 }
```

Das Bsp. Pub KeyFile:


```
-----BEGIN PUBLIC KEY-----
MEowDQYJKoZIhvcNAQEBBQADOQAwNgIvNMCE91/Wbe4YoIQva8+f38gQm6EIVbyY
bgTouD/XRl+90W7Zj/Dn+cKSB4dKcdcCAwEAAQ==
-----END PUBLIC KEY-----
```


----------



## tekknokrat (12. Mai 2008)

Thema erledigt.  :bae: 
Man braucht die Keys im DER Format und nicht im PEM.

also falls ein Key nur als PEM vorliegt muß dieser erst umgewandelt werden.
Vielleicht gibts da auch was internes in Java aber ich habs auf die schnelle mit openssl gemacht.


```
openssl rsa -pubin -in testpub.pem -outform DER
```

in Datei


```
openssl rsa -pubin -in testpub.pem -outform DER -out testpub.der
```


----------

