Java加密技术（九）

小咪咪 2022-06-18 01:52 157阅读 0赞

在**[Java加密技术（八）][Java]**中，我们模拟了一个基于RSA非对称加密网络的安全通信。现在我们深度了解一下现有的安全网络通信——SSL。   
    我们需要构建一个由CA机构签发的有效证书，这里我们使用上文中生成的自签名证书**zlex.cer**   
    这里，我们将证书导入到我们的密钥库。

Shell代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  keytool -import -alias www.zlex.org -file d:/zlex.cer -keystore d:/zlex.keystore

其中   
\-import表示 **导入**   
\-alias指定别名，这里是 **www.zlex.org**   
\-file指定算法，这里是 **d:/zlex.cer**   
\-keystore指定存储位置，这里是 **d:/zlex.keystore**   
在这里我使用的密码为 **654321**   
  
控制台输出：

Console代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  输入keystore密码：  
2.  再次输入新密码:  
3.  所有者:CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN  
4.  签发人:CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN  
5.  序列号:4a1e48df  
6.  有效期: Thu May 28 16:18:39 CST 2009 至Wed Aug 26 16:18:39 CST 2009  
7.  证书指纹:  
8.           MD5:19:CA:E6:36:E2:DF:AD:96:31:97:2F:A9:AD:FC:37:6A  
9.           SHA1:49:88:30:59:29:45:F1:69:CA:97:A9:6D:8A:CF:08:D2:C3:D5:C0:C4  
10.          签名算法名称:SHA1withRSA  
11.          版本: 3  
12. 信任这个认证？ \[否\]：  y  
13. 认证已添加至keystore中

