JWT adalah standard terbuka untuk penghantaran maklumat yang selamat. Di Java, pengesahan dan kebenaran dapat dicapai melalui Perpustakaan JJWT. 1. Tambah JJWT API, Impl dan Jackson Dependencies; 2. Buat kelas alat JWTutil untuk menjana, menghuraikan dan mengesahkan token; 3. Tulis jwtfilter untuk memintas permintaan dan sahkan token pembawa dalam tajuk kebenaran; 4. Daftar penapis pada boot musim bunga untuk melindungi laluan yang ditentukan; 5. Menyediakan antara muka log masuk untuk mengembalikan JWT selepas mengesahkan pengguna; 6. Antara muka yang dilindungi memperoleh identiti dan peranan pengguna untuk mengawal akses dengan menghuraikan token, dan akhirnya menyedari mekanisme keselamatan yang tidak terperinci dan extensible, yang sesuai untuk aplikasi sistem yang diedarkan. Perhatikan cadangan keselamatan seperti keselamatan utama, tamat tempoh dan penghantaran HTTPS.

Dalam pembangunan aplikasi web moden, menggunakan Java untuk melaksanakan pengesahan pengguna (pengesahan) dan kebenaran adalah keperluan umum. JWT (JSON Web Token) telah menjadi salah satu penyelesaian arus perdana untuk melaksanakan pengesahan keselamatan kerana sokongan yang tidak berkesudahan, berskala dan silang domain. Berikut ini menerangkan cara menggunakan JWT untuk menyelesaikan pengesahan dan kebenaran dalam aplikasi Java.

Apa itu JWT?

JWT adalah standard terbuka (RFC 7519) yang digunakan untuk menghantar maklumat dengan selamat sebagai objek JSON antara pihak. Ia biasanya digunakan untuk pengesahan dan pertukaran maklumat. JWT terdiri daripada tiga bahagian:

• Header : Mengandungi jenis token dan algoritma tandatangan (seperti HMAC SHA256)
• Muatan : Mengandungi tuntutan, seperti ID Pengguna, Peranan, Masa Tamat, dll.
• Tandatangan : Tandatangan Dua Bahagian Pertama Untuk Memastikan Data belum diganggu

Formatnya ialah: xxxxx.yyyyy.zzzzz

Proses asas

1. Log masuk pengguna, serahkan nama pengguna dan kata laluan
2. Kelayakan pengesahan pelayan, menjana JWT dan kembali kepada pelanggan
3. Pelanggan membawa JWT dalam permintaan berikutnya (biasanya dalam tajuk Authorization )
4. Pelayan mengesahkan kesahihan JWT dan memutuskan sama ada untuk memberi kuasa akses kepada sumber berdasarkan kenyataan di dalamnya.

Gunakan Java JWT untuk melaksanakan pengesahan dan kebenaran

1. Tambah kebergantungan (mengambil maven sebagai contoh)

Gunakan Perpustakaan JJWT untuk mengendalikan JWT:

 <geterlihat>
    <groupId> io.jsonwebtoken </groupId>
    <stistfactid> jjwt-api </artifactid>
    <versi> 0.11.5 </versi>
</ketergantungan>
<geterlihat>
    <groupId> io.jsonwebtoken </groupId>
    <stistfactid> jjwt-impl </artifactid>
    <versi> 0.11.5 </versi>
    <scope> runtime </scope>
</ketergantungan>
<geterlihat>
    <groupId> io.jsonwebtoken </groupId>
    <ctiFactId> JJWT-Jackson </artifactid>
    <versi> 0.11.5 </versi>
    <scope> runtime </scope>
</ketergantungan>

Nota: JJWT 0.11 menyokong modulariti, yang memerlukan pengenalan API, IMPL dan Jackson sokongan.

2. Buat kelas alat JWT

 import io.jsonwebtoken.*;
import io.jsonwebtoken.security.keys;

import javax.crypto.secretkey;
import java.util.date;

jwtutil kelas awam {
    SecretKey SecretKey Secrety_Key = kunci.secretKeyFor (signatureAlgorithm.hs256);
    Expiration Long Static Long Static Private = 86400000; // 24 jam

    // menjana jwt
    rentetan statik awam GenerateToken (nama pengguna rentetan, peranan rentetan) {
        kembali jwts.builder ()
                .SetSubject (nama pengguna)
                .claim ("peranan", peranan)
                .SetIsedat (tarikh baru ())
                .SetExpiration (tarikh baru (System.CurrentTimemillis () expiration_time)))
                .signwith (rahsia_key)
                .compact ();
    }

    // parse dan sahkan jwt
    Tuntutan statik awam ParsetOken (Token String) {
        Cuba {
            kembali jwts.parserbuilder ()
                    .setsigningKey (rahsia_key)
                    .build ()
                    .parseclaimsjws (token)
                    .getBody ();
        } tangkapan (expiredjwtException e) {
            System.out.println ("token tamat tempoh");
            kembali null;
        } tangkapan (malformedjwtException | SignatureException e) {
            System.out.println ("Token tidak sah");
            kembali null;
        }
    }

    // Dapatkan Nama Pengguna String Static Public GetUsernameFromToken (String Token) {
        Tuntutan tuntutan = ParsetOken (token);
        Pulangan Tuntutan! = Null? tuntutan.getSubject (): null;
    }

    // Dapatkan peranan rentetan statik awam getRoleFromToken (String Token) {
        Tuntutan tuntutan = ParsetOken (token);
        pulangan (string) tuntutan.get ("peranan");
    }

    // Sahkan sama ada token adalah boolean static boolean awam yang sah (token string, nama pengguna string) {
        String tokenuserName = getUsernameFromToken (token);
        kembali (tokenuserName! = null && tokenusername.equals (nama pengguna) && parsetOken (token)! = null);
    }
}

3. Permintaan Intercept: Melaksanakan Penapis (Penapis)

Buat JwtFilter untuk memintas permintaan dan sahkan JWT.

 import javax.servlet.*;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletResponse;
import java.io.ioException;

Kelas awam JWTFilter melaksanakan penapis {

    @Override
    dofilter kekosongan awam (permintaan ServletRequest, respons servletResponse, rantai penapis)
            melemparkan ioException, ServletException {

        HttpservletRequest httprequest = (httpservletrequest) permintaan;
        HttpservletResponse httpresponse = (httpservletResponse) respons;

        String token = httprequest.getheader ("kebenaran");

        jika (token! = null && token.startswith ("pembawa")) {
            token = token.substring (7); // Keluarkan "pembawa"
            String username = jwtutil.getUserNameRefromToken (token);

            jika (nama pengguna! = null && jwtutil.istokenvalid (token, nama pengguna)) {
                // Maklumat pengguna boleh disimpan dalam atribut permintaan atau konteks keselamatan
                httprequest.setAttribute ("currentUser", username);
                httprequest.setAttribute ("peranan", jwtutil.getRolefromToken (token));
                chain.dofilter (permintaan, respons);
            } else {
                httpresponse.setStatus (httpservletResponse.sc_unuthorized);
                httpresponse.getwriter (). tulis ("token tidak sah atau tamat");
            }
        } else {
            httpresponse.setStatus (httpservletResponse.sc_unuthorized);
            httpresponse.getwriter (). tulis ("token hilang");
        }
    }
}

4. Konfigurasikan penapis (mengambil boot musim bunga sebagai contoh)

Jika anda menggunakan Spring Boot, anda boleh mendaftarkan penapis dalam kelas konfigurasi:

 @Bean
public FilterRegistrationBean <Jwtfilter> jwtfilter () {
    FilterRegistrationBean <Jwtfilter> pendaftaranBean = new FilterRegistrationBean <> ();
    RegistrationBean.SetFilter (JWtFilter baru ());
    RegistrationBean.AddurlPatterns ("/api/selamat/*"); // Laluan Pulangan Pulangan yang dilindungi;
}

5. Contoh antara muka log masuk

 @PostMapping ("/login")
Response PublicEntity <?> Login (@RequestBody userLogInRequest permintaan) {
    // dipermudahkan: Malah, kata laluan pangkalan data hendaklah diperiksa untuk pengesahan penyulitan jika ("admin" .equals (request.getusername ()) && "kata laluan" .equals (request.getpassword ())) {
        String token = jwTutil.GenerateToken (request.getUserName (), "admin");
        kembali responseEntity.ok (). Body (map.of ("token", token));
    }
    kembali responseEntity.status (401) .body ("di bawah nama pengguna atau kata laluan");
}

6. Contoh antara muka yang dilindungi

 @GetMapping ("/selamat/data")
Response PublicEntity <?> GetSeCuredata (permintaan httpservletRequest) {
    String user = (string) request.getAttribute ("currentUser");
    Rentetan string = (string) request.getAttribute ("peranan");

    jika ("admin" .equals (peranan)) {
        Return ResponseEntity.OK ("Hello" pengguna ", anda mempunyai akses admin!");
    } else {
        kembali responseEntity.status (403) .body ("kebenaran tidak mencukupi");
    }
}

Nasihat Keselamatan

• Pengurusan Utama : Jangan Kunci Hardcode dalam Kod, Gunakan Pembolehubah Alam Sekitar atau Pusat Konfigurasi
• Masa tamat tempoh : Tetapkan masa tamat tempoh dengan munasabah. Adalah disyorkan untuk menggunakan token jangka pendek apabila operasi sensitif.
• Refresh Token : Boleh meningkatkan pengalaman pengguna dengan mekanisme Token Refresh
• Https : pastikan keselamatan lapisan pengangkutan dan menghalang token daripada dicuri
• Elakkan maklumat sensitif : Jangan simpan data sensitif seperti kata laluan dalam muatan JWT

Meringkaskan

Menggunakan JWT untuk melaksanakan pengesahan dan kebenaran di Java tidak rumit, inti adalah:

• Menjana tanda selepas log masuk dengan jayanya
• Pelanggan membawa permintaan token
• Pelayan mengesahkan token melalui penapis dan mengekstrak maklumat pengguna
• Melaksanakan kawalan kebenaran mengikut peranan

Mekanisme ini sesuai untuk seni bina yang diedarkan dan microservice, mengelakkan overhead sesi penyimpanan pelayan.

Pada dasarnya semua ini, tidak rumit tetapi mudah untuk mengabaikan butiran, seperti pengendalian pengecualian dan keselamatan utama.

Atas ialah kandungan terperinci Pengesahan dan kebenaran Java dengan JWT. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!