Wie SpringBoot die API-Verschlüsselung implementiert

SpringBoots API-Verschlüsselungs-Docking

Um die Datensicherheit zu gewährleisten, verschlüsseln wir in Projekten häufig die übertragenen Daten. Zu den häufig verwendeten Verschlüsselungsalgorithmen gehören die symmetrische Verschlüsselung (AES) und die asymmetrische Verschlüsselung (RSA). Für die folgende Erklärung wählte der Blogger das einfachste API-Verschlüsselungsprojekt auf Code Cloud aus.

Das Folgende ist unser hellstes Projekt

rsa-encrypt-body-spring-boot

Projekteinführung

Dieses Projekt verwendet RSA-Verschlüsselung, um die von der API-Schnittstelle zurückgegebenen Daten zu verschlüsseln, wodurch die API-Daten sicherer werden. Andere können die bereitgestellten Daten nicht entschlüsseln. Die Spring Boot-Schnittstellenverschlüsselung kann Rückgabewerte und Parameterwerte durch Anmerkungen automatisch verschlüsseln und entschlüsseln.

Was ist RSA-Verschlüsselung?

Zuallererst müssen wir natürlich die RSA-Verschlüsselung verstehen.

RSA-Verschlüsselung ist eine asymmetrische Verschlüsselung. Die Entschlüsselung kann ohne direkte Weitergabe des Schlüssels erfolgen. Dies gewährleistet die Sicherheit der Informationen und vermeidet das Risiko, durch direkte Schlüsselübertragung geknackt zu werden. Dabei handelt es sich um einen Prozess der Verschlüsselung und Entschlüsselung unter Verwendung eines Schlüsselpaars, das als öffentlicher Schlüssel bzw. privater Schlüssel bezeichnet wird. Zwischen beiden besteht ein mathematischer Zusammenhang. Das Prinzip dieses Verschlüsselungsalgorithmus besteht in der Schwierigkeit, eine sehr große ganze Zahl zu faktorisieren, um die Sicherheit zu gewährleisten. Normalerweise behalten Einzelpersonen private Schlüssel und öffentliche Schlüssel sind öffentlich (können von mehreren Personen gleichzeitig gehalten werden).

Nehmen wir ein Beispiel

Verschlüsselung und Signatur dienen beide Sicherheitsgründen, unterscheiden sich jedoch geringfügig. Oft wird gefragt, ob private oder öffentliche Schlüssel für Verschlüsselung und Signaturen verwendet werden sollen. Tatsächlich sind sie alle verwirrt über die Rolle von Verschlüsselung und Signatur. Einfach ausgedrückt dient die Verschlüsselung dazu, zu verhindern, dass Informationen verloren gehen, und die Signatur soll verhindern, dass Informationen manipuliert werden. Hier sind 2 Beispiele.

Die erste Szene: Auf dem Schlachtfeld möchte B eine Nachricht an A senden, deren Inhalt eine bestimmte Anweisung ist.

Der Verschlüsselungsprozess von RSA ist wie folgt:

(1) A generiert ein Schlüsselpaar (öffentlicher Schlüssel und privater Schlüssel). Der private Schlüssel wird nicht veröffentlicht und von A selbst aufbewahrt. Der öffentliche Schlüssel ist öffentlich und kann von jedem erhalten werden.

(2) A gibt seinen öffentlichen Schlüssel an B weiter und B verwendet den öffentlichen Schlüssel von A, um die Nachricht zu verschlüsseln.

(3) A empfängt die von B verschlüsselte Nachricht und verwendet den eigenen privaten Schlüssel von A, um die Nachricht zu entschlüsseln.

Bei diesem Vorgang gibt es nur zwei Übertragungsvorgänge. Beim ersten Mal überträgt A den öffentlichen Schlüssel an B und beim zweiten Mal überträgt B die verschlüsselte Nachricht an A. Auch wenn sie dort vom Feind abgefangen werden Es besteht keine Gefahr, da nur A Nur der private Schlüssel kann zum Entschlüsseln der Nachricht verwendet werden, wodurch ein Durchsickern des Nachrichteninhalts verhindert wird.

**Zweites Szenario:**Nachdem A die Nachricht von B erhalten hat, muss es mit „empfangen“ antworten.

Der Prozess der RSA-Signatur ist wie folgt:

(1) A generiert ein Schlüsselpaar (öffentlicher Schlüssel und privater Schlüssel). Der private Schlüssel wird nicht veröffentlicht und von A selbst aufbewahrt. Der öffentliche Schlüssel ist öffentlich und kann von jedem erhalten werden.

(2) A signiert die Nachricht mit seinem eigenen privaten Schlüssel, um eine Signatur zu bilden, und übergibt die signierte Nachricht und die Nachricht selbst an B.

(3) Nachdem B die Nachricht empfangen hat, erhält es den öffentlichen Schlüssel von A, um die Signatur zu überprüfen. Wenn der Inhalt der Signatur mit der Nachricht selbst übereinstimmt, beweist dies, dass die Nachricht von A beantwortet wurde.

