3825859da6
build / build (push) Successful in 2m20s
PP 增加受控凭据更新、真实登录与目录检查,待验证修改不会替换生效配置;扫描与取件共享生效修订。 钉钉来源向导、校验与登记共用 DWS 授权,支持中途恢复与换账号保护,取消旧扫码自动回落。 认证审计复用已有来源审计页,配置响应不回传密码;补齐运行镜像脚本与权限。 验证:make verify 退出 0;PP/DWS/httpapi 目标 race 回归通过;隔离 HTTP 服务验证 PP 协议及扫描/取件消费者。 尚未部署;真实 PP 凭据与目录可用性在测试站部署后验证。
357 lines
11 KiB
Go
357 lines
11 KiB
Go
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
|
||
}
|