aipilot-cli/crypto_test.go at main · softwarity/aipilot-cli · GitHub

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
package main

import (
	"encoding/hex"
	"testing"
)

func TestGenerateX25519KeyPair(t *testing.T) {
	priv, pub, err := GenerateX25519KeyPair()
	if err != nil {
		t.Fatalf("GenerateX25519KeyPair failed: %v", err)
	}

	allZero := true
	for _, b := range priv {
		if b != 0 {
			allZero = false
			break
		}
	}
	if allZero {
		t.Error("private key is all zeros")
	}

	allZero = true
	for _, b := range pub {
		if b != 0 {
			allZero = false
			break
		}
	}
	if allZero {
		t.Error("public key is all zeros")
	}
}

func TestGenerateX25519KeyPairUniqueness(t *testing.T) {
	_, pub1, _ := GenerateX25519KeyPair()
	_, pub2, _ := GenerateX25519KeyPair()

	if pub1 == pub2 {
		t.Error("expected different key pairs")
	}
}

func TestEncryptForMobile(t *testing.T) {
	pcPriv, _, err := GenerateX25519KeyPair()
	if err != nil {
		t.Fatalf("generate PC keypair failed: %v", err)
	}

	_, mobilePub, err := GenerateX25519KeyPair()
	if err != nil {
		t.Fatalf("generate mobile keypair failed: %v", err)
	}

	mobilePubHex := hex.EncodeToString(mobilePub[:])

	encrypted, err := EncryptForMobile("test-token", mobilePubHex, pcPriv)
	if err != nil {
		t.Fatalf("EncryptForMobile failed: %v", err)
	}

	if len(encrypted) == 0 {
		t.Error("encrypted output is empty")
	}

	_, err = hex.DecodeString(encrypted)
	if err != nil {
		t.Errorf("encrypted output is not valid hex: %v", err)
	}
}

func TestEncryptForMobileInvalidKey(t *testing.T) {
	pcPriv, _, _ := GenerateX25519KeyPair()

	_, err := EncryptForMobile("test", "not-hex", pcPriv)
	if err == nil {
		t.Error("expected error for invalid hex key")
	}

	_, err = EncryptForMobile("test", "abcd", pcPriv)
	if err == nil {
		t.Error("expected error for wrong-length key")
	}
}

func TestGetPrivateKeyFromHex(t *testing.T) {
	priv, _, _ := GenerateX25519KeyPair()
	hexKey := hex.EncodeToString(priv[:])

	recovered, err := GetPrivateKeyFromHex(hexKey)
	if err != nil {
		t.Fatalf("GetPrivateKeyFromHex failed: %v", err)
	}

	if recovered != priv {
		t.Error("recovered key does not match original")
	}
}

func TestGetPrivateKeyFromHexInvalid(t *testing.T) {
	_, err := GetPrivateKeyFromHex("not-hex")
	if err == nil {
		t.Error("expected error for invalid hex")
	}

	_, err = GetPrivateKeyFromHex("abcd")
	if err == nil {
		t.Error("expected error for wrong-length key")
	}
}