久久久精品免费看美女,成人免费毛片???网站

前段時間再看關(guān)于JDK算法相關(guān)的知識時，看到很多與jdk中security包下的模塊有一定關(guān)聯(lián)，之前對這塊一直沒有關(guān)注，趁此機(jī)會先做個簡單的了解。

本文旨在深入探討Java的Security技術(shù)，包括其核心概念、關(guān)鍵模塊以及具體應(yīng)用。通過詳細(xì)分析，希望幫助讀者更好地理解如何在Java應(yīng)用程序中實(shí)現(xiàn)安全防護(hù)，提高系統(tǒng)的可靠性和穩(wěn)定性。

主要功能包括授權(quán)、訪問控制、數(shù)據(jù)加密、身份驗(yàn)證等

核心模塊

授權(quán)與訪問控制
Java Security提供了一套完整的授權(quán)和訪問控制機(jī)制，包括基于角色的訪問控制、基于聲明的訪問控制、自定義訪問控制等。這些機(jī)制可以有效地保護(hù)系統(tǒng)資源，防止未經(jīng)授權(quán)的訪問。
數(shù)據(jù)加密與解密
Java Security提供了豐富的加密算法，如AES、RSA等，用于對敏感數(shù)據(jù)進(jìn)行加密和解密。通過使用這些算法，我們可以保護(hù)數(shù)據(jù)的安全性，防止數(shù)據(jù)泄露。
身份驗(yàn)證與授權(quán)
身份驗(yàn)證是確認(rèn)用戶身份的過程，授權(quán)則是確定用戶是否有權(quán)執(zhí)行某項(xiàng)任務(wù)。Java Security提供了各種身份驗(yàn)證和授權(quán)機(jī)制，如用戶名密碼驗(yàn)證、數(shù)字證書驗(yàn)證等，以滿足不同場景的需求。
安全套接字層（SSL）與傳輸層安全（TLS）
SSL和TLS是用于在通信過程中保證數(shù)據(jù)傳輸安全的協(xié)議。Java Security提供了SSL和TLS的實(shí)現(xiàn)，可用于構(gòu)建安全的網(wǎng)絡(luò)通信。

授權(quán)與訪問控制

Java提供了對敏感信息的訪問控制功能，比如本地文件，類方法等的訪問約束，以此來組建安全的代碼框架

先看一個文件寫入的示例：

定義policy

grant {
    permission com.sucl.blog.security.jdk.control.UserResourcePermission "read";
}

編寫測試類

public class FileAccessController {

    static {
//       -Djava.security.manager
        System.setSecurityManager( new SecurityManager() );
    }

    public static void main(String[] args) throws IOException {
        SecurityManager securityManager = System.getSecurityManager();
        if( securityManager == null ){
            System.out.println("執(zhí)行文件寫入1");
            writeHello("hello");
        }else{
            System.out.println("執(zhí)行文件寫入2");
            AccessController.doPrivileged(new PrivilegedAction< Object >() {
                @Override
                public Object run() {
                    try {
                        writeHello("world");
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    return null;
                }
            }, AccessController.getContext());
        }
    }

    private static void writeHello(String text) throws IOException {
        FileOutputStream fos = new FileOutputStream("e:homeile.txt", true);
        PrintWriter pw = new PrintWriter(fos);
        pw.println(text);
        pw.close();
        fos.close();
    }

}

測試 cd 到target/classes

java -D"java.security.policy=pathfile.policy"  com.sucl.blog.security.jdk.control.file.FileAccessController

上面的例子中如果沒有定義policy時，如果調(diào)用文件寫入方法，此時會拋出異常

java.security.AccessControlException: access denied ("java.io.FilePermission" "e:homefile.txt" "write")

這樣通過自定義polic編寫權(quán)限策略，則可以實(shí)現(xiàn)對資源訪問控制的效果。

如果看spring的源代碼，你會發(fā)現(xiàn)有很多類似AccessController.doPrivileged這樣的寫法，不知道當(dāng)時有沒考慮過其目的，雖然在調(diào)試時發(fā)現(xiàn)其根本沒有執(zhí)行

數(shù)據(jù)加密與解密

Java Security API提供了可互操作的算法和安全服務(wù)的實(shí)現(xiàn)。服務(wù)以provider的形式實(shí)現(xiàn)，可以以插件的形式植入應(yīng)用程序中。程序員可以透明地使用這些服務(wù)，如此使得程序員可以集中精力在如何把安全組件集成到自己的應(yīng)用程序中，而不是去實(shí)現(xiàn)這些安全功能。此外，除了Java提供的安全服務(wù)外，用戶可以編寫自定義的security provider，按需擴(kuò)展Java的security平臺。

算法

Message digest algorithms 【信息摘要算法, 如：MD5】 Digital signature algorithms 【數(shù)字簽名算法，DSA】 Symmetric bulk encryption 【對稱塊加密，如：DES】 Symmetric stream encryption 【對稱流加密，如：RC4】 Asymmetric encryption 【非對稱加密，如：RSA】 Password-based encryption (PBE) 【密碼加密】 Elliptic Curve Cryptography (ECC) 【橢圓曲線加密】 Key agreement algorithms 【key協(xié)議算法】 Key generators 【key生成器】 Message Authentication Codes (MACs) 【消息認(rèn)證碼】 (Pseudo-)random number generators 【偽隨機(jī)數(shù)生成器】

示例

Java內(nèi)置的Provider提供了許多通用的密碼算法，比如：RSA, DSA, ECDSA等簽名算法、DES, AES, ARCFOUR等加密算法、MD5, SHA-1, SHA-256等信息摘要算法、還有Diffie-Hellman和ECDH這樣的密鑰協(xié)商算法。下面簡單的實(shí)現(xiàn)了MD5、DES、RSA幾個我們常用的算法

MD5

public class MD5 {