Bei diesem Vorgang gibt es nur zwei Übertragungsvorgänge. Beim ersten Mal überträgt A die signierte Nachricht und die Nachricht selbst an B. Beim zweiten Mal erhält B den öffentlichen Schlüssel von A. Auch wenn sie vom Feind abgefangen werden. Es besteht keine Gefahr, da nur der private Schlüssel von A die Nachricht signieren kann. Selbst wenn der Nachrichteninhalt bekannt ist, kann eine signierte Antwort an B nicht gefälscht werden, wodurch eine Manipulation des Nachrichteninhalts verhindert wird.

Wenn Sie jedoch die beiden Szenarien kombinieren, werden Sie feststellen, dass im ersten Szenario die abgefangene Nachricht zwar nicht durchgesickert ist, der abgefangene öffentliche Schlüssel jedoch verwendet werden kann, um die falschen Anweisungen zu verschlüsseln und sie dann an A weiterzuleiten. Im zweiten Szenario kann die abgefangene Nachricht zwar nicht manipuliert werden, der Inhalt der Nachricht kann jedoch mithilfe der Signaturüberprüfung des öffentlichen Schlüssels ermittelt werden, was ein Leck nicht verhindert. Daher sollten in praktischen Anwendungen je nach Situation auch Verschlüsselung und Signatur verwendet werden. Beispielsweise verfügen A und B über einen eigenen Satz öffentlicher und privater Schlüssel Für B verwendet er zunächst das öffentliche Schlüsselpaar von B, um die Nachricht zu verschlüsseln, und dann wird der private Schlüssel von A zum Signieren der verschlüsselten Nachricht verwendet, sodass sie weder durchgesickert noch manipuliert wird und die Sicherheit der Nachricht gewährleistet ist.

Praktische Verschlüsselung

Blogger, du twitterst so viel, ich weiß bereits, was RSA macht. Ist es nicht nur Verschlüsselung mit öffentlichem Schlüssel, Entschlüsselung mit privatem Schlüssel, Signaturüberprüfung mit öffentlichem Schlüssel

Praktische Vorbereitung

1. Erstellen Sie ein neues Springboot-Projekt

springboot_api_encryption

2. Stellen Sie Maven Yilai vor

<dependency>
    <groupId>cn.shuibo</groupId>
    <artifactId>rsa-encrypt-body-spring-boot</artifactId>
    <version>1.0.1.RELEASE</version>
</dependency>

3. Beginnen Sie mit dem Hinzufügen der @EnableSecurity-Annotation zur Anwendungsklasse.

@SpringBootApplication
@EnableSecurity
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

4. Fügen Sie den öffentlichen RSA-Schlüssel und den privaten Schlüssel in application.yml oder application.properties hinzu Artikel

rsa:
  encrypt:
    open: false # 是否开启加密 true  or  false
    showLog: true # 是否打印加解密log true  or  false
    publicKey: # RSA公钥 软件生成
    privateKey: # RSA私钥 软件生成

5. Ja, die API-Methode im Controller ist verschlüsselt.

@Encrypt
@GetMapping("/encryption")
public TestBean encryption(){
    TestBean testBean = new TestBean();
    testBean.setName("shuibo.cn");
    testBean.setAge(18);
    return testBean;
}

6. Entschlüsseln Sie die übergebenen Verschlüsselungsparameter. Andere Java-Endprogramme können Anmerkungen verwenden

@Decrypt
@PostMapping("/decryption")
public String Decryption(@RequestBody TestBean testBean){
    return testBean.toString();
}

Echtes Schwert und echte Waffe

1. Stellen Sie Maven vor

2、启动类添加注解

3、YML添加配置密钥

4、创建一个实体类

5、写一个对外API接口

6、启动项目

请求地址: http://localhost:8080/encryption

我们看到返回的数据未加密

7、修改

修改open为true 打开加密

rsa:
  encrypt:
    open: true # 是否开启加密 true  or  false
    showLog: true # 是否打印加解密log true  or  false
    publicKey: # RSA公钥 软件生成
    privateKey: # RSA私钥 软件生成

8、再次重启项目

请求地址: http://localhost:8080/encryption

我们看到返回的数据已加密

9、加密日志

解密实战

如果是其他springboot项目，跟前面一样。我们这儿就当客户端是springboot项目，其他的请使用RSA解密协议解密！

服务端有私密钥、跟公密钥

前端只需要公密钥就可以

实战准备

在原来的springboot基础上写一份解密方法

1、前端js解密方法

<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.5.1/jquery.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/jsencrypt/3.0.0-rc.1/jsencrypt.js"></script>

2、后台增加解密方法

/**
 * 解密
 * @param user
 * @return
 */
@PostMapping("/decryption")
@Decrypt
@ResponseBody
public String Decryption(@RequestBody User user){
    System.out.println(user.toString());
    return user.toString();
}

