likedream/internal/application/smartedu/cryptoutil/encdata_test.go

package cryptoutil

import (
	"fmt"
	"strings"
	"testing"
)

func TestEncdata(t *testing.T) {
	// 使用与JavaScript版本相同的clientToken
	clientToken := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

	data := map[string]interface{}{
		"username": "admin",
		"password": "123456",
	}
	encData := EncData(data, clientToken)
	fmt.Println("EncData result:", encData)

	// 创建一个模拟的JR对象来测试DescData
	jr := map[string]interface{}{
		"flag": true,
		"key":  getKeyFromCiphertext(encData["ciphertext"]),
		"data": getDataFromCiphertext(encData["ciphertext"]),
	}

	descResult := DescData(jr, clientToken)
	fmt.Println("DescData result:", descResult)
}

func TestDecdata(t *testing.T) {
	// 使用与JavaScript版本相同的clientToken
	clientToken := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

	data := map[string]interface{}{
		"flag": true,
		"data": "YN4tHIF4S3OQgfhTICpFqR425z2sHwCEmlsGdVYt5m6ssyIagtqEvf0hEXdzhc0u",
		"key":  "120-54-61-117",
	}

	// 调试信息
	fmt.Println("Input data:", data)

	// 手动测试密钥生成
	axes := "120-54-61-117"
	aesaxes := strings.ReplaceAll(axes, "-", ",")
	aesKey := encryptKey(aesaxes, clientToken)
	fmt.Println("Generated key:", aesKey)
	fmt.Println("Key length:", len(aesKey))

	// 直接测试解密
	encryptedData := "YN4tHIF4S3OQgfhTICpFqR425z2sHwCEmlsGdVYt5m6ssyIagtqEvf0hEXdzhc0u"
	decrypted := Decrypt(encryptedData, aesKey)
	fmt.Println("Direct decrypt result:", decrypted)
	fmt.Printf("Direct decrypt result (bytes): %v\n", []byte(decrypted))

	result := DescData(data, clientToken)
	fmt.Println("TestDecdata result:", result)

	// 检查结果
	if result["flag"] != true {
		t.Errorf("Expected flag to be true, got %v", result["flag"])
	}
}

// getKeyFromCiphertext 从ciphertext中提取key部分
func getKeyFromCiphertext(ciphertext string) string {
	parts := strings.Split(ciphertext, ",")
	if len(parts) > 1 {
		return parts[1]
	}
	return ""
}

// getDataFromCiphertext 从ciphertext中提取data部分
func getDataFromCiphertext(ciphertext string) string {
	parts := strings.Split(ciphertext, ",")
	if len(parts) > 0 {
		return parts[0]
	}
	return ""
}

// 添加一个简单的加密/解密测试
func TestEncryptDecrypt(t *testing.T) {
	originalData := `{"username":"admin","password":"123456"}`
	key := "abcdabcdabcdabcd" // 16字节密钥

	// 加密
	encrypted := Encrypt(originalData, key)
	fmt.Println("Encrypted:", encrypted)

	// 解密
	decrypted := Decrypt(encrypted, key)
	fmt.Println("Decrypted:", decrypted)

	if decrypted != originalData {
		t.Errorf("Decrypt failed. Expected: %s, Got: %s", originalData, decrypted)
	}
}

// 测试特定的axes生成密钥
func TestEncryptKey(t *testing.T) {
	// 使用与JavaScript版本相同的clientToken
	clientToken := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

	// 测试提供的axes
	axes := "120,54,61,117"

	key := encryptKey(axes, clientToken)
	fmt.Println("Test axes:", axes)
	fmt.Println("Generated key:", key)
	fmt.Println("Key length:", len(key))

	// 验证每个部分
	fmt.Println("Client token length:", len(clientToken))

	// 分别计算每个部分
	parts := strings.Split(axes, ",")
	for i, part := range parts {
		axisInt := parseInt(part)
		fmt.Printf("Part %d: %s -> %d\n", i, part, axisInt)

		if axisInt >= 0 && axisInt < len(clientToken) {
			end := axisInt + 4
			if end <= len(clientToken) {
				fmt.Printf("  Extracted: %s\n", clientToken[axisInt:end])
			} else {
				fmt.Printf("  Extracted: %s (partial)\n", clientToken[axisInt:])
			}
		} else {
			fmt.Printf("  Out of range, using default\n")
		}
	}
}

// 测试具体案例
func TestSpecificCase(t *testing.T) {
	// 使用与JavaScript版本相同的clientToken
	clientToken := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

	// 使用你提供的具体数据
	axes := "120,54,61,117"
	key := encryptKey(axes, clientToken)

	fmt.Println("=== Specific Case Test ===")
	fmt.Printf("Axes: %s\n", axes)
	fmt.Printf("Generated Key: %s\n", key)
	fmt.Printf("Key Length: %d\n", len(key))

	// 测试加密
	testData := "test data"
	encrypted := Encrypt(testData, key)
	fmt.Printf("Encrypted: %s\n", encrypted)

	// 测试解密
	decrypted := Decrypt(encrypted, key)
	fmt.Printf("Decrypted: %s\n", decrypted)

	if testData != decrypted {
		fmt.Println("WARNING: Encryption/Decryption mismatch!")
	} else {
		fmt.Println("SUCCESS: Encryption/Decryption works correctly!")
	}
}

// 测试你提供的实际加密数据
func TestActualEncryptedData(t *testing.T) {
	// 使用与JavaScript版本相同的clientToken
	clientToken := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

	// 你提供的实际加密数据
	encryptedData := "YN4tHIF4S3OQgfhTICpFqR425z2sHwCEmlsGdVYt5m6ssyIagtqEvf0hEXdzhc0u"

	// 根据axes "120,54,61,117" 生成密钥
	axes := "120,54,61,117"
	key := encryptKey(axes, clientToken)

	fmt.Println("=== Actual Encrypted Data Test ===")
	fmt.Printf("Encrypted Data: %s\n", encryptedData)
	fmt.Printf("Key: %s\n", key)

	// 尝试解密
	decrypted := Decrypt(encryptedData, key)
	fmt.Printf("Decrypted Result: '%s'\n", decrypted)
	fmt.Printf("Decrypted Length: %d\n", len(decrypted))
	fmt.Printf("Decrypted Bytes: %v\n", []byte(decrypted))

	// 检查是否是有效的JSON
	if len(decrypted) > 0 {
		fmt.Println("Possible JSON data detected")
	} else {
		fmt.Println("No data returned from decryption")
	}
}

// 最终验证测试
func TestFinalVerification(t *testing.T) {
	// 使用与JavaScript版本相同的clientToken
	clientToken := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

	fmt.Println("=== Final Verification Test ===")

	// 使用你提供的axes生成密钥
	axes := "120,54,61,117"
	key := encryptKey(axes, clientToken)
	fmt.Printf("Generated key for axes '%s': '%s'\n", axes, key)

	// 你提供的加密数据
	encryptedData := "YN4tHIF4S3OQgfhTICpFqR425z2sHwCEmlsGdVYt5m6ssyIagtqEvf0hEXdzhc0u"

	// 尝试解密
	decrypted := Decrypt(encryptedData, key)
	fmt.Printf("Decrypted result: '%s'\n", decrypted)

	// 如果解密结果为空，尝试不同的方法
	if len(decrypted) == 0 {
		fmt.Println("Trying alternative decryption approaches...")

		// 尝试不同的填充处理
		fmt.Println("Testing raw decryption without padding removal...")
		// 这里我们可以添加更多的调试信息

		// 输出一些调试信息
		fmt.Printf("Key bytes: %v\n", []byte(key))
		fmt.Printf("Encrypted data length: %d\n", len(encryptedData))
	}
}