211 lines
9.5 KiB
Go
211 lines
9.5 KiB
Go
package monitor
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type endDateFix struct {
|
|
now time.Time
|
|
tokens []EndingToken
|
|
reps []BoxCertReport
|
|
state map[string]time.Time
|
|
events []string
|
|
c *EndDateChecker
|
|
}
|
|
|
|
func newEndDateFix() *endDateFix {
|
|
f := &endDateFix{now: time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC), state: map[string]time.Time{}}
|
|
f.c = NewEndDateChecker(
|
|
func() ([]EndingToken, error) { return f.tokens, nil },
|
|
func() ([]BoxCertReport, error) { return f.reps, nil },
|
|
func(k string) time.Time { return f.state[k] },
|
|
func(k string, t time.Time) error { f.state[k] = t; return nil },
|
|
func(prefix string) []string {
|
|
var out []string
|
|
for k := range f.state {
|
|
if strings.HasPrefix(k, prefix) {
|
|
out = append(out, k)
|
|
}
|
|
}
|
|
return out
|
|
},
|
|
func(cust, typ, sev, msg, details, src string) {
|
|
f.events = append(f.events, cust+"|"+typ+"|"+sev+"|"+msg+"|"+details)
|
|
}, log.New(io.Discard, "", 0))
|
|
f.c.now = func() time.Time { return f.now }
|
|
return f
|
|
}
|
|
|
|
// step moves the clock (past the hourly throttle) and runs the check.
|
|
func (f *endDateFix) step(d time.Duration) { f.now = f.now.Add(d); f.c.Check() }
|
|
|
|
func certReport(certs ...string) string { return `{"web_certs":[` + strings.Join(certs, ",") + `]}` }
|
|
func cert(domain string, at time.Time) string {
|
|
return fmt.Sprintf(`{"domain":%q,"not_after":%q,"issuer":"YR2"}`, domain, at.UTC().Format(time.RFC3339))
|
|
}
|
|
|
|
// R-1379 (D77): the operator is warned 14 days before an end date — not at 15, once at 14, not again every hour, once
|
|
// more (as an error) when the date passes with the same thing still there, and never for a token or certificate that
|
|
// was renewed. The stored effect asserted is the event. Both kinds, one test each way.
|
|
// COMPANION RED-PROOFS (observed, audits/night-build-2026-11-14/B/redproof-hub-end-dates.txt).
|
|
func TestEndDates_FourteenDaysOnceThenEndedOnce(t *testing.T) {
|
|
f := newEndDateFix()
|
|
day := 24 * time.Hour
|
|
tokEnd := f.now.Add(16*day + time.Hour)
|
|
certEnd := f.now.Add(16*day + 2*time.Hour)
|
|
f.tokens = []EndingToken{{ID: 7, Name: "CC hub token", ExpiresAt: tokEnd}, {ID: 8, Name: "fresh", ExpiresAt: f.now.Add(80 * day)}}
|
|
f.reps = []BoxCertReport{{CustomerID: "demo-hp", ReportJSON: certReport(cert("*.enkisfelhom.hu", certEnd))},
|
|
{CustomerID: "old-box", ReportJSON: `{"health":{"status":"ok"}}`}} // a controller that sends no web_certs
|
|
f.step(0)
|
|
f.step(day) // 15 days and a bit left
|
|
if len(f.events) != 0 {
|
|
t.Fatalf("at more than 14 days: %v", f.events)
|
|
}
|
|
f.step(2 * day) // 13 days and a bit left
|
|
for i := 0; i < 30; i++ {
|
|
f.step(2 * time.Hour)
|
|
}
|
|
if len(f.events) != 2 {
|
|
t.Fatalf("inside the 14 days, 31 hourly checks: %d event(s), want ONE per end date: %v", len(f.events), f.events)
|
|
}
|
|
all := strings.Join(f.events, "\n")
|
|
for _, want := range []string{"|operator_token_ends_soon|warning|", "„CC hub token”", tokEnd.Format("2006-01-02"), "401",
|
|
"demo-hp|web_cert_ends_soon|warning|", "*.enkisfelhom.hu", certEnd.Format("2006-01-02"), "renewal has FAILED", `"issuer":"YR2"`} {
|
|
if !strings.Contains(all, want) {
|
|
t.Errorf("the events lack %q:\n%s", want, all)
|
|
}
|
|
}
|
|
if !strings.HasPrefix(f.events[0], "|") {
|
|
t.Errorf("the token's event must carry no household: %s", f.events[0])
|
|
}
|
|
// the end dates pass, nothing was renewed: one ERROR each, once
|
|
f.now = certEnd.Add(time.Hour)
|
|
f.c.Check()
|
|
f.step(2 * time.Hour)
|
|
if len(f.events) != 4 || !strings.Contains(f.events[2]+f.events[3], "ENDED on") || strings.Count(f.events[2]+f.events[3], "|error|") != 2 {
|
|
t.Fatalf("after the end date: %v", f.events[2:])
|
|
}
|
|
}
|
|
|
|
// A renewed certificate has a new end date: nothing is told. A certificate that is renewed AFTER the warning needs no
|
|
// „all clear” — and a later failure of the new one is told again. Old things are no news: a token that ended months
|
|
// ago, and nobody replaced, raises nothing when the checker first runs.
|
|
func TestEndDates_RenewedAndLongGoneAreQuiet(t *testing.T) {
|
|
f := newEndDateFix()
|
|
day := 24 * time.Hour
|
|
f.tokens = []EndingToken{{ID: 1, Name: "old", ExpiresAt: f.now.Add(-120 * day)}}
|
|
f.reps = []BoxCertReport{{CustomerID: "n100", ReportJSON: certReport(cert("*.example.hu", f.now.Add(40*day)))}}
|
|
f.step(0)
|
|
f.step(2 * time.Hour)
|
|
if len(f.events) != 0 {
|
|
t.Fatalf("a token that ended 120 days ago and a certificate 40 days out: %v", f.events)
|
|
}
|
|
f.reps[0].ReportJSON = certReport(cert("*.example.hu", f.now.Add(10*day)))
|
|
f.step(2 * time.Hour)
|
|
if len(f.events) != 1 {
|
|
t.Fatalf("10 days left: %v", f.events)
|
|
}
|
|
f.reps[0].ReportJSON = certReport(cert("*.example.hu", f.now.Add(89*day))) // renewed
|
|
f.step(2 * time.Hour)
|
|
f.step(11 * day)
|
|
if len(f.events) != 1 {
|
|
t.Fatalf("after the renewal: %v", f.events[1:])
|
|
}
|
|
f.step(70 * day) // the NEW certificate is now 8 days from its end
|
|
if len(f.events) != 2 {
|
|
t.Fatalf("the new certificate's own warning: %d event(s)", len(f.events))
|
|
}
|
|
}
|
|
|
|
// The list is the box's. A name that is not a host name and a date that is not a date are dropped, more than eight
|
|
// entries are cut, and a token whose name is not plain text is named by its number.
|
|
func TestEndDates_TheBoxesWordsAreChecked(t *testing.T) {
|
|
f := newEndDateFix()
|
|
soon := f.now.Add(5 * 24 * time.Hour)
|
|
var many []string
|
|
for i := 0; i < 20; i++ {
|
|
many = append(many, cert(fmt.Sprintf("n%02d.example.hu", i), soon.Add(time.Duration(i)*time.Minute)))
|
|
}
|
|
f.reps = []BoxCertReport{
|
|
{CustomerID: "evil", ReportJSON: certReport(cert(`<script>alert(1)</script>`, soon), cert("a b.example.hu", soon),
|
|
`{"domain":"ok.example.hu","not_after":"tomorrow"}`, cert("fine.example.hu", soon))},
|
|
{CustomerID: "many", ReportJSON: certReport(many...)},
|
|
{CustomerID: "evil", ReportJSON: certReport(cert("second-report.example.hu", soon))}, // a duplicate row of the same household
|
|
}
|
|
// an issuer name that is not a plain name is dropped, the certificate is still told
|
|
f.reps = append(f.reps, BoxCertReport{CustomerID: "iss", ReportJSON: `{"web_certs":[{"domain":"x.example.hu","not_after":"` + soon.UTC().Format(time.RFC3339) + `","issuer":"<i>CA</i>"}]}`})
|
|
f.tokens = []EndingToken{{ID: 9, Name: "<b>x</b>", ExpiresAt: soon}}
|
|
f.step(0)
|
|
all := strings.Join(f.events, "\n")
|
|
if strings.Contains(all, "alert(1)") || strings.Contains(all, "a b.example") || strings.Contains(all, "<b>") || strings.Contains(all, "second-report") {
|
|
t.Fatalf("an unchecked word of a box or a token name reached an event:\n%s", all)
|
|
}
|
|
if n := strings.Count(all, "evil|web_cert_ends_soon"); n != 1 || !strings.Contains(all, "fine.example.hu") {
|
|
t.Errorf("household „evil”: %d event(s), want one for fine.example.hu", n)
|
|
}
|
|
if n := strings.Count(all, "many|web_cert_ends_soon"); n != webCertsReadMax {
|
|
t.Errorf("household „many”: %d event(s), want the cap %d", n, webCertsReadMax)
|
|
}
|
|
if !strings.Contains(all, "iss|web_cert_ends_soon") || strings.Contains(all, "<i>") || !strings.Contains(all, `"issuer":""`) {
|
|
t.Errorf("an issuer that is not a plain name must be dropped and the certificate still told:\n%s", all)
|
|
}
|
|
if !strings.Contains(all, "„token #9”") {
|
|
t.Errorf("a token with a name that is not plain text must be named by its number:\n%s", all)
|
|
}
|
|
}
|
|
|
|
// Found by review, 2026-11-14. (1) The FIRST run after a deploy: a token that already ended, was replaced long ago and
|
|
// never revoked, must not mail „ENDED” — it is marked, not told; a thing that ends within the 14 days is still told.
|
|
// (2) The marks are the hub's settings and the names and dates are the box's: a box that sends another end date every
|
|
// hour, or new names every hour, must not mint a mail or a mark each time.
|
|
func TestEndDates_FirstRunAndABoxCannotMintMarks(t *testing.T) {
|
|
day := 24 * time.Hour
|
|
f := newEndDateFix()
|
|
f.tokens = []EndingToken{{ID: 1, Name: "replaced", ExpiresAt: f.now.Add(-3 * day)}, {ID: 2, Name: "soon", ExpiresAt: f.now.Add(5 * day)}}
|
|
f.reps = []BoxCertReport{{CustomerID: "old", ReportJSON: certReport(cert("gone.example.hu", f.now.Add(-2*day)))}}
|
|
f.step(0)
|
|
if len(f.events) != 1 || !strings.Contains(f.events[0], "„soon”") {
|
|
t.Fatalf("the first run: %v — want only the token that ends in 5 days", f.events)
|
|
}
|
|
f.step(2 * time.Hour)
|
|
f.step(2 * time.Hour)
|
|
if len(f.events) != 1 {
|
|
t.Fatalf("the already-ended things were told at a later run: %v", f.events[1:])
|
|
}
|
|
// after the first run, a token that ends is told as ended (the normal rule)
|
|
f.tokens = append(f.tokens, EndingToken{ID: 3, Name: "third", ExpiresAt: f.now.Add(-time.Hour)})
|
|
f.step(2 * time.Hour)
|
|
if len(f.events) != 2 || !strings.Contains(f.events[1], "„third” ENDED") {
|
|
t.Fatalf("a token that ended after the first run: %v", f.events[1:])
|
|
}
|
|
|
|
// a box that sends ANOTHER end date at every report
|
|
g := newEndDateFix()
|
|
g.step(0) // the baseline run
|
|
for i := 0; i < 48; i++ {
|
|
g.reps = []BoxCertReport{{CustomerID: "evil", ReportJSON: certReport(cert("x.example.hu", g.now.Add(5*day+time.Duration(i)*time.Minute)))}}
|
|
g.step(61 * time.Minute)
|
|
}
|
|
if len(g.events) > 3 {
|
|
t.Fatalf("a box that moves its end date by a minute each hour got %d mails in two days (want at most a few: a new mail needs a date a day later)", len(g.events))
|
|
}
|
|
marksBefore := len(g.state)
|
|
// and a box that sends eight NEW names every hour
|
|
for i := 0; i < 24; i++ {
|
|
var cs []string
|
|
for n := 0; n < 8; n++ {
|
|
cs = append(cs, cert(fmt.Sprintf("h%dn%d.example.hu", i, n), g.now.Add(6*day)))
|
|
}
|
|
g.reps = []BoxCertReport{{CustomerID: "evil", ReportJSON: certReport(cs...)}}
|
|
g.step(61 * time.Minute)
|
|
}
|
|
if grew := len(g.state) - marksBefore; grew > webCertMaxMarks {
|
|
t.Fatalf("192 invented names made %d marks, want at most %d for one household", grew, webCertMaxMarks)
|
|
}
|
|
}
|