logback日志文件sm3摘要运算

logback日志文件sm3摘要运算

• 1.我们可以自定义一个附加器MyAppender重新RollingFileAppender的subAppender方法
  SM3算法加密包：

	
		org.bouncycastle
		bcprov-jdk15on
		1.60
	

	
		org.apache.commons
		commons-lang3
		3.8.1
		true
	
1
2
3
4
5
6
7
8
9
10
11
12

import ch.qos.logback.core.encoder.Encoder;
import ch.qos.logback.core.rolling.RollingFileAppender;
import ch.qos.logback.core.spi.DeferredProcessingAware;
import com.gsww.ioop.util.sm3.SM3Utils;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * Created by IntelliJ IDEA.
 *
 * @Author: ylz
 * @Date:2022/08/03/12:12
 * @description:自定义日志文件附加器
 */
public class MyAppender<E> extends RollingFileAppender<E>  {

    //encoder标签
    private Encoder encoder;

    public void setEncoder(Encoder encoder) {
        //自定义的appender的父类OutputStreamAppender在启动的时候会判断是否有encoder ，无的话自定义appender启动会失败
        super.setEncoder(encoder);
        this.encoder = encoder;
    }


    /**
     * 覆盖父类OutputStreamAppender的日志记录功能，再这里面做日志切操作功能
     * @param event
     */
    protected void subAppend(E event) {
        if (this.isStarted()) {
            try {
                if (event instanceof DeferredProcessingAware) {
                    ((DeferredProcessingAware)event).prepareForDeferredProcessing();
                }
                //根据标签规则拿到日志字符串，这里可以再次修改日志信息
                byte[] byteArray = this.encoder.encode(event);
                //做一些日志的特殊处理
//                writeMongo(...);
//                writeRedis(...);
//                writeMq(...);
                //写入日志文件
                writeBytes(byteArray);
            } catch (IOException var3) {
                this.started = false;
            }
        }
    }

    private void writeBytes(byte[] byteArray) throws IOException {
        if (byteArray != null && byteArray.length != 0) {
            this.lock.lock();
            try {
                //this.getOutputStream().write(byteArray);
                String digestStr=SM3Utils.digest(byteArray);//进行SM3原文摘要运算
                this.getOutputStream().write(digestStr.getBytes(StandardCharsets.UTF_8));
                if (this.isImmediateFlush()) {
                    this.getOutputStream().flush();
                }
            } finally {
                this.lock.unlock();
            }
        }
    }




}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

• 2.sm3摘要运算工具类

import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
import org.bouncycastle.util.encoders.Hex;

import java.io.UnsupportedEncodingException;
import java.security.Security;
import java.util.Arrays;

/**
 * Created by IntelliJ IDEA.
 *
 * @Author: ylz
 * @Date:2022/08/03/10:05
 * @description:SM3加密算法工具类
 */
public class SM3Utils {
    private static final String ENCODING = "UTF-8";

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

    /**
     * sm3算法加密
     *
     * @param paramStr 待加密字符串
     * @return 返回加密后，固定长度=32的16进制字符串
     * @explain
     */
    public static String encrypt(String paramStr) {
        // 将返回的hash值转换成16进制字符串
        String resultHexString = "";
        try {
            // 将字符串转换成byte数组
            byte[] srcData = paramStr.getBytes(ENCODING);
            // 调用hash()
            byte[] resultHash = hash(srcData);
            // 将返回的hash值转换成16进制字符串
            resultHexString = ByteUtils.toHexString(resultHash);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return resultHexString;
    }

    /**
     * 返回长度=32的byte数组
     *
     * @param srcData
     * @return
     * @explain 生成对应的hash值
     */
    public static byte[] hash(byte[] srcData) {
        SM3Digest digest = new SM3Digest();
        digest.update(srcData, 0, srcData.length);
        byte[] hash = new byte[digest.getDigestSize()];
        digest.doFinal(hash, 0);
        return hash;
    }

    /**
     * 判断源数据与加密数据是否一致
     *
     * @param srcStr       原字符串
     * @param sm3HexString 16进制字符串
     * @return 校验结果
     * @explain 通过验证原数组和生成的hash数组是否为同一数组，验证2者是否为同一数据
     */
    public static boolean verify(String srcStr, String sm3HexString) {
        boolean flag = false;
        try {
            byte[] srcData = srcStr.getBytes(ENCODING);
            byte[] sm3Hash = ByteUtils.fromHexString(sm3HexString);
            byte[] newHash = hash(srcData);
            if (Arrays.equals(newHash, sm3Hash)) {
                flag = true;
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 字符串做摘要运算
     * @param src
     * @return
     */
    public static String generateSM3HASH(String src) {
        byte[] md = new byte[32];
        byte[] msg1 = src.getBytes();
        SM3Digest sm3 = new SM3Digest();
        sm3.update(msg1, 0, msg1.length);
        sm3.doFinal(md, 0);
        String s = new String(Hex.encode(md));
        return s.toUpperCase();
    }

    /**
     * 对输入的原文做摘要运算
     * @param srcData
     * @return
     */
    public static String digest(byte[] srcData) {
        try {
            SM3Digest sm3Digest = new SM3Digest();
            sm3Digest.update(srcData, 0, srcData.length);
            byte[] hashData = new byte[sm3Digest.getDigestSize()];
            sm3Digest.doFinal(hashData, 0);
            return ByteUtils.toHexString(hashData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }



    public static void main(String[] args) {
        //sm3测试
        String str="activityCode";
        String encryptData=encrypt(str);
        try {
            byte[] array= hash(str.getBytes());
            String sy=array.toString();
            System.out.println("加密后的byte数组为:"+sy);
            System.out.println("加密后的字符串为:"+encryptData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //sm3摘要运算
        String str3="混吃等死成功jckdhkchsdv;dsvhdkjvhkjdvgjkdvkdjgv dgvhjdgvhjsdgvhjsghjkdsghjvgjsdhvghjsdghjsdgvhjdsvghsdjgvhsdjgvvgdjcdvfdv";
        System.out.println("摘要运算结果:"+generateSM3HASH("124"));
        System.out.println("摘要运算结果:"+digest(str3.getBytes()));


    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

• 3.logback.xml文件定义appender

<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
	<springProperty scope="context" name="appName" source="spring.application.name"/>
	<property name="CATALINA_BASE" value="D:/opt/logs"></property>
<!-- 自定义文件sm3摘要运算输出 -->
	<appender name="LogFileAppender" class="com.********.MyAppender">
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<!-- daily rollover -->
			<fileNamePattern>${CATALINA_BASE}/servers2-%d{yyyy-MM-dd}.log</fileNamePattern>
			<!-- keep 30 days' worth of history -->
			<maxHistory>30</maxHistory>
		</rollingPolicy>
		<encoder charset="UTF-8">
			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n</pattern>
		</encoder>
	</appender>
<!-- 日志输出级别 -->
	<root level="INFO">
		<appender-ref ref="LogFileAppender"/>
	</root>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 4.需要注意的是logback的pom的version 1…1.1以上，不然找不到Encoder.encode方法，我的version是1.2.3