129 lines
3.0 KiB
Go
129 lines
3.0 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package x509
|
|
|
|
// CertPool is a set of certificates.
|
|
type CertPool struct {
|
|
bySubjectKeyId map[string][]int
|
|
byName map[string][]int
|
|
bySHA256 map[string]int
|
|
certs []*Certificate
|
|
}
|
|
|
|
// NewCertPool returns a new, empty CertPool.
|
|
func NewCertPool() *CertPool {
|
|
return &CertPool{
|
|
bySubjectKeyId: make(map[string][]int),
|
|
byName: make(map[string][]int),
|
|
bySHA256: make(map[string]int),
|
|
}
|
|
}
|
|
|
|
// findVerifiedParents attempts to find certificates in s which have signed the
|
|
// given certificate. If any candidates were rejected then errCert will be set
|
|
// to one of them, arbitrarily, and err will contain the reason that it was
|
|
// rejected.
|
|
func (s *CertPool) findVerifiedParents(cert *Certificate) (parents []int, errCert *Certificate, err error) {
|
|
if s == nil {
|
|
return
|
|
}
|
|
var candidates []int
|
|
|
|
if len(cert.AuthorityKeyId) > 0 {
|
|
candidates, _ = s.bySubjectKeyId[string(cert.AuthorityKeyId)]
|
|
}
|
|
if len(candidates) == 0 {
|
|
candidates, _ = s.byName[string(cert.RawIssuer)]
|
|
}
|
|
|
|
for _, c := range candidates {
|
|
if err = cert.CheckSignatureFrom(s.certs[c]); err == nil {
|
|
cert.validSignature = true
|
|
parents = append(parents, c)
|
|
} else {
|
|
errCert = s.certs[c]
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// AddCert adds a certificate to a pool.
|
|
func (s *CertPool) AddCert(cert *Certificate) {
|
|
if cert == nil {
|
|
panic("adding nil Certificate to CertPool")
|
|
}
|
|
|
|
// Check that the certificate isn't being added twice.
|
|
sha256fp := string(cert.FingerprintSHA256)
|
|
if _, ok := s.bySHA256[sha256fp]; ok {
|
|
return
|
|
}
|
|
|
|
n := len(s.certs)
|
|
s.certs = append(s.certs, cert)
|
|
|
|
if len(cert.SubjectKeyId) > 0 {
|
|
keyId := string(cert.SubjectKeyId)
|
|
s.bySubjectKeyId[keyId] = append(s.bySubjectKeyId[keyId], n)
|
|
}
|
|
name := string(cert.RawSubject)
|
|
s.byName[name] = append(s.byName[name], n)
|
|
s.bySHA256[sha256fp] = n
|
|
}
|
|
|
|
// Contains returns true if c is in s.
|
|
func (s *CertPool) Contains(c *Certificate) bool {
|
|
if s == nil {
|
|
return false
|
|
}
|
|
_, ok := s.bySHA256[string(c.FingerprintSHA256)]
|
|
return ok
|
|
}
|
|
|
|
// Covers returns true if all certs in pool are in s.
|
|
func (s *CertPool) Covers(pool *CertPool) bool {
|
|
if pool == nil {
|
|
return true
|
|
}
|
|
for _, c := range pool.certs {
|
|
if !s.Contains(c) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Certificates returns a list of parsed certificates in the pool.
|
|
func (s *CertPool) Certificates() []*Certificate {
|
|
out := make([]*Certificate, 0, len(s.certs))
|
|
out = append(out, s.certs...)
|
|
return out
|
|
}
|
|
|
|
// Size returns the number of unique certificates in the CertPool.
|
|
func (s *CertPool) Size() int {
|
|
if s == nil {
|
|
return 0
|
|
}
|
|
return len(s.certs)
|
|
}
|
|
|
|
// Sum returns the union of two certificate pools as a new certificate pool.
|
|
func (s *CertPool) Sum(other *CertPool) (sum *CertPool) {
|
|
sum = NewCertPool()
|
|
if s != nil {
|
|
for _, c := range s.certs {
|
|
sum.AddCert(c)
|
|
}
|
|
}
|
|
if other != nil {
|
|
for _, c := range other.certs {
|
|
sum.AddCert(c)
|
|
}
|
|
}
|
|
return
|
|
}
|