update: Leet flag generator

Author: fressive

internal/util/flag.go

@@ -0,0 +1,86 @@
+// Copyright 2025 Rina
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util
+
+import (
+	"regexp"
+	"strings"
+	"unicode"
+
+	"golang.org/x/exp/rand"
+)
+
+var leetMap = map[rune][]rune{
+	'A': {'4', 'A', 'a'},
+	'B': {'8', 'B', 'b'},
+	'C': {'C', 'c'},
+	'D': {'D', 'd'},
+	'E': {'3', 'E', 'e'},
+	'F': {'F', 'f'},
+	'G': {'6', 'G', 'g'},
+	'H': {'H', 'h'},
+	'I': {'I', 'i', '1'},
+	'J': {'J', 'j'},
+	'K': {'K', 'k'},
+	'L': {'L', 'l', '1'},
+	'M': {'M', 'm'},
+	'N': {'N', 'n'},
+	'O': {'O', 'o', '0'},
+	'P': {'P', 'p'},
+	'Q': {'Q', 'q'},
+	'R': {'R', 'r'},
+	'S': {'S', 's', '5', '$'},
+	'T': {'T', 't', '7'},
+	'U': {'U', 'u'},
+	'V': {'V', 'v'},
+	'W': {'W', 'w'},
+	'X': {'X', 'x'},
+	'Y': {'Y', 'y'},
+	'Z': {'Z', 'z', '2'},
+}
+
+func Leetify(input string, seed uint64) string {
+	rand.Seed(seed)
+
+	var result strings.Builder
+	for _, char := range input {
+		if leetChars, ok := leetMap[unicode.ToUpper(char)]; ok {
+			result.WriteRune(leetChars[rand.Intn(len(leetChars))])
+		} else {
+			result.WriteRune(char)
+		}
+	}
+
+	return result.String()
+}
+
+func GenerateFlagContent(format string, seed string) string {
+	// Use [] to wrap the string to be leetified
+	// Use {hash} to insert the sha256ed seed
+	// Use {uuid} to insert a random uuid
+
+	leetRe := regexp.MustCompile(`\[([^\[\]]+)\]`)
+
+	result := format
+	result = strings.ReplaceAll(result, "{hash}", SHA256(seed)[:8])
+	result = strings.ReplaceAll(result, "{uuid}", UUID())
+
+	leet := leetRe.FindAllString(result, -1)
+	for _, l := range leet {
+		result = strings.ReplaceAll(result, l, Leetify(l[1:len(l)-1], SHA256Uint64(seed)))
+	}
+
+	return result
+}

internal/util/flag_test.go

@@ -0,0 +1,42 @@
+// Copyright 2025 Rina
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFlag(t *testing.T) {
+	flag1 := GenerateFlagContent("takanashi_hoshino_is_super_kawaii", "random_seed")
+	assert.Equal(t, "takanashi_hoshino_is_super_kawaii", flag1, "they should be equal")
+
+	flag2 := GenerateFlagContent("[takanashi_hoshino_is_super_kawaii]_[leet2]", "random_seed")
+	println(flag2)
+	assert.NotEqual(t, "takanashi_hoshino_is_super_kawaii_leet2", flag2, "they should not be equal")
+
+	flag3 := GenerateFlagContent("[takanashi_hoshino_is_super_kawaii]_[leet2]", "random_seed")
+	flag6 := GenerateFlagContent("[takanashi_hoshino_is_super_kawaii]_[leet2]", "random_seeeeeeed")
+	println(flag3, flag6)
+	assert.Equal(t, flag2, flag3, "they should be equal")
+	assert.NotEqual(t, flag3, flag6, "they should not be equal")
+
+	flag4 := GenerateFlagContent("[takanashi_hoshino_is_super_kawaii]_{seed}", "random_seed")
+	flag5 := GenerateFlagContent("[takanashi_hoshino_is_super_kawaii_{seed}]", "random_seed")
+	println(flag4, flag5)
+	assert.NotEqual(t, flag4, flag5, "they should not be equal")
+
+}

internal/util/hash.go

@@ -17,6 +17,7 @@ package util
 import (
 	"crypto/sha256"
 	"fmt"
+	"strconv"
 	"time"
 
 	"github.com/google/uuid"
@@ -34,6 +35,11 @@ func SHA256(secret string) string {
 	return fmt.Sprintf("%x", h.Sum(nil))
 }
 
+func SHA256Uint64(secret string) uint64 {
+	res, _ := strconv.ParseUint(SHA256(secret)[:16], 16, 64)
+	return res
+}
+
 func SHA256WithSalt(secret string, salt string) string {
 	return SHA256(secret + salt)
 }

internal/util/hash_test.go

@@ -40,3 +40,10 @@ func TestGenerateRandomText(t *testing.T) {
 	randomText := GenerateRandomText(length)
 	assert.Equal(t, length, int32(len(randomText)), "length should be equal to the specified length")
 }
+
+func TestSHA256Uint64(t *testing.T) {
+	seedToInt := SHA256Uint64("takanashi_hoshino_is_super_kawaii")
+	assert.Equal(t, uint64(0xa649edaea14f0f0), seedToInt, "they should be equal")
+	seedToInt2 := SHA256Uint64("takanashi_hoshino_is_super_kawaii222")
+	assert.NotEqual(t, seedToInt, seedToInt2, "they should not be equal")
+}