Lumpuhkan CSRF dan menetapkan dasar penciptaan sesi ke Stateless di SecurityConfig untuk memastikan tiada sesi dibuat; 2. Gunakan JWT untuk pengesahan berasaskan token dengan menghasilkan token yang ditandatangani selepas log masuk dan mengembalikannya kepada pelanggan; 3. Mengesahkan JWT dalam penapis tersuai (JWTAuthFilter) yang mengekstrak token dari tajuk kebenaran dan menetapkan pengesahan dalam konteks keselamatan; 4. Titik akhir selamat menggunakan kawalan akses berasaskan peranan melalui pencocokan permintaan atau anotasi peringkat kaedah seperti @Preauthorize; 5. Ikuti amalan terbaik termasuk menggunakan HTTPS, token jangka pendek, token menyegarkan, mengehadkan kadar, dan mengelakkan pembalakan token untuk meningkatkan keselamatan. Pendekatan ini memastikan API REST yang selamat, tanpa statik, dan berskala di Jawa dengan keselamatan musim bunga.

Mengamankan API REST di Java Menggunakan Keselamatan Spring adalah keperluan umum untuk aplikasi web moden. Oleh kerana API REST tidak bertauliah dengan reka bentuk, keselamatan berasaskan sesi tradisional tidak sesuai dengan baik. Walau bagaimanapun, keselamatan musim bunga menyediakan alat yang fleksibel untuk menjamin titik akhir REST dengan berkesan-terutamanya apabila digabungkan dengan pengesahan berasaskan token seperti JWT (JSON Web Tokens).

Inilah cara untuk mengamankan API REST dengan betul di Java menggunakan keselamatan musim bunga:

1. Lumpuhkan csrf dan aktifkan pengesahan tanpa statur

API REST biasanya dimakan oleh aplikasi frontend, pelanggan mudah alih, atau perkhidmatan pihak ketiga, bukan pelayar yang bergantung kepada kuki. Oleh itu, perlindungan CSRF tidak perlu dan boleh mengganggu panggilan API.

Di SecurityConfig anda, lumpuhkan CSRF dan tetapkan strategi sesi ke tanpa statur :

 @Configuration
@EnableWebsecurity
kelas awam SecurityConfig {

    @Bean
    Public SecurityFilterChain FilterChain (httpsecurity http) melemparkan pengecualian {
        http
            .csrf (). lumpuhkan () // tidak diperlukan untuk API tanpa statur
            .SessionManagement (). sessionCeationPolicy (sessionCeationPolicy.Stateless)
            .dan ()
            . AkhorizeSHttPrequests (Authz -> Authz
                .RequestMatchers ("/API/public/**"). PermitAll ()
                .RequestMatchers ("/API/Admin/**"). Hasrole ("Admin")
                .yeRequest (). Disahkan ()
            )
            .httpbasic (). lumpuhkan () // lebih suka berasaskan token atas asas auth
            .AddFilterBefore (JWTAuthFilter (), userNamePassWordAuthenticationFilter.class);

        kembali http.build ();
    }

    @Bean
    Public AuthenticationManager AuthenticationManager (
            AuthenticationConfiguration AuthConfig) melemparkan Pengecualian {
        kembali authConfig.getAuthenticationManager ();
    }

    @Bean
    public jwtauthfilter jwtauthfilter () {
        kembali jwtauthfilter baru ();
    }
}

? Titik Utama: Gunakan SessionCreationPolicy.STATELESS So Spring tidak membuat atau menggunakan sesi HTTP.

2. Gunakan JWT untuk pengesahan berasaskan token

JWT adalah cara yang padat, selamat untuk mewakili tuntutan antara pihak. Ia sesuai untuk API REST kerana ia membawa maklumat pengguna dan mandiri.

Langkah -langkah untuk melaksanakan JWT:

• Menjana token : Selepas log masuk yang berjaya, menghasilkan JWT yang mengandungi butiran pengguna (misalnya, nama pengguna, peranan).
• Hantar Token : Kembalikannya dalam respons (biasanya dalam badan JSON atau tajuk Authorization ).
• Mengesahkan Token : Pada setiap permintaan, ekstrak dan sahkan JWT dari Header Authorization: Bearer <token> .

Contoh kelas JwtUtil yang mudah:

 @Component
jwtutil kelas awam {
    RECRICE STRINE SRETRICE = "YoursEcretKey"; // Gunakan kunci yang kuat dari persekitaran
    Int Expiry Private = 86400; // 24 jam

    rentetan awam generateToken (userDetails userDetails) {
        Peta <string, object> claims = hashMap baru <> ();
        kembali jwts.builder ()
                .setClaims (tuntutan)
                .setSubject (userDetails.getUserName ())
                .SetIsedat (tarikh baru ())
                .SetExpiration (tarikh baru (System.CurrentTimemillis () tamat * 1000))
                .signwith (signaturealgorithm.hs512, rahsia)
                .compact ();
    }

    public boolean isTokenValid (String Token, String Username) {
        kembali getUsernameFromToken (token) .equals (nama pengguna) &&! iSTOKeNExpired (token);
    }

    String public getUsernameFromToken (String Token) {
        kembali getClaim (token, tuntutan :: getSubject);
    }

    Private <t> t getClaim (token string, fungsi <tuntutan, t> resolver) {
        Tuntutan tuntutan = jwts.parser ()
                .SetsigningKey (Rahsia)
                .parseclaimsjws (token)
                .getBody ();
        mengembalikan resolver.apply (tuntutan);
    }

    Boolean Private isTokenExpired (String Token) {
        kembali getClaim (token, tuntutan :: getExpiration). Sebelum (tarikh baru ());
    }
}

?? Never Hardcode Kunci rahsia dalam pembolehubah persekitaran penggunaan pengeluaran atau pengurus rahsia.

3. Penapis tersuai untuk memintas dan mengesahkan JWT

Buat penapis yang berjalan sebelum rantaian pengesahan utama untuk memeriksa JWT dalam tajuk permintaan.

 @Component
Kelas awam JWTAuthFilter memanjangkan OncePerRequestFilter {

    @Autowired
    UserDetailSService UserDetailSService;

    @Autowired
    Jwtutil swasta JWtutil;

    @Override
    dilindungi void dofilterinternal (permintaan httpservletrequest,
                                    HttpservletResponse Response,
                                    Rantaian Filterchain) melemparkan ServletException, ioException {

        header rentetan akhir = request.geTheader ("kebenaran");
        String jwt = null;
        Nama pengguna String = null;

        jika (header! = null && header.startswith ("pembawa")) {
            jwt = header.substring (7);
            Cuba {
                nama pengguna = jwtutil.getusernamefromtoken (jwt);
            } menangkap (pengecualian e) {
                // token tidak sah
            }
        }

        jika (nama pengguna! = null && keselamatanContexTholder.getContext (). getAuthentication () == null) {
            UserDetails userDetails = userDetailsService.loadUserByUserName (username);
            jika (jwtutil.istokenvalid (jwt, userDetails.getuserName ())) {
                UserNamePassWordAuthenticationToken AuthToken =
                        newAnamePassWordAuthenticationToken (userDetails, null, userDetails.getAuthorities ());
                authToken.setDetails (baru WebAuthenticationDetailSsource (). BuildDetails (Request));
                KeselamatanContexTholder.getContext (). SetAuthentication (authToken);
            }
        }

        chain.dofilter (permintaan, respons);
    }
}

Penapis ini:

• Ekstrak token dari tajuk Authorization .
• Parses dan mengesahkannya.
• Memuatkan pengguna dan menetapkan pengesahan dalam konteks keselamatan.

4. Titik akhir selamat dengan akses berasaskan peranan yang betul

Gunakan anotasi keselamatan musim bunga untuk melindungi kaedah atau titik akhir:

 @RestController
@RequestMapping ("/API/Admin")
@Preauthorize ("Hasrole ('Admin')")
ADMINCONTROLLER kelas awam {

    @GetMapping ("/Users")
    Senarai awam <gusu> getAllUsers () {
        // hanya boleh diakses oleh pentadbir
    }
}

Dayakan Keselamatan Tahap Kaedah:

 @Configuration
@EnableGlobalMethodSecurity (prepostenabled = true)
MethodSecurityConfig Kelas Kelas Awam {
    // tidak diperlukan konfigurasi tambahan
}

5. Amalan terbaik keselamatan tambahan

• ? Gunakan HTTPS : Sentiasa berkhidmat API ke atas HTTPS untuk melindungi token dalam transit.
• ? Tetapkan token pendek tamat : Kurangkan tetingkap pendedahan jika token dicuri.
• ? Token Refresh : Gunakan mekanisme token penyegaran untuk menerbitkan semula token akses tanpa login semula.
• ? Mengehadkan kadar : Mencegah serangan kekerasan menggunakan alat seperti Bucket4j atau Spring Cloud Gateway .
• ? Elakkan token pembalakan : Pastikan token tidak secara tidak sengaja log masuk log pelayan.

Ringkasan

Untuk mengamankan API rehat di Java dengan keselamatan musim bunga:

• Lumpuhkan CSRF dan gunakan sesi tanpa stat.
• Gunakan JWT untuk pengesahan dan bukan sesi.
• Mengesahkan token melalui penapis tersuai.
• Menguatkuasakan kawalan akses dengan kaedah atau keselamatan peringkat.
• Ikuti amalan terbaik keselamatan (HTTPS, token jangka pendek, dll.).

Dengan persediaan ini, API REST anda akan selamat dan berskala -sempurna untuk spa, aplikasi mudah alih, atau microservices.

Pada asasnya, ia tidak kompleks apabila anda mendapat aliran: mengesahkan sekali, dapatkan token, dan membuktikan identiti pada setiap permintaan tanpa sesi.

Atas ialah kandungan terperinci Mengamankan API rehat di Java menggunakan keselamatan musim bunga. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!