   private static final Charset DEFAULT_CHARSET = Charset.defaultCharset();

   static MessageDigest messageDigest;

   static {
      try {
         messageDigest = MessageDigest.getInstance("MD5");
      } catch (NoSuchAlgorithmException e) {
         throw new RuntimeException(e);
      }
   }
}

DES

public class DES {

    private static final String DES = "DES";

    private static final int DEFAULT_ENCRYPT_CHUNK = 245;

    private static final int DEFAULT_DECRYPT_CHUNK = 256;

    private String salt;

    private SecretKey secretKey;

    public DES(String salt){
        this.salt = salt;
        initKey();
    }

    public void initKey(){
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance(DES);
            SecureRandom secureRandom = new SecureRandom(salt.getBytes());
            keyGenerator.init(secureRandom);
            this.secretKey = keyGenerator.generateKey();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    public String encrypt(String text){
        try {
            Cipher cipher = Cipher.getInstance(DES);
            cipher.init(Cipher.ENCRYPT_MODE, this.secretKey);

            byte[] codes = text.getBytes();
            int length = codes.length;

            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int check = 0;
            byte[] cache ;
            while (check < length){
                int chunk = Math.min(DEFAULT_ENCRYPT_CHUNK, length-check);
                cache = cipher.doFinal(codes, check, chunk);
                check += chunk;
                out.write(cache, 0, cache.length);
            }
            return Base64.getEncoder().encodeToString(out.toByteArray());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public String decrypt(String text){
        try {
            Cipher cipher = Cipher.getInstance(DES);
            cipher.init(Cipher.DECRYPT_MODE, this.secretKey);

            byte[] base64Text = Base64.getDecoder().decode(text);

            int length = base64Text.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int check = 0;
            byte[] cache ;
            while (check < length){
                int chunk = Math.min(DEFAULT_DECRYPT_CHUNK, length-check);
                cache = cipher.doFinal(base64Text, check, chunk);
                check += chunk;
                out.write(cache, 0, cache.length);
            }
            return new String(out.toByteArray());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

RSA

@Slf4j
public class RSA {

    private static final String KEY_ALGORITHM = "RSA";
    private static final int KEY_PAIR_SIZE = 2048;
    /**
     * 不大于245
     */
    private static final int DEFAULT_ENCRYPT_CHUNK = 245;
    /**
     * 不大于256，改成其他值時：Decryption error
     */
    private static final int DEFAULT_DECRYPT_CHUNK = 256;

    /**
     * NONEwithRSA
     * MD5withRSA
     * SHA256withRSA
     */
    private static final String SIGN_ALGORITHM = "SHA256withRSA";
    private static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";

    private KeyPair keyPair;

    public RSA() {
        this.keyPair = getKeyPair();
    }

    /**
     * 生成公鑰、私鑰
     * @param key
     * @return
     */
    private KeyPair getKeyPair(){
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            keyPairGen.initialize(KEY_PAIR_SIZE);
            return keyPairGen.generateKeyPair();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 獲取公鑰
     * @param base64PublicKey base64編碼的值 基于KeyPair公鑰
     * @return
     */
    private PublicKey getPublicKey(String base64PublicKey){
        try {
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            KeySpec keySpec = new X509EncodedKeySpec(hexToBytes(base64PublicKey)); //
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            return publicKey;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 獲取私鑰
     * @param base64PrivateKey base64編碼的值 基于KeyPair私鑰
     * @return
     */
    private PrivateKey getPrivateKey(String base64PrivateKey){
        try {
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//            Security.addProvider(BouncyCastleProviderSingleton.getInstance());
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(hexToBytes(base64PrivateKey));
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            return privateKey;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public String getPublicKey(){
        return bytesToHex(keyPair.getPublic().getEncoded());
    }

    public String getPrivateKey(){
        return bytesToHex(keyPair.getPrivate().getEncoded());
    }

    /**
     * 通過私鑰簽名
     * @param data
     * @param privateKeyStr
     * @return
     */
    public String sign(byte[] data){
        PrivateKey privateKey = getPrivateKey(getPrivateKey());
        try {
            Signature sig = Signature.getInstance(SIGN_ALGORITHM);
            sig.initSign(privateKey);
            sig.update(data);
            return bytesToHex(sig.sign());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 校驗(yàn)簽名
     * @param data
     * @param sign
     * @param publicKeyStr
     * @return
     */
    public boolean verify(byte[] data, String sign){
        PublicKey publicKey = getPublicKey(getPublicKey());
        try {
            Signature sig = Signature.getInstance(SIGN_ALGORITHM);
            sig.initVerify(publicKey);
            sig.update(data);
            return sig.verify(hexToBytes(sign));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 通過公鑰加密
     * @param text
     * @param publicKey
     * @return
     */
    public String encrypt(String text){
        byte[] codes = text.getBytes();
        PublicKey publicKey = getPublicKey(getPublicKey());
        try {
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            int length = codes.length;

            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int check = 0;
            byte[] cache ;
            while (check < length){
                int chunk = Math.min(DEFAULT_ENCRYPT_CHUNK, length-check);
                cache = cipher.doFinal(codes, check, chunk);
                check += chunk;
                out.write(cache, 0, cache.length);
            }
            return bytesToHex(out.toByteArray());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 通過私鑰解密
     * @param text 加密內(nèi)容
     * @param privateKeyStr
     * @return
     */
    public String decrypt(String text){
        PrivateKey privateKey = getPrivateKey(getPrivateKey());
        try {
            byte[] base64Text = hexToBytes(text);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);

            int length = base64Text.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int check = 0;
            byte[] cache ;
            while (check < length){
                int chunk = Math.min(DEFAULT_DECRYPT_CHUNK, length-check);
                cache = cipher.doFinal(base64Text, check, chunk);
                check += chunk;
                out.write(cache, 0, cache.length);
            }
            return new String(out.toByteArray());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public byte[] hexToBytes(String str){
        return Base64.getDecoder().decode(str);
    }

    public String bytesToHex(byte[] bytes){
        return Base64.getEncoder().encodeToString(bytes);
    }
}

身份驗(yàn)證與授權(quán)

客戶端向服務(wù)器發(fā)送身份驗(yàn)證請求。服務(wù)器隨機(jī)生成一個挑戰(zhàn)參數(shù)，發(fā)送給客戶端。客戶端使用挑戰(zhàn)參數(shù)和密碼計算出響應(yīng)參數(shù)，并將響應(yīng)參數(shù)發(fā)送給服務(wù)器。服務(wù)器使用挑戰(zhàn)參數(shù)、用戶名和密碼計算出期望的響應(yīng)參數(shù)，并將其與客戶端發(fā)送的響應(yīng)參數(shù)進(jìn)行比較，以驗(yàn)證客戶端的身份。

身份認(rèn)證

import javax.security.auth.login.LoginContext;

public class App {

   public static void main(String[] args) {
      URL url = ClassLoader.getSystemClassLoader().getResource("jaas.config");
      System.setProperty("java.security.auth.login.config", url.getPath());

      Subject subject = new Subject();
      subject.getPrincipals().add(new User("admin"));
      
      LoginContext loginContext = new LoginContext("app", subject);
      
      loginContext.login();
   }

}

AppLoginModule

@Slf4j
public class AppLoginModule implements LoginModule {

    @Override
    public void initialize(Subject subject, CallbackHandler callbackHandler, Map< String, ? > sharedState, Map< String, ? > options) {
        log.info("initialize");
        // 基于配置構(gòu)建認(rèn)證環(huán)境
    }

    @Override
    public boolean login() throws LoginException {
        log.info("login");
        return true;
    }

    @Override
    public boolean commit() throws LoginException {
        log.info("commit");
        return true;
    }

    @Override
    public boolean abort() throws LoginException {
        log.info("abort");
        return false;
    }

    @Override
    public boolean logout() throws LoginException {
        log.info("logout");
        return false;
    }
}

jaas.config，放到classpath即可

app {
    com.sucl.blog.security.jdk.auth.AppLoginModule required
    useTicketCache=true
    doNotPrompt=true;
};

相關(guān)這塊知識在網(wǎng)上找了一圈，發(fā)現(xiàn)很少有人講到，在編寫示例準(zhǔn)備讓文心一言給出點(diǎn)提示，發(fā)現(xiàn)它只會傻傻的坑我，由于時間原因這塊內(nèi)容也沒有過多的深入，通過關(guān)鍵接口的實(shí)現(xiàn)，可以看到，在很多成熟的項(xiàng)目中都有被用到，可能jdk本身的模塊更多是應(yīng)用在構(gòu)建基礎(chǔ)系統(tǒng)架構(gòu)中吧。

常用工具類

java.security 包是 Java 安全框架的核心部分，上面說到它提供了各種類和接口來支持加密、解密、簽名、驗(yàn)證等安全操作。下面簡單羅列了常用的工具類及其使用場景。

KeyPairGenerator 和 KeyPair：
- KeyPairGenerator 是用于生成公鑰和私鑰對的類。它提供了生成 RSA、DSA 等算法的密鑰對的接口。
- KeyPair 是由公鑰和私鑰組成的鍵對類。它包含公鑰和私鑰的信息，并提供了操作密鑰的方法。
- 使用場景：用于實(shí)現(xiàn)基于公鑰加密和數(shù)字簽名的安全通信，保證數(shù)據(jù)傳輸?shù)陌踩院蜕矸蒡?yàn)證的準(zhǔn)確性。
Certificate 和 CertificateFactory：
- Certificate 是表示證書的類。它提供了證書的基本信息，如頒發(fā)者、持有者、有效期等。
- CertificateFactory 是用于處理證書的類。它提供了解析證書的接口，可以將證書從各種格式轉(zhuǎn)換為 Certificate 對象。
- 使用場景：用于驗(yàn)證遠(yuǎn)程身份，確保數(shù)據(jù)傳輸?shù)陌踩?。常用?HTTPS 等安全協(xié)議中驗(yàn)證服務(wù)器證書。
AlgorithmParameters 和 AlgorithmParameterGenerator：
- AlgorithmParameters 是用于處理加密算法參數(shù)的類。它提供了獲取和設(shè)置加密算法參數(shù)的方法。
- AlgorithmParameterGenerator 是用于生成加密算法參數(shù)的類。它提供了生成特定加密算法參數(shù)的接口。
- 使用場景：用于增強(qiáng)加密算法的強(qiáng)度，提供更多的安全選項(xiàng)。例如，可以用于生成 RSA 加密算法中的密鑰長度和填充方式。
SecureRandom：
- SecureRandom 是用于生成隨機(jī)數(shù)的類。它提供了加密強(qiáng)度的隨機(jī)數(shù)生成器，生成的隨機(jī)數(shù)更加安全可靠。
- 使用場景：用于生成隨機(jī)數(shù)驗(yàn)證碼、隨機(jī)密鑰等，提高密碼安全性。還可以用于初始化加密算法中的隨機(jī)數(shù)生成器。
KeyStore：
- KeyStore 是用于管理密鑰和證書存儲的類。它提供了存儲和管理私鑰、公鑰證書等安全憑據(jù)的方法。
- 使用場景：用于管理應(yīng)用程序的安全憑據(jù)，如私鑰、公鑰證書等。可以用于存儲和管理用戶的密鑰對，保證數(shù)據(jù)的安全性。

除了上述模塊，java.security 包還包含其他與安全相關(guān)的類和接口，如權(quán)限、策略等。這些模塊提供了更細(xì)粒度的安全控制和配置選項(xiàng)，適用于各種安全場景。要了解全面的安全功能和用法，請參考 Java 官方文檔或相關(guān)資源。

總結(jié)

Java Security技術(shù)提供了全面的安全防護(hù)機(jī)制，包括授權(quán)、訪問控制、數(shù)據(jù)加密、身份驗(yàn)證等。通過深入了解和掌握這些技術(shù)，我們可以構(gòu)建更加安全、可靠的Java應(yīng)用程序。本文通過詳細(xì)介紹Java Security的核心模塊和代碼演示，旨在幫助讀者更好地理解和應(yīng)用這些技術(shù)。未來，隨著技術(shù)的不斷發(fā)展，Java Security將會不斷完善和改進(jìn)，為我們的應(yīng)用程序提供更加安全、可靠的保障。

聲明：本文內(nèi)容及配圖由入駐作者撰寫或者入駐合作網(wǎng)站授權(quán)轉(zhuǎn)載。文章觀點(diǎn)僅代表作者本人，不代表電子發(fā)燒友網(wǎng)立場。文章及其配圖僅供工程師學(xué)習(xí)之用，如有內(nèi)容侵權(quán)或者其他違規(guī)問題，請聯(lián)系本站處理。舉報投訴