Golang中實現(xiàn)數(shù)據(jù)脫敏處理的go-mask包分享

更新時間：2023年05月23日 16:46:43 作者：Go學堂

這篇文章主要是來和大家分享一個在輸出中對敏感數(shù)據(jù)進行脫敏的工作包：go-mask，可以將敏感信息輸出的時候替換成星號或其他字符，感興趣的小編可以跟隨小編一起了解下

特征

通過結構體的tag功能可以脫敏結構體中的任何字段
除了使用go-mask的內置的脫敏函數(shù)外，用戶還可以自定義脫敏函數(shù)。

支持的tags標簽

go-mask只提供了有限的幾個tags。原因是用戶可以根據(jù)需要自定義脫敏函數(shù)。以下是go-mask支持的tags：

tag	type	描述
mask:"filled"	string	輸出和原字符串相同個數(shù)的脫敏字符。例如：原字符串是4個字符，那么就輸出4個星號：****
mask:"filledXXX"	string	XXX是脫敏字符的個數(shù)。即輸出XXX個脫敏字符。例如：mask:"filled3"代表最終輸出"***"
mask:"fixed"	string	輸出固定個數(shù)的脫敏字符，默認是8個字符。例如：********
mask:"hash"	string	對原字符串使用sha1哈希輸出
mask:"randomXXX"	int / float64	XXX代表數(shù)字值。將原值轉換成0-XXX之間的隨機值輸出
mask:"zero"	any	輸出對應類型的零值

如何使用

對字符串類型脫敏

package main
import (
	"fmt"
	mask "github.com/showa-93/go-mask"
)
func main() {
	maskValue, _ := mask.String(mask.MaskTypeFixed, "Hello World!!")
	fmt.Println(maskValue) //輸出固定的8個脫敏字符： ********
}

對結構體中的string類型字段進行脫敏處理。如下：

package main
import (
	"fmt"
	mask "github.com/showa-93/go-mask"
)
func main() {
	value := struct {
		Title string   `mask:"filled"`
		Casts []string `mask:"fixed"`
	}{
		Title: "Catch Me If You Can",
		Casts: []string{
			"Thomas Jeffrey \"Tom\" Hanks",
			"Leonardo Wilhelm DiCaprio",
		},
	}
    maskValue, _ := mask.Mask(value)
	fmt.Printf("value:%+v\n", value)
	fmt.Printf("maskValue:%+v\n", maskValue) //脫敏字符輸出符號是：*
    masker := mask.NewMasker()
	masker.SetMaskChar("-") //自定義脫敏字符為 - 
    // 給對應的tag注冊對應的脫敏處理函數(shù)
	masker.RegisterMaskStringFunc(mask.MaskTypeFilled, masker.MaskFilledString)
	masker.RegisterMaskStringFunc(mask.MaskTypeFixed, masker.MaskFixedString)
	maskValue2, _ := masker.Mask(value)
	fmt.Printf("maskValue2:%+v\n", maskValue2)
}

輸出結果如下：

value:{Title:Catch Me If You Can Casts:[Thomas Jeffrey "Tom" Hanks Leonardo Wilhelm DiCaprio]}
maskValue:{Title:******************* Casts:[******** ********]}
maskValue2:{Title:------------------- Casts:[-------- --------]}

對int/float64類型字段脫敏

對int/float64類型的字段一般使用mask:"randomXXX"的標簽，表示轉換成從0到XXX的隨機數(shù)。如下：

package main
import (
	"fmt"
	mask "github.com/showa-93/go-mask"
)
func main() {
	{
		maskValue, _ := mask.Int("random100", 10)
		fmt.Println(maskValue)
	}
	{
		maskValue, _ := mask.Float64("random100.2", 12.3)
		fmt.Println(maskValue)
	}
	{
		value := struct {
			Price   int     `mask:"random1000"`
			Percent float64 `mask:"random1.3"`
		}{
			Price:   300,
			Percent: 0.80,
		}
		masker := mask.NewMasker()
		masker.RegisterMaskIntFunc(mask.MaskTypeRandom, masker.MaskRandomInt)
		masker.RegisterMaskFloat64Func(mask.MaskTypeRandom, masker.MaskRandomFloat64)
		maskValue, _ := mask.Mask(value)
		maskValue2, _ := masker.Mask(value)
		fmt.Printf("%+v\n", maskValue)
		fmt.Printf("%+v\n", maskValue2)
	}
}

對應的輸出結果如下：

29
50.45
{Price:917 Percent:0.183}
{Price:733 Percent:0.241}

對slice類型脫敏處理

