|
| 1 | +/* |
| 2 | +Copyright 2026 The Flux authors |
| 3 | +
|
| 4 | +Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | +you may not use this file except in compliance with the License. |
| 6 | +You may obtain a copy of the License at |
| 7 | +
|
| 8 | + http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | +
|
| 10 | +Unless required by applicable law or agreed to in writing, software |
| 11 | +distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | +See the License for the specific language governing permissions and |
| 14 | +limitations under the License. |
| 15 | +*/ |
| 16 | + |
| 17 | +package spiffe_test |
| 18 | + |
| 19 | +import ( |
| 20 | + "crypto/ecdsa" |
| 21 | + "crypto/elliptic" |
| 22 | + "crypto/rand" |
| 23 | + "crypto/x509" |
| 24 | + "crypto/x509/pkix" |
| 25 | + "errors" |
| 26 | + "math/big" |
| 27 | + "net" |
| 28 | + "net/url" |
| 29 | + "os" |
| 30 | + "sync" |
| 31 | + "testing" |
| 32 | + "time" |
| 33 | + |
| 34 | + "github.com/spiffe/go-spiffe/v2/proto/spiffe/workload" |
| 35 | + "github.com/spiffe/go-spiffe/v2/spiffeid" |
| 36 | + "github.com/spiffe/go-spiffe/v2/workloadapi" |
| 37 | + "google.golang.org/grpc" |
| 38 | +) |
| 39 | + |
| 40 | +type testCA struct { |
| 41 | + cert *x509.Certificate |
| 42 | + key *ecdsa.PrivateKey |
| 43 | +} |
| 44 | + |
| 45 | +func newTestCA(t *testing.T) *testCA { |
| 46 | + t.Helper() |
| 47 | + |
| 48 | + key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) |
| 49 | + if err != nil { |
| 50 | + t.Fatalf("failed to generate CA key: %v", err) |
| 51 | + } |
| 52 | + tmpl := &x509.Certificate{ |
| 53 | + SerialNumber: big.NewInt(1), |
| 54 | + Subject: pkix.Name{CommonName: "test-ca"}, |
| 55 | + NotBefore: time.Now().Add(-time.Hour), |
| 56 | + NotAfter: time.Now().Add(time.Hour), |
| 57 | + KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageCRLSign, |
| 58 | + BasicConstraintsValid: true, |
| 59 | + IsCA: true, |
| 60 | + } |
| 61 | + der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key) |
| 62 | + if err != nil { |
| 63 | + t.Fatalf("failed to create CA certificate: %v", err) |
| 64 | + } |
| 65 | + cert, err := x509.ParseCertificate(der) |
| 66 | + if err != nil { |
| 67 | + t.Fatalf("failed to parse CA certificate: %v", err) |
| 68 | + } |
| 69 | + return &testCA{cert: cert, key: key} |
| 70 | +} |
| 71 | + |
| 72 | +func (ca *testCA) newCertificate(t *testing.T, id spiffeid.ID, serial int64) (*x509.Certificate, *ecdsa.PrivateKey) { |
| 73 | + t.Helper() |
| 74 | + |
| 75 | + key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) |
| 76 | + if err != nil { |
| 77 | + t.Fatalf("failed to generate SVID key: %v", err) |
| 78 | + } |
| 79 | + uri, err := url.Parse(id.String()) |
| 80 | + if err != nil { |
| 81 | + t.Fatalf("failed to parse SPIFFE ID: %v", err) |
| 82 | + } |
| 83 | + tmpl := &x509.Certificate{ |
| 84 | + SerialNumber: big.NewInt(serial), |
| 85 | + NotBefore: time.Now().Add(-time.Hour), |
| 86 | + NotAfter: time.Now().Add(time.Hour), |
| 87 | + KeyUsage: x509.KeyUsageDigitalSignature, |
| 88 | + ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth}, |
| 89 | + URIs: []*url.URL{uri}, |
| 90 | + } |
| 91 | + der, err := x509.CreateCertificate(rand.Reader, tmpl, ca.cert, &key.PublicKey, ca.key) |
| 92 | + if err != nil { |
| 93 | + t.Fatalf("failed to create SVID certificate: %v", err) |
| 94 | + } |
| 95 | + cert, err := x509.ParseCertificate(der) |
| 96 | + if err != nil { |
| 97 | + t.Fatalf("failed to parse SVID certificate: %v", err) |
| 98 | + } |
| 99 | + return cert, key |
| 100 | +} |
| 101 | + |
| 102 | +func (ca *testCA) newX509SVID(t *testing.T, id spiffeid.ID, serial int64) *workload.X509SVID { |
| 103 | + t.Helper() |
| 104 | + |
| 105 | + cert, key := ca.newCertificate(t, id, serial) |
| 106 | + keyDER, err := x509.MarshalPKCS8PrivateKey(key) |
| 107 | + if err != nil { |
| 108 | + t.Fatalf("failed to marshal SVID key: %v", err) |
| 109 | + } |
| 110 | + return &workload.X509SVID{ |
| 111 | + SpiffeId: id.String(), |
| 112 | + X509Svid: cert.Raw, |
| 113 | + X509SvidKey: keyDER, |
| 114 | + Bundle: ca.cert.Raw, |
| 115 | + } |
| 116 | +} |
| 117 | + |
| 118 | +type fakeWorkloadAPI struct { |
| 119 | + workload.UnimplementedSpiffeWorkloadAPIServer |
| 120 | + |
| 121 | + mtx sync.Mutex |
| 122 | + resp *workload.X509SVIDResponse |
| 123 | + updated chan struct{} |
| 124 | +} |
| 125 | + |
| 126 | +func newFakeWorkloadAPI(svid *workload.X509SVID) *fakeWorkloadAPI { |
| 127 | + f := &fakeWorkloadAPI{updated: make(chan struct{})} |
| 128 | + f.setX509SVID(svid) |
| 129 | + return f |
| 130 | +} |
| 131 | + |
| 132 | +func (f *fakeWorkloadAPI) setX509SVID(svid *workload.X509SVID) { |
| 133 | + f.mtx.Lock() |
| 134 | + defer f.mtx.Unlock() |
| 135 | + f.resp = &workload.X509SVIDResponse{Svids: []*workload.X509SVID{svid}} |
| 136 | + close(f.updated) |
| 137 | + f.updated = make(chan struct{}) |
| 138 | +} |
| 139 | + |
| 140 | +func (f *fakeWorkloadAPI) FetchX509SVID(_ *workload.X509SVIDRequest, |
| 141 | + stream grpc.ServerStreamingServer[workload.X509SVIDResponse]) error { |
| 142 | + for { |
| 143 | + f.mtx.Lock() |
| 144 | + resp := f.resp |
| 145 | + updated := f.updated |
| 146 | + f.mtx.Unlock() |
| 147 | + |
| 148 | + if err := stream.Send(resp); err != nil { |
| 149 | + return err |
| 150 | + } |
| 151 | + |
| 152 | + select { |
| 153 | + case <-updated: |
| 154 | + case <-stream.Context().Done(): |
| 155 | + return nil |
| 156 | + } |
| 157 | + } |
| 158 | +} |
| 159 | + |
| 160 | +func newSocketPath(t *testing.T) string { |
| 161 | + t.Helper() |
| 162 | + dir, err := os.MkdirTemp("", "flux-spiffe") |
| 163 | + if err != nil { |
| 164 | + t.Fatalf("failed to create temporary directory: %v", err) |
| 165 | + } |
| 166 | + t.Cleanup(func() { _ = os.RemoveAll(dir) }) |
| 167 | + return dir + "/api.sock" |
| 168 | +} |
| 169 | + |
| 170 | +func startWorkloadAPI(t *testing.T, socketPath string, handler *fakeWorkloadAPI) (stop func()) { |
| 171 | + t.Helper() |
| 172 | + |
| 173 | + if err := os.Remove(socketPath); err != nil && !errors.Is(err, os.ErrNotExist) { |
| 174 | + t.Fatalf("failed to remove stale socket: %v", err) |
| 175 | + } |
| 176 | + listener, err := net.Listen("unix", socketPath) |
| 177 | + if err != nil { |
| 178 | + t.Fatalf("failed to listen on socket: %v", err) |
| 179 | + } |
| 180 | + server := grpc.NewServer() |
| 181 | + workload.RegisterSpiffeWorkloadAPIServer(server, handler) |
| 182 | + go func() { _ = server.Serve(listener) }() |
| 183 | + |
| 184 | + var once sync.Once |
| 185 | + stop = func() { |
| 186 | + once.Do(func() { |
| 187 | + server.Stop() |
| 188 | + _ = listener.Close() |
| 189 | + _ = os.Remove(socketPath) |
| 190 | + }) |
| 191 | + } |
| 192 | + t.Cleanup(stop) |
| 193 | + return stop |
| 194 | +} |
| 195 | + |
| 196 | +type fastBackoff struct{} |
| 197 | + |
| 198 | +func (fastBackoff) NewBackoff() workloadapi.Backoff { |
| 199 | + return fastBackoffInstance{} |
| 200 | +} |
| 201 | + |
| 202 | +type fastBackoffInstance struct{} |
| 203 | + |
| 204 | +func (fastBackoffInstance) Next() time.Duration { return 10 * time.Millisecond } |
| 205 | +func (fastBackoffInstance) Reset() {} |
0 commit comments