Wie Zeichen-string mit dem private key

Wie bekomme ich die Signatur einer Zeichenkette mit SHA1withRSA wenn ich bereits den Privaten Schlüssel als byte[] oder String?

Sie können sich nicht anmelden, nichts mit einem öffentlichen Schlüssel.
Ein öffentlicher Schlüssel kann nur verwendet werden, um die Nachricht zu Lesen, aber Sie können sich nicht anmelden, eine neue Nachricht mit einem öffentlichen Schlüssel. Eine der private Schlüssel zum signieren der Nachricht verwendet.
Die beiden oben genannten Kommentare sind eigentlich nicht das wahre ist (in der Regel). Am häufigsten können Sie verschlüsseln (und damit Zeichen) Sachen mit Schlüssel (private oder öffentliche). Dies ist, wie asymmetrische Verschlüsselung funktioniert. Wenn Bob schicken will, eine verschlüsselte Nachricht an Alice, die er tatsächlich nutzt Alice ' s öffentlichen Schlüssel zum verschlüsseln seiner Nachricht, und Sie verwenden Ihren privaten Schlüssel zum entschlüsseln. Wenn er will auch zum signieren der Nachricht, er verwendet seinen privaten Schlüssel zur Verschlüsselung eines hash der Nachricht und Alice benutzt Bob ' s öffentlichen Schlüssel zum entschlüsseln des hash-und überprüfen Sie es gegen die Nachricht erhielt.

InformationsquelleAutor xain | 2011-08-28

  1. 40

    Ich denke was Sie sagen ist Sie weiß, der key-pair-Mädchen vor der hand und wollen signieren/überprüfen.

    Finden Sie in der folgenden code.

    import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.Signature;

import sun.misc.BASE64Encoder;

public class MainClass {
    public static void main(String[] args) throws Exception {

        KeyPair keyPair = getKeyPair();

        byte[] data = "test".getBytes("UTF8");

        Signature sig = Signature.getInstance("SHA1WithRSA");
        sig.initSign(keyPair.getPrivate());
        sig.update(data);
        byte[] signatureBytes = sig.sign();
        System.out.println("Signature:" + new BASE64Encoder().encode(signatureBytes));

        sig.initVerify(keyPair.getPublic());
        sig.update(data);

        System.out.println(sig.verify(signatureBytes));
    }

    private static KeyPair getKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
        kpg.initialize(1024);
        return kpg.genKeyPair();
    }
}

    Hier müssen Sie die Methode ändern getKeyPair() zur Versorgung Ihrer bekannten Schlüsselpaar. Sie können laden Sie es aus einer java-key-store [JKS].

    Können Sie nicht nur ein beliebiger byte-array entweder als public key oder private key. Sie sollten erzeugt werden, in Beziehung zu setzen.

    InformationsquelleAutor Prabath Siriwardena

  2. 2

    Müssen Sie es zuerst erstellen Sie einen öffentlichen Schlüssel von array von bytes 

    byte publicKeyBytes[] = .... your public key in bytes ... 
KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBytes)); 
PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);

    und nach mit dem publicKey verschlüsseln

    String data = "... data to be encrypted ....";
String alg = "RSA/ECB/PKCS1Padding";
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte encryptedBytes[] = cipher.doFinal(data.getBytes());

    Nun, nur haben die privateKey kann Ihre Daten Lesen

    @rczajka: ein publicKey ist ein Schlüssel. Sie können es verwenden, um Zeichen somethig, dass nur der Besitzer (die das privateKey) Lesen kann.

    Er wird nicht Fragen, wie, um Daten zu verschlüsseln, er wird Fragen, wie die zum signieren der Daten. verschlüsseln != melden

    InformationsquelleAutor frusso

  3. -1
    public static String sign(String samlResponseString, String keystoreFile, String keyStorePassword, String privateKeyPassword, String alias)
            throws NoSuchAlgorithmException, UnsupportedEncodingException,
            InvalidKeyException, SignatureException {
        PrivateKey pkey=getPrivateKey(  keystoreFile,   keyStorePassword, privateKeyPassword,   alias);
        String signedString = null;
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initSign(pkey);
        signature.update(samlResponseString.getBytes());
        byte[] signatureBytes = signature.sign();
        byte[] encryptedByteValue = Base64.encodeBase64(signatureBytes);
        signedString = new String(encryptedByteValue, "UTF-8");
        System.out.println(signedString);
        return signedString;
    }

    InformationsquelleAutor Trushar Patel

Schreibe einen Kommentar