OK，最复杂的准备工作已经完成。   
接下来我们将域名 **www.zlex.org**定位到本机上。打开 **C:\\Windows\\System32\\drivers\\etc\\hosts**文件，将 **www.zlex.org**绑定在本机上。在文件末尾追加 **127.0.0.1       www.zlex.org**。现在通过地址栏访问 [http://www.zlex.org][http_www.zlex.org]，或者通过 **ping**命令，如果能够定位到本机，域名映射就搞定了。   
现在，配置tomcat。先将 **zlex.keystore**拷贝到tomcat的conf目录下，然后配置 **server.xml**。将如下内容加入配置文件

Xml代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  **<****Connector**  
2.      SSLEnabled="true"  
3.      URIEncoding="UTF-8"  
4.      clientAuth="false"  
5.      keystoreFile="conf/zlex.keystore"  
6.      keystorePass="123456"  
7.      maxThreads="150"  
8.      port="443"  
9.      protocol="HTTP/1.1"  
10.     scheme="https"  
11.     secure="true"  
12.     sslProtocol="TLS" **/>**

注意 **clientAuth="false"**测试阶段，置为 **false**，正式使用时建议使用 **true**。现在启动tomcat，访问 [https://www.zlex.org/][https_www.zlex.org]。 ![66433698-0a4c-3869-9cd5-d4288a3e51e2.jpg][]   
显然，证书未能通过认证，这个时候你可以选择安装证书（上文中的 **zlex.cer**文件就是证书），作为 **受信任的根证书颁发机构**导入，再次重启浏览器（IE，其他浏览器对于域名www.zlex.org不支持本地方式访问），访问 [https://www.zlex.org/][https_www.zlex.org]，你会看到地址栏中会有个小锁 ![1ca0c1b4-7d04-3d68-8b8b-9466380fb7b4.jpg][]，就说明安装成功。所有的浏览器联网操作已经在RSA加密解密系统的保护之下了。但似乎我们感受不到。   
这个时候很多人开始怀疑，如果我们要手工做一个这样的https的访问是不是需要把浏览器的这些个功能都实现呢？不需要！   
  
接着上篇内容，给出如下代码实现：

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  **import** java.io.FileInputStream;  
2.  **import** java.security.KeyStore;  
3.  **import** java.security.PrivateKey;  
4.  **import** java.security.PublicKey;  
5.  **import** java.security.Signature;  
6.  **import** java.security.cert.Certificate;  
7.  **import** java.security.cert.CertificateFactory;  
8.  **import** java.security.cert.X509Certificate;  
9.  **import** java.util.Date;  
10.   
11. **import** javax.crypto.Cipher;  
12. **import** javax.net.ssl.HttpsURLConnection;  
13. **import** javax.net.ssl.KeyManagerFactory;  
14. **import** javax.net.ssl.SSLContext;  
15. **import** javax.net.ssl.SSLSocketFactory;  
16. **import** javax.net.ssl.TrustManagerFactory;  
17.   
18. /\*\* 
19.  \* 证书组件 
20.  \*  
21.  \* @author 梁栋 
22.  \* @version 1.0 
23.  \* @since 1.0 
24.  \*/  
25. **public** **abstract** **class** CertificateCoder **extends** Coder \{  
26.   
27.     /\*\* 
28.      \* Java密钥库(Java Key Store，JKS)KEY\_STORE 
29.      \*/  
30.     **public** **static** **final** String KEY\_STORE = "JKS";  
31.   
32.     **public** **static** **final** String X509 = "X.509";  
33.     **public** **static** **final** String SunX509 = "SunX509";  
34.     **public** **static** **final** String SSL = "SSL";  
35.   
36.     /\*\* 
37.      \* 由KeyStore获得私钥 
38.      \*  
39.      \* @param keyStorePath 
40.      \* @param alias 
41.      \* @param password 
42.      \* @return 
43.      \* @throws Exception 
44.      \*/  
45.     **private** **static** PrivateKey getPrivateKey(String keyStorePath, String alias,  
46.             String password) **throws** Exception \{  
47.         KeyStore ks = getKeyStore(keyStorePath, password);  
48.         PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());  
49.         **return** key;  
50.     \}  
51.   
52.     /\*\* 
53.      \* 由Certificate获得公钥 
54.      \*  
55.      \* @param certificatePath 
56.      \* @return 
57.      \* @throws Exception 
58.      \*/  
59.     **private** **static** PublicKey getPublicKey(String certificatePath)  
60.             **throws** Exception \{  
61.         Certificate certificate = getCertificate(certificatePath);  
62.         PublicKey key = certificate.getPublicKey();  
63.         **return** key;  
64.     \}  
65.   
66.     /\*\* 
67.      \* 获得Certificate 
68.      \*  
69.      \* @param certificatePath 
70.      \* @return 
71.      \* @throws Exception 
72.      \*/  
73.     **private** **static** Certificate getCertificate(String certificatePath)  
74.             **throws** Exception \{  
75.         CertificateFactory certificateFactory = CertificateFactory  
76.                 .getInstance(X509);  
77.         FileInputStream in = **new** FileInputStream(certificatePath);  
78.   
79.         Certificate certificate = certificateFactory.generateCertificate(in);  
80.         in.close();  
81.   
82.         **return** certificate;  
83.     \}  
84.   
85.     /\*\* 
86.      \* 获得Certificate 
87.      \*  
88.      \* @param keyStorePath 
89.      \* @param alias 
90.      \* @param password 
91.      \* @return 
92.      \* @throws Exception 
93.      \*/  
94.     **private** **static** Certificate getCertificate(String keyStorePath,  
95.             String alias, String password) **throws** Exception \{  
96.         KeyStore ks = getKeyStore(keyStorePath, password);  
97.         Certificate certificate = ks.getCertificate(alias);  
98.   
99.         **return** certificate;  
100.     \}  
101.   
102.     /\*\* 
103.      \* 获得KeyStore 
104.      \*  
105.      \* @param keyStorePath 
106.      \* @param password 
107.      \* @return 
108.      \* @throws Exception 
109.      \*/  
110.     **private** **static** KeyStore getKeyStore(String keyStorePath, String password)  
111.             **throws** Exception \{  
112.         FileInputStream is = **new** FileInputStream(keyStorePath);  
113.         KeyStore ks = KeyStore.getInstance(KEY\_STORE);  
114.         ks.load(is, password.toCharArray());  
115.         is.close();  
116.         **return** ks;  
117.     \}  
118.   
119.     /\*\* 
120.      \* 私钥加密 
121.      \*  
122.      \* @param data 
123.      \* @param keyStorePath 
124.      \* @param alias 
125.      \* @param password 
126.      \* @return 
127.      \* @throws Exception 
128.      \*/  
129.     **public** **static** **byte**\[\] encryptByPrivateKey(**byte**\[\] data, String keyStorePath,  
130.             String alias, String password) **throws** Exception \{  
131.         // 取得私钥  
132.         PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);  
133.   
134.         // 对数据加密  
135.         Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());  
136.         cipher.init(Cipher.ENCRYPT\_MODE, privateKey);  
137.   
138.         **return** cipher.doFinal(data);  
139.   
140.     \}  
141.   
142.     /\*\* 
143.      \* 私钥解密 
144.      \*  
145.      \* @param data 
146.      \* @param keyStorePath 
147.      \* @param alias 
148.      \* @param password 
149.      \* @return 
150.      \* @throws Exception 
151.      \*/  
152.     **public** **static** **byte**\[\] decryptByPrivateKey(**byte**\[\] data, String keyStorePath,  
153.             String alias, String password) **throws** Exception \{  
154.         // 取得私钥  
155.         PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);  
156.   
157.         // 对数据加密  
158.         Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());  
159.         cipher.init(Cipher.DECRYPT\_MODE, privateKey);  
160.   
161.         **return** cipher.doFinal(data);  
162.   
163.     \}  
164.   
165.     /\*\* 
166.      \* 公钥加密 
167.      \*  
168.      \* @param data 
169.      \* @param certificatePath 
170.      \* @return 
171.      \* @throws Exception 
172.      \*/  
173.     **public** **static** **byte**\[\] encryptByPublicKey(**byte**\[\] data, String certificatePath)  
174.             **throws** Exception \{  
175.   
176.         // 取得公钥  
177.         PublicKey publicKey = getPublicKey(certificatePath);  
178.         // 对数据加密  
179.         Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());  
180.         cipher.init(Cipher.ENCRYPT\_MODE, publicKey);  
181.   
182.         **return** cipher.doFinal(data);  
183.   
184.     \}  
185.   
186.     /\*\* 
187.      \* 公钥解密 
188.      \*  
189.      \* @param data 
190.      \* @param certificatePath 
191.      \* @return 
192.      \* @throws Exception 
193.      \*/  
194.     **public** **static** **byte**\[\] decryptByPublicKey(**byte**\[\] data, String certificatePath)  
195.             **throws** Exception \{  
196.         // 取得公钥  
197.         PublicKey publicKey = getPublicKey(certificatePath);  
198.   
199.         // 对数据加密  
200.         Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());  
201.         cipher.init(Cipher.DECRYPT\_MODE, publicKey);  
202.   
203.         **return** cipher.doFinal(data);  
204.   
205.     \}  
206.   
207.     /\*\* 
208.      \* 验证Certificate 
209.      \*  
210.      \* @param certificatePath 
211.      \* @return 
212.      \*/  
213.     **public** **static** **boolean** verifyCertificate(String certificatePath) \{  
214.         **return** verifyCertificate(**new** Date(), certificatePath);  
215.     \}  
216.   
217.     /\*\* 
218.      \* 验证Certificate是否过期或无效 
219.      \*  
220.      \* @param date 
221.      \* @param certificatePath 
222.      \* @return 
223.      \*/  
224.     **public** **static** **boolean** verifyCertificate(Date date, String certificatePath) \{  
225.         **boolean** status = **true**;  
226.         **try** \{  
227.             // 取得证书  
228.             Certificate certificate = getCertificate(certificatePath);  
229.             // 验证证书是否过期或无效  
230.             status = verifyCertificate(date, certificate);  
231.         \} **catch** (Exception e) \{  
232.             status = **false**;  
233.         \}  
234.         **return** status;  
235.     \}  
236.   
237.     /\*\* 
238.      \* 验证证书是否过期或无效 
239.      \*  
240.      \* @param date 
241.      \* @param certificate 
242.      \* @return 
243.      \*/  
244.     **private** **static** **boolean** verifyCertificate(Date date, Certificate certificate) \{  
245.         **boolean** status = **true**;  
246.         **try** \{  
247.             X509Certificate x509Certificate = (X509Certificate) certificate;  
248.             x509Certificate.checkValidity(date);  
249.         \} **catch** (Exception e) \{  
250.             status = **false**;  
251.         \}  
252.         **return** status;  
253.     \}  
254.   
255.     /\*\* 
256.      \* 签名 
257.      \*  
258.      \* @param keyStorePath 
259.      \* @param alias 
260.      \* @param password 
261.      \*  
262.      \* @return 
263.      \* @throws Exception 
264.      \*/  
265.     **public** **static** String sign(**byte**\[\] sign, String keyStorePath, String alias,  
266.             String password) **throws** Exception \{  
267.         // 获得证书  
268.         X509Certificate x509Certificate = (X509Certificate) getCertificate(  
269.                 keyStorePath, alias, password);  
270.         // 获取私钥  
271.         KeyStore ks = getKeyStore(keyStorePath, password);  
272.         // 取得私钥  
273.         PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password  
274.                 .toCharArray());  
275.   
276.         // 构建签名  
277.         Signature signature = Signature.getInstance(x509Certificate  
278.                 .getSigAlgName());  
279.         signature.initSign(privateKey);  
280.         signature.update(sign);  
281.         **return** encryptBASE64(signature.sign());  
282.     \}  
283.   
284.     /\*\* 
285.      \* 验证签名 
286.      \*  
287.      \* @param data 
288.      \* @param sign 
289.      \* @param certificatePath 
290.      \* @return 
291.      \* @throws Exception 
292.      \*/  
293.     **public** **static** **boolean** verify(**byte**\[\] data, String sign,  
294.             String certificatePath) **throws** Exception \{  
295.         // 获得证书  
296.         X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);  
297.         // 获得公钥  
298.         PublicKey publicKey = x509Certificate.getPublicKey();  
299.         // 构建签名  
300.         Signature signature = Signature.getInstance(x509Certificate  
301.                 .getSigAlgName());  
302.         signature.initVerify(publicKey);  
303.         signature.update(data);  
304.   
305.         **return** signature.verify(decryptBASE64(sign));  
306.   
307.     \}  
308.   
309.     /\*\* 
310.      \* 验证Certificate 
311.      \*  
312.      \* @param keyStorePath 
313.      \* @param alias 
314.      \* @param password 
315.      \* @return 
316.      \*/  
317.     **public** **static** **boolean** verifyCertificate(Date date, String keyStorePath,  
318.             String alias, String password) \{  
319.         **boolean** status = **true**;  
320.         **try** \{  
321.             Certificate certificate = getCertificate(keyStorePath, alias,  
322.                     password);  
323.             status = verifyCertificate(date, certificate);  
324.         \} **catch** (Exception e) \{  
325.             status = **false**;  
326.         \}  
327.         **return** status;  
328.     \}  
329.   
330.     /\*\* 
331.      \* 验证Certificate 
332.      \*  
333.      \* @param keyStorePath 
334.      \* @param alias 
335.      \* @param password 
336.      \* @return 
337.      \*/  
338.     **public** **static** **boolean** verifyCertificate(String keyStorePath, String alias,  
339.             String password) \{  
340.         **return** verifyCertificate(**new** Date(), keyStorePath, alias, password);  
341.     \}  
342.   
343.     /\*\* 
344.      \* 获得SSLSocektFactory 
345.      \*  
346.      \* @param password 
347.      \*            密码 
348.      \* @param keyStorePath 
349.      \*            密钥库路径 
350.      \*  
351.      \* @param trustKeyStorePath 
352.      \*            信任库路径 
353.      \* @return 
354.      \* @throws Exception 
355.      \*/  
356.     **private** **static** SSLSocketFactory getSSLSocketFactory(String password,  
357.             String keyStorePath, String trustKeyStorePath) **throws** Exception \{  
358.         // 初始化密钥库  
359.         KeyManagerFactory keyManagerFactory = KeyManagerFactory  
360.                 .getInstance(SunX509);  
361.         KeyStore keyStore = getKeyStore(keyStorePath, password);  
362.         keyManagerFactory.init(keyStore, password.toCharArray());  
363.   
364.         // 初始化信任库  
365.         TrustManagerFactory trustManagerFactory = TrustManagerFactory  
366.                 .getInstance(SunX509);  
367.         KeyStore trustkeyStore = getKeyStore(trustKeyStorePath, password);  
368.         trustManagerFactory.init(trustkeyStore);  
369.   
370.         // 初始化SSL上下文  
371.         SSLContext ctx = SSLContext.getInstance(SSL);  
372.         ctx.init(keyManagerFactory.getKeyManagers(), trustManagerFactory  
373.                 .getTrustManagers(), **null**);  
374.         SSLSocketFactory sf = ctx.getSocketFactory();  
375.   
376.         **return** sf;  
377.     \}  
378.   
379.     /\*\* 
380.      \* 为HttpsURLConnection配置SSLSocketFactory 
381.      \*  
382.      \* @param conn 
383.      \*            HttpsURLConnection 
384.      \* @param password 
385.      \*            密码 
386.      \* @param keyStorePath 
387.      \*            密钥库路径 
388.      \*  
389.      \* @param trustKeyStorePath 
390.      \*            信任库路径 
391.      \* @throws Exception 
392.      \*/  
393.     **public** **static** **void** configSSLSocketFactory(HttpsURLConnection conn,  
394.             String password, String keyStorePath, String trustKeyStorePath)  
395.             **throws** Exception \{  
396.         conn.setSSLSocketFactory(getSSLSocketFactory(password, keyStorePath,  
397.                 trustKeyStorePath));  
398.     \}  
399. \}

