f3c80c4eef
Protobuf Refactoring for Multi-Module Cleanliness This commit includes the following: Moves all packages that were within proto/ to proto/private Rewrites imports to account for the packages being moved Adds in buf.work.yaml to enable buf workspaces Names the proto-public buf module so that we can override the Go package imports within proto/buf.yaml Bumps the buf version dependency to 1.14.0 (I was trying out the version to see if it would get around an issue - it didn't but it also doesn't break things and it seemed best to keep up with the toolchain changes) Why: In the future we will need to consume other protobuf dependencies such as the Google HTTP annotations for openapi generation or grpc-gateway usage. There were some recent changes to have our own ratelimiting annotations. The two combined were not working when I was trying to use them together (attempting to rebase another branch) Buf workspaces should be the solution to the problem Buf workspaces means that each module will have generated Go code that embeds proto file names relative to the proto dir and not the top level repo root. This resulted in proto file name conflicts in the Go global protobuf type registry. The solution to that was to add in a private/ directory into the path within the proto/ directory. That then required rewriting all the imports. Is this safe? AFAICT yes The gRPC wire protocol doesn't seem to care about the proto file names (although the Go grpc code does tack on the proto file name as Metadata in the ServiceDesc) Other than imports, there were no changes to any generated code as a result of this.
404 lines
12 KiB
Go
404 lines
12 KiB
Go
package proxycfgglue
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/hashicorp/consul/acl"
|
|
cachetype "github.com/hashicorp/consul/agent/cache-types"
|
|
|
|
"github.com/hashicorp/consul/agent/consul/state"
|
|
"github.com/hashicorp/consul/agent/proxycfg"
|
|
"github.com/hashicorp/consul/agent/structs"
|
|
"github.com/hashicorp/consul/lib"
|
|
"github.com/hashicorp/consul/proto/private/pbpeering"
|
|
"github.com/hashicorp/consul/sdk/testutil"
|
|
)
|
|
|
|
func TestServerTrustBundle(t *testing.T) {
|
|
const (
|
|
index uint64 = 123
|
|
peerName = "peer1"
|
|
)
|
|
|
|
store := state.NewStateStore(nil)
|
|
|
|
// Peering must exist for ptb write to succeed
|
|
require.NoError(t, store.PeeringWrite(index-1, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
Name: peerName,
|
|
ID: "2ae8c79e-242e-4f4a-afd6-9aede8831c5f",
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: peerName,
|
|
TrustDomain: "before.com",
|
|
}))
|
|
|
|
dataSource := ServerTrustBundle(ServerDataSourceDeps{
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(acl.ManageAll()),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleReadRequest{
|
|
Request: &pbpeering.TrustBundleReadRequest{
|
|
Name: peerName,
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
testutil.RunStep(t, "initial state", func(t *testing.T) {
|
|
result := getEventResult[*pbpeering.TrustBundleReadResponse](t, eventCh)
|
|
require.Equal(t, "before.com", result.Bundle.TrustDomain)
|
|
})
|
|
|
|
testutil.RunStep(t, "update trust bundle", func(t *testing.T) {
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index+1, &pbpeering.PeeringTrustBundle{
|
|
PeerName: peerName,
|
|
TrustDomain: "after.com",
|
|
}))
|
|
|
|
result := getEventResult[*pbpeering.TrustBundleReadResponse](t, eventCh)
|
|
require.Equal(t, "after.com", result.Bundle.TrustDomain)
|
|
})
|
|
}
|
|
|
|
func TestServerTrustBundle_ACLEnforcement(t *testing.T) {
|
|
const (
|
|
index uint64 = 123
|
|
peerName = "peer1"
|
|
)
|
|
|
|
store := state.NewStateStore(nil)
|
|
|
|
// Peering must exist for ptb write to succeed
|
|
require.NoError(t, store.PeeringWrite(index-1, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
Name: peerName,
|
|
ID: "2ae8c79e-242e-4f4a-afd6-9aede8831c5f",
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: peerName,
|
|
TrustDomain: "before.com",
|
|
}))
|
|
|
|
testutil.RunStep(t, "can read", func(t *testing.T) {
|
|
authz := policyAuthorizer(t, `
|
|
service "web" { policy = "write" }`)
|
|
dataSource := ServerTrustBundle(ServerDataSourceDeps{
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(authz),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleReadRequest{
|
|
Request: &pbpeering.TrustBundleReadRequest{
|
|
Name: peerName,
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
result := getEventResult[*pbpeering.TrustBundleReadResponse](t, eventCh)
|
|
require.Equal(t, "before.com", result.Bundle.TrustDomain)
|
|
})
|
|
|
|
testutil.RunStep(t, "can't read", func(t *testing.T) {
|
|
authz := policyAuthorizer(t, ``)
|
|
dataSource := ServerTrustBundle(ServerDataSourceDeps{
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(authz),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleReadRequest{
|
|
Request: &pbpeering.TrustBundleReadRequest{
|
|
Name: peerName,
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
err = getEventError(t, eventCh)
|
|
require.Contains(t, err.Error(), "token with AccessorID '' lacks permission 'service:write' on \"any service\"")
|
|
})
|
|
}
|
|
|
|
func TestServerTrustBundleList(t *testing.T) {
|
|
const index uint64 = 123
|
|
|
|
t.Run("list by service", func(t *testing.T) {
|
|
const (
|
|
serviceName = "web"
|
|
us = "default"
|
|
them = "peer2"
|
|
)
|
|
|
|
store := state.NewStateStore(nil)
|
|
require.NoError(t, store.CASetConfig(index, &structs.CAConfiguration{ClusterID: "cluster-id"}))
|
|
|
|
testutil.RunStep(t, "export service to peer", func(t *testing.T) {
|
|
require.NoError(t, store.PeeringWrite(index, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
ID: testUUID(t),
|
|
Name: them,
|
|
State: pbpeering.PeeringState_ACTIVE,
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: them,
|
|
}))
|
|
|
|
require.NoError(t, store.EnsureConfigEntry(index, &structs.ExportedServicesConfigEntry{
|
|
Name: us,
|
|
Services: []structs.ExportedService{
|
|
{
|
|
Name: serviceName,
|
|
Consumers: []structs.ServiceConsumer{
|
|
{Peer: them},
|
|
},
|
|
},
|
|
},
|
|
}))
|
|
})
|
|
|
|
dataSource := ServerTrustBundleList(ServerDataSourceDeps{
|
|
Datacenter: "dc1",
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(acl.ManageAll()),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleListRequest{
|
|
Request: &pbpeering.TrustBundleListByServiceRequest{
|
|
ServiceName: serviceName,
|
|
Partition: us,
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
testutil.RunStep(t, "initial state", func(t *testing.T) {
|
|
result := getEventResult[*pbpeering.TrustBundleListByServiceResponse](t, eventCh)
|
|
require.Len(t, result.Bundles, 1)
|
|
})
|
|
|
|
testutil.RunStep(t, "unexport the service", func(t *testing.T) {
|
|
require.NoError(t, store.EnsureConfigEntry(index+1, &structs.ExportedServicesConfigEntry{
|
|
Name: us,
|
|
Services: []structs.ExportedService{},
|
|
}))
|
|
|
|
result := getEventResult[*pbpeering.TrustBundleListByServiceResponse](t, eventCh)
|
|
require.Len(t, result.Bundles, 0)
|
|
})
|
|
})
|
|
|
|
t.Run("list for mesh gateway", func(t *testing.T) {
|
|
store := state.NewStateStore(nil)
|
|
require.NoError(t, store.CASetConfig(index, &structs.CAConfiguration{ClusterID: "cluster-id"}))
|
|
|
|
// Peering must exist for ptb write to succeed
|
|
require.NoError(t, store.PeeringWrite(index, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
Name: "peer1",
|
|
ID: "2ae8c79e-242e-4f4a-afd6-9aede8831c5f",
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringWrite(index, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
Name: "peer2",
|
|
ID: "e69f14e3-f253-43bc-bdbe-888994ca4f81",
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: "peer1",
|
|
}))
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: "peer2",
|
|
}))
|
|
|
|
dataSource := ServerTrustBundleList(ServerDataSourceDeps{
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(acl.ManageAll()),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleListRequest{
|
|
Request: &pbpeering.TrustBundleListByServiceRequest{
|
|
Kind: string(structs.ServiceKindMeshGateway),
|
|
Partition: "default",
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
result := getEventResult[*pbpeering.TrustBundleListByServiceResponse](t, eventCh)
|
|
require.Len(t, result.Bundles, 2)
|
|
})
|
|
}
|
|
|
|
func TestServerTrustBundleList_ACLEnforcement(t *testing.T) {
|
|
const index uint64 = 123
|
|
var (
|
|
authzWriteWeb = policyAuthorizer(t, `service "web" { policy = "write" }`)
|
|
authzWriteAll = policyAuthorizer(t, `service "" { policy = "write" }`)
|
|
authzNothing = policyAuthorizer(t, ``)
|
|
)
|
|
|
|
t.Run("ACL enforcement: list by service", func(t *testing.T) {
|
|
const (
|
|
serviceName = "web"
|
|
us = "default"
|
|
them = "peer2"
|
|
)
|
|
|
|
store := state.NewStateStore(nil)
|
|
require.NoError(t, store.CASetConfig(index, &structs.CAConfiguration{ClusterID: "cluster-id"}))
|
|
|
|
testutil.RunStep(t, "export service to peer", func(t *testing.T) {
|
|
require.NoError(t, store.PeeringWrite(index, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
ID: testUUID(t),
|
|
Name: them,
|
|
State: pbpeering.PeeringState_ACTIVE,
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: them,
|
|
}))
|
|
|
|
require.NoError(t, store.EnsureConfigEntry(index, &structs.ExportedServicesConfigEntry{
|
|
Name: us,
|
|
Services: []structs.ExportedService{
|
|
{
|
|
Name: serviceName,
|
|
Consumers: []structs.ServiceConsumer{
|
|
{Peer: them},
|
|
},
|
|
},
|
|
},
|
|
}))
|
|
})
|
|
|
|
testutil.RunStep(t, "can read", func(t *testing.T) {
|
|
dataSource := ServerTrustBundleList(ServerDataSourceDeps{
|
|
Datacenter: "dc1",
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(authzWriteWeb),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleListRequest{
|
|
Request: &pbpeering.TrustBundleListByServiceRequest{
|
|
ServiceName: serviceName,
|
|
Partition: us,
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
result := getEventResult[*pbpeering.TrustBundleListByServiceResponse](t, eventCh)
|
|
require.Len(t, result.Bundles, 1)
|
|
})
|
|
|
|
testutil.RunStep(t, "can't read", func(t *testing.T) {
|
|
dataSource := ServerTrustBundleList(ServerDataSourceDeps{
|
|
Datacenter: "dc1",
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(authzNothing),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleListRequest{
|
|
Request: &pbpeering.TrustBundleListByServiceRequest{
|
|
ServiceName: serviceName,
|
|
Partition: us,
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
err = getEventError(t, eventCh)
|
|
require.Contains(t, err.Error(), "token with AccessorID '' lacks permission 'service:write' on \"web\"")
|
|
})
|
|
})
|
|
|
|
t.Run("ACL Enforcement: list for mesh gateway", func(t *testing.T) {
|
|
store := state.NewStateStore(nil)
|
|
require.NoError(t, store.CASetConfig(index, &structs.CAConfiguration{ClusterID: "cluster-id"}))
|
|
|
|
// Peering must exist for ptb write to succeed
|
|
require.NoError(t, store.PeeringWrite(index, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
Name: "peer1",
|
|
ID: "2ae8c79e-242e-4f4a-afd6-9aede8831c5f",
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringWrite(index, &pbpeering.PeeringWriteRequest{
|
|
Peering: &pbpeering.Peering{
|
|
Name: "peer2",
|
|
ID: "e69f14e3-f253-43bc-bdbe-888994ca4f81",
|
|
},
|
|
}))
|
|
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: "peer1",
|
|
}))
|
|
require.NoError(t, store.PeeringTrustBundleWrite(index, &pbpeering.PeeringTrustBundle{
|
|
PeerName: "peer2",
|
|
}))
|
|
|
|
testutil.RunStep(t, "can read", func(t *testing.T) {
|
|
dataSource := ServerTrustBundleList(ServerDataSourceDeps{
|
|
Datacenter: "dc1",
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(authzWriteAll),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleListRequest{
|
|
Request: &pbpeering.TrustBundleListByServiceRequest{
|
|
Kind: string(structs.ServiceKindMeshGateway),
|
|
Partition: "default",
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
result := getEventResult[*pbpeering.TrustBundleListByServiceResponse](t, eventCh)
|
|
require.Len(t, result.Bundles, 2)
|
|
})
|
|
|
|
testutil.RunStep(t, "can't read", func(t *testing.T) {
|
|
dataSource := ServerTrustBundleList(ServerDataSourceDeps{
|
|
Datacenter: "dc1",
|
|
GetStore: func() Store { return store },
|
|
ACLResolver: newStaticResolver(authzNothing),
|
|
})
|
|
|
|
eventCh := make(chan proxycfg.UpdateEvent)
|
|
err := dataSource.Notify(context.Background(), &cachetype.TrustBundleListRequest{
|
|
Request: &pbpeering.TrustBundleListByServiceRequest{
|
|
Kind: string(structs.ServiceKindMeshGateway),
|
|
Partition: "default",
|
|
},
|
|
}, "", eventCh)
|
|
require.NoError(t, err)
|
|
|
|
err = getEventError(t, eventCh)
|
|
require.Contains(t, err.Error(), "token with AccessorID '' lacks permission 'service:write'")
|
|
})
|
|
})
|
|
}
|
|
|
|
func testUUID(t *testing.T) string {
|
|
v, err := lib.GenerateUUID(nil)
|
|
require.NoError(t, err)
|
|
return v
|
|
}
|