系统安全与加密算法：三方安全测试问题修复

已于 2024-01-17 09:53:23 修改
阅读量360 收藏 5
点赞数 6
分类专栏： 安全架构 文章标签： 安全性测试 安全架构 java
于 2024-01-15 23:55:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46464597/article/details/135613507
版权
本文讨论了在第三方测试中针对系统安全的严格要求，重点关注了数据传输加密（如SM2、SM3、SM4）、非对称加密技术和安全架构5A方法论的应用。文章强调了在身份认证、授权、访问控制等环节采取的措施，以增强大型政府项目等场景下的数据安全性。
摘要由CSDN通过智能技术生成

第三方测试-系统安全测试问题

现在国内越来越重视系统安全，最近我们公司在做第三方测试过程中对系统安全、系统性能等做出了严格的要求，并进行了很大的整改，就从这篇文章开始总结一下最近三个月以及以后还会继续整改的涉及系统安全的相关测试漏洞的修改方案，相信这些问题会帮助到大家，尤其是比较大型的政府项目，对系统安全更加注重。

在互联网和新兴技术高速发展的今天，数据信息充斥在各行各业中，并发挥着重要的作用。然而，在享受信息化时代带来便利的同时，数据安全问题也成为大家关注的焦点。无论是从toG、toB、toC的各业务场景来看，还是从网络安全（CyberSecurity）的架构来看，数据安全（DataSecurity）都是一个主要的组成部分，而且在新兴技术日新月异的数据时代变得越来越重要，范围也越来越大。
------- 引自 《数据安全架构设计与实战》

安全架构5A方法论

无论是进行产品的安全架构设计或评估，还是规划安全技术体系架构的时候，都有几个需要重点关注的逻辑模块，它们可以在逻辑上视为安全架构的核心元素。
以应用/产品为例，核心元素包括：
■ 身份认证（Authentication）：用户主体是谁？
■ 授权（Authorization）：授予某些用户主体允许或拒绝访问客体的权限。
■ 访问控制（Access Control）：控制措施以及是否放行的执行者。
■ 可审计（Auditable）：形成可供追溯的操作日志。
■ 资产保护（Asset Protection）：资产的保密性、完整性、可用性保障

关于数据安全方面

我们在测试过程中涉及到了对数据传输加密、数据存储加密、对称加密、非对称加密、SM2、SM3、SM4国密加密，CA证书等等

什么是非对称加密呢？

非对称加密是一种密码学技术，与传统的对称加密不同，它使用一对密钥来进行加密和解密操作，这对密钥分别称为公钥和私钥。这两个密钥是数学上相关联的，但却不能通过已知一个密钥来轻松地推导出另一个密钥。

我们可以想象一下，就像你有一把锁和一把钥匙，任何人都可以得到这把锁，但只有你有这把唯一的钥匙。任何人都可以使用这把锁将信息锁住，但只有你能够使用你的独特的钥匙来解锁这个信息。

  • 公钥： 就像是一个开放的锁，任何人都可以获得。它用于加密信息，只有拥有与之相关的私钥的人才能解密。
  • 私钥： 这是与公钥相关联的唯一的解锁密钥，只有密钥的拥有者才能解密用公钥加密的信息。

举例来说，考虑用户密码的存储问题。通过非对称加密的方式，可以将用户密码加密后写入数据库。当用户再次登录时，系统将客户端输入的明文密码使用相同的非对称加密方式加密，然后与数据库中的密文进行比对。这样的设计大大提高了安全性，即使数据库被攻击，攻击者也无法轻松获取用户的明文密码。
国密SM2加密方式就是非对称加密的。下面是国密SM2加密工具的源码：

/*椭圆曲线非对称加密算法*/
public class SM2Util {

    public static final String key_pubk= "pub";
    public static final String key_prik= "pri";

    private static SM2 sm2 = SM2.instance();

	private static final String DEFAULT_PRIVATE_KEY = "27cd96b1500f8330fc523e7c47ef02a";
	private static final String DEFAULT_PUBLIC_KEY = "047ec86bb18f57714e6c5c72383c5b122";

	/**
	 * 生成公私钥
	 * @return
	 */
    public static Map<String,String> generateKeyPair() {
        Map<String,String> result = new HashMap<>();
        AsymmetricCipherKeyPair key = sm2.eccKeyPairGenerator.generateKeyPair();

        BigInteger privateKey = ((ECPrivateKeyParameters)key.getPrivate()).getD();
        ECPoint publicKey = ((ECPublicKeyParameters)key.getPublic()).getQ();

        String pubk = new String(Hex.encode(publicKey.getEncoded(false)), StandardCharsets.UTF_8);
        String prik = new String(Hex.encode(privateKey.toByteArray()), StandardCharsets.UTF_8);


        result.put(key_pubk, pubk);
        result.put(key_prik, prik);

        return result;
    }