增加了 **configSSLSocketFactory**方法供外界调用，该方法为HttpsURLConnection配置了SSLSocketFactory。当HttpsURLConnection配置了SSLSocketFactory后，我们就可以通过HttpsURLConnection的getInputStream、getOutputStream，像往常使用HttpURLConnection做操作了。尤其要说明一点，未配置SSLSocketFactory前，HttpsURLConnection的getContentLength()获得值永远都是 **-1**。   
  
给出相应测试类：

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  **import** **static** org.junit.Assert.\*;  
2.    
3.  **import** java.io.DataInputStream;  
4.  **import** java.io.InputStream;  
5.  **import** java.net.URL;  
6.    
7.  **import** javax.net.ssl.HttpsURLConnection;  
8.    
9.  **import** org.junit.Test;  
10.   
11. /\*\* 
12.  \*  
13.  \* @author 梁栋 
14.  \* @version 1.0 
15.  \* @since 1.0 
16.  \*/  
17. **public** **class** CertificateCoderTest \{  
18.     **private** String password = "123456";  
19.     **private** String alias = "www.zlex.org";  
20.     **private** String certificatePath = "d:/zlex.cer";  
21.     **private** String keyStorePath = "d:/zlex.keystore";  
22.     **private** String clientKeyStorePath = "d:/zlex-client.keystore";  
23.     **private** String clientPassword = "654321";  
24.   
25.     @Test  
26.     **public** **void** test() **throws** Exception \{  
27.         System.err.println("公钥加密——私钥解密");  
28.         String inputStr = "Ceritifcate";  
29.         **byte**\[\] data = inputStr.getBytes();  
30.   
31.         **byte**\[\] encrypt = CertificateCoder.encryptByPublicKey(data,  
32.                 certificatePath);  
33.   
34.         **byte**\[\] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,  
35.                 keyStorePath, alias, password);  
36.         String outputStr = **new** String(decrypt);  
37.   
38.         System.err.println("加密前: " + inputStr + "\\n\\r" + "解密后: " + outputStr);  
39.   
40.         // 验证数据一致  
41.         assertArrayEquals(data, decrypt);  
42.   
43.         // 验证证书有效  
44.         assertTrue(CertificateCoder.verifyCertificate(certificatePath));  
45.   
46.     \}  
47.   
48.     @Test  
49.     **public** **void** testSign() **throws** Exception \{  
50.         System.err.println("私钥加密——公钥解密");  
51.   
52.         String inputStr = "sign";  
53.         **byte**\[\] data = inputStr.getBytes();  
54.   
55.         **byte**\[\] encodedData = CertificateCoder.encryptByPrivateKey(data,  
56.                 keyStorePath, alias, password);  
57.   
58.         **byte**\[\] decodedData = CertificateCoder.decryptByPublicKey(encodedData,  
59.                 certificatePath);  
60.   
61.         String outputStr = **new** String(decodedData);  
62.         System.err.println("加密前: " + inputStr + "\\n\\r" + "解密后: " + outputStr);  
63.         assertEquals(inputStr, outputStr);  
64.   
65.         System.err.println("私钥签名——公钥验证签名");  
66.         // 产生签名  
67.         String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,  
68.                 password);  
69.         System.err.println("签名:\\r" + sign);  
70.   
71.         // 验证签名  
72.         **boolean** status = CertificateCoder.verify(encodedData, sign,  
73.                 certificatePath);  
74.         System.err.println("状态:\\r" + status);  
75.         assertTrue(status);  
76.   
77.     \}  
78.   
79.     @Test  
80.     **public** **void** testHttps() **throws** Exception \{  
81.         URL url = **new** URL("https://www.zlex.org/examples/");  
82.         HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();  
83.   
84.         conn.setDoInput(**true**);  
85.         conn.setDoOutput(**true**);  
86.   
87.         CertificateCoder.configSSLSocketFactory(conn, clientPassword,  
88.                 clientKeyStorePath, clientKeyStorePath);  
89.   
90.         InputStream is = conn.getInputStream();  
91.   
92.         **int** length = conn.getContentLength();  
93.   
94.         DataInputStream dis = **new** DataInputStream(is);  
95.         **byte**\[\] data = **new** **byte**\[length\];  
96.         dis.readFully(data);  
97.   
98.         dis.close();  
99.         System.err.println(**new** String(data));  
100.         conn.disconnect();  
101.     \}  
102. \}

