hiddenpath

type AddressResolver interface {
	// Resolve creates an address with a path to the remote ISD-AS that is
	// specified.
	Resolve(context.Context, addr.IA) (net.Addr, error)
}

type AuthoritativeServer struct {
	// Groups is the current set of groups.
	Groups map[GroupID]*Group
	// DB is used to read hidden segments.
	DB Store
	// LocalIA is the ISD-AS this server is run in.
	LocalIA addr.IA
}

type BeaconWriter struct {
	// InternalErrors counts errors that happened before being able to send a
	// segment to a remote. This can be during terminating the segment, looking
	// up the remote etc. If the counter is nil errors are not counted.
	InternalErrors metrics.Counter
	// Registered counts the amount of registered segments. A label is used to
	// indicate the status of the registration.
	Registered metrics.Counter
	// Intfs gives access to the interfaces this CS beacons over.
	Intfs *ifstate.Interfaces
	// Extender is used to terminate the beacon.
	Extender beaconing.Extender
	// RPC is used to send the segment to the remote. For public registrations
	// the entry with an empty group ID as key is used.
	RPC Register
	// Pather is used to construct paths to the originator of a beacon.
	Pather beaconing.Pather
	// RegistrationPolicy is the hidden path registration policy.
	RegistrationPolicy RegistrationPolicy
	// AddressResolver is used to resolve remote ASes.
	AddressResolver AddressResolver
}

type Discoverer interface {
	Discover(ctx context.Context, dsAddr net.Addr) (Servers, error)
}

type ForwardServer struct {
	Groups    map[GroupID]*Group
	LocalAuth Lookuper
	LocalIA   addr.IA
	RPC       RPC
	Resolver  AddressResolver
	Verifier  Verifier
}

type Group struct {
	// ID is a 64-bit unique identifier of the group. It is the concatenation of
	// the owner AS number and a hex encoded 16-bit suffix.
	ID GroupID
	// Owner is the AS ID of the owner of the hidden path group. The Owner AS is
	// responsible for maintaining the hidden path group configuration and
	// distributing it to all entities that require it.
	Owner addr.IA
	// Writers contains all ASes in the group that are allowed to register hidden
	// paths.
	Writers map[addr.IA]struct{}
	// Readers contains all ASes in the group which are allowed to read hidden
	// path information.
	Readers map[addr.IA]struct{}
	// Registries contains all ASes in the group at which Writers register hidden
	// paths.
	Registries map[addr.IA]struct{}
}

type GroupID struct {
	OwnerAS addr.AS
	Suffix  uint16
}

type Groups map[GroupID]*Group

type InterfacePolicy struct {
	// The policy for registering the segment publicly.
	Public bool
	// The policies for the different hidden path groups.
	Groups map[GroupID]*Group
}

type LookupResolver struct {
	Router     snet.Router
	Discoverer Discoverer
}

type Lookuper interface {
	Segments(context.Context, SegmentRequest) ([]*seg.Meta, error)
}

type RPC interface {
	HiddenSegments(context.Context, SegmentRequest, net.Addr) ([]*seg.Meta, error)
}

type Register interface {
	RegisterSegment(context.Context, SegmentRegistration, net.Addr) error
}

type Registration struct {
	// Segments are the segments to be registered.
	Segments []*seg.Meta
	// GroupID is the hiddenpath group ID under which the segments should be
	// registered.
	GroupID GroupID
	// Peer is the address of the writer of the segments.
	Peer *snet.SVCAddr
}

type RegistrationPolicy map[uint64]InterfacePolicy

type RegistrationResolver struct {
	Router     snet.Router
	Discoverer Discoverer
}

type Registry interface {
	Register(context.Context, Registration) error
}

type RegistryServer struct {
	// Groups is the current set of groups.
	Groups map[GroupID]*Group
	// DB is used to write received segments.
	DB Store
	// Verifier is used to verify the received segments.
	Verifier Verifier
	// LocalIA is the IA this handler is in.
	LocalIA addr.IA
}

type Roles struct {
	Owner    bool
	Registry bool
	Reader   bool
	Writer   bool
}

type SegmentRegistration struct {
	GroupID GroupID
	Seg     seg.Meta
}

type SegmentRequest struct {
	// GroupIDs are the hidden path group IDs for which the segments are
	// requested.
	GroupIDs []GroupID
	// DstIA is the destination ISD-AS of the segments that are requested.
	DstIA addr.IA
	// Peer is ISD-AS of the requesting peer.
	Peer addr.IA
}

type Servers struct {
	// Lookup is the list of lookup addresses.
	Lookup []*net.UDPAddr
	// Registration is the list of registration addresses.
	Registration []*net.UDPAddr
}

type Store interface {
	// Get gets the segments that end at the given IA and are in one of the given
	// hidden path groups.
	Get(context.Context, addr.IA, []GroupID) ([]*seg.Meta, error)
	// Put puts the given segments in the database and associates them with the
	// given hidden path group ID.
	Put(context.Context, []*seg.Meta, GroupID) error
}

type Storer struct {
	DB pathdb.DB
}

type Verifier interface {
	// Verify fetches the crypto material from the server and verifies the segments.
	Verify(ctx context.Context, segments []*seg.Meta, server net.Addr) error
}

type VerifierAdapter struct {
	Verifier infra.Verifier
}