github.com/mundipagg/boleto-api@v0.0.0-20230620145841-3f9ec742599f/util/mask.go

package util

import (
	"encoding/json"
	"fmt"
	"strings"

	mxj "github.com/clbanning/mxj/v2"
	"github.com/go-xmlfmt/xmlfmt"
	"github.com/mundipagg/boleto-api/config"
	"github.com/mundipagg/boleto-api/log"
)

var (
	fieldsShouldBeMasked = map[string]bool{
		"access_token":  true,
		"refresh_token": true,
		"AUTENTICACAO":  true,
		"CdtrId":        true,
		"ticket":        true,
		"clientId":      true,
		"clientSecret":  true,
	}
)

type Mask struct {
	log         *log.Log
	messageType string
}

func NewMask(log *log.Log, messageType string) *Mask {
	return &Mask{
		log:         log,
		messageType: messageType,
	}
}

func (mask *Mask) MaskJsonContentFields(content string) string {
	if !config.Get().MaskLogs {
		return content
	}

	contentMap := mask.jsonStringToMap(content)

	if contentMap == nil {
		return content
	}

	if !mask.mask(contentMap) {
		return content
	}

	maskContent := mask.mapToJson(contentMap)

	if maskContent == "" {
		return content
	}

	return maskContent
}

func (mask *Mask) MaskXMLContentFields(content string) string {
	if !config.Get().MaskLogs {
		return content
	}

	contentMap := mask.xmlStringToMap(content)

	if contentMap == nil {
		return content
	}

	if !mask.mask(contentMap) {
		return content
	}

	maskContent := mask.mapToXML(contentMap)

	if maskContent == "" {
		return content
	}

	return maskContent
}

func (mask *Mask) MaskQueryParamsContentFields(content string) string {
	if !config.Get().MaskLogs {
		return content
	}

	contentMap := mask.queryParamsStringToMap(content)

	if contentMap == nil {
		return content
	}

	if !mask.mask(contentMap) {
		return content
	}

	maskContent := mask.mapToQueryParams(contentMap)

	if maskContent == "" {
		return content
	}

	return maskContent
}

//JsonStringToMap Converte uma string json para um map[string]interface
//Caso a string não seja compatível com um json retorna nulo
func (mask *Mask) jsonStringToMap(value string) map[string]interface{} {
	defer mask.log.HandleMaskErrors("JsonStringToMap", mask.messageType, value)

	var m map[string]interface{}

	if err := json.Unmarshal([]byte(value), &m); err != nil {
		return nil
	}

	return m
}

//MapToJson Converte um map[string]interface para uma string json
func (mask *Mask) mapToJson(m map[string]interface{}) string {
	defer mask.log.HandleMaskErrors("MapToJson", mask.messageType, m)

	jsonBytes, err := json.Marshal(m)
	if err != nil {
		return ""
	}

	return string(jsonBytes)
}

//XMLStringToMap Converte uma string xml para um map[string]interface
//Caso a string não seja compatível com um json retorna nulo
func (mask *Mask) xmlStringToMap(xml string) map[string]interface{} {
	defer mask.log.HandleMaskErrors("XMLStringToMap", mask.messageType, xml)

	xmlVal := []byte(xml)
	mapVal, _ := mxj.NewMapXml(xmlVal)

	return mapVal
}

//MapToXML Converte um map[string]interface para uma string xml
func (mask *Mask) mapToXML(m map[string]interface{}) string {
	defer mask.log.HandleMaskErrors("MapToXML", mask.messageType, m)
	xmlMap := mxj.Map(m)
	xmlContent, _ := xmlMap.Xml()
	formattedXml := xmlfmt.FormatXML(string(xmlContent), "\t", "  ")

	return formattedXml
}

//mask Função recursiva para mascarar campos do content
func (mask *Mask) mask(contentMap map[string]interface{}) bool {
	defer mask.log.HandleMaskErrors("mask", mask.messageType, contentMap)

	for key, value := range contentMap {
		switch value := value.(type) {
		case map[string]interface{}:
			mask.mask(value)
		case string:
			innerMap := mask.jsonStringToMap(value)
			if innerMap != nil {
				mask.mask(innerMap)
				contentMap[key] = innerMap
			} else {
				if _, exists := fieldsShouldBeMasked[key]; exists {
					contentMap[key] = "[REDACTED]"
				}
			}
		default:
			break
		}
	}

	return true
}

//queryParamsStringToMap Converte uma string com parâmetros URI no formato key1=value1&keyN=valueN para um map[string]interface
func (mask *Mask) queryParamsStringToMap(queryParams string) map[string]interface{} {
	defer mask.log.HandleMaskErrors("QueryParamsStringToMap", mask.messageType, queryParams)

	m := make(map[string]interface{})
	listParams := strings.Split(queryParams, "&")

	for _, p := range listParams {
		pair := strings.SplitN(p, "=", 2)
		m[pair[0]] = pair[1]
	}

	return m
}

//mapToQueryParams Converte um map em uma string com parâmetros URI no formato key1=value1&keyN=valueN
func (mask *Mask) mapToQueryParams(m map[string]interface{}) string {
	defer mask.log.HandleMaskErrors("MapToQueryParams", mask.messageType, m)

	var queryParams strings.Builder
	var parameter string
	n := 1

	for k, v := range m {
		if n < len(m) {
			parameter = fmt.Sprintf("%s=%s&", k, v)
		} else {
			parameter = fmt.Sprintf("%s=%s", k, v)
		}
		queryParams.WriteString(parameter)
		n++
	}

	return queryParams.String()
}