注意 **testHttps**方法，几乎和我们往常做HTTP访问没有差别，我们来看控制台输出：

Console代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.    
17. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
18. <HTML><HEAD><TITLE>Apache Tomcat Examples</TITLE>  
19. <META http-equiv=Content-Type content="text/html">  
20. </HEAD>  
21. <BODY>  
22. <P>  
23. <H3>Apache Tomcat Examples</H3>  
24. <P></P>  
25. <ul>  
26. <li><a href="servlets">Servlets examples</a></li>  
27. <li><a href="jsp">JSP Examples</a></li>  
28. </ul>  
29. </BODY></HTML>

通过浏览器直接访问 [https://www.zlex.org/examples/][https_www.zlex.org_examples]你也会获得上述内容。也就是说应用甲方作为服务器构建tomcat服务，乙方可以通过上述方式访问甲方受保护的SSL应用，并且不需要考虑具体的加密解密问题。甲乙双方可以经过相应配置，通过双方的tomcat配置有效的SSL服务，简化上述代码实现，完全通过证书配置完成SSL双向认证！ ![icon_biggrin.gif][]

[Java]: http://snowolf.iteye.com/blog/391931
[icon_star.png]: http://snowolf.iteye.com/images/icon_star.png
[icon_star.png 1]: /images/20220618/48e7092a06d642d89581e8b8bf8a8854.png
[http_www.zlex.org]: http://www.zlex.org/
[https_www.zlex.org]: https://www.zlex.org/
[66433698-0a4c-3869-9cd5-d4288a3e51e2.jpg]: /images/20220618/e25956572b9040978b8e6b16e585be77.png
[1ca0c1b4-7d04-3d68-8b8b-9466380fb7b4.jpg]: /images/20220618/fd5c2c290add4ca3a47d147ba074a2ed.png
[https_www.zlex.org_examples]: https://www.zlex.org/examples/
[icon_biggrin.gif]: /images/20220618/49c81e81eb304fcf8d030d3fc06e24eb.png