對slice類型的處理本質上還是對基礎類型的處理，類似于結構體或對應的string/int/float64類型。如下：

package main
import (
	"fmt"
	"github.com/showa-93/go-mask"
)
type Value struct {
	Name string `mask:"filled"`
	Type int    `mask:"random10"`
}
func main() {
	values := []Value{
		{
			Name: "Thomas Jeffrey \"Tom\" Hanks",
			Type: 1,
		},
		{
			Name: "Leonardo Wilhelm DiCaprio",
			Type: 2,
		},
	}
	masker := mask.NewMasker()
	masker.SetMaskChar("+")
	masker.RegisterMaskStringFunc(mask.MaskTypeFilled, masker.MaskFilledString)
	masker.RegisterMaskIntFunc(mask.MaskTypeRandom, masker.MaskRandomInt)
	maskValues, _ := mask.Mask(values)
	maskValues2, _ := masker.Mask(values)
	fmt.Printf("%+v\n", values)
	fmt.Printf("%+v\n", maskValues)
	fmt.Printf("%+v\n", maskValues2)
}

輸出如下：

[{Name:Thomas Jeffrey "Tom" Hanks Type:1} {Name:Leonardo Wilhelm DiCaprio Type:2}]
[{Name:************************** Type:8} {Name:************************* Type:9}]
[{Name:++++++++++++++++++++++++++ Type:4} {Name:+++++++++++++++++++++++++ Type:8}]

對map類型進行處理

對map類型的處理，是處理的map中的value，對key不做處理。如下：

package main
import (
	"fmt"
	"github.com/showa-93/go-mask"
)
type Value struct {
	Name string `mask:"filled"`
	Type int    `mask:"random10"`
}
func main() {
	values := map[string]Value{
		"one": {
			Name: "Thomas Jeffrey \"Tom\" Hanks",
			Type: 1,
		},
		"two": {
			Name: "Leonardo Wilhelm DiCaprio",
			Type: 2,
		},
	}
	masker := mask.NewMasker()
	masker.SetMaskChar("")
	masker.RegisterMaskStringFunc(mask.MaskTypeFilled, masker.MaskFilledString)
	masker.RegisterMaskIntFunc(mask.MaskTypeRandom, masker.MaskRandomInt)
	maskValues, _ := mask.Mask(values)
	maskValues2, _ := masker.Mask(values)
	fmt.Printf("%+v\n", values)
	fmt.Printf("%+v\n", maskValues)
	fmt.Printf("%+v\n", maskValues2)
}

輸出結果如下：

map[one:{Name:Thomas Jeffrey "Tom" Hanks Type:1} two:{Name:Leonardo Wilhelm DiCaprio Type:2}]
map[one:{Name:************************** Type:8} two:{Name:************************* Type:6}]
map[one:{Name: Type:6} two:{Name: Type:2}]

自定義脫敏函數(shù)

go-mask包還支持自定義的脫敏函數(shù)的處理。將定義好的函數(shù)通過mask.RegisterMaskStringFunc函數(shù)進行注冊即可。如下，定義了regexp標簽和MaskRegExp脫敏處理函數(shù)：

package main
import (
	"fmt"
	"regexp"
	"strings"
	mask "github.com/showa-93/go-mask"
)
func init() {
	maskTypeRegExp := "regexp"
	mask.RegisterMaskStringFunc(maskTypeRegExp, MaskRegExp)
}
// MaskRegExp is sample to add a custom mask function
func MaskRegExp(arg, value string) (string, error) {
	var (
		reg *regexp.Regexp
		err error
	)
	reg, err = regexp.Compile(arg)
	if err != nil {
		return "", err
	}
	indexes := reg.FindStringSubmatchIndex(value)
	if len(indexes) >= 4 && indexes[2] >= 0 && indexes[3] >= 0 {
		var sb strings.Builder
		sb.WriteString(value[:indexes[2]])
		sb.WriteString(mask.MaskChar())
		sb.WriteString(value[indexes[3]:])
		return sb.String(), nil
	}
	return value, nil
}
func main() {
	mask.SetMaskChar("cat")
	type Hachiware struct {
		Message string `mask:"regexp(gopher)."`
	}
	input := Hachiware{Message: "I love gopher!"}
	got, _ := mask.Mask(input)
	fmt.Printf("%+v\n", input)
	fmt.Printf("%+v\n", got)
	// The Masker initialized with NewMasker does not have
	// any custom masking functions registered, so no masking will occur
	masker := mask.NewMasker()
	got2, _ := masker.Mask(input)
	fmt.Printf("%+v\n", got2)
}

輸出結果：