certificates

type Certificate interface {
	GetSolution() Solution
	GetInfo() *CertificateInfo
	GetEntity() CertificateEntity
	Equals(other Certificate) bool
}

type CertificateEntity interface {
	Certificate() Certificate
}

type CertificateInfo struct {
	Version           string
	SN                string
	StartedAt         time.Time
	StoppedAt         time.Time
	FingerprintSHA1   []byte
	FingerprintSHA256 []byte

	Subject Name
	Issuer  Name
}

type Chain interface {
	GetParent() Chain
	GetCertificate() Certificate
}

type Name struct {
	Country, Organization, OrganizationalUnit string
	Locality, Province                        string
	StreetAddress, PostalCode                 string
	SerialNumber, CommonName                  string
}

type Raw struct {
	Data []byte
}

type Root interface {
	Certificate
	Title() string
}

type RootManager interface {
	ListAll() []Root
	Find(target *Name) (Root, error)
	Contains(cert Certificate) bool
}

type RootRegistration struct {
	Title   string
	Raw     *Raw
	Enabled bool
}

type RootRegistry interface {
	ListRegistrations() []*RootRegistration
}

type Solution interface {
	Load(raw *Raw) ([]Certificate, error)
	Verify(chain Chain, op *VerifyOptions) error
	GetInfo() *SolutionInfo
}

type SolutionInfo struct {
	Algorithm   string // like 'RSA'
	ContentType string // like 'block'
	Format      string // like 'x509'
}

type SolutionManager interface {
	Solution

	MakeChain(certs []Certificate) (Chain, error)

	LoadChain(raw *Raw) (Chain, error)

	ListAll() []Solution
}

type SolutionRegistration struct {
	Info     SolutionInfo
	Solution Solution
}

type SolutionRegistry interface {
	GetRegistration() *SolutionRegistration
}

type VerifyOptions struct {
	IgnoreTime    bool
	IgnoreRoot    bool
	IgnoreParents bool
}