    /**
     * 获取默认公钥
     * @return
     */
    public static String getDefaultPublicKey() {
    	return DEFAULT_PUBLIC_KEY;
    }

    /**
     * 获取默认私钥
     * @return
     */
    public static String getDefaultPrivateKey() {
    	return DEFAULT_PRIVATE_KEY;
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    protected static byte[] encrypt(String data, byte[] publicKey) {
    	if (StringUtils.isBlank(data)) {
    		return null;
    	}


    	SM2Cipher cipher = new SM2Cipher();

    	// C1
    	byte[] c1Bytes = new byte[65];
    	ECPoint c1 = cipher.encryptInit(sm2, sm2.eccCurve.decodePoint(publicKey));
    	c1Bytes = c1.getEncoded(false);

        // C2
        byte[] c2Bytes = data.getBytes(StandardCharsets.UTF_8);
        cipher.encrypt(c2Bytes);

        // C3
        byte[] c3Bytes = new byte[32];
        cipher.doFinal(c3Bytes);

        byte[] encryptData = new byte[c1Bytes.length + c2Bytes.length + c3Bytes.length];
		System.arraycopy(c1Bytes, 0, encryptData, 0, c1Bytes.length);
		System.arraycopy(c2Bytes, 0, encryptData, c1Bytes.length, c2Bytes.length);
		System.arraycopy(c3Bytes, 0, encryptData, c1Bytes.length + c2Bytes.length, c3Bytes.length);

        return encryptData;
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static byte[] encrypt(String data, String publicKey) {
    	return encrypt(data, HexUtil.hexToByte(publicKey));
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static byte[] encrypt(byte[] data, String publicKey) {
    	return encrypt(new String(data, StandardCharsets.UTF_8), HexUtil.hexToByte(publicKey));
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static String encryptToHexString(String data, String publicKey) {
    	return HexUtil.byteToHex(encrypt(data, HexUtil.hexToByte(publicKey)));
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static String encryptToHexString(byte[] data, String publicKey) {
    	return HexUtil.byteToHex(encrypt(new String(data, StandardCharsets.UTF_8), HexUtil.hexToByte(publicKey)));
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    protected static byte[] decrypt(byte[] encryptedData, byte[] privateKey) {
    	if (ArrayUtils.isEmpty(encryptedData)) {
    		return null;
    	}


    	SM2Cipher cipher = new SM2Cipher();

        // C1
        byte[] c1Bytes = new byte[65];
        System.arraycopy(encryptedData, 0, c1Bytes, 0, c1Bytes.length);
        ECPoint c1 = sm2.eccCurve.decodePoint(c1Bytes).normalize();

        // C3
        byte[] c3Bytes = new byte[32];
        System.arraycopy(encryptedData, encryptedData.length - 32, c3Bytes, 0, 32);

        // C2
        int c2Len = encryptedData.length - 65 - 32;
        byte[] c2Bytes = new byte[c2Len];
        System.arraycopy(encryptedData, 65, c2Bytes, 0, c2Len);

        cipher.decryptInit(new BigInteger(1, privateKey), c1);
        cipher.decrypt(c2Bytes);
        cipher.doFinal(c3Bytes);
        return c2Bytes;
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    public static byte[] decrypt(byte[] encryptedData, String privateKey) {
    	return decrypt(encryptedData, HexUtil.hexToByte(privateKey));
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    public static String decryptToString(byte[] encryptedData, String privateKey) {
    	return new String(decrypt(encryptedData, HexUtil.hexToByte(privateKey)), StandardCharsets.UTF_8);
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    public static String decryptToString(String encryptedData, String privateKey) {
    	return new String(decrypt(Hex.decode(encryptedData), HexUtil.hexToByte(privateKey)), StandardCharsets.UTF_8);
    }
}

此外，CA（Certificate Authority，证书颁发机构）机构通常也使用非对称加密的方式来确保数字证书的安全性。CA机构在数字证书颁发过程中起到了信任的中介角色，其操作基于公钥基础设施（PKI）。

下面是CA机构使用非对称加密的一般流程：

  1. 证书请求： 实体（通常是个人或组织）向CA机构提交证书请求，请求包括实体的公钥和一些身份信息。
  2. 验证身份： CA机构对证书请求中的身份信息进行验证，确保请求者确实拥有所声明的身份。这可以通过一系列验证步骤来完成。
  3. 颁发数字证书： 验证通过后，CA机构使用自己的私钥对实体的公钥和身份信息进行签名，生成数字证书。这个签名过程就是使用非对称加密，其中CA的私钥用于签署证书信息。
  4. 证书分发： CA机构将生成的数字证书发送给请求者，同时可以将证书公开发布到公共目录中，以便其他人可以验证证书的真实性。
  5. 证书验证： 在通信过程中，当其他人需要验证实体的身份时，他们可以使用CA机构公开的公钥来验证数字证书的签名。如果验证通过，就可以信任该数字证书所附的公钥。

非对称加密的优势在于它提供了更高的安全性。即使在公共环境下传输公钥，也无法通过公钥轻松计算出私钥。这使得非对称加密在安全地实现身份验证、数字签名和加密通信等场景中发挥重要作用。

相对的，什么是对称加密呢？

对称加密是一种加密算法，它使用相同的密钥同时进行数据的加密和解密。这意味着在对称加密中，使用加密和解密操作的相同密钥。对称加密算法在加密和解密的过程中都使用相同的密钥，因此密钥的保管和分发变得至关重要。
我们了解的国密SM4就是采用的对称加密的方式实现的，源码工具如下：

/**
 * （分组密码算法）国密对称加密算法
 */
@Slf4j
public abstract class SM4Util {

	static {
        Security.addProvider(new BouncyCastleProvider());
    }

    private static final Charset ENCODING = StandardCharsets.UTF_8;

    public static final String ALGORITHM_NAME = "SM4";

    // 加密算法/分组加密模式/分组填充方式
    public static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS5Padding";

    public static final String ALGORITHM_NAME_CBC_PADDING = "SM4/CBC/PKCS5Padding";

    // 128-32位16进制；256-64位16进制
    public static final int DEFAULT_KEY_SIZE = 128;

    public static final String DEFAULT_KEY = "86C63180C2806ED1F47B859DE501215B";
    public static final String DEFAULT_IV = "8F5CB6272B594B53AD1A2197361378DC";

    private static Cipher generateCipherECB(String algorithmName, int mode, byte[] key) throws Exception {
        Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);
        cipher.init(mode, new SecretKeySpec(key, ALGORITHM_NAME));
        return cipher;
    }

    private static Cipher generateCipherCBC(String algorithmName, int mode, byte[] key, byte[] iv) throws Exception {
        Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);
        cipher.init(mode, new SecretKeySpec(key, ALGORITHM_NAME), new IvParameterSpec(iv));
        return cipher;
    }
    public static String generateKey() {
        try {
			return HexUtil.byteToHex(generateKey(DEFAULT_KEY_SIZE));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
        return null;
    }

    public static byte[] generateKey(int keySize) throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
        kg.init(keySize, new SecureRandom());
        return kg.generateKey().getEncoded();
    }

    protected static byte[] encryptECBPadding(byte[] data, byte[] key) throws Exception {
        Cipher cipher = generateCipherECB(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);
        return cipher.doFinal(data);
    }

	protected static byte[] decryptECBPadding(byte[] encrypted, byte[] key) throws Exception {
	    Cipher cipher = generateCipherECB(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);
	    return cipher.doFinal(encrypted);
	}

    protected static byte[] encryptCBCPadding(byte[] data, byte[] key, byte[] iv) throws Exception {
        Cipher cipher = generateCipherCBC(ALGORITHM_NAME_CBC_PADDING, Cipher.ENCRYPT_MODE, key, iv);
        return cipher.doFinal(data);
    }

	protected static byte[] decryptCBCPadding(byte[] encrypted, byte[] key, byte[] iv) throws Exception {
	    Cipher cipher = generateCipherCBC(ALGORITHM_NAME_CBC_PADDING, Cipher.DECRYPT_MODE, key, iv);
	    return cipher.doFinal(encrypted);
	}

    public static String encrypt(String source) {
        return encrypt(source, DEFAULT_KEY);
    }
    public static String encrypt(byte[] source) {
        return encrypt(source, DEFAULT_KEY);
    }
    public static String encrypt(String source, String hexKey) {
        return encrypt(source.getBytes(ENCODING), hexKey);
    }
    public static String encrypt(byte[] source, String hexKey) {
        byte[] cipherArray;
		try {
			cipherArray = encryptECBPadding(source, ByteUtils.fromHexString(hexKey));
			return ByteUtils.toHexString(cipherArray);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}

        return null;
    }
    public static byte[] decrypt(String encrypted) {
		return decrypt(encrypted, DEFAULT_KEY);
    }
    public static String decryptToString(String encrypted) {
		return decryptToString(encrypted, DEFAULT_KEY);
    }
    public static String decryptToString(String encrypted, String hexKey) {
		return new String(decrypt(encrypted, hexKey), ENCODING);
    }
    public static byte[] decrypt(String encrypted, String hexKey) {
		try {
			return decryptECBPadding(ByteUtils.fromHexString(encrypted), ByteUtils.fromHexString(hexKey));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return encrypted.getBytes(StandardCharsets.UTF_8);
    }
    public static String encrypt(String source, String hexKey, String iv) {
        return encrypt(source.getBytes(ENCODING), hexKey, iv);
    }
    public static String encrypt(byte[] source, String hexKey, String iv) {
        byte[] cipherArray;
		try {
			cipherArray = encryptCBCPadding(
							source
							, ByteUtils.fromHexString(hexKey)
							, ByteUtils.fromHexString(iv));
			return ByteUtils.toHexString(cipherArray);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new RuntimeException("数据加密失败", e);
		}
    }
    public static String decryptToString(String encrypted, String hexKey, String iv) {
		return new String(decrypt(encrypted, hexKey, iv), ENCODING);
    }

    public static byte[] decrypt(String encrypted, String hexKey, String iv) {
		try {
			if (StringUtils.isBlank(encrypted)) {
				return new byte[] {};
			}

			return decryptCBCPadding(
				 	ByteUtils.fromHexString(encrypted)
					, ByteUtils.fromHexString(hexKey)
					, ByteUtils.fromHexString(iv));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return encrypted.getBytes(StandardCharsets.UTF_8);
    }
}

相信你也一定听过国密SM3算法，它是对称加密还是非对称加密呢？
其实SM3是一种密码杂凑算法，用于生成消息的哈希值，主要用于数据完整性验证、数字签名等场景，而不是进行加密和解密操作。所以它既不是对称加密也不是非对称加密，它常常与SM2与SM4组合一起使用，可以把它看成一个随机数。
例如：
系统数据存储加密应采用SM3+SM4的实现方式。
系统数据传输加密应采用SM2+SM3的实现方式。

总结
在系统安全测试中，我们通过采用多层加密算法、合理的安全架构设计以及严格的数据安全措施，提高了系统在身份认证、授权、访问控制、审计和资产保护等方面的安全性。这有助于在互联网和新兴技术时代中更好地处理数据安全问题，特别适用于大型政府项目等对安全性要求较高的场景。数据安全相关的知识属于另一个领域了，知识点真是深不可测，还需要平时多学习，积累更多的知识储备才行。

季同学 `
关注
专栏目录
山东大学软件工程应用与实践——GMSSL开源库（十二）——浅尝SM3
m0_51588039的博客
11-26 4321
2021SC@SDUSC 标题先介绍一下HASH吧SM3算法大致过程GMSSL中SM3算法的实现小结 先介绍一下HASH吧 Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。（来自百度百科） 哈希函数由于其
原生加密：腾讯云数据安全中台解决方案
colorfulyan的博客
08-14 3688
导语 | 数据安全问题既是技术问题，也是管理问题。本文是对腾讯安全云鼎实验室专家姬生利老师在云+社区沙龙online的分享整理，从技术角度剖析当前国内数据安全面临的难题及密码应用现状，并带来腾讯数据安全解决方案和云密码应用最佳实践解析，帮助大家构建安全有效的数据管理策略。 一、 企业数据安全风险和国内密码应用现状 随着企业上云和数字化转型升级的深化，数据正在成为企业的核心资产之一，在生产过程中发挥的价值越来越大。 近几年大规模的数据泄露事件频发，外部威胁和内部威胁左右夹击，由内部威胁带来的大规模数据泄露.
数字政府应用场景中数据安全体系
securitypaper的博客
08-27 1776
数字政府是全面数字化发展的基础性、先导性工程，在促进数字经济、建设数字社会、完善数字生态中起到关键的引领作用。加强数字政府建设是创新政府治理理念和方式的重要举措，对加快转变政府职能，建设法治政府、廉洁政府、服务型政府意义重大。近年来，我国数字政府建设取得显著成效，以数字化促改革、以数字化助决策、以数字化提服务的理念不断深入人心...
信息安全如此重要，国密算法（SM3）终于支持
weixin_37097605的博客
09-04 3966
作者简介惠春阳Intel 软件工程师，主要从事spdk，isa-l开发和存储软件性能优化的工作。· · ·国密算法.SM3生活在信息时代的我们， 无时无刻不在产生和消费数...
sm3摘要算法python_Modbus TCP/IP协议安全加固关键技术研究与实现
weixin_39793189的博客
12-15 349
摘要：工业控制系统广泛应用于化工,核电,制造,交通等关键领域,其安全问题关系到国计民生.工业控制系统通信协议安全机制不健全已经成为"工业4.0","中国制造2025"以及两化融合进程推进的瓶颈.因此,对工业控制系统通信协议安全性进行研究具有重要意义.本文聚焦在工业控制系统中广泛应用的Modbus TCP/IP协议安全加固,对其存在的数据包缺乏完整性检测,认证,授权以及机密性保护进行研究,提出了一种...
境外支付系统：警惕金融风险之安全测试实践
OKCRoss的博客
08-13 681
碍于篇幅长度，今天我们只能介绍金融领域内安全测试的冰山一角，以上的这些内容是关于境外支付系统安全测试中的相关基础测试关注点与内容。在之后的文章中，我将会大家带来更多安全测试下的境外支付系统的实践经验与个人看法。
国内首家商密OS重磅发布，Anolis商密版OS为用户数据保驾护航
weixin_60347558的博客
09-26 266
金秋九月，继龙蜥操作系统（Anolis OS）之后，Anolis 商密 Beta 版正式出炉，Anolis 商密版 OS 是国内首家从操作系统层面提供商用密码的 OS 解决方案。商用密码是由国家密码管理局组织制定的密码标准，作为中国自主研发可控的密码算法，对于保护国内数据和网络安全是至关重要的。密码算法是保障信息和数据安全的核心技术，随着近年来外部的国际贸易冲突和技术封锁...
密码应用安全性评估-应用层国密改造
热门推荐
Hyacinth12138的博客
09-06 1万+
密码应用安全性评估-应用层国密改造参考
鉴权认证串authorization
小博要变强啊~
08-18 453
签名头signedHeaders 的作用是，告知 YOP 平台请求中的哪些标头是签名过程的一部分以及在验证请求时 YOP 平台可以忽略哪些标头（例如，由代理添加的任何附加标头）。简单来说，签名主要包含两个过程：摘要和非对称加密，首先对需要签名的数据做摘要（类似于常见的MD5）后得到摘要结果，然后通过签名者的私钥对摘要结果进行非对称加密即可得到签名结果。签名过程是，商户用摘要算法对规范请求canonicalRequest 生成摘要，然后用自己的私钥对这个摘要进行加密，得到的就是签名signature。
【系统架构设计师】案例专题六（8大系统架构设计之7）： 安全架构设计考点梳理
数据知道的博客
10-13 156
安全架构是架构面向安全性方向上的一种细分，可关注三个安全方面，即产品安全架构、安全技术体系架构和审计架构， 这三个方面可组成三道安全防线。信息的可用性、完整性、机密性、可控性和不可抵赖性等安全保障尤为重要如果安全性体现在产品上，那么，通常的产品安全架构、安全技术体系架构和审计架构可组成三道安全防线。(1)产品安全架构: 构建产品安全质量属性的主要组成部分以及它们之间的关系。产品安全架构的目标是如何在不依赖外部防御系统的情况下，从源头打造自身安全的产品。(2)安全技术体系架构。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1404
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
spring task的使用场景
qq_40603125的博客
10-13 96
spring任务调度框架约定的时间。
Backend - Java 基础
是萝卜干呀的博客
10-11 555
知识量决定了未来能走多远
Netty 相比原生IO模型的优势
lssffy的博客
10-09 629
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Hex编码
weixin_74305514的博客
10-13 92
emps;是一种将数据转换为十六进制表示的方法。Hex编码使用16个字符来表示数据。&emps;
Spring Boot 整合 Minio
cmh1008611的博客
10-09 920
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
初始Python篇（2）——逻辑控制、序列
最新发布
我要学编程的博客
10-14 815
程序的组织结构：顺序、选择、循环 pass空语句 猜数字小游戏 序列、序列相关操作
超混沌系统双图关联加密算法：提升安全与效率
本文介绍了一种创新的图像加密技术，即基于超混沌系统的双图关联加密算法，旨在解决现有混沌图像加密算法中的安全性和效率问题。传统混沌图像加密算法往往面临系统安全性不足、易受明文攻击、加密图像独立以及效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值