123 lines
2.9 KiB
Go
123 lines
2.9 KiB
Go
package node
|
|
|
|
import (
|
|
"crypto/ed25519"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
type State struct {
|
|
Version int `json:"version"`
|
|
PrivateKey []byte `json:"private_key"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
type Store struct {
|
|
mu sync.Mutex
|
|
path string
|
|
state State
|
|
}
|
|
|
|
func OpenStore(dir string) (*Store, error) {
|
|
if err := os.MkdirAll(dir, 0700); err != nil {
|
|
return nil, err
|
|
}
|
|
s := &Store{path: filepath.Join(dir, "identity.json")}
|
|
b, err := os.ReadFile(s.path)
|
|
if err == nil {
|
|
if err = json.Unmarshal(b, &s.state); err != nil {
|
|
return nil, errors.New("invalid identity; recovery required")
|
|
}
|
|
if s.state.Version != 1 || len(s.state.PrivateKey) != ed25519.PrivateKeySize {
|
|
return nil, errors.New("unsupported identity; recovery required")
|
|
}
|
|
derived := ed25519.NewKeyFromSeed(s.state.PrivateKey[:ed25519.SeedSize])
|
|
if !equalKey(derived, s.state.PrivateKey) {
|
|
return nil, errors.New("corrupt identity; recovery required")
|
|
}
|
|
if info, e := os.Stat(s.path); e != nil || info.Mode().Perm()&0077 != 0 {
|
|
return nil, errors.New("identity permissions must be private")
|
|
}
|
|
return s, nil
|
|
}
|
|
if !errors.Is(err, os.ErrNotExist) {
|
|
return nil, err
|
|
}
|
|
_, key, err := ed25519.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
s.state = State{Version: 1, PrivateKey: key, Name: "Моя нода"}
|
|
if err := s.write(s.state); err != nil {
|
|
return nil, err
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func equalKey(a, b []byte) bool { return string(a) == string(b) }
|
|
|
|
func (s *Store) write(state State) error {
|
|
b, err := json.Marshal(state)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
f, err := os.CreateTemp(filepath.Dir(s.path), ".identity-*")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer os.Remove(f.Name())
|
|
if _, err = f.Write(b); err != nil {
|
|
f.Close()
|
|
return err
|
|
}
|
|
if err = f.Sync(); err != nil {
|
|
f.Close()
|
|
return err
|
|
}
|
|
if err = f.Close(); err != nil {
|
|
return err
|
|
}
|
|
if err = os.Rename(f.Name(), s.path); err != nil {
|
|
return err
|
|
}
|
|
d, err := os.Open(filepath.Dir(s.path))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer d.Close()
|
|
return d.Sync()
|
|
}
|
|
|
|
func (s *Store) Public() (string, string) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
pub := ed25519.PrivateKey(s.state.PrivateKey).Public().(ed25519.PublicKey)
|
|
hash := sha256.Sum256(pub)
|
|
return "node_" + hex.EncodeToString(hash[:]), s.state.Name
|
|
}
|
|
|
|
func (s *Store) Rename(name string) error {
|
|
name = strings.TrimSpace(name)
|
|
if name == "" || !utf8.ValidString(name) || utf8.RuneCountInString(name) > 64 || strings.ContainsFunc(name, unicode.IsControl) {
|
|
return errors.New("Название должно содержать от 1 до 64 символов без управляющих знаков")
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
next := s.state
|
|
next.Name = name
|
|
if err := s.write(next); err != nil {
|
|
return errors.New("Не удалось сохранить название")
|
|
}
|
|
s.state = next
|
|
return nil
|
|
}
|