vendor/github.com/docker/swarmkit/agent/secrets/secrets.go

   1 package secrets
   2
   3 import (
   4         "fmt"
   5         "sync"
   6
   7         "github.com/docker/swarmkit/agent/exec"
   8         "github.com/docker/swarmkit/api"
   9 )
  10
  11 // secrets is a map that keeps all the currently available secrets to the agent
  12 // mapped by secret ID.
  13 type secrets struct {
  14         mu sync.RWMutex
  15         m  map[string]*api.Secret
  16 }
  17
  18 // NewManager returns a place to store secrets.
  19 func NewManager() exec.SecretsManager {
  20         return &secrets{
  21                 m: make(map[string]*api.Secret),
  22         }
  23 }
  24
  25 // Get returns a secret by ID.  If the secret doesn't exist, returns nil.
  26 func (s *secrets) Get(secretID string) (*api.Secret, error) {
  27         s.mu.RLock()
  28         defer s.mu.RUnlock()
  29         if s, ok := s.m[secretID]; ok {
  30                 return s, nil
  31         }
  32         return nil, fmt.Errorf("secret %s not found", secretID)
  33 }
  34
  35 // Add adds one or more secrets to the secret map.
  36 func (s *secrets) Add(secrets ...api.Secret) {
  37         s.mu.Lock()
  38         defer s.mu.Unlock()
  39         for _, secret := range secrets {
  40                 s.m[secret.ID] = secret.Copy()
  41         }
  42 }
  43
  44 // Remove removes one or more secrets by ID from the secret map.  Succeeds
  45 // whether or not the given IDs are in the map.
  46 func (s *secrets) Remove(secrets []string) {
  47         s.mu.Lock()
  48         defer s.mu.Unlock()
  49         for _, secret := range secrets {
  50                 delete(s.m, secret)
  51         }
  52 }
  53
  54 // Reset removes all the secrets.
  55 func (s *secrets) Reset() {
  56         s.mu.Lock()
  57         defer s.mu.Unlock()
  58         s.m = make(map[string]*api.Secret)
  59 }
  60
  61 // taskRestrictedSecretsProvider restricts the ids to the task.
  62 type taskRestrictedSecretsProvider struct {
  63         secrets   exec.SecretGetter
  64         secretIDs map[string]struct{} // allow list of secret ids
  65 }
  66
  67 func (sp *taskRestrictedSecretsProvider) Get(secretID string) (*api.Secret, error) {
  68         if _, ok := sp.secretIDs[secretID]; !ok {
  69                 return nil, fmt.Errorf("task not authorized to access secret %s", secretID)
  70         }
  71
  72         return sp.secrets.Get(secretID)
  73 }
  74
  75 // Restrict provides a getter that only allows access to the secrets
  76 // referenced by the task.
  77 func Restrict(secrets exec.SecretGetter, t *api.Task) exec.SecretGetter {
  78         sids := map[string]struct{}{}
  79
  80         container := t.Spec.GetContainer()
  81         if container != nil {
  82                 for _, ref := range container.Secrets {
  83                         sids[ref.SecretID] = struct{}{}
  84                 }
  85         }
  86
  87         return &taskRestrictedSecretsProvider{secrets: secrets, secretIDs: sids}
  88 }