Rumah > Artikel > Java > Apakah proses dan prinsip pertahanan SpringBoot terhadap serangan CSRF?

Apakah proses dan prinsip pertahanan SpringBoot terhadap serangan CSRF?

WBOYke hadapan: 2023-05-12 21:13:04848semak imbas

Prinsip CSRF

Jika kita ingin bertahan daripada serangan CSRF, kita perlu terlebih dahulu memahami apa itu serangan CSRF Marilah kita menyelesaikan proses serangan CSRF melalui ilustrasi berikut:

Malah, proses ini sangat mudah:
1 Andaikan pengguna membuka laman web Perbankan Dalam Talian China Merchants dan log masuk.
2. Selepas log masuk berjaya, perbankan dalam talian akan mengembalikan kuki ke bahagian hadapan, dan penyemak imbas akan menyimpan kuki.
3. Pengguna membuka tab baharu dalam penyemak imbas tanpa log keluar daripada perbankan dalam talian, dan kemudian melawat tapak web berbahaya.
4. Terdapat hiperpautan pada tapak web berbahaya ini, dan alamat hiperpautan itu menghala ke Perbankan Dalam Talian Pedagang China.
4. Pengguna mengklik pada pautan ini Memandangkan hiperpautan ini secara automatik akan membawa kuki yang disimpan dalam penyemak imbas, pengguna tanpa sedar mengakses perbankan dalam talian, yang boleh menyebabkan kerugian kepada dirinya sendiri.

Proses CSRF secara kasarnya begini Seterusnya, saya akan gunakan contoh mudah untuk menunjukkan apa itu CSRF.

Amalan CSRF

1 Saya telah mencipta projek Spring Boot yang dinamakan csrf-mry Ketergantungan Keselamatan adalah seperti berikut:

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-security</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>

2 Selepas penciptaan berjaya, untuk kemudahan, kami terus mengkonfigurasi nama pengguna/kata laluan Spring Security dalam fail application.properties:

server.port= 8866
spring.security.user.name=javaboy
spring.security.user.password=123

3 kami menyediakan dua antara muka ujian A

package com.mry.csrf.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class CsrfDemoController {
    @PostMapping("/transfer")
    public void transferMoney(String name, Integer money) {
        System.out.println("name = " + name);
        System.out.println("money = " + money);
    }
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }
}

Anggapkan bahawa /transfer ialah antara muka pemindahan (ini adalah andaian, terutamanya untuk menunjukkan serangan CSRF, antara muka pemindahan sebenar adalah lebih rumit daripada ini).

4. Kami juga perlu mengkonfigurasi Spring Security, kerana Spring Security boleh bertahan secara automatik daripada serangan CSRF secara lalai, jadi kami perlu mematikan ini.

package com.mry.csrf.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .csrf()
                .disable();
    }
}

Selepas konfigurasi selesai, kami memulakan projek csrf-simulate-web.

5 Mari kita cipta satu lagi projek csrf-loophole-web.
Selepas projek berjaya dibuat, mula-mula ubah suai port projek:

server.port= 8855

6 Kemudian kami mencipta hello.html dalam direktori sumber/statik dengan kandungan berikut.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="http://localhost:8866/transfer" method="post">
        <input type="hidden" value="javaboy" name="name">
        <input type="hidden" value="10000" name="money">
        <input type="submit" value="点击查看美女图片">
    </form>
</body>
</html>

Terdapat hiperpautan di sini Teks hiperpautan adalah untuk mengklik untuk melihat gambar wanita cantik Apabila anda mengklik hiperpautan, ia akan meminta antara muka http://localhost:8866/transfer secara automatik. dan domain tersembunyi juga membawa dua parameter.

Selepas konfigurasi selesai, anda boleh memulakan projek csrf-loophole-web.

Seterusnya, pengguna mula-mula mengakses antara muka dalam projek csrf-simulate-web Apabila mengakses, dia perlu log masuk, dan pengguna melakukan operasi log masuk Selepas akses selesai, pengguna tidak melakukan operasi log keluar, dan kemudian pengguna yang saya melawat halaman dalam csrf-loophole-web dan melihat hiperpautan saya ingin tahu tentang rupa kecantikan ini Sebaik sahaja saya mengklik padanya, wang itu telah dipindahkan.

Pertahanan CSRF

Mari kita bercakap tentang idea pertahanan dahulu.

Pertahanan CSRF, idea teras ialah menambah nombor rawak pada permintaan bahagian hadapan.

Kerana dalam serangan CSRF, laman web penggodam sebenarnya tidak tahu apa itu kuki pengguna Ia membolehkan pengguna menghantar permintaan ke laman web perbankan dalam talian dengan sendiri, kerana proses ini akan membawa kuki secara automatik. maklumat.

Jadi idea pertahanan kami adalah seperti berikut: apabila pengguna mengakses perbankan dalam talian, selain membawa maklumat dalam kuki, dia juga perlu membawa nombor rawak Jika pengguna tidak membawa nombor rawak ini, laman web perbankan dalam talian akan Menolak permintaan. Apabila tapak web penggodam mendorong pengguna untuk mengklik pada hiperpautan, ia secara automatik akan membawa maklumat dalam kuki, tetapi ia tidak akan membawa nombor rawak secara automatik, sekali gus berjaya mengelakkan serangan CSRF.

Spring Security memberikan sokongan yang baik untuk ini, mari kita lihat.

Penyelesaian bukan pemisah belakang dan belakang

Spring Security sebenarnya menyediakan pertahanan CSRF secara lalai, tetapi ia memerlukan pembangun melakukan lebih banyak perkara.
Mula-mula kami mencipta projek Spring Boot baharu dan memperkenalkan Spring Security, Thymeleaf dan kebergantungan web semasa menciptanya.

1.pom information

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-security</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-thymeleaf</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
</dependencies>

2 Selepas projek berjaya dibuat, kami masih mengkonfigurasi nama pengguna/kata laluan dalam application.properties

spring.security.user.name=mry
spring.security.user.password=123456

3 Antara muka ujian

package com.mry.csrf.controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SecurityCsrfController {
    @PostMapping("/hello")
    @ResponseBody
    public String hello() {
        return "hello";
    }
}

Ambil perhatian bahawa antara muka ujian ini ialah permintaan POST, kerana secara lalai, GET, HEAD, TRACE dan OPTIONS tidak perlu disahkan untuk serangan CSRF.

4 Kemudian, kami mencipta templat thymeleaf baharu dalam direktori sumber/templat

<!DOCTYPE html>
<!--导入thymeleaf的名称空间-->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/hello" method="post">
        <input type="hidden" th:value="${_csrf.token}" th:name="${_csrf.parameterName}">
        <input type="submit" value="hello">
    </form>
</body>
</html>

Perhatikan bahawa semasa menghantar permintaan POST, domain tersembunyi tambahan dan kunci domain tersembunyi dibawa. ialah ${_csrf.parameterName} dan nilai ialah ${_csrf.token}.

Pelayan akan membawa kedua-dua nilai ini secara automatik, kami hanya perlu memaparkannya di bahagian hadapan.

5. Seterusnya, tambahkan pengawal pada halaman hello.html bahagian hadapan

@GetMapping("/hello")
public String hello2() {
	return "hello";
}

6 Selepas penambahan selesai, mulakan projek dan lawati halaman helo perlu log masuk dahulu. Log masuk Selepas berjaya, kita dapat melihat bahawa terdapat parameter tambahan dalam permintaan log masuk

Apakah proses dan prinsip pertahanan SpringBoot terhadap serangan CSRF?

这里我们用了 Spring Security 的默认登录页面，如果大家使用自定义登录页面，可以参考上面 hello.html 的写法，通过一个隐藏域传递 _csrf 参数。

访问到 hello 页面之后，再去点击【hello】按钮，就可以访问到 hello 接口了。

Apakah proses dan prinsip pertahanan SpringBoot terhadap serangan CSRF?

这是 Spring Security 中默认的方案，通过 Model 将相关的数据带到前端来。

如果你的项目是前后端不分项目，这种方案就可以了，如果你的项目是前后端分离项目，这种方案很明显不够用。

前后端分离方案

如果是前后端分离项目，Spring Security 也提供了解决方案。
这次不是将 _csrf 放在 Model 中返回前端了，而是放在 Cookie 中返回前端，配置方式如下：

package com.mry.csrf.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
    }
}

有小伙伴可能会说放在 Cookie 中不是又被黑客网站盗用了吗？其实不会的，大家注意如下两个问题：
(1)黑客网站根本不知道你的 Cookie 里边存的啥，他也不需要知道，因为 CSRF 攻击是浏览器自动携带上 Cookie 中的数据的。
(2)我们将服务端生成的随机数放在 Cookie 中，前端需要从 Cookie 中自己提取出来 _csrf 参数，然后拼接成参数传递给后端，单纯的将 Cookie 中的数据传到服务端是没用的。
理解透了上面两点，你就会发现 _csrf 放在 Cookie 中是没有问题的，但是大家注意，配置的时候我们通过 withHttpOnlyFalse 方法获取了 CookieCsrfTokenRepository 的实例，该方法会设置 Cookie 中的 HttpOnly 属性为 false，也就是允许前端通过 js 操作 Cookie（否则你就没有办法获取到 _csrf）。

配置完成后，重启项目，此时我们就发现返回的 Cookie 中多了一项：

Apakah proses dan prinsip pertahanan SpringBoot terhadap serangan CSRF?

接下来，我们通过自定义登录页面，来看看前端要如何操作。

首先我们在 resources/static 目录下新建一个 html 页面叫做 login.html：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://libs.baidu.com/jquery/2.1.4/jquery.min.js"></script>
    <script src="https://cdn.bootcss.com/jquery-cookie/1.4.1/jquery.cookie.min.js"></script>
</head>
<body>
<div>
    <input type="text" id="username">
    <input type="password" id="password">
    <input type="button" value="登录" id="loginBtn">
</div>
<script>
    $("#loginBtn").click(function () {
        let _csrf = $.cookie(&#39;XSRF-TOKEN&#39;);
        $.post(&#39;/login.html&#39;,{username:$("#username").val(),password:$("#password").val(),_csrf:_csrf},function (data) {
            alert(data);
        })
    })
</script>
</body>
</html>

这段 html 给大家解释一下：
(1)首先引入 jquery 和 jquery.cookie ，方便我们一会操作 Cookie。
(2)定义三个 input，前两个是用户名和密码，第三个是登录按钮。
(3)点击登录按钮之后，我们先从 Cookie 中提取出 XSRF-TOKEN，这也就是我们要上传的 csrf 参数。
(4)通过一个 POST 请求执行登录操作，注意携带上 _csrf 参数。

服务端我们也稍作修改，如下：

package com.mry.csrf.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/static/js/**");
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().anyRequest().authenticated()
                .and()
                .formLogin()
                .loginPage("/login.html")
                .successHandler((req,resp,authentication)->{
                    resp.getWriter().write("success");
                })
                .permitAll()
                .and()
                .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
    }
}

一方面这里给 js 文件放行。

另一方面配置一下登录页面，以及登录成功的回调，这里简单期间，登录成功的回调我就给一个字符串就可以了。在登录成功后回调的详细解释。

OK，所有事情做完之后，我们访问 login.html 页面，输入用户名密码进行登录，结果如下：

Apakah proses dan prinsip pertahanan SpringBoot terhadap serangan CSRF?

可以看到，我们的 _csrf 配置已经生效了。

Atas ialah kandungan terperinci Apakah proses dan prinsip pertahanan SpringBoot terhadap serangan CSRF?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

spring spring boot jquery html csrf Static Cookie Token 字符串接口 JS input http

Kenyataan：

Artikel ini dikembalikan pada:yisu.com. Jika ada pelanggaran, sila hubungi admin@php.cn Padam

Artikel sebelumnya：Apakah prinsip reka bentuk Java bagi Penyongsangan Ketergantungan?Artikel seterusnya：Apakah prinsip reka bentuk Java bagi Penyongsangan Ketergantungan?

Artikel berkaitan

Lihat lagi