3、js方法

#公钥
 var PUBLIC_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAobhGH4WMwMvJRUlTxWrCVIOQtsHijAxPJNvAWAgq80ADpFEWrpbcGB9cKqp6XHRH4k/CVtCUZ7jm9UKwhaeAm18sKtcwe+M8JFNX6FSHpgde0o8C9S/QpcmLxf4iN7nGZ7P3ZTvMdmKUcdRMsVQnsydG2Bj6gRxP2+kexEebTeODbdM7dHlkxAL0RxGWmX/ZOBzsoWZw2gKcC0vxwyIZBGHUdImG2T3nEA+VMfK2Yqv3uSYukmlKP+0mjfhrTtLFDuTV1VER9BfryBMvpQCxLO4pqgZnXPd+SOQcZHZ2OL0wqo5OX1+GPYx7TNxz5Qi76pK//T2mH7s6X/BuyT21HQIDAQAB";

/**
 * 加密方法
 * @returns {PromiseLike<ArrayBuffer>}
 * @constructor
 */
function RSA_encryption(jsonData) {
 var encrypt = new JSEncrypt();
 encrypt.setPublicKey("-----BEGIN PUBLIC KEY-----" + PUBLIC_KEY + "-----END PUBLIC KEY-----");
 var encrypted = encrypt.encrypt(JSON.stringify(jsonData));
 console.log("加密前数据:%o", str);
 console.log("加密后数据:%o", encrypted);
 return encrypted;
}


/**
 * 提交方法
 */
function tijiao() {
 var str = {
 "name":"1223334",
 "password":"asd",
 age:1
 };
 $.ajax({
 url: "/decryption",
 type : "POST",
 contentType: "application/json;charset=utf-8",
 data : RSA_encryption(str) ,
 success : function(data) {
 alert(data);
 }
 })
}

真刀真枪

1、 Controller添加解密方法接口

2、前端页面引入js以及方法

    
    


加密传后端，后端解密
加密传后端
<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.5.1/jquery.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/jsencrypt/3.0.0-rc.1/jsencrypt.js"></script>
<script>
    var PUBLIC_KEY = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAobhGH4WMwMvJRUlTxWrCVIOQtsHijAxPJNvAWAgq80ADpFEWrpbcGB9cKqp6XHRH4k/CVtCUZ7jm9UKwhaeAm18sKtcwe+M8JFNX6FSHpgde0o8C9S/QpcmLxf4iN7nGZ7P3ZTvMdmKUcdRMsVQnsydG2Bj6gRxP2+kexEebTeODbdM7dHlkxAL0RxGWmX/ZOBzsoWZw2gKcC0vxwyIZBGHUdImG2T3nEA+VMfK2Yqv3uSYukmlKP+0mjfhrTtLFDuTV1VER9BfryBMvpQCxLO4pqgZnXPd+SOQcZHZ2OL0wqo5OX1+GPYx7TNxz5Qi76pK//T2mH7s6X/BuyT21HQIDAQAB";

    /**
     * 加密方法
     * @returns {PromiseLike<ArrayBuffer>}
     * @constructor
     */
    function RSA_encryption(jsonData) {
        var encrypt = new JSEncrypt();
        encrypt.setPublicKey("-----BEGIN PUBLIC KEY-----" + PUBLIC_KEY + "-----END PUBLIC KEY-----");
        var encrypted = encrypt.encrypt(JSON.stringify(jsonData));
        console.log("加密前数据:%o", jsonData);
        console.log("加密后数据:%o", encrypted);
        return encrypted;
    }

    /**
     * 提交方法
     */
    function tijiao() {
        var str = {
            "name":"1223334",
            "password":"asd",
            age:1
        };
            $.ajax({
                url: "/decryption",
                type : "POST",
                contentType: "application/json;charset=utf-8",
                data : RSA_encryption(str) ,
                success : function(data) {
                    alert(data);
                }
            })
    }


</script>

3、启动访问

http://localhost:8080

4、后台解密日志

总结

经过上面的接口加密解密操作。可以看出我们的接口如果没有公钥、或者私钥别人根本无法解密！这样就对API接口起到了很好的保护作用，防止别人抓包！

祝大家：每天学习一点，技术成长飞快

项目坑点

此项目的demo无法访问，难点就在前端如何加密回传到后台解密，此坑我带大家爬出来了！

以下是主意事项：

1、主意ajax的 contentType: “application/json;charset=utf-8”

$.ajax({
    url: "/decryption",
    type : "POST",
    contentType: "application/json;charset=utf-8",
    data : RSA_encryption(str) ,
    success : function(data) {
        alert(data);
    }
})

2、解密方法必须 @RequestBody

@PostMapping("/decryption")
@Decrypt
@ResponseBody
public String Decryption(@RequestBody User user){
    System.out.println(user.toString());
    return user.toString();
}

Das obige ist der detaillierte Inhalt vonWie SpringBoot die API-Verschlüsselung implementiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!