mirror of
https://github.com/SSLMate/certspotter.git
synced 2025-06-27 10:15:33 +02:00
958e7a9efb
Instead use the time at which the STH was observed (which for FilesystemState is assumed to be the mtime of the STH file). This is easier to reason about: we don't have to worry about logs lying about the time; we don't have to take into account the delay between STH fetch and healthcheck; we won't raise spurious health checks about logs with MMDs longer than the healthcheck interval.
110 lines
2.9 KiB
Go
110 lines
2.9 KiB
Go
// Copyright (C) 2017, 2023 Opsmate, Inc.
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla
|
|
// Public License, v. 2.0. If a copy of the MPL was not distributed
|
|
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
//
|
|
// This software is distributed WITHOUT A WARRANTY OF ANY KIND.
|
|
// See the Mozilla Public License for details.
|
|
|
|
package monitor
|
|
|
|
import (
|
|
"cmp"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"software.sslmate.com/src/certspotter/cttypes"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type StoredSTH struct {
|
|
cttypes.SignedTreeHead
|
|
StoredAt time.Time `json:"stored_at"` // time at which the STH was first stored
|
|
}
|
|
|
|
func loadSTHsFromDir(dirPath string) ([]*StoredSTH, error) {
|
|
entries, err := os.ReadDir(dirPath)
|
|
if errors.Is(err, fs.ErrNotExist) {
|
|
return []*StoredSTH{}, nil
|
|
} else if err != nil {
|
|
return nil, err
|
|
}
|
|
sths := make([]*StoredSTH, 0, len(entries))
|
|
for _, entry := range entries {
|
|
filename := entry.Name()
|
|
if strings.HasPrefix(filename, ".") || !strings.HasSuffix(filename, ".json") {
|
|
continue
|
|
}
|
|
sth, err := readSTHFile(filepath.Join(dirPath, filename))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sths = append(sths, sth)
|
|
}
|
|
slices.SortFunc(sths, func(a, b *StoredSTH) int { return cmp.Compare(a.TreeSize, b.TreeSize) })
|
|
return sths, nil
|
|
}
|
|
|
|
func readSTHFile(filePath string) (*StoredSTH, error) {
|
|
file, err := os.Open(filePath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
|
|
info, err := file.Stat()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sth := &StoredSTH{
|
|
StoredAt: info.ModTime(),
|
|
}
|
|
|
|
fileBytes, err := io.ReadAll(file)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading %s: %w", filePath, err)
|
|
}
|
|
if err := json.Unmarshal(fileBytes, &sth.SignedTreeHead); err != nil {
|
|
return nil, fmt.Errorf("error parsing %s: %w", filePath, err)
|
|
}
|
|
return sth, nil
|
|
}
|
|
|
|
func storeSTHInDir(dirPath string, sth *cttypes.SignedTreeHead) error {
|
|
filePath := filepath.Join(dirPath, sthFilename(sth))
|
|
if fileExists(filePath) {
|
|
// If the file already exists, we don't want its mtime to change
|
|
// because StoredSTH.StoredAt needs to be the time the STH was *first* stored.
|
|
return nil
|
|
}
|
|
return writeJSONFile(filePath, sth, 0666)
|
|
}
|
|
|
|
func removeSTHFromDir(dirPath string, sth *cttypes.SignedTreeHead) error {
|
|
filePath := filepath.Join(dirPath, sthFilename(sth))
|
|
err := os.Remove(filePath)
|
|
if err != nil && !errors.Is(err, fs.ErrNotExist) {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// generate a filename that uniquely identifies the STH (within the context of a particular log)
|
|
func sthFilename(sth *cttypes.SignedTreeHead) string {
|
|
hasher := sha256.New()
|
|
binary.Write(hasher, binary.LittleEndian, sth.Timestamp)
|
|
hasher.Write(sth.RootHash[:])
|
|
return strconv.FormatUint(sth.TreeSize, 10) + "-" + base64.RawURLEncoding.EncodeToString(hasher.Sum(nil)) + ".json"
|
|
}
|