Was sind die am häufigsten verwendeten Algorithmen für digitale Signaturen?

Die digitale Signatur ist ein Nachrichten-Digest-Algorithmus mit einem Schlüssel. Dieser Schlüssel umfasst einen öffentlichen Schlüssel und einen privaten Schlüssel, der zur Überprüfung der Datenintegrität, zur Authentifizierung der Datenquelle und zum Schutz vor Ablehnung verwendet wird das OSI-Referenzmodell, das Signieren privater Schlüssel und die Überprüfung öffentlicher Schlüssel. Es ist auch eine Kombination aus asymmetrischem Verschlüsselungsalgorithmus und Message Digest-Algorithmus. Zu den gängigen Algorithmen für digitale Signaturen gehören hauptsächlich RSA, DSA und ECDSA.

RSA ist der klassischste Algorithmus in der Computerkryptographie und der bisher am weitesten verbreitete digitale Signaturalgorithmus. Die Schlüsselimplementierung des RSA-Algorithmus für digitale Signaturen ist dieselbe wie die des RSA-Verschlüsselungsalgorithmus alle heißen RSA.

Der Nachrichtenübermittlungsvorgang ist:

1 Der Nachrichtensender erstellt ein Schlüsselpaar,

2. Der Nachrichtensender veröffentlicht den öffentlichen Schlüssel ,

3. Der Nachrichtensender verwendet den privaten Schlüssel, um die Nachricht zu signieren

4. Der Nachrichtenempfänger verwendet den öffentlichen Schlüssel, um die Nachricht zu überprüfen

RSA-Nummer Signaturcode-Implementierung :

Die Implementierung der DSA-Signatur ist ähnlich, die ECDSA-Implementierung unterscheidet sich jedoch in der Art und Weise, wie das Schlüsselpaar erfolgreich ist, im Vergleich zu den ersten beiden.

import org.apache.commons.codec.binary.Base64;

import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class RSASignature {

    private static final String KEY_ALGORITHM="RSA";
    private static final String SIGNATURE_ALGORITHM="MD5withRSA";
    private static final String PUBLIC_KEY="RSAPublicKey";
    private static final String PRIVATE_KEY="RSAPrivateKey";
    /**
     * RSA密匙长度，默认是1024位，密匙长度必须是在64的倍数
     * 范围是512--65536之间
     *
     */
    private static final int KEY_SIZE = 512;

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

        String str = "hello vison";
        Map<String, Object> map = initKey();
        byte[] privateKey = getPrivateKey(map);
        //签名
        byte[] signData = sign(str.getBytes(), privateKey);
        System.out.println("signData: " + Base64.encodeBase64(signData));
        //校验
        byte[] pulicKey = getPulicKey(map);
        boolean status = verify(str.getBytes(), pulicKey, signData);
        System.out.println("verify result: " + status);

    }

    /**
     *
     * @param data 待校验的数据
     * @param key 公钥
     * @param sign 数据签名
     * @return boolean 校验成功返回true,否则返回false
     * @throws Exception
     */
    public static boolean verify(byte[] data,byte[] key,byte[] sign)throws Exception{
        //获取公钥
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        //校验数据
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey);
        signature.update(data);
        return signature.verify(sign);
    }
    /**
     * 私钥签名
     * @param data 待签名数据
     * @param key 私钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] sign(byte[] data,byte[] key) throws Exception {
        //获取私钥
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        //签名
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey);
        signature.update(data);
        return signature.sign();
    }
    /**
     * 获取私钥
     * @param keyMap
     * @return
     */
    public static byte[] getPrivateKey(Map<String,Object> keyMap){
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }
    /**
     * 获取公钥
     * @param keyMap
     * @return
     */
    public static byte[] getPulicKey(Map<String,Object> keyMap){
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();

    }
    /**
     * 初始化密匙对
     * @return Map 密钥map
     * @throws Exception
     */
    public static Map<String,Object> initKey() throws Exception {
        //实例化密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密匙对
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        //私钥
        RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
        //公钥
        RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
        //封装密钥
        HashMap<String, Object> map = new HashMap<>(2);
        map.put(PUBLIC_KEY,publicKey);
        map.put(PRIVATE_KEY,privateKey);
        return map;
    }
}

Das obige ist der detaillierte Inhalt vonWas sind die am häufigsten verwendeten Algorithmen für digitale Signaturen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!