File size: 5,260 Bytes
7e312e3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
package reqlog

import (
	"crypto/rand"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"time"
)

// LogKey 是只读日志 API 的访问凭证。只保存 SHA-256 哈希,明文仅在创建时返回一次。
type LogKey struct {
	ID         string `json:"id"`
	Name       string `json:"name"`
	Prefix     string `json:"prefix"`
	Hash       string `json:"hash"`
	CreatedAt  int64  `json:"created_at"`
	ExpiresAt  int64  `json:"expires_at,omitempty"`
	LastUsedAt int64  `json:"last_used_at,omitempty"`
	RevokedAt  int64  `json:"revoked_at,omitempty"`
}

// Public 用于返回给管理界面,隐藏哈希。
type PublicLogKey struct {
	ID         string `json:"id"`
	Name       string `json:"name"`
	Prefix     string `json:"prefix"`
	CreatedAt  int64  `json:"created_at"`
	ExpiresAt  int64  `json:"expires_at,omitempty"`
	LastUsedAt int64  `json:"last_used_at,omitempty"`
	Revoked    bool   `json:"revoked"`
}

func (k LogKey) Public() PublicLogKey {
	return PublicLogKey{
		ID:         k.ID,
		Name:       k.Name,
		Prefix:     k.Prefix,
		CreatedAt:  k.CreatedAt,
		ExpiresAt:  k.ExpiresAt,
		LastUsedAt: k.LastUsedAt,
		Revoked:    k.RevokedAt > 0,
	}
}

// KeyStore 负责日志 API Key 的生成、校验与持久化。
type KeyStore struct {
	mu     sync.RWMutex
	path   string
	keys   []LogKey
	byHash map[string]int
}

const KeyPrefix = "ds2log_"

func NewKeyStore(path string) *KeyStore {
	s := &KeyStore{path: strings.TrimSpace(path), byHash: map[string]int{}}
	s.load()
	return s
}

func (s *KeyStore) load() {
	if s.path == "" {
		return
	}
	b, err := os.ReadFile(s.path)
	if err != nil {
		if !os.IsNotExist(err) {
			// 读取失败时保持空列表,避免影响服务启动。
			return
		}
		return
	}
	var keys []LogKey
	if err := json.Unmarshal(b, &keys); err != nil {
		return
	}
	s.mu.Lock()
	s.keys = keys
	s.rebuildLocked()
	s.mu.Unlock()
}

func (s *KeyStore) rebuildLocked() {
	s.byHash = make(map[string]int, len(s.keys))
	for i, k := range s.keys {
		if k.Hash != "" {
			s.byHash[k.Hash] = i
		}
	}
}

func (s *KeyStore) saveLocked() error {
	if s.path == "" {
		return nil
	}
	if err := os.MkdirAll(filepath.Dir(s.path), 0o750); err != nil {
		return err
	}
	b, err := json.MarshalIndent(s.keys, "", "  ")
	if err != nil {
		return err
	}
	tmp := s.path + ".tmp"
	if err := os.WriteFile(tmp, b, 0o600); err != nil {
		return err
	}
	return os.Rename(tmp, s.path)
}

// Create 生成新 key,返回明文与记录。
func (s *KeyStore) Create(name string, ttl time.Duration) (string, PublicLogKey, error) {
	name = strings.TrimSpace(name)
	if name == "" {
		name = "log-reader"
	}
	buf := make([]byte, 24)
	if _, err := rand.Read(buf); err != nil {
		return "", PublicLogKey{}, err
	}
	plain := KeyPrefix + hex.EncodeToString(buf)
	sum := sha256.Sum256([]byte(plain))
	now := time.Now()
	item := LogKey{
		ID:        "lk_" + hex.EncodeToString(buf[:6]),
		Name:      name,
		Prefix:    plain[:len(KeyPrefix)+6],
		Hash:      hex.EncodeToString(sum[:]),
		CreatedAt: now.Unix(),
	}
	if ttl > 0 {
		item.ExpiresAt = now.Add(ttl).Unix()
	}
	s.mu.Lock()
	s.keys = append(s.keys, item)
	s.rebuildLocked()
	err := s.saveLocked()
	s.mu.Unlock()
	if err != nil {
		return "", PublicLogKey{}, err
	}
	return plain, item.Public(), nil
}

// Verify 校验 token;成功后刷新 last_used_at(最多每分钟写一次盘)。
func (s *KeyStore) Verify(token string) (PublicLogKey, bool) {
	token = strings.TrimSpace(token)
	if token == "" || !strings.HasPrefix(token, KeyPrefix) {
		return PublicLogKey{}, false
	}
	sum := sha256.Sum256([]byte(token))
	hash := hex.EncodeToString(sum[:])
	now := time.Now().Unix()
	s.mu.Lock()
	defer s.mu.Unlock()
	idx, ok := s.byHash[hash]
	if !ok {
		return PublicLogKey{}, false
	}
	item := s.keys[idx]
	if item.RevokedAt > 0 {
		return PublicLogKey{}, false
	}
	if item.ExpiresAt > 0 && item.ExpiresAt <= now {
		return PublicLogKey{}, false
	}
	if now-item.LastUsedAt >= 60 {
		s.keys[idx].LastUsedAt = now
		if err := s.saveLocked(); err != nil {
			// 使用记录写盘失败不影响鉴权结果。
			_ = err
		}
	}
	return s.keys[idx].Public(), true
}

// List 返回全部 key(新的在前)。
func (s *KeyStore) List() []PublicLogKey {
	s.mu.RLock()
	defer s.mu.RUnlock()
	out := make([]PublicLogKey, 0, len(s.keys))
	for _, k := range s.keys {
		out = append(out, k.Public())
	}
	sort.SliceStable(out, func(i, j int) bool { return out[i].CreatedAt > out[j].CreatedAt })
	return out
}

var ErrKeyNotFound = errors.New("log key not found")

// Revoke 立即吊销 key。
func (s *KeyStore) Revoke(id string) error {
	id = strings.TrimSpace(id)
	s.mu.Lock()
	defer s.mu.Unlock()
	for i := range s.keys {
		if s.keys[i].ID != id {
			continue
		}
		if s.keys[i].RevokedAt == 0 {
			s.keys[i].RevokedAt = time.Now().Unix()
			return s.saveLocked()
		}
		return nil
	}
	return ErrKeyNotFound
}

// Delete 永久删除 key 记录。
func (s *KeyStore) Delete(id string) error {
	id = strings.TrimSpace(id)
	s.mu.Lock()
	defer s.mu.Unlock()
	for i := range s.keys {
		if s.keys[i].ID != id {
			continue
		}
		s.keys = append(s.keys[:i], s.keys[i+1:]...)
		s.rebuildLocked()
		return s.saveLocked()
	}
	return ErrKeyNotFound
}