Delete dead code

Author: mcpherrinm

core/challenges.go

@@ -1,7 +1,5 @@
 package core
 
-import "fmt"
-
 func newChallenge(challengeType AcmeChallenge, token string) Challenge {
 	return Challenge{
 		Type:   challengeType,
@@ -29,20 +27,3 @@ func TLSALPNChallenge01(token string) Challenge {
 func DNSAccountChallenge01(token string) Challenge {
 	return newChallenge(ChallengeTypeDNSAccount01, token)
 }
-
-// NewChallenge constructs a challenge of the given kind. It returns an
-// error if the challenge type is unrecognized.
-func NewChallenge(kind AcmeChallenge, token string) (Challenge, error) {
-	switch kind {
-	case ChallengeTypeHTTP01:
-		return HTTPChallenge01(token), nil
-	case ChallengeTypeDNS01:
-		return DNSChallenge01(token), nil
-	case ChallengeTypeTLSALPN01:
-		return TLSALPNChallenge01(token), nil
-	case ChallengeTypeDNSAccount01:
-		return DNSAccountChallenge01(token), nil
-	default:
-		return Challenge{}, fmt.Errorf("unrecognized challenge type %q", kind)
-	}
-}

log/mock.go

@@ -5,7 +5,6 @@ import (
 	"log/syslog"
 	"regexp"
 	"strings"
-	"time"
 )
 
 // UseMock sets a mock logger as the default logger, and returns it.
@@ -20,13 +19,6 @@ func NewMock() *Mock {
 	return &Mock{impl{newMockWriter()}}
 }
 
-// NewWaitingMock creates a mock logger implementing the writer interface.
-// It stores all logged messages in a buffer for inspection by test
-// functions.
-func NewWaitingMock() *WaitingMock {
-	return &WaitingMock{impl{newWaitingMockWriter()}}
-}
-
 // Mock is a logger that stores all log messages in memory to be examined by a
 // test.
 type Mock struct {
@@ -130,39 +122,3 @@ func (m *Mock) Clear() {
 	w := m.w.(*mockWriter)
 	w.clearChan <- struct{}{}
 }
-
-type waitingMockWriter struct {
-	logChan chan string
-}
-
-// newWaitingMockWriter returns a new waitingMockWriter
-func newWaitingMockWriter() *waitingMockWriter {
-	logChan := make(chan string, 1000)
-	return &waitingMockWriter{
-		logChan,
-	}
-}
-
-func (m *waitingMockWriter) logAtLevel(p syslog.Priority, msg string, a ...any) {
-	m.logChan <- fmt.Sprintf("%s: %s", levelName[p&7], fmt.Sprintf(msg, a...))
-}
-
-// WaitForMatch returns the first log line matching a regex. It accepts a
-// regexp string and timeout. If the timeout value is met before the
-// matching pattern is read from the channel, an error is returned.
-func (m *WaitingMock) WaitForMatch(reString string, timeout time.Duration) (string, error) {
-	w := m.w.(*waitingMockWriter)
-	deadline := time.After(timeout)
-	re := regexp.MustCompile(reString)
-	for {
-		select {
-		case logLine := <-w.logChan:
-			if re.MatchString(logLine) {
-				close(w.logChan)
-				return logLine, nil
-			}
-		case <-deadline:
-			return "", fmt.Errorf("timeout waiting for match: %q", reString)
-		}
-	}
-}

mocks/sa.go

@@ -39,12 +39,6 @@ type StorageAuthority struct {
 	StorageAuthorityReadOnly
 }
 
-// NewStorageAuthority creates a new mock storage authority
-// with the given clock.
-func NewStorageAuthority(clk clock.Clock) *StorageAuthority {
-	return &StorageAuthority{StorageAuthorityReadOnly{clk}}
-}
-
 const (
 	test1KeyPublicJSON  = `{"kty":"RSA","n":"yNWVhtYEKJR21y9xsHV-PD_bYwbXSeNuFal46xYxVfRL5mqha7vttvjB_vc7Xg2RvgCxHPCqoxgMPTzHrZT75LjCwIW2K_klBYN8oYvTwwmeSkAz6ut7ZxPv-nZaT5TJhGk0NT2kh_zSpdriEJ_3vW-mqxYbbBmpvHqsa1_zx9fSuHYctAZJWzxzUZXykbWMWQZpEiE0J4ajj51fInEzVn7VxV-mzfMyboQjujPh7aNJxAWSq4oQEJJDgWwSh9leyoJoPpONHxh5nEE5AjE01FkGICSxjpZsF-w8hOTI3XXohUdu29Se26k2B0PolDSuj0GIQU6-W9TdLXSjBb2SpQ","e":"AQAB"}`
 	test2KeyPublicJSON  = `{"kty":"RSA","n":"qnARLrT7Xz4gRcKyLdydmCr-ey9OuPImX4X40thk3on26FkMznR3fRjs66eLK7mmPcBZ6uOJseURU6wAaZNmemoYx1dMvqvWWIyiQleHSD7Q8vBrhR6uIoO4jAzJZR-ChzZuSDt7iHN-3xUVspu5XGwXU_MVJZshTwp4TaFx5elHIT_ObnTvTOU3Xhish07AbgZKmWsVbXh5s-CrIicU4OexJPgunWZ_YJJueOKmTvnLlTV4MzKR2oZlBKZ27S0-SfdV_QDx_ydle5oMAyKVtlAV35cyPMIsYNwgUGBCdY_2Uzi5eX0lTc7MPRwz6qR1kip-i59VcGcUQgqHV6Fyqw","e":"AQAB"}`

probs/probs.go

@@ -312,19 +312,6 @@ func UnsupportedIdentifier(detail string, a ...any) *ProblemDetails {
 // Additional helper functions that return variations on MalformedProblem with
 // different HTTP status codes set.
 
-// Canceled returns a ProblemDetails with a MalformedProblem and a 408 Request
-// Timeout status code.
-func Canceled(detail string, a ...any) *ProblemDetails {
-	if len(a) > 0 {
-		detail = fmt.Sprintf(detail, a...)
-	}
-	return &ProblemDetails{
-		Type:       MalformedProblem,
-		Detail:     detail,
-		HTTPStatus: http.StatusRequestTimeout,
-	}
-}
-
 // Conflict returns a ProblemDetails with a ConflictProblem and a 409 Conflict
 // status code.
 func Conflict(detail string) *ProblemDetails {

test/certs.go

@@ -2,67 +2,20 @@ package test
 
 import (
 	"bytes"
-	"crypto"
 	"crypto/ecdsa"
 	"crypto/elliptic"
 	"crypto/rand"
-	"crypto/rsa"
 	"crypto/x509"
 	"encoding/hex"
-	"encoding/pem"
-	"errors"
 	"fmt"
 	"math/big"
 	"net"
-	"os"
 	"testing"
 	"time"
 
 	"github.com/jmhodges/clock"
 )
 
-// LoadSigner loads a PEM private key specified by filename or returns an error.
-// Can be paired with issuance.LoadCertificate to get both a CA cert and its
-// associated private key for use in signing throwaway test certs.
-func LoadSigner(filename string) (crypto.Signer, error) {
-	keyBytes, err := os.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-
-	// pem.Decode does not return an error as its 2nd arg, but instead the "rest"
-	// that was leftover from parsing the PEM block. We only care if the decoded
-	// PEM block was empty for this test function.
-	block, _ := pem.Decode(keyBytes)
-	if block == nil {
-		return nil, errors.New("Unable to decode private key PEM bytes")
-	}
-
-	// Try decoding as an RSA private key
-	if rsaKey, err := x509.ParsePKCS1PrivateKey(block.Bytes); err == nil {
-		return rsaKey, nil
-	}
-
-	// Try decoding as a PKCS8 private key
-	if key, err := x509.ParsePKCS8PrivateKey(block.Bytes); err == nil {
-		// Determine the key's true type and return it as a crypto.Signer
-		switch k := key.(type) {
-		case *rsa.PrivateKey:
-			return k, nil
-		case *ecdsa.PrivateKey:
-			return k, nil
-		}
-	}
-
-	// Try as an ECDSA private key
-	if ecdsaKey, err := x509.ParseECPrivateKey(block.Bytes); err == nil {
-		return ecdsaKey, nil
-	}
-
-	// Nothing worked! Fail hard.
-	return nil, errors.New("Unable to decode private key PEM bytes")
-}
-
 // ThrowAwayCert is a small test helper function that creates a self-signed
 // certificate with one SAN. It returns the parsed certificate and its serial
 // in string form for convenience.

web/context.go

@@ -208,16 +208,6 @@ func (th *TopHandler) logEvent(logEvent *RequestEvent) {
 		int(logEvent.Latency*1000), logEvent.RealIP, jsonEvent)
 }
 
-// GetClientAddr returns a comma-separated list of HTTP clients involved in
-// making this request, starting with the original requester and ending with the
-// remote end of our TCP connection (which is typically our own proxy).
-func GetClientAddr(r *http.Request) string {
-	if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
-		return xff + "," + r.RemoteAddr
-	}
-	return r.RemoteAddr
-}
-
 func KeyTypeToString(pub crypto.PublicKey) string {
 	switch pk := pub.(type) {
 	case *rsa.PublicKey: