Files
knowledge-governance/internal/ppauth/manager.go
T
姚章浩 3825859da6
build / build (push) Successful in 2m20s
feat(settings): 打通 PP 认证配置并统一 DWS 来源授权
PP 增加受控凭据更新、真实登录与目录检查,待验证修改不会替换生效配置;扫描与取件共享生效修订。
钉钉来源向导、校验与登记共用 DWS 授权,支持中途恢复与换账号保护,取消旧扫码自动回落。
认证审计复用已有来源审计页,配置响应不回传密码;补齐运行镜像脚本与权限。

验证:make verify 退出 0;PP/DWS/httpapi 目标 race 回归通过;隔离 HTTP 服务验证 PP 协议及扫描/取件消费者。
尚未部署;真实 PP 凭据与目录可用性在测试站部署后验证。
2026-11-17 19:08:46 +08:00

357 lines
11 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package ppauth
import (
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"net/url"
"os"
"path/filepath"
"strings"
"syscall"
"time"
)
type Credentials struct {
ID string `json:"id"`
BaseURL string `json:"base_url"`
Username string `json:"username"`
Password string `json:"password"`
}
type Draft struct {
BaseURL string `json:"base_url"`
Username string `json:"username"`
Password string `json:"password,omitempty"`
PendingID string `json:"pending_id,omitempty"`
Revision int `json:"revision"`
}
type Observation struct {
State string `json:"state"`
Message string `json:"message"`
CheckedAt string `json:"checked_at"`
Previous *Observation `json:"previous,omitempty"`
}
type Metadata struct {
ID string `json:"id"`
BaseURL string `json:"base_url"`
Username string `json:"username"`
PasswordConfigured bool `json:"password_configured"`
}
type View struct {
Revision int `json:"revision"`
Active *Metadata `json:"active"`
Pending *Metadata `json:"pending"`
Observation *Observation `json:"observation"`
PendingObservation *Observation `json:"pending_observation"`
}
type AuditEvent struct {
ID string `json:"id"`
SourceName string `json:"source_name"`
Action string `json:"action"`
Actor string `json:"actor"`
CreatedAt time.Time `json:"created_at"`
Detail string `json:"detail"`
}
type State struct {
Revision int `json:"revision"`
Active *Credentials `json:"active"`
Pending *Credentials `json:"pending"`
Observation *Observation `json:"observation"`
PendingObservation *Observation `json:"pending_observation"`
Audit []AuditEvent `json:"audit"`
}
type Manager struct {
Path string
LegacyPath string
Probe func(context.Context, Credentials) Observation
}
var ErrRejected = errors.New("PP 配置校验未通过,原配置保留")
var ErrInvalid = errors.New("API 地址必须为 HTTPS 根地址,且不能包含凭据、查询参数或片段")
var ErrConflict = errors.New("配置已被更新,请刷新后重新提交")
func ValidateBaseURL(raw string) bool {
u, err := url.Parse(raw)
return err == nil && len(raw) <= 300 && strings.TrimSpace(raw) == raw && u.Scheme == "https" && u.Host != "" && u.Hostname() != "" && u.Opaque == "" && u.User == nil && u.RawQuery == "" && !u.ForceQuery && u.Fragment == "" && !strings.Contains(raw, "#") && (u.Path == "" || u.Path == "/")
}
func metadata(c *Credentials) *Metadata {
if c == nil {
return nil
}
return &Metadata{ID: c.ID, BaseURL: c.BaseURL, Username: c.Username, PasswordConfigured: c.Password != ""}
}
func view(s State) View {
return View{Revision: s.Revision, Active: metadata(s.Active), Pending: metadata(s.Pending), Observation: s.Observation, PendingObservation: s.PendingObservation}
}
func randomID() string {
var b [16]byte
if _, err := rand.Read(b[:]); err != nil {
panic("secure random unavailable")
}
return hex.EncodeToString(b[:])
}
func (m *Manager) locked(ctx context.Context, fn func(*State) (bool, error)) error {
if !filepath.IsAbs(m.Path) {
return errors.New("PP credential storage path is invalid")
}
dir := filepath.Dir(m.Path)
if err := os.MkdirAll(dir, 0700); err != nil {
return errors.New("PP 配置存储不可用")
}
info, err := os.Lstat(dir)
if err != nil || !info.IsDir() || info.Mode().Perm()&0077 != 0 {
return errors.New("PP 配置目录权限必须为 0700")
}
lockPath := m.Path + ".lock"
if info, e := os.Lstat(lockPath); e == nil && (info.Mode()&os.ModeSymlink != 0 || info.Mode().Perm()&0077 != 0) {
return errors.New("PP 配置锁权限不安全")
}
lock, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0600)
if err != nil {
return errors.New("PP 配置存储不可用")
}
defer lock.Close()
for {
err = syscall.Flock(int(lock.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
if err == nil {
break
}
if err != syscall.EWOULDBLOCK {
return errors.New("PP 配置锁不可用")
}
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(20 * time.Millisecond):
}
}
defer syscall.Flock(int(lock.Fd()), syscall.LOCK_UN)
var s State
info, err = os.Lstat(m.Path)
if err == nil {
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() || info.Mode().Perm()&0077 != 0 || info.Size() > 16<<20 {
return errors.New("PP 凭据文件权限或格式不安全")
}
raw, e := os.ReadFile(m.Path)
if e != nil || json.Unmarshal(raw, &s) != nil {
return errors.New("无法读取 PP 配置")
}
} else if !errors.Is(err, os.ErrNotExist) {
return errors.New("无法读取 PP 配置")
} else if m.LegacyPath != "" {
raw, e := os.ReadFile(m.LegacyPath)
if e == nil {
var c Credentials
if json.Unmarshal(raw, &c) != nil {
return errors.New("旧 PP 配置格式不正确")
}
if c.BaseURL == "" {
c.BaseURL = "https://api.dobot.cn"
}
c.ID = "legacy"
s.Active = &c
} else if !errors.Is(e, os.ErrNotExist) {
return errors.New("无法读取旧 PP 配置")
}
}
changed, err := fn(&s)
if err != nil || !changed {
return err
}
raw, err := json.Marshal(s)
if err != nil {
return errors.New("PP 配置保存失败")
}
f, err := os.CreateTemp(dir, ".pp-next-")
if err != nil {
return errors.New("PP 配置保存失败")
}
tmp := f.Name()
defer os.Remove(tmp)
if err = f.Chmod(0600); err == nil {
_, err = f.Write(raw)
}
if err == nil {
err = f.Sync()
}
closeErr := f.Close()
if err == nil {
err = closeErr
}
if err == nil {
err = os.Rename(tmp, m.Path)
}
if err != nil {
return errors.New("PP 配置保存失败")
}
d, e := os.Open(dir)
if e != nil {
return errors.New("PP 配置持久化未确认")
}
defer d.Close()
if d.Sync() != nil {
return errors.New("PP 配置持久化未确认")
}
return nil
}
func (m *Manager) View() (v View, err error) {
err = m.locked(context.Background(), func(s *State) (bool, error) { v = view(*s); return false, nil })
return
}
func (m *Manager) snapshot(ctx context.Context) (s State, err error) {
err = m.locked(ctx, func(state *State) (bool, error) { s = *state; return false, nil })
return
}
func candidate(s State, d Draft) (Credentials, error) {
if !ValidateBaseURL(d.BaseURL) {
return Credentials{}, ErrInvalid
}
if len(d.Username) > 255 || strings.ContainsAny(d.Username, "\n\r\x00") || len(d.Password) > 8192 {
return Credentials{}, errors.New("账号或密码格式不正确")
}
c := Credentials{ID: randomID(), BaseURL: strings.TrimRight(d.BaseURL, "/"), Username: strings.TrimSpace(d.Username), Password: d.Password}
if c.Password == "" && d.PendingID != "" {
if s.Pending == nil || s.Pending.ID != d.PendingID {
return Credentials{}, ErrConflict
}
c.Password = s.Pending.Password
} else if c.Password == "" && s.Active != nil {
c.Password = s.Active.Password
}
return c, nil
}
func same(a, b *Credentials) bool {
return a != nil && b != nil && a.BaseURL == b.BaseURL && a.Username == b.Username && a.Password == b.Password
}
func (m *Manager) probe(ctx context.Context, c Credentials) Observation {
o := Observation{State: "incomplete", Message: "配置未完成,请填写账号和密码"}
if c.Username != "" && c.Password != "" {
if m.Probe == nil {
o = Observation{State: "unavailable", Message: "PP 检查服务未接通"}
} else {
o = m.Probe(ctx, c)
}
}
switch o.State {
case "valid", "auth_failed", "permission_denied", "incomplete", "unavailable", "invalid_response":
default:
o = Observation{State: "unavailable", Message: "检查结果不可识别,请重试"}
}
if o.CheckedAt == "" {
o.CheckedAt = time.Now().UTC().Format(time.RFC3339Nano)
}
return o
}
func addAudit(s *State, source, action, actor, detail string) {
s.Audit = append(s.Audit, AuditEvent{ID: "auth-" + randomID(), SourceName: source, Action: action, Actor: actor, CreatedAt: time.Now().UTC(), Detail: detail})
}
func retainObservation(old *Observation, next Observation) *Observation {
if next.State == "unavailable" && old != nil {
if old.State == "unavailable" && old.Previous != nil {
next.Previous = old.Previous
} else {
next.Previous = old
}
}
return &next
}
func (m *Manager) Save(ctx context.Context, d Draft, actor string) (v View, err error) {
s, err := m.snapshot(ctx)
if err != nil {
return v, err
}
if s.Revision != d.Revision {
return v, ErrConflict
}
c, err := candidate(s, d)
if err != nil {
return v, err
}
o := m.probe(ctx, c)
rejected := o.State == "auth_failed" || o.State == "permission_denied" || o.State == "invalid_response"
err = m.locked(ctx, func(current *State) (bool, error) {
if current.Revision != s.Revision {
return false, ErrConflict
}
if rejected {
if same(current.Active, &c) {
current.Observation = retainObservation(current.Observation, o)
}
addAudit(current, "PP 资料下载中心", "credential_rejected", actor, o.Message)
v = view(*current)
return true, nil
}
current.Revision++
if o.State == "valid" {
current.Active = &c
current.Pending = nil
current.Observation = retainObservation(current.Observation, o)
current.PendingObservation = nil
} else {
current.Pending = &c
current.PendingObservation = &o
}
detail := "认证配置已保存并生效"
if o.State != "valid" {
detail = "修改已保存为待验证,未替换生效配置"
}
if d.Password != "" {
detail += ";密码已更新"
}
addAudit(current, "PP 资料下载中心", "credential_configured", actor, detail)
v = view(*current)
return true, nil
})
if err == nil && rejected {
err = fmt.Errorf("%w:%s", ErrRejected, o.Message)
}
return
}
func (m *Manager) Test(ctx context.Context, d Draft, actor string) (o Observation, err error) {
s, err := m.snapshot(ctx)
if err != nil {
return o, err
}
if s.Revision != d.Revision {
return o, ErrConflict
}
c, err := candidate(s, d)
if err != nil {
return o, err
}
o = m.probe(ctx, c)
err = m.locked(ctx, func(current *State) (bool, error) {
if current.Revision != s.Revision {
return false, ErrConflict
}
if same(current.Active, &c) {
current.Observation = retainObservation(current.Observation, o)
}
addAudit(current, "PP 资料下载中心", "credential_test", actor, o.Message)
return true, nil
})
return
}
func (m *Manager) Audit(ctx context.Context, source, action, actor, detail string) error {
return m.locked(ctx, func(s *State) (bool, error) { addAudit(s, source, action, actor, detail); return true, nil })
}
func (m *Manager) AuditOnce(ctx context.Context, id, source, action, actor, detail string) error {
return m.locked(ctx, func(s *State) (bool, error) {
for _, e := range s.Audit {
if e.ID == id {
return false, nil
}
}
addAudit(s, source, action, actor, detail)
s.Audit[len(s.Audit)-1].ID = id
return true, nil
})
}
func (m *Manager) Events(ctx context.Context) (events []AuditEvent, err error) {
err = m.locked(ctx, func(s *State) (bool, error) { events = append(events, s.Audit...); return false, nil })
return
}