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 }