kyle/goutils
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

cmd: continue lint fixes.

Browse Source
This commit is contained in:
Kyle Isom
2025-11-16 01:32:19 -08:00
parent f31d74243f
commit 0f77bd49dc
44 changed files with 888 additions and 875 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.golangci.yml
View File

@@ -86,7 +86,6 @@ linters:
- godoclint # checks Golang's documentation practice - godoclint # checks Golang's documentation practice
- godot # checks if comments end in a period - godot # checks if comments end in a period
- gomoddirectives # manages the use of 'replace', 'retract', and 'excludes' directives in go.mod - gomoddirectives # manages the use of 'replace', 'retract', and 'excludes' directives in go.mod
- goprintffuncname # checks that printf-like functions are named with f at the end
- gosec # inspects source code for security problems - gosec # inspects source code for security problems
- govet # reports suspicious constructs, such as Printf calls whose arguments do not align with the format string - govet # reports suspicious constructs, such as Printf calls whose arguments do not align with the format string
- iface # checks the incorrect use of interfaces, helping developers avoid interface pollution - iface # checks the incorrect use of interfaces, helping developers avoid interface pollution
@@ -465,6 +464,8 @@ linters:
linters: [ testableexamples ] linters: [ testableexamples ]
- path: 'main.go' - path: 'main.go'
linters: [ forbidigo, mnd, reassign ] linters: [ forbidigo, mnd, reassign ]
- path: 'cmd/cruntar/main.go'
linters: [ unparam ]
- source: 'TODO' - source: 'TODO'
linters: [ godot ] linters: [ godot ]
- text: 'should have a package comment' - text: 'should have a package comment'

126
cache/lru/lru_internal_test.go vendored
View File

@@ -1,87 +1,87 @@
package lru package lru
import ( import (
"testing" "testing"
"time" "time"
"github.com/benbjohnson/clock" "github.com/benbjohnson/clock"
) )
// These tests mirror the MRU-style behavior present in this LRU package // These tests mirror the MRU-style behavior present in this LRU package
// implementation (eviction removes the most-recently-used entry). // implementation (eviction removes the most-recently-used entry).
func TestBasicCacheEviction(t *testing.T) { func TestBasicCacheEviction(t *testing.T) {
mock := clock.NewMock() mock := clock.NewMock()
c := NewStringKeyCache[int](2) c := NewStringKeyCache[int](2)
c.clock = mock c.clock = mock
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if c.Len() != 0 { if c.Len() != 0 {
t.Fatal("cache should have size 0") t.Fatal("cache should have size 0")
} }
c.evict() c.evict()
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
c.Store("raven", 1) c.Store("raven", 1)
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if len(c.store) != 1 { if len(c.store) != 1 {
t.Fatalf("store should have length=1, have length=%d", len(c.store)) t.Fatalf("store should have length=1, have length=%d", len(c.store))
} }
mock.Add(time.Second) mock.Add(time.Second)
c.Store("owl", 2) c.Store("owl", 2)
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if len(c.store) != 2 { if len(c.store) != 2 {
t.Fatalf("store should have length=2, have length=%d", len(c.store)) t.Fatalf("store should have length=2, have length=%d", len(c.store))
} }
mock.Add(time.Second) mock.Add(time.Second)
c.Store("goat", 3) c.Store("goat", 3)
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if len(c.store) != 2 { if len(c.store) != 2 {
t.Fatalf("store should have length=2, have length=%d", len(c.store)) t.Fatalf("store should have length=2, have length=%d", len(c.store))
} }
// Since this implementation evicts the most-recently-used item, inserting // Since this implementation evicts the most-recently-used item, inserting
// "goat" when full evicts "owl" (the most recent at that time). // "goat" when full evicts "owl" (the most recent at that time).
mock.Add(time.Second) mock.Add(time.Second)
if _, ok := c.Get("owl"); ok { if _, ok := c.Get("owl"); ok {
t.Fatal("store should not have an entry for owl (MRU-evicted)") t.Fatal("store should not have an entry for owl (MRU-evicted)")
} }
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
mock.Add(time.Second) mock.Add(time.Second)
c.Store("elk", 4) c.Store("elk", 4)
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if !c.Has("elk") { if !c.Has("elk") {
t.Fatal("store should contain an entry for 'elk'") t.Fatal("store should contain an entry for 'elk'")
} }
// Before storing elk, keys were: raven (older), goat (newer). Evict MRU -> goat. // Before storing elk, keys were: raven (older), goat (newer). Evict MRU -> goat.
if !c.Has("raven") { if !c.Has("raven") {
t.Fatal("store should contain an entry for 'raven'") t.Fatal("store should contain an entry for 'raven'")
} }
if c.Has("goat") { if c.Has("goat") {
t.Fatal("store should not contain an entry for 'goat'") t.Fatal("store should not contain an entry for 'goat'")
} }
} }

64
cache/lru/timestamps_internal_test.go vendored
View File

@@ -1,50 +1,50 @@
package lru package lru
import ( import (
"testing" "testing"
"time" "time"
"github.com/benbjohnson/clock" "github.com/benbjohnson/clock"
) )
// These tests validate timestamps ordering semantics for the LRU package. // These tests validate timestamps ordering semantics for the LRU package.
// Note: The LRU timestamps are sorted with most-recent-first (descending by t). // Note: The LRU timestamps are sorted with most-recent-first (descending by t).
func TestTimestamps(t *testing.T) { func TestTimestamps(t *testing.T) {
ts := newTimestamps[string](3) ts := newTimestamps[string](3)
mock := clock.NewMock() mock := clock.NewMock()
// raven // raven
ts.Update("raven", mock.Now().UnixNano()) ts.Update("raven", mock.Now().UnixNano())
// raven, owl // raven, owl
mock.Add(time.Millisecond) mock.Add(time.Millisecond)
ts.Update("owl", mock.Now().UnixNano()) ts.Update("owl", mock.Now().UnixNano())
// raven, owl, goat // raven, owl, goat
mock.Add(time.Second) mock.Add(time.Second)
ts.Update("goat", mock.Now().UnixNano()) ts.Update("goat", mock.Now().UnixNano())
if err := ts.ConsistencyCheck(); err != nil { if err := ts.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
// make owl the most recent // make owl the most recent
mock.Add(time.Millisecond) mock.Add(time.Millisecond)
ts.Update("owl", mock.Now().UnixNano()) ts.Update("owl", mock.Now().UnixNano())
if err := ts.ConsistencyCheck(); err != nil { if err := ts.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
// For LRU timestamps: most recent first. Expected order: owl, goat, raven. // For LRU timestamps: most recent first. Expected order: owl, goat, raven.
if ts.K(0) != "owl" { if ts.K(0) != "owl" {
t.Fatalf("first key should be owl, have %s", ts.K(0)) t.Fatalf("first key should be owl, have %s", ts.K(0))
} }
if ts.K(1) != "goat" { if ts.K(1) != "goat" {
t.Fatalf("second key should be goat, have %s", ts.K(1)) t.Fatalf("second key should be goat, have %s", ts.K(1))
} }
if ts.K(2) != "raven" { if ts.K(2) != "raven" {
t.Fatalf("third key should be raven, have %s", ts.K(2)) t.Fatalf("third key should be raven, have %s", ts.K(2))
} }
} }

28
cache/mru/mru_internal_test.go vendored
View File

@@ -8,9 +8,9 @@ import (
) )
func TestBasicCacheEviction(t *testing.T) { func TestBasicCacheEviction(t *testing.T) {
mock := clock.NewMock() mock := clock.NewMock()
c := NewStringKeyCache[int](2) c := NewStringKeyCache[int](2)
c.clock = mock c.clock = mock
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
@@ -55,18 +55,18 @@ func TestBasicCacheEviction(t *testing.T) {
} }
mock.Add(time.Second) mock.Add(time.Second)
v, ok := c.Get("owl") v, ok := c.Get("owl")
if !ok { if !ok {
t.Fatal("store should have an entry for owl") t.Fatal("store should have an entry for owl")
} }
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
itm := v itm := v
if err := c.ConsistencyCheck(); err != nil { if err := c.ConsistencyCheck(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if itm != 2 { if itm != 2 {
t.Fatalf("stored item should be 2, have %d", itm) t.Fatalf("stored item should be 2, have %d", itm)

4
cache/mru/timestamps_internal_test.go vendored
View File

@@ -8,8 +8,8 @@ import (
) )
func TestTimestamps(t *testing.T) { func TestTimestamps(t *testing.T) {
ts := newTimestamps[string](3) ts := newTimestamps[string](3)
mock := clock.NewMock() mock := clock.NewMock()
// raven // raven
ts.Update("raven", mock.Now().UnixNano()) ts.Update("raven", mock.Now().UnixNano())

107
cmd/cert-revcheck/main.go
View File

@@ -1,20 +1,21 @@
package main package main
import ( import (
"crypto/tls" "context"
"crypto/x509" "crypto/tls"
"errors" "crypto/x509"
"flag" "errors"
"fmt" "flag"
"net" "fmt"
"os" "net"
"strings" "os"
"time" "strings"
"time"
"git.wntrmute.dev/kyle/goutils/certlib" "git.wntrmute.dev/kyle/goutils/certlib"
hosts "git.wntrmute.dev/kyle/goutils/certlib/hosts" hosts "git.wntrmute.dev/kyle/goutils/certlib/hosts"
"git.wntrmute.dev/kyle/goutils/certlib/revoke" "git.wntrmute.dev/kyle/goutils/certlib/revoke"
"git.wntrmute.dev/kyle/goutils/fileutil" "git.wntrmute.dev/kyle/goutils/fileutil"
) )
var ( var (
@@ -78,17 +79,17 @@ func processTarget(target string) (string, error) {
} }
func checkFile(path string) (string, error) { func checkFile(path string) (string, error) {
// Prefer high-level helpers from certlib to load certificates from disk // Prefer high-level helpers from certlib to load certificates from disk
if certs, err := certlib.LoadCertificates(path); err == nil && len(certs) > 0 { if certs, err := certlib.LoadCertificates(path); err == nil && len(certs) > 0 {
// Evaluate the first certificate (leaf) by default // Evaluate the first certificate (leaf) by default
return evaluateCert(certs[0]) return evaluateCert(certs[0])
} }
cert, err := certlib.LoadCertificate(path) cert, err := certlib.LoadCertificate(path)
if err != nil || cert == nil { if err != nil || cert == nil {
return strUnknown, err return strUnknown, err
} }
return evaluateCert(cert) return evaluateCert(cert)
} }
func checkSite(hostport string) (string, error) { func checkSite(hostport string) (string, error) {
@@ -99,18 +100,27 @@ func checkSite(hostport string) (string, error) {
} }
d := &net.Dialer{Timeout: timeout} d := &net.Dialer{Timeout: timeout}
conn, err := tls.DialWithDialer( tcfg := &tls.Config{
d, InsecureSkipVerify: true,
"tcp", ServerName: target.Host,
target.String(), } // #nosec G402 -- CLI tool only verifies revocation
&tls.Config{InsecureSkipVerify: true, ServerName: target.Host}, // #nosec G402 td := &tls.Dialer{NetDialer: d, Config: tcfg}
)
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
conn, err := td.DialContext(ctx, "tcp", target.String())
if err != nil { if err != nil {
return strUnknown, err return strUnknown, err
} }
defer conn.Close() defer conn.Close()
state := conn.ConnectionState() tconn, ok := conn.(*tls.Conn)
if !ok {
return strUnknown, errors.New("connection is not TLS")
}
state := tconn.ConnectionState()
if len(state.PeerCertificates) == 0 { if len(state.PeerCertificates) == 0 {
return strUnknown, errors.New("no peer certificates presented") return strUnknown, errors.New("no peer certificates presented")
} }
@@ -118,23 +128,24 @@ func checkSite(hostport string) (string, error) {
} }
func evaluateCert(cert *x509.Certificate) (string, error) { func evaluateCert(cert *x509.Certificate) (string, error) {
// Delegate validity and revocation checks to certlib/revoke helper. // Delegate validity and revocation checks to certlib/revoke helper.
// It returns revoked=true for both revoked and expired/not-yet-valid. // It returns revoked=true for both revoked and expired/not-yet-valid.
// Map those cases back to our statuses using the returned error text. // Map those cases back to our statuses using the returned error text.
revoked, ok, err := revoke.VerifyCertificateError(cert) revoked, ok, err := revoke.VerifyCertificateError(cert)
if revoked { if revoked {
if err != nil { if err != nil {
msg := err.Error() msg := err.Error()
if strings.Contains(msg, "expired") || strings.Contains(msg, "isn't valid until") || strings.Contains(msg, "not valid until") { if strings.Contains(msg, "expired") || strings.Contains(msg, "isn't valid until") ||
return strExpired, err strings.Contains(msg, "not valid until") {
} return strExpired, err
} }
return strRevoked, err }
} return strRevoked, err
if !ok { }
// Revocation status could not be determined if !ok {
return strUnknown, err // Revocation status could not be determined
} return strUnknown, err
}
return strOK, nil return strOK, nil
} }

5
cmd/certchain/certchain.go → cmd/certchain/main.go
View File

@@ -7,6 +7,7 @@ import (
"fmt" "fmt"
"os" "os"
"regexp" "regexp"
"strings"
"git.wntrmute.dev/kyle/goutils/die" "git.wntrmute.dev/kyle/goutils/die"
) )
@@ -27,13 +28,15 @@ func main() {
die.If(err) die.If(err)
details := conn.ConnectionState() details := conn.ConnectionState()
var chainSb30 strings.Builder
for _, cert := range details.PeerCertificates { for _, cert := range details.PeerCertificates {
p := pem.Block{ p := pem.Block{
Type: "CERTIFICATE", Type: "CERTIFICATE",
Bytes: cert.Raw, Bytes: cert.Raw,
} }
chain += string(pem.EncodeToMemory(&p)) chainSb30.WriteString(string(pem.EncodeToMemory(&p)))
} }
chain += chainSb30.String()
fmt.Fprintln(os.Stdout, chain) fmt.Fprintln(os.Stdout, chain)
} }

197
cmd/certdump/certdump.go → cmd/certdump/main.go
View File

@@ -1,3 +1,4 @@
//lint:file-ignore SA1019 allow strict compatibility for old certs
package main package main
import ( import (
@@ -101,30 +102,30 @@ func extUsage(ext []x509.ExtKeyUsage) string {
} }
func showBasicConstraints(cert *x509.Certificate) { func showBasicConstraints(cert *x509.Certificate) {
fmt.Fprint(os.Stdout, "\tBasic constraints: ") fmt.Fprint(os.Stdout, "\tBasic constraints: ")
if cert.BasicConstraintsValid { if cert.BasicConstraintsValid {
fmt.Fprint(os.Stdout, "valid") fmt.Fprint(os.Stdout, "valid")
} else { } else {
fmt.Fprint(os.Stdout, "invalid") fmt.Fprint(os.Stdout, "invalid")
} }
if cert.IsCA { if cert.IsCA {
fmt.Fprint(os.Stdout, ", is a CA certificate") fmt.Fprint(os.Stdout, ", is a CA certificate")
if !cert.BasicConstraintsValid { if !cert.BasicConstraintsValid {
fmt.Fprint(os.Stdout, " (basic constraint failure)") fmt.Fprint(os.Stdout, " (basic constraint failure)")
} }
} else { } else {
fmt.Fprint(os.Stdout, "is not a CA certificate") fmt.Fprint(os.Stdout, "is not a CA certificate")
if cert.KeyUsage&x509.KeyUsageKeyEncipherment != 0 { if cert.KeyUsage&x509.KeyUsageKeyEncipherment != 0 {
fmt.Fprint(os.Stdout, " (key encipherment usage enabled!)") fmt.Fprint(os.Stdout, " (key encipherment usage enabled!)")
} }
} }
if (cert.MaxPathLen == 0 && cert.MaxPathLenZero) || (cert.MaxPathLen > 0) { if (cert.MaxPathLen == 0 && cert.MaxPathLenZero) || (cert.MaxPathLen > 0) {
fmt.Fprintf(os.Stdout, ", max path length %d", cert.MaxPathLen) fmt.Fprintf(os.Stdout, ", max path length %d", cert.MaxPathLen)
} }
fmt.Fprintln(os.Stdout) fmt.Fprintln(os.Stdout)
} }
const oneTrueDateFormat = "2006-01-02T15:04:05-0700" const oneTrueDateFormat = "2006-01-02T15:04:05-0700"
@@ -135,41 +136,43 @@ var (
) )
func wrapPrint(text string, indent int) { func wrapPrint(text string, indent int) {
tabs := "" tabs := ""
for i := 0; i < indent; i++ { var tabsSb140 strings.Builder
tabs += "\t" for range indent {
} tabsSb140.WriteString("\t")
}
tabs += tabsSb140.String()
fmt.Fprintf(os.Stdout, tabs+"%s\n", wrap(text, indent)) fmt.Fprintf(os.Stdout, tabs+"%s\n", wrap(text, indent))
} }
func displayCert(cert *x509.Certificate) { func displayCert(cert *x509.Certificate) {
fmt.Fprintln(os.Stdout, "CERTIFICATE") fmt.Fprintln(os.Stdout, "CERTIFICATE")
if showHash { if showHash {
fmt.Fprintln(os.Stdout, wrap(fmt.Sprintf("SHA256: %x", sha256.Sum256(cert.Raw)), 0)) fmt.Fprintln(os.Stdout, wrap(fmt.Sprintf("SHA256: %x", sha256.Sum256(cert.Raw)), 0))
} }
fmt.Fprintln(os.Stdout, wrap("Subject: "+displayName(cert.Subject), 0)) fmt.Fprintln(os.Stdout, wrap("Subject: "+displayName(cert.Subject), 0))
fmt.Fprintln(os.Stdout, wrap("Issuer: "+displayName(cert.Issuer), 0)) fmt.Fprintln(os.Stdout, wrap("Issuer: "+displayName(cert.Issuer), 0))
fmt.Fprintf(os.Stdout, "\tSignature algorithm: %s / %s\n", sigAlgoPK(cert.SignatureAlgorithm), fmt.Fprintf(os.Stdout, "\tSignature algorithm: %s / %s\n", sigAlgoPK(cert.SignatureAlgorithm),
sigAlgoHash(cert.SignatureAlgorithm)) sigAlgoHash(cert.SignatureAlgorithm))
fmt.Fprintln(os.Stdout, "Details:") fmt.Fprintln(os.Stdout, "Details:")
wrapPrint("Public key: "+certPublic(cert), 1) wrapPrint("Public key: "+certPublic(cert), 1)
fmt.Fprintf(os.Stdout, "\tSerial number: %s\n", cert.SerialNumber) fmt.Fprintf(os.Stdout, "\tSerial number: %s\n", cert.SerialNumber)
if len(cert.AuthorityKeyId) > 0 { if len(cert.AuthorityKeyId) > 0 {
fmt.Fprintf(os.Stdout, "\t%s\n", wrap("AKI: "+dumpHex(cert.AuthorityKeyId), 1)) fmt.Fprintf(os.Stdout, "\t%s\n", wrap("AKI: "+dumpHex(cert.AuthorityKeyId), 1))
} }
if len(cert.SubjectKeyId) > 0 { if len(cert.SubjectKeyId) > 0 {
fmt.Fprintf(os.Stdout, "\t%s\n", wrap("SKI: "+dumpHex(cert.SubjectKeyId), 1)) fmt.Fprintf(os.Stdout, "\t%s\n", wrap("SKI: "+dumpHex(cert.SubjectKeyId), 1))
} }
wrapPrint("Valid from: "+cert.NotBefore.Format(dateFormat), 1) wrapPrint("Valid from: "+cert.NotBefore.Format(dateFormat), 1)
fmt.Fprintf(os.Stdout, "\t until: %s\n", cert.NotAfter.Format(dateFormat)) fmt.Fprintf(os.Stdout, "\t until: %s\n", cert.NotAfter.Format(dateFormat))
fmt.Fprintf(os.Stdout, "\tKey usages: %s\n", keyUsages(cert.KeyUsage)) fmt.Fprintf(os.Stdout, "\tKey usages: %s\n", keyUsages(cert.KeyUsage))
if len(cert.ExtKeyUsage) > 0 { if len(cert.ExtKeyUsage) > 0 {
fmt.Fprintf(os.Stdout, "\tExtended usages: %s\n", extUsage(cert.ExtKeyUsage)) fmt.Fprintf(os.Stdout, "\tExtended usages: %s\n", extUsage(cert.ExtKeyUsage))
} }
showBasicConstraints(cert) showBasicConstraints(cert)
@@ -217,19 +220,19 @@ func displayCert(cert *x509.Certificate) {
} }
func displayAllCerts(in []byte, leafOnly bool) { func displayAllCerts(in []byte, leafOnly bool) {
certs, err := certlib.ParseCertificatesPEM(in) certs, err := certlib.ParseCertificatesPEM(in)
if err != nil { if err != nil {
certs, _, err = certlib.ParseCertificatesDER(in, "") certs, _, err = certlib.ParseCertificatesDER(in, "")
if err != nil { if err != nil {
_, _ = lib.Warn(err, "failed to parse certificates") _, _ = lib.Warn(err, "failed to parse certificates")
return return
} }
} }
if len(certs) == 0 { if len(certs) == 0 {
_, _ = lib.Warnx("no certificates found") _, _ = lib.Warnx("no certificates found")
return return
} }
if leafOnly { if leafOnly {
displayCert(certs[0]) displayCert(certs[0])
@@ -243,11 +246,11 @@ func displayAllCerts(in []byte, leafOnly bool) {
func displayAllCertsWeb(uri string, leafOnly bool) { func displayAllCertsWeb(uri string, leafOnly bool) {
ci := getConnInfo(uri) ci := getConnInfo(uri)
conn, err := tls.Dial("tcp", ci.Addr, permissiveConfig()) conn, err := tls.Dial("tcp", ci.Addr, permissiveConfig())
if err != nil { if err != nil {
_, _ = lib.Warn(err, "couldn't connect to %s", ci.Addr) _, _ = lib.Warn(err, "couldn't connect to %s", ci.Addr)
return return
} }
defer conn.Close() defer conn.Close()
state := conn.ConnectionState() state := conn.ConnectionState()
@@ -260,34 +263,34 @@ func displayAllCertsWeb(uri string, leafOnly bool) {
state = conn.ConnectionState() state = conn.ConnectionState()
} }
conn.Close() conn.Close()
} else { } else {
_, _ = lib.Warn(err, "TLS verification error with server name %s", ci.Host) _, _ = lib.Warn(err, "TLS verification error with server name %s", ci.Host)
} }
if len(state.PeerCertificates) == 0 { if len(state.PeerCertificates) == 0 {
_, _ = lib.Warnx("no certificates found") _, _ = lib.Warnx("no certificates found")
return return
} }
if leafOnly { if leafOnly {
displayCert(state.PeerCertificates[0]) displayCert(state.PeerCertificates[0])
return return
} }
if len(state.VerifiedChains) == 0 { if len(state.VerifiedChains) == 0 {
_, _ = lib.Warnx("no verified chains found; using peer chain") _, _ = lib.Warnx("no verified chains found; using peer chain")
for i := range state.PeerCertificates { for i := range state.PeerCertificates {
displayCert(state.PeerCertificates[i]) displayCert(state.PeerCertificates[i])
} }
} else { } else {
fmt.Fprintln(os.Stdout, "TLS chain verified successfully.") fmt.Fprintln(os.Stdout, "TLS chain verified successfully.")
for i := range state.VerifiedChains { for i := range state.VerifiedChains {
fmt.Fprintf(os.Stdout, "--- Verified certificate chain %d ---%s", i+1, "\n") fmt.Fprintf(os.Stdout, "--- Verified certificate chain %d ---%s", i+1, "\n")
for j := range state.VerifiedChains[i] { for j := range state.VerifiedChains[i] {
displayCert(state.VerifiedChains[i][j]) displayCert(state.VerifiedChains[i][j])
} }
} }
} }
} }
func main() { func main() {
@@ -298,28 +301,28 @@ func main() {
flag.Parse() flag.Parse()
if flag.NArg() == 0 || (flag.NArg() == 1 && flag.Arg(0) == "-") { if flag.NArg() == 0 || (flag.NArg() == 1 && flag.Arg(0) == "-") {
certs, err := io.ReadAll(os.Stdin) certs, err := io.ReadAll(os.Stdin)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "couldn't read certificates from standard input") _, _ = lib.Warn(err, "couldn't read certificates from standard input")
os.Exit(1) os.Exit(1)
} }
// This is needed for getting certs from JSON/jq. // This is needed for getting certs from JSON/jq.
certs = bytes.TrimSpace(certs) certs = bytes.TrimSpace(certs)
certs = bytes.Replace(certs, []byte(`\n`), []byte{0xa}, -1) certs = bytes.ReplaceAll(certs, []byte(`\n`), []byte{0xa})
certs = bytes.Trim(certs, `"`) certs = bytes.Trim(certs, `"`)
displayAllCerts(certs, leafOnly) displayAllCerts(certs, leafOnly)
} else { } else {
for _, filename := range flag.Args() { for _, filename := range flag.Args() {
fmt.Fprintf(os.Stdout, "--%s ---%s", filename, "\n") fmt.Fprintf(os.Stdout, "--%s ---%s", filename, "\n")
if strings.HasPrefix(filename, "https://") { if strings.HasPrefix(filename, "https://") {
displayAllCertsWeb(filename, leafOnly) displayAllCertsWeb(filename, leafOnly)
} else { } else {
in, err := os.ReadFile(filename) in, err := os.ReadFile(filename)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "couldn't read certificate") _, _ = lib.Warn(err, "couldn't read certificate")
continue continue
} }
displayAllCerts(in, leafOnly) displayAllCerts(in, leafOnly)
} }

141
cmd/certdump/util.go
View File

@@ -26,94 +26,79 @@ var keyUsage = map[x509.KeyUsage]string{
} }
var extKeyUsages = map[x509.ExtKeyUsage]string{ var extKeyUsages = map[x509.ExtKeyUsage]string{
x509.ExtKeyUsageAny: "any", x509.ExtKeyUsageAny: "any",
x509.ExtKeyUsageServerAuth: "server auth", x509.ExtKeyUsageServerAuth: "server auth",
x509.ExtKeyUsageClientAuth: "client auth", x509.ExtKeyUsageClientAuth: "client auth",
x509.ExtKeyUsageCodeSigning: "code signing", x509.ExtKeyUsageCodeSigning: "code signing",
x509.ExtKeyUsageEmailProtection: "s/mime", x509.ExtKeyUsageEmailProtection: "s/mime",
x509.ExtKeyUsageIPSECEndSystem: "ipsec end system", x509.ExtKeyUsageIPSECEndSystem: "ipsec end system",
x509.ExtKeyUsageIPSECTunnel: "ipsec tunnel", x509.ExtKeyUsageIPSECTunnel: "ipsec tunnel",
x509.ExtKeyUsageIPSECUser: "ipsec user", x509.ExtKeyUsageIPSECUser: "ipsec user",
x509.ExtKeyUsageTimeStamping: "timestamping", x509.ExtKeyUsageTimeStamping: "timestamping",
x509.ExtKeyUsageOCSPSigning: "ocsp signing", x509.ExtKeyUsageOCSPSigning: "ocsp signing",
x509.ExtKeyUsageMicrosoftServerGatedCrypto: "microsoft sgc", x509.ExtKeyUsageMicrosoftServerGatedCrypto: "microsoft sgc",
x509.ExtKeyUsageNetscapeServerGatedCrypto: "netscape sgc", x509.ExtKeyUsageNetscapeServerGatedCrypto: "netscape sgc",
x509.ExtKeyUsageMicrosoftCommercialCodeSigning: "microsoft commercial code signing", x509.ExtKeyUsageMicrosoftCommercialCodeSigning: "microsoft commercial code signing",
x509.ExtKeyUsageMicrosoftKernelCodeSigning: "microsoft kernel code signing", x509.ExtKeyUsageMicrosoftKernelCodeSigning: "microsoft kernel code signing",
}
func pubKeyAlgo(a x509.PublicKeyAlgorithm) string {
switch a {
case x509.UnknownPublicKeyAlgorithm:
return "unknown public key algorithm"
case x509.RSA:
return "RSA"
case x509.ECDSA:
return "ECDSA"
case x509.DSA:
return "DSA"
case x509.Ed25519:
return "Ed25519"
default:
return "unknown public key algorithm"
}
} }
func sigAlgoPK(a x509.SignatureAlgorithm) string { func sigAlgoPK(a x509.SignatureAlgorithm) string {
switch a { switch a {
case x509.MD2WithRSA, x509.MD5WithRSA, x509.SHA1WithRSA, x509.SHA256WithRSA, x509.SHA384WithRSA, x509.SHA512WithRSA: case x509.MD2WithRSA, x509.MD5WithRSA, x509.SHA1WithRSA, x509.SHA256WithRSA, x509.SHA384WithRSA, x509.SHA512WithRSA:
return "RSA" return "RSA"
case x509.SHA256WithRSAPSS, x509.SHA384WithRSAPSS, x509.SHA512WithRSAPSS: case x509.SHA256WithRSAPSS, x509.SHA384WithRSAPSS, x509.SHA512WithRSAPSS:
return "RSA-PSS" return "RSA-PSS"
case x509.ECDSAWithSHA1, x509.ECDSAWithSHA256, x509.ECDSAWithSHA384, x509.ECDSAWithSHA512: case x509.ECDSAWithSHA1, x509.ECDSAWithSHA256, x509.ECDSAWithSHA384, x509.ECDSAWithSHA512:
return "ECDSA" return "ECDSA"
case x509.DSAWithSHA1, x509.DSAWithSHA256: case x509.DSAWithSHA1, x509.DSAWithSHA256:
return "DSA" return "DSA"
case x509.PureEd25519: case x509.PureEd25519:
return "Ed25519" return "Ed25519"
case x509.UnknownSignatureAlgorithm: case x509.UnknownSignatureAlgorithm:
return "unknown public key algorithm" return "unknown public key algorithm"
default: default:
return "unknown public key algorithm" return "unknown public key algorithm"
} }
} }
func sigAlgoHash(a x509.SignatureAlgorithm) string { func sigAlgoHash(a x509.SignatureAlgorithm) string {
switch a { switch a {
case x509.MD2WithRSA: case x509.MD2WithRSA:
return "MD2" return "MD2"
case x509.MD5WithRSA: case x509.MD5WithRSA:
return "MD5" return "MD5"
case x509.SHA1WithRSA, x509.ECDSAWithSHA1, x509.DSAWithSHA1: case x509.SHA1WithRSA, x509.ECDSAWithSHA1, x509.DSAWithSHA1:
return "SHA1" return "SHA1"
case x509.SHA256WithRSA, x509.ECDSAWithSHA256, x509.DSAWithSHA256: case x509.SHA256WithRSA, x509.ECDSAWithSHA256, x509.DSAWithSHA256:
return "SHA256" return "SHA256"
case x509.SHA256WithRSAPSS: case x509.SHA256WithRSAPSS:
return "SHA256" return "SHA256"
case x509.SHA384WithRSA, x509.ECDSAWithSHA384: case x509.SHA384WithRSA, x509.ECDSAWithSHA384:
return "SHA384" return "SHA384"
case x509.SHA384WithRSAPSS: case x509.SHA384WithRSAPSS:
return "SHA384" return "SHA384"
case x509.SHA512WithRSA, x509.ECDSAWithSHA512: case x509.SHA512WithRSA, x509.ECDSAWithSHA512:
return "SHA512" return "SHA512"
case x509.SHA512WithRSAPSS: case x509.SHA512WithRSAPSS:
return "SHA512" return "SHA512"
case x509.PureEd25519: case x509.PureEd25519:
return "SHA512" return "SHA512"
case x509.UnknownSignatureAlgorithm: case x509.UnknownSignatureAlgorithm:
return "unknown hash algorithm" return "unknown hash algorithm"
default: default:
return "unknown hash algorithm" return "unknown hash algorithm"
} }
} }
const maxLine = 78 const maxLine = 78
func makeIndent(n int) string { func makeIndent(n int) string {
s := " " s := " "
for i := 0; i < n; i++ { var sSb97 strings.Builder
s += " " for range n {
sSb97.WriteString(" ")
} }
s += sSb97.String()
return s return s
} }
@@ -121,7 +106,7 @@ func indentLen(n int) int {
return 4 + (8 * n) return 4 + (8 * n)
} }
// this isn't real efficient, but that's not a problem here // this isn't real efficient, but that's not a problem here.
func wrap(s string, indent int) string { func wrap(s string, indent int) string {
if indent > 3 { if indent > 3 {
indent = 3 indent = 3
@@ -144,9 +129,11 @@ func wrap(s string, indent int) string {
func dumpHex(in []byte) string { func dumpHex(in []byte) string {
var s string var s string
var sSb130 strings.Builder
for i := range in { for i := range in {
s += fmt.Sprintf("%02X:", in[i]) sSb130.WriteString(fmt.Sprintf("%02X:", in[i]))
} }
s += sSb130.String()
return strings.Trim(s, ":") return strings.Trim(s, ":")
} }

52
cmd/certexpiry/main.go
View File

@@ -1,17 +1,17 @@
package main package main
import ( import (
"crypto/x509" "crypto/x509"
"crypto/x509/pkix" "crypto/x509/pkix"
"flag" "flag"
"fmt" "fmt"
"os" "os"
"strings" "strings"
"time" "time"
"git.wntrmute.dev/kyle/goutils/certlib" "git.wntrmute.dev/kyle/goutils/certlib"
"git.wntrmute.dev/kyle/goutils/die" "git.wntrmute.dev/kyle/goutils/die"
"git.wntrmute.dev/kyle/goutils/lib" "git.wntrmute.dev/kyle/goutils/lib"
) )
var warnOnly bool var warnOnly bool
@@ -53,7 +53,7 @@ func displayName(name pkix.Name) string {
} }
func expires(cert *x509.Certificate) time.Duration { func expires(cert *x509.Certificate) time.Duration {
return cert.NotAfter.Sub(time.Now()) return time.Until(cert.NotAfter)
} }
func inDanger(cert *x509.Certificate) bool { func inDanger(cert *x509.Certificate) bool {
@@ -79,21 +79,21 @@ func main() {
flag.DurationVar(&leeway, "t", leeway, "warn if certificates are closer than this to expiring") flag.DurationVar(&leeway, "t", leeway, "warn if certificates are closer than this to expiring")
flag.Parse() flag.Parse()
for _, file := range flag.Args() { for _, file := range flag.Args() {
in, err := os.ReadFile(file) in, err := os.ReadFile(file)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "failed to read file") _, _ = lib.Warn(err, "failed to read file")
continue continue
} }
certs, err := certlib.ParseCertificatesPEM(in) certs, err := certlib.ParseCertificatesPEM(in)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "while parsing certificates") _, _ = lib.Warn(err, "while parsing certificates")
continue continue
} }
for _, cert := range certs { for _, cert := range certs {
checkCert(cert) checkCert(cert)
} }
} }
} }

3
cmd/certverify/main.go
View File

@@ -4,7 +4,6 @@ import (
"crypto/x509" "crypto/x509"
"flag" "flag"
"fmt" "fmt"
"io/ioutil"
"os" "os"
"time" "time"
@@ -68,7 +67,7 @@ func main() {
lib.ProgName()) lib.ProgName())
} }
fileData, err := ioutil.ReadFile(flag.Arg(0)) fileData, err := os.ReadFile(flag.Arg(0))
die.If(err) die.If(err)
chain, err := certlib.ParseCertificatesPEM(fileData) chain, err := certlib.ParseCertificatesPEM(fileData)

84
cmd/clustersh/main.go
View File

@@ -1,16 +1,16 @@
package main package main
import ( import (
"bufio" "bufio"
"flag" "errors"
"fmt" "flag"
"io" "fmt"
"errors" "io"
"log" "log"
"net" "net"
"os" "os"
"strings" "strings"
"sync" "sync"
"git.wntrmute.dev/kyle/goutils/lib" "git.wntrmute.dev/kyle/goutils/lib"
"github.com/pkg/sftp" "github.com/pkg/sftp"
@@ -83,7 +83,7 @@ func scanner(host string, in io.Reader, out io.Writer) {
} }
} }
func logError(host string, err error, format string, args ...interface{}) { func logError(host string, err error, format string, args ...any) {
msg := fmt.Sprintf(format, args...) msg := fmt.Sprintf(format, args...)
log.Printf("[%s] FAILED: %s: %v\n", host, msg, err) log.Printf("[%s] FAILED: %s: %v\n", host, msg, err)
} }
@@ -93,12 +93,12 @@ func exec(wg *sync.WaitGroup, user, host string, commands []string) {
defer func() { defer func() {
for i := len(shutdown) - 1; i >= 0; i-- { for i := len(shutdown) - 1; i >= 0; i-- {
err := shutdown[i]() err := shutdown[i]()
if err != nil && !errors.Is(err, io.EOF) { if err != nil && !errors.Is(err, io.EOF) {
logError(host, err, "shutting down") logError(host, err, "shutting down")
} }
} }
}() }()
defer wg.Done() defer wg.Done()
conf := sshConfig(user) conf := sshConfig(user)
@@ -150,12 +150,12 @@ func upload(wg *sync.WaitGroup, user, host, local, remote string) {
defer func() { defer func() {
for i := len(shutdown) - 1; i >= 0; i-- { for i := len(shutdown) - 1; i >= 0; i-- {
err := shutdown[i]() err := shutdown[i]()
if err != nil && !errors.Is(err, io.EOF) { if err != nil && !errors.Is(err, io.EOF) {
logError(host, err, "shutting down") logError(host, err, "shutting down")
} }
} }
}() }()
defer wg.Done() defer wg.Done()
conf := sshConfig(user) conf := sshConfig(user)
@@ -200,13 +200,13 @@ func upload(wg *sync.WaitGroup, user, host, local, remote string) {
fmt.Printf("[%s] wrote %d-byte chunk\n", host, n) fmt.Printf("[%s] wrote %d-byte chunk\n", host, n)
} }
if errors.Is(err, io.EOF) { if errors.Is(err, io.EOF) {
break break
} else if err != nil { } else if err != nil {
logError(host, err, "reading chunk") logError(host, err, "reading chunk")
return return
} }
} }
fmt.Printf("[%s] %s uploaded to %s\n", host, remote, local) fmt.Printf("[%s] %s uploaded to %s\n", host, remote, local)
} }
@@ -215,12 +215,12 @@ func download(wg *sync.WaitGroup, user, host, local, remote string) {
defer func() { defer func() {
for i := len(shutdown) - 1; i >= 0; i-- { for i := len(shutdown) - 1; i >= 0; i-- {
err := shutdown[i]() err := shutdown[i]()
if err != nil && !errors.Is(err, io.EOF) { if err != nil && !errors.Is(err, io.EOF) {
logError(host, err, "shutting down") logError(host, err, "shutting down")
} }
} }
}() }()
defer wg.Done() defer wg.Done()
conf := sshConfig(user) conf := sshConfig(user)
@@ -266,12 +266,12 @@ func download(wg *sync.WaitGroup, user, host, local, remote string) {
fmt.Printf("[%s] wrote %d-byte chunk\n", host, n) fmt.Printf("[%s] wrote %d-byte chunk\n", host, n)
} }
if errors.Is(err, io.EOF) { if errors.Is(err, io.EOF) {
break break
} else if err != nil { } else if err != nil {
logError(host, err, "reading chunk") logError(host, err, "reading chunk")
return return
} }
} }
fmt.Printf("[%s] %s downloaded to %s\n", host, remote, local) fmt.Printf("[%s] %s downloaded to %s\n", host, remote, local)
} }

11
cmd/cruntar/main.go
View File

@@ -262,15 +262,14 @@ func main() {
tfr := tar.NewReader(r) tfr := tar.NewReader(r)
for { for {
hdr, err := tfr.Next() hdr, err := tfr.Next()
if errors.Is(err, io.EOF) { if errors.Is(err, io.EOF) {
break break
} }
die.If(err) die.If(err)
err = processFile(tfr, hdr, top) err = processFile(tfr, hdr, top)
die.If(err) die.If(err)
} }
r.Close() r.Close()

6
cmd/csrpubdump/pubdump.go → cmd/csrpubdump/main.go
View File

@@ -47,8 +47,8 @@ func main() {
Bytes: out, Bytes: out,
} }
err = os.WriteFile(fileName+".pub", pem.EncodeToMemory(p), 0o644) err = os.WriteFile(fileName+".pub", pem.EncodeToMemory(p), 0o644)
die.If(err) die.If(err)
fmt.Fprintf(os.Stdout, "[+] wrote %s.\n", fileName+".pub") fmt.Fprintf(os.Stdout, "[+] wrote %s.\n", fileName+".pub")
} }
} }

1
cmd/data_sync/main.go
View File

@@ -163,7 +163,6 @@ func init() {
} }
func main() { func main() {
var logLevel, mountDir, syncDir, target string var logLevel, mountDir, syncDir, target string
var dryRun, quietMode, noSyslog, verboseRsync bool var dryRun, quietMode, noSyslog, verboseRsync bool

32
cmd/diskimg/main.go
View File

@@ -15,43 +15,41 @@ import (
const defaultHashAlgorithm = "sha256" const defaultHashAlgorithm = "sha256"
var ( var (
hAlgo string hAlgo string
debug = dbg.New() debug = dbg.New()
) )
func openImage(imageFile string) (*os.File, []byte, error) {
func openImage(imageFile string) (image *os.File, hash []byte, err error) { f, err := os.Open(imageFile)
image, err = os.Open(imageFile)
if err != nil { if err != nil {
return return nil, nil, err
} }
hash, err = ahash.SumReader(hAlgo, image) h, err := ahash.SumReader(hAlgo, f)
if err != nil { if err != nil {
return return nil, nil, err
} }
_, err = image.Seek(0, 0) if _, err := f.Seek(0, 0); err != nil {
if err != nil { return nil, nil, err
return
} }
debug.Printf("%s %x\n", imageFile, hash) debug.Printf("%s %x\n", imageFile, h)
return return f, h, nil
} }
func openDevice(devicePath string) (device *os.File, err error) { func openDevice(devicePath string) (*os.File, error) {
fi, err := os.Stat(devicePath) fi, err := os.Stat(devicePath)
if err != nil { if err != nil {
return return nil, err
} }
device, err = os.OpenFile(devicePath, os.O_RDWR|os.O_SYNC, fi.Mode()) device, err := os.OpenFile(devicePath, os.O_RDWR|os.O_SYNC, fi.Mode())
if err != nil { if err != nil {
return return nil, err
} }
return return device, nil
} }
func main() { func main() {

22
cmd/dumpbytes/main.go
View File

@@ -3,28 +3,30 @@ package main
import ( import (
"flag" "flag"
"fmt" "fmt"
"git.wntrmute.dev/kyle/goutils/die"
"io" "io"
"os" "os"
"strings"
"git.wntrmute.dev/kyle/goutils/die"
) )
func usage(w io.Writer, exc int) { func usage(w io.Writer, exc int) {
fmt.Fprintln(w, `usage: dumpbytes <file>`) fmt.Fprintln(w, `usage: dumpbytes -n tabs <file>`)
os.Exit(exc) os.Exit(exc)
} }
func printBytes(buf []byte) { func printBytes(buf []byte) {
fmt.Printf("\t") fmt.Printf("\t")
for i := 0; i < len(buf); i++ { for i := range buf {
fmt.Printf("0x%02x, ", buf[i]) fmt.Printf("0x%02x, ", buf[i])
} }
fmt.Println() fmt.Println()
} }
func dumpFile(path string, indentLevel int) error { func dumpFile(path string, indentLevel int) error {
indent := "" var indent strings.Builder
for i := 0; i < indentLevel; i++ { for range indentLevel {
indent += "\t" indent.WriteByte('\t')
} }
file, err := os.Open(path) file, err := os.Open(path)
@@ -34,13 +36,13 @@ func dumpFile(path string, indentLevel int) error {
defer file.Close() defer file.Close()
fmt.Printf("%svar buffer = []byte{\n", indent) fmt.Printf("%svar buffer = []byte{\n", indent.String())
for { for {
buf := make([]byte, 8) buf := make([]byte, 8)
n, err := file.Read(buf) n, err := file.Read(buf)
if err == io.EOF { if err == io.EOF {
if n > 0 { if n > 0 {
fmt.Printf("%s", indent) fmt.Printf("%s", indent.String())
printBytes(buf[:n]) printBytes(buf[:n])
} }
break break
@@ -50,11 +52,11 @@ func dumpFile(path string, indentLevel int) error {
return err return err
} }
fmt.Printf("%s", indent) fmt.Printf("%s", indent.String())
printBytes(buf[:n]) printBytes(buf[:n])
} }
fmt.Printf("%s}\n", indent) fmt.Printf("%s}\n", indent.String())
return nil return nil
} }

6
cmd/eig/main.go
View File

@@ -7,7 +7,7 @@ import (
"git.wntrmute.dev/kyle/goutils/die" "git.wntrmute.dev/kyle/goutils/die"
) )
// size of a kilobit in bytes // size of a kilobit in bytes.
const kilobit = 128 const kilobit = 128
const pageSize = 4096 const pageSize = 4096
@@ -29,7 +29,7 @@ func main() {
fillByte := uint8(*fill) fillByte := uint8(*fill)
buf := make([]byte, pageSize) buf := make([]byte, pageSize)
for i := 0; i < pageSize; i++ { for i := range pageSize {
buf[i] = fillByte buf[i] = fillByte
} }
@@ -40,7 +40,7 @@ func main() {
die.If(err) die.If(err)
defer file.Close() defer file.Close()
for i := 0; i < pages; i++ { for range pages {
_, err = file.Write(buf) _, err = file.Write(buf)
die.If(err) die.If(err)
} }

18
cmd/fragment/fragment.go → cmd/fragment/main.go
View File

@@ -80,7 +80,7 @@ func main() {
var fmtStr string var fmtStr string
if !*quiet { if !*quiet {
maxLine := fmt.Sprintf("%d", len(lines)) maxLine := strconv.Itoa(len(lines))
fmtStr = fmt.Sprintf("%%0%dd: %%s", len(maxLine)) fmtStr = fmt.Sprintf("%%0%dd: %%s", len(maxLine))
} }
@@ -95,12 +95,12 @@ func main() {
return false return false
} }
fmtStr += "\n" fmtStr += "\n"
for i := start; !endFunc(i); i++ { for i := start; !endFunc(i); i++ {
if *quiet { if *quiet {
fmt.Fprintln(os.Stdout, lines[i]) fmt.Fprintln(os.Stdout, lines[i])
} else { } else {
fmt.Fprintf(os.Stdout, fmtStr, i, lines[i]) fmt.Fprintf(os.Stdout, fmtStr, i, lines[i])
} }
} }
} }

103
cmd/jlp/jlp.go → cmd/jlp/main.go
View File

@@ -1,51 +1,51 @@
package main package main
import ( import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"flag" "flag"
"fmt" "fmt"
"io" "io"
"os" "os"
"git.wntrmute.dev/kyle/goutils/lib" "git.wntrmute.dev/kyle/goutils/lib"
) )
func prettify(file string, validateOnly bool) error { func prettify(file string, validateOnly bool) error {
var in []byte var in []byte
var err error var err error
if file == "-" { if file == "-" {
in, err = io.ReadAll(os.Stdin) in, err = io.ReadAll(os.Stdin)
} else { } else {
in, err = os.ReadFile(file) in, err = os.ReadFile(file)
} }
if err != nil { if err != nil {
_, _ = lib.Warn(err, "ReadFile") _, _ = lib.Warn(err, "ReadFile")
return err return err
} }
var buf = &bytes.Buffer{} var buf = &bytes.Buffer{}
err = json.Indent(buf, in, "", " ") err = json.Indent(buf, in, "", " ")
if err != nil { if err != nil {
_, _ = lib.Warn(err, "%s", file) _, _ = lib.Warn(err, "%s", file)
return err return err
} }
if validateOnly { if validateOnly {
return nil return nil
} }
if file == "-" { if file == "-" {
_, err = os.Stdout.Write(buf.Bytes()) _, err = os.Stdout.Write(buf.Bytes())
} else { } else {
err = os.WriteFile(file, buf.Bytes(), 0o644) err = os.WriteFile(file, buf.Bytes(), 0o644)
} }
if err != nil { if err != nil {
_, _ = lib.Warn(err, "WriteFile") _, _ = lib.Warn(err, "WriteFile")
} }
return err return err
} }
@@ -54,44 +54,44 @@ func compact(file string, validateOnly bool) error {
var in []byte var in []byte
var err error var err error
if file == "-" { if file == "-" {
in, err = io.ReadAll(os.Stdin) in, err = io.ReadAll(os.Stdin)
} else { } else {
in, err = os.ReadFile(file) in, err = os.ReadFile(file)
} }
if err != nil { if err != nil {
_, _ = lib.Warn(err, "ReadFile") _, _ = lib.Warn(err, "ReadFile")
return err return err
} }
var buf = &bytes.Buffer{} var buf = &bytes.Buffer{}
err = json.Compact(buf, in) err = json.Compact(buf, in)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "%s", file) _, _ = lib.Warn(err, "%s", file)
return err return err
} }
if validateOnly { if validateOnly {
return nil return nil
} }
if file == "-" { if file == "-" {
_, err = os.Stdout.Write(buf.Bytes()) _, err = os.Stdout.Write(buf.Bytes())
} else { } else {
err = os.WriteFile(file, buf.Bytes(), 0o644) err = os.WriteFile(file, buf.Bytes(), 0o644)
} }
if err != nil { if err != nil {
_, _ = lib.Warn(err, "WriteFile") _, _ = lib.Warn(err, "WriteFile")
} }
return err return err
} }
func usage() { func usage() {
progname := lib.ProgName() progname := lib.ProgName()
fmt.Fprintf(os.Stdout, `Usage: %s [-h] files... fmt.Fprintf(os.Stdout, `Usage: %s [-h] files...
%s is used to lint and prettify (or compact) JSON files. The %s is used to lint and prettify (or compact) JSON files. The
files will be updated in-place. files will be updated in-place.
@@ -100,7 +100,6 @@ func usage() {
-h Print this help message. -h Print this help message.
-n Don't prettify; only perform validation. -n Don't prettify; only perform validation.
`, progname, progname) `, progname, progname)
} }
func init() { func init() {

92
cmd/kgz/main.go
View File

@@ -1,68 +1,68 @@
package main package main
import ( import (
"compress/flate" "compress/flate"
"compress/gzip" "compress/gzip"
"flag" "flag"
"fmt" "fmt"
"io" "io"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
) )
const gzipExt = ".gz" const gzipExt = ".gz"
func compress(path, target string, level int) error { func compress(path, target string, level int) error {
sourceFile, err := os.Open(path) sourceFile, err := os.Open(path)
if err != nil { if err != nil {
return fmt.Errorf("opening file for read: %w", err) return fmt.Errorf("opening file for read: %w", err)
} }
defer sourceFile.Close() defer sourceFile.Close()
destFile, err := os.Create(target) destFile, err := os.Create(target)
if err != nil { if err != nil {
return fmt.Errorf("opening file for write: %w", err) return fmt.Errorf("opening file for write: %w", err)
} }
defer destFile.Close() defer destFile.Close()
gzipCompressor, err := gzip.NewWriterLevel(destFile, level) gzipCompressor, err := gzip.NewWriterLevel(destFile, level)
if err != nil { if err != nil {
return fmt.Errorf("invalid compression level: %w", err) return fmt.Errorf("invalid compression level: %w", err)
} }
defer gzipCompressor.Close() defer gzipCompressor.Close()
_, err = io.Copy(gzipCompressor, sourceFile) _, err = io.Copy(gzipCompressor, sourceFile)
if err != nil { if err != nil {
return fmt.Errorf("compressing file: %w", err) return fmt.Errorf("compressing file: %w", err)
} }
return nil return nil
} }
func uncompress(path, target string) error { func uncompress(path, target string) error {
sourceFile, err := os.Open(path) sourceFile, err := os.Open(path)
if err != nil { if err != nil {
return fmt.Errorf("opening file for read: %w", err) return fmt.Errorf("opening file for read: %w", err)
} }
defer sourceFile.Close() defer sourceFile.Close()
gzipUncompressor, err := gzip.NewReader(sourceFile) gzipUncompressor, err := gzip.NewReader(sourceFile)
if err != nil { if err != nil {
return fmt.Errorf("reading gzip headers: %w", err) return fmt.Errorf("reading gzip headers: %w", err)
} }
defer gzipUncompressor.Close() defer gzipUncompressor.Close()
destFile, err := os.Create(target) destFile, err := os.Create(target)
if err != nil { if err != nil {
return fmt.Errorf("opening file for write: %w", err) return fmt.Errorf("opening file for write: %w", err)
} }
defer destFile.Close() defer destFile.Close()
_, err = io.Copy(destFile, gzipUncompressor) _, err = io.Copy(destFile, gzipUncompressor)
if err != nil { if err != nil {
return fmt.Errorf("uncompressing file: %w", err) return fmt.Errorf("uncompressing file: %w", err)
} }
return nil return nil
} }
@@ -106,9 +106,9 @@ func pathForUncompressing(source, dest string) (string, error) {
} }
source = filepath.Base(source) source = filepath.Base(source)
if !strings.HasSuffix(source, gzipExt) { if !strings.HasSuffix(source, gzipExt) {
return "", fmt.Errorf("%s is a not gzip-compressed file", source) return "", fmt.Errorf("%s is a not gzip-compressed file", source)
} }
outFile := source[:len(source)-len(gzipExt)] outFile := source[:len(source)-len(gzipExt)]
outFile = filepath.Join(dest, outFile) outFile = filepath.Join(dest, outFile)
return outFile, nil return outFile, nil
@@ -120,9 +120,9 @@ func pathForCompressing(source, dest string) (string, error) {
} }
source = filepath.Base(source) source = filepath.Base(source)
if strings.HasSuffix(source, gzipExt) { if strings.HasSuffix(source, gzipExt) {
return "", fmt.Errorf("%s is a gzip-compressed file", source) return "", fmt.Errorf("%s is a gzip-compressed file", source)
} }
dest = filepath.Join(dest, source+gzipExt) dest = filepath.Join(dest, source+gzipExt)
return dest, nil return dest, nil

12
cmd/minmax/minmax.go → cmd/minmax/main.go
View File

@@ -40,14 +40,14 @@ func main() {
usage() usage()
} }
min, err := strconv.Atoi(flag.Arg(1)) minVal, err := strconv.Atoi(flag.Arg(1))
dieIf(err) dieIf(err)
max, err := strconv.Atoi(flag.Arg(2)) maxVal, err := strconv.Atoi(flag.Arg(2))
dieIf(err) dieIf(err)
code := kind << 6 code := kind << 6
code += (min << 3) code += (minVal << 3)
code += max code += maxVal
fmt.Fprintf(os.Stdout, "%0o\n", code) fmt.Fprintf(os.Stdout, "%0o\n", code)
} }

5
cmd/parts/main.go
View File

@@ -5,7 +5,6 @@ import (
"flag" "flag"
"fmt" "fmt"
"io" "io"
"io/ioutil"
"os" "os"
"path/filepath" "path/filepath"
"sort" "sort"
@@ -47,7 +46,7 @@ func help(w io.Writer) {
} }
func loadDatabase() { func loadDatabase() {
data, err := ioutil.ReadFile(dbFile) data, err := os.ReadFile(dbFile)
if err != nil && os.IsNotExist(err) { if err != nil && os.IsNotExist(err) {
partsDB = &database{ partsDB = &database{
Version: dbVersion, Version: dbVersion,
@@ -74,7 +73,7 @@ func writeDB() {
data, err := json.Marshal(partsDB) data, err := json.Marshal(partsDB)
die.If(err) die.If(err)
err = ioutil.WriteFile(dbFile, data, 0644) err = os.WriteFile(dbFile, data, 0644)
die.If(err) die.If(err)
} }

5
cmd/pem2bin/main.go
View File

@@ -4,14 +4,13 @@ import (
"encoding/pem" "encoding/pem"
"flag" "flag"
"fmt" "fmt"
"io/ioutil"
"os" "os"
) )
var ext = ".bin" var ext = ".bin"
func stripPEM(path string) error { func stripPEM(path string) error {
data, err := ioutil.ReadFile(path) data, err := os.ReadFile(path)
if err != nil { if err != nil {
return err return err
} }
@@ -22,7 +21,7 @@ func stripPEM(path string) error {
fmt.Fprintf(os.Stderr, " (only the first object will be decoded)\n") fmt.Fprintf(os.Stderr, " (only the first object will be decoded)\n")
} }
return ioutil.WriteFile(path+ext, p.Bytes, 0644) return os.WriteFile(path+ext, p.Bytes, 0644)
} }
func main() { func main() {

24
cmd/pembody/pembody.go → cmd/pembody/main.go
View File

@@ -18,21 +18,21 @@ func main() {
var in []byte var in []byte
var err error var err error
path := flag.Arg(0) path := flag.Arg(0)
if path == "-" { if path == "-" {
in, err = io.ReadAll(os.Stdin) in, err = io.ReadAll(os.Stdin)
} else { } else {
in, err = os.ReadFile(flag.Arg(0)) in, err = os.ReadFile(flag.Arg(0))
} }
if err != nil { if err != nil {
lib.Err(lib.ExitFailure, err, "couldn't read file") lib.Err(lib.ExitFailure, err, "couldn't read file")
} }
p, _ := pem.Decode(in) p, _ := pem.Decode(in)
if p == nil { if p == nil {
lib.Errx(lib.ExitFailure, "%s isn't a PEM-encoded file", flag.Arg(0)) lib.Errx(lib.ExitFailure, "%s isn't a PEM-encoded file", flag.Arg(0))
} }
if _, err := os.Stdout.Write(p.Bytes); err != nil { if _, err := os.Stdout.Write(p.Bytes); err != nil {
lib.Err(lib.ExitFailure, err, "writing body") lib.Err(lib.ExitFailure, err, "writing body")
} }
} }

2
cmd/pemit/main.go
View File

@@ -70,7 +70,7 @@ func main() {
lib.Err(lib.ExitFailure, err, "failed to read input") lib.Err(lib.ExitFailure, err, "failed to read input")
} }
case argc > 1: case argc > 1:
for i := 0; i < argc; i++ { for i := range argc {
path := flag.Arg(i) path := flag.Arg(i)
err = copyFile(path, buf) err = copyFile(path, buf)
if err != nil { if err != nil {

18
cmd/readchain/chain.go → cmd/readchain/main.go
View File

@@ -1,25 +1,25 @@
package main package main
import ( import (
"crypto/x509" "crypto/x509"
"encoding/pem" "encoding/pem"
"flag" "flag"
"fmt" "fmt"
"os" "os"
) )
func main() { func main() {
flag.Parse() flag.Parse()
for _, fileName := range flag.Args() { for _, fileName := range flag.Args() {
data, err := os.ReadFile(fileName) data, err := os.ReadFile(fileName)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "[!] %s: %v\n", fileName, err) fmt.Fprintf(os.Stderr, "[!] %s: %v\n", fileName, err)
continue continue
} }
fmt.Fprintf(os.Stdout, "[+] %s:\n", fileName) fmt.Fprintf(os.Stdout, "[+] %s:\n", fileName)
rest := data[:] rest := data
for { for {
var p *pem.Block var p *pem.Block
p, rest = pem.Decode(rest) p, rest = pem.Decode(rest)
@@ -33,7 +33,7 @@ func main() {
break break
} }
fmt.Fprintf(os.Stdout, "\t%+v\n", cert.Subject.CommonName) fmt.Fprintf(os.Stdout, "\t%+v\n", cert.Subject.CommonName)
} }
} }
} }

42
cmd/renfnv/renfnv.go → cmd/renfnv/main.go
View File

@@ -43,7 +43,7 @@ func newName(path string) (string, error) {
return hashName(path, encodedHash), nil return hashName(path, encodedHash), nil
} }
func move(dst, src string, force bool) (err error) { func move(dst, src string, force bool) error {
if fileutil.FileDoesExist(dst) && !force { if fileutil.FileDoesExist(dst) && !force {
return fmt.Errorf("%s exists (pass the -f flag to overwrite)", dst) return fmt.Errorf("%s exists (pass the -f flag to overwrite)", dst)
} }
@@ -52,21 +52,23 @@ func move(dst, src string, force bool) (err error) {
return err return err
} }
defer func(e error) { var retErr error
defer func(e *error) {
dstFile.Close() dstFile.Close()
if e != nil { if *e != nil {
os.Remove(dst) os.Remove(dst)
} }
}(err) }(&retErr)
srcFile, err := os.Open(src) srcFile, err := os.Open(src)
if err != nil { if err != nil {
retErr = err
return err return err
} }
defer srcFile.Close() defer srcFile.Close()
_, err = io.Copy(dstFile, srcFile) if _, err = io.Copy(dstFile, srcFile); err != nil {
if err != nil { retErr = err
return err return err
} }
@@ -109,27 +111,27 @@ func main() {
for _, file := range flag.Args() { for _, file := range flag.Args() {
renamed, err := newName(file) renamed, err := newName(file)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "failed to get new file name") _, _ = lib.Warn(err, "failed to get new file name")
continue continue
} }
if verbose && !printChanged { if verbose && !printChanged {
fmt.Fprintln(os.Stdout, file) fmt.Fprintln(os.Stdout, file)
} }
if renamed != file { if renamed != file {
if !dryRun { if !dryRun {
err = move(renamed, file, force) err = move(renamed, file, force)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "failed to rename file from %s to %s", file, renamed) _, _ = lib.Warn(err, "failed to rename file from %s to %s", file, renamed)
continue continue
} }
} }
if printChanged && !verbose { if printChanged && !verbose {
fmt.Fprintln(os.Stdout, file, "->", renamed) fmt.Fprintln(os.Stdout, file, "->", renamed)
} }
} }
} }
} }

10
cmd/rolldie/main.go
View File

@@ -17,11 +17,11 @@ func rollDie(count, sides int) []int {
sum := 0 sum := 0
var rolls []int var rolls []int
for i := 0; i < count; i++ { for range count {
roll := rand.IntN(sides) + 1 roll := rand.IntN(sides) + 1
sum += roll sum += roll
rolls = append(rolls, roll) rolls = append(rolls, roll)
} }
rolls = append(rolls, sum) rolls = append(rolls, sum)
return rolls return rolls

14
cmd/showimp/main.go
View File

@@ -53,7 +53,7 @@ func init() {
project = wd[len(gopath):] project = wd[len(gopath):]
} }
func walkFile(path string, info os.FileInfo, err error) error { func walkFile(path string, _ os.FileInfo, err error) error {
if ignores[path] { if ignores[path] {
return filepath.SkipDir return filepath.SkipDir
} }
@@ -62,13 +62,17 @@ func walkFile(path string, info os.FileInfo, err error) error {
return nil return nil
} }
debug.Println(path)
f, err := parser.ParseFile(fset, path, nil, parser.ImportsOnly)
if err != nil { if err != nil {
return err return err
} }
debug.Println(path)
f, err2 := parser.ParseFile(fset, path, nil, parser.ImportsOnly)
if err2 != nil {
return err2
}
for _, importSpec := range f.Imports { for _, importSpec := range f.Imports {
importPath := strings.Trim(importSpec.Path.Value, `"`) importPath := strings.Trim(importSpec.Path.Value, `"`)
if stdLibRegexp.MatchString(importPath) { if stdLibRegexp.MatchString(importPath) {
@@ -102,7 +106,7 @@ func main() {
ignores["vendor"] = true ignores["vendor"] = true
} }
for _, word := range strings.Split(ignoreLine, ",") { for word := range strings.SplitSeq(ignoreLine, ",") {
ignores[strings.TrimSpace(word)] = true ignores[strings.TrimSpace(word)] = true
} }

93
cmd/ski/main.go
View File

@@ -1,23 +1,23 @@
package main package main
import ( import (
"bytes" "bytes"
"crypto" "crypto"
"crypto/ecdsa" "crypto/ecdsa"
"crypto/rsa" "crypto/rsa"
"crypto/sha1" "crypto/sha1"
"crypto/x509" "crypto/x509"
"crypto/x509/pkix" "crypto/x509/pkix"
"encoding/asn1" "encoding/asn1"
"encoding/pem" "encoding/pem"
"flag" "flag"
"fmt" "fmt"
"io" "io"
"os" "os"
"strings" "strings"
"git.wntrmute.dev/kyle/goutils/die" "git.wntrmute.dev/kyle/goutils/die"
"git.wntrmute.dev/kyle/goutils/lib" "git.wntrmute.dev/kyle/goutils/lib"
) )
func usage(w io.Writer) { func usage(w io.Writer) {
@@ -38,15 +38,15 @@ func init() {
flag.Usage = func() { usage(os.Stderr) } flag.Usage = func() { usage(os.Stderr) }
} }
func parse(path string) (public []byte, kt, ft string) { func parse(path string) ([]byte, string, string) {
data, err := os.ReadFile(path) data, err := os.ReadFile(path)
die.If(err) die.If(err)
data = bytes.TrimSpace(data) data = bytes.TrimSpace(data)
p, rest := pem.Decode(data) p, rest := pem.Decode(data)
if len(rest) > 0 { if len(rest) > 0 {
_, _ = lib.Warnx("trailing data in PEM file") _, _ = lib.Warnx("trailing data in PEM file")
} }
if p == nil { if p == nil {
die.With("no PEM data found") die.With("no PEM data found")
@@ -54,6 +54,12 @@ func parse(path string) (public []byte, kt, ft string) {
data = p.Bytes data = p.Bytes
var (
public []byte
kt string
ft string
)
switch p.Type { switch p.Type {
case "PRIVATE KEY", "RSA PRIVATE KEY", "EC PRIVATE KEY": case "PRIVATE KEY", "RSA PRIVATE KEY", "EC PRIVATE KEY":
public, kt = parseKey(data) public, kt = parseKey(data)
@@ -68,11 +74,11 @@ func parse(path string) (public []byte, kt, ft string) {
die.With("unknown PEM type %s", p.Type) die.With("unknown PEM type %s", p.Type)
} }
return return public, kt, ft
} }
func parseKey(data []byte) (public []byte, kt string) { func parseKey(data []byte) ([]byte, string) {
privInterface, err := x509.ParsePKCS8PrivateKey(data) privInterface, err := x509.ParsePKCS8PrivateKey(data)
if err != nil { if err != nil {
privInterface, err = x509.ParsePKCS1PrivateKey(data) privInterface, err = x509.ParsePKCS1PrivateKey(data)
if err != nil { if err != nil {
@@ -84,6 +90,7 @@ func parseKey(data []byte) (public []byte, kt string) {
} }
var priv crypto.Signer var priv crypto.Signer
var kt string
switch p := privInterface.(type) { switch p := privInterface.(type) {
case *rsa.PrivateKey: case *rsa.PrivateKey:
priv = p priv = p
@@ -95,17 +102,18 @@ func parseKey(data []byte) (public []byte, kt string) {
die.With("unknown private key type %T", privInterface) die.With("unknown private key type %T", privInterface)
} }
public, err = x509.MarshalPKIXPublicKey(priv.Public()) public, err := x509.MarshalPKIXPublicKey(priv.Public())
die.If(err) die.If(err)
return return public, kt
} }
func parseCertificate(data []byte) (public []byte, kt string) { func parseCertificate(data []byte) ([]byte, string) {
cert, err := x509.ParseCertificate(data) cert, err := x509.ParseCertificate(data)
die.If(err) die.If(err)
pub := cert.PublicKey pub := cert.PublicKey
var kt string
switch pub.(type) { switch pub.(type) {
case *rsa.PublicKey: case *rsa.PublicKey:
kt = "RSA" kt = "RSA"
@@ -115,16 +123,17 @@ func parseCertificate(data []byte) (public []byte, kt string) {
die.With("unknown public key type %T", pub) die.With("unknown public key type %T", pub)
} }
public, err = x509.MarshalPKIXPublicKey(pub) public, err := x509.MarshalPKIXPublicKey(pub)
die.If(err) die.If(err)
return return public, kt
} }
func parseCSR(data []byte) (public []byte, kt string) { func parseCSR(data []byte) ([]byte, string) {
csr, err := x509.ParseCertificateRequest(data) csr, err := x509.ParseCertificateRequest(data)
die.If(err) die.If(err)
pub := csr.PublicKey pub := csr.PublicKey
var kt string
switch pub.(type) { switch pub.(type) {
case *rsa.PublicKey: case *rsa.PublicKey:
kt = "RSA" kt = "RSA"
@@ -134,16 +143,18 @@ func parseCSR(data []byte) (public []byte, kt string) {
die.With("unknown public key type %T", pub) die.With("unknown public key type %T", pub)
} }
public, err = x509.MarshalPKIXPublicKey(pub) public, err := x509.MarshalPKIXPublicKey(pub)
die.If(err) die.If(err)
return return public, kt
} }
func dumpHex(in []byte) string { func dumpHex(in []byte) string {
var s string var s string
var sSb153 strings.Builder
for i := range in { for i := range in {
s += fmt.Sprintf("%02X:", in[i]) sSb153.WriteString(fmt.Sprintf("%02X:", in[i]))
} }
s += sSb153.String()
return strings.Trim(s, ":") return strings.Trim(s, ":")
} }
@@ -170,10 +181,10 @@ func main() {
var subPKI subjectPublicKeyInfo var subPKI subjectPublicKeyInfo
_, err := asn1.Unmarshal(public, &subPKI) _, err := asn1.Unmarshal(public, &subPKI)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "failed to get subject PKI") _, _ = lib.Warn(err, "failed to get subject PKI")
continue continue
} }
pubHash := sha1.Sum(subPKI.SubjectPublicKey.Bytes) pubHash := sha1.Sum(subPKI.SubjectPublicKey.Bytes)
pubHashString := dumpHex(pubHash[:]) pubHashString := dumpHex(pubHash[:])
@@ -181,10 +192,10 @@ func main() {
ski = pubHashString ski = pubHashString
} }
if shouldMatch && ski != pubHashString { if shouldMatch && ski != pubHashString {
_, _ = lib.Warnx("%s: SKI mismatch (%s != %s)", _, _ = lib.Warnx("%s: SKI mismatch (%s != %s)",
path, ski, pubHashString) path, ski, pubHashString)
} }
fmt.Printf("%s %s (%s %s)\n", path, pubHashString, kt, ft) fmt.Printf("%s %s (%s %s)\n", path, pubHashString, kt, ft)
} }
} }

42
cmd/sprox/main.go
View File

@@ -10,19 +10,19 @@ import (
) )
func proxy(conn net.Conn, inside string) error { func proxy(conn net.Conn, inside string) error {
proxyConn, err := net.Dial("tcp", inside) proxyConn, err := net.Dial("tcp", inside)
if err != nil { if err != nil {
return err return err
} }
defer proxyConn.Close() defer proxyConn.Close()
defer conn.Close() defer conn.Close()
go func() { go func() {
_, _ = io.Copy(conn, proxyConn) _, _ = io.Copy(conn, proxyConn)
}() }()
_, err = io.Copy(proxyConn, conn) _, err = io.Copy(proxyConn, conn)
return err return err
} }
func main() { func main() {
@@ -34,17 +34,17 @@ func main() {
l, err := net.Listen("tcp", "0.0.0.0:"+outside) l, err := net.Listen("tcp", "0.0.0.0:"+outside)
die.If(err) die.If(err)
for { for {
conn, err := l.Accept() conn, err := l.Accept()
if err != nil { if err != nil {
_, _ = lib.Warn(err, "accept failed") _, _ = lib.Warn(err, "accept failed")
continue continue
} }
go func() { go func() {
if err := proxy(conn, "127.0.0.1:"+inside); err != nil { if err := proxy(conn, "127.0.0.1:"+inside); err != nil {
_, _ = lib.Warn(err, "proxy error") _, _ = lib.Warn(err, "proxy error")
} }
}() }()
} }
} }

92
cmd/stealchain-server/main.go
View File

@@ -45,18 +45,18 @@ func main() {
os.Exit(1) os.Exit(1)
} }
cfg.Certificates = append(cfg.Certificates, cert) cfg.Certificates = append(cfg.Certificates, cert)
if sysRoot != "" { if sysRoot != "" {
pemList, err := os.ReadFile(sysRoot) pemList, err := os.ReadFile(sysRoot)
die.If(err) die.If(err)
roots := x509.NewCertPool() roots := x509.NewCertPool()
if !roots.AppendCertsFromPEM(pemList) { if !roots.AppendCertsFromPEM(pemList) {
fmt.Printf("[!] no valid roots found") fmt.Printf("[!] no valid roots found")
roots = nil roots = nil
} }
cfg.RootCAs = roots cfg.RootCAs = roots
} }
l, err := net.Listen("tcp", listenAddr) l, err := net.Listen("tcp", listenAddr)
if err != nil { if err != nil {
@@ -64,46 +64,46 @@ func main() {
os.Exit(1) os.Exit(1)
} }
for { for {
conn, err := l.Accept() conn, err := l.Accept()
if err != nil { if err != nil {
fmt.Println(err.Error()) fmt.Println(err.Error())
continue continue
} }
handleConn(conn, cfg) handleConn(conn, cfg)
} }
} }
// handleConn performs a TLS handshake, extracts the peer chain, and writes it to a file. // handleConn performs a TLS handshake, extracts the peer chain, and writes it to a file.
func handleConn(conn net.Conn, cfg *tls.Config) { func handleConn(conn net.Conn, cfg *tls.Config) {
defer conn.Close() defer conn.Close()
raddr := conn.RemoteAddr() raddr := conn.RemoteAddr()
tconn := tls.Server(conn, cfg) tconn := tls.Server(conn, cfg)
if err := tconn.Handshake(); err != nil { if err := tconn.Handshake(); err != nil {
fmt.Printf("[+] %v: failed to complete handshake: %v\n", raddr, err) fmt.Printf("[+] %v: failed to complete handshake: %v\n", raddr, err)
return return
} }
cs := tconn.ConnectionState() cs := tconn.ConnectionState()
if len(cs.PeerCertificates) == 0 { if len(cs.PeerCertificates) == 0 {
fmt.Printf("[+] %v: no chain presented\n", raddr) fmt.Printf("[+] %v: no chain presented\n", raddr)
return return
} }
var chain []byte var chain []byte
for _, cert := range cs.PeerCertificates { for _, cert := range cs.PeerCertificates {
p := &pem.Block{Type: "CERTIFICATE", Bytes: cert.Raw} p := &pem.Block{Type: "CERTIFICATE", Bytes: cert.Raw}
chain = append(chain, pem.EncodeToMemory(p)...) chain = append(chain, pem.EncodeToMemory(p)...)
} }
var nonce [16]byte var nonce [16]byte
if _, err := rand.Read(nonce[:]); err != nil { if _, err := rand.Read(nonce[:]); err != nil {
fmt.Printf("[+] %v: failed to generate filename nonce: %v\n", raddr, err) fmt.Printf("[+] %v: failed to generate filename nonce: %v\n", raddr, err)
return return
} }
fname := fmt.Sprintf("%v-%v.pem", raddr, hex.EncodeToString(nonce[:])) fname := fmt.Sprintf("%v-%v.pem", raddr, hex.EncodeToString(nonce[:]))
if err := os.WriteFile(fname, chain, 0o644); err != nil { if err := os.WriteFile(fname, chain, 0o644); err != nil {
fmt.Printf("[+] %v: failed to write %v: %v\n", raddr, fname, err) fmt.Printf("[+] %v: failed to write %v: %v\n", raddr, fname, err)
return return
} }
fmt.Printf("%v: [+] wrote %v.\n", raddr, fname) fmt.Printf("%v: [+] wrote %v.\n", raddr, fname)
} }

5
cmd/stealchain/thief.go → cmd/stealchain/main.go
View File

@@ -6,7 +6,6 @@ import (
"encoding/pem" "encoding/pem"
"flag" "flag"
"fmt" "fmt"
"io/ioutil"
"net" "net"
"os" "os"
@@ -23,7 +22,7 @@ func main() {
flag.Parse() flag.Parse()
if sysRoot != "" { if sysRoot != "" {
pemList, err := ioutil.ReadFile(sysRoot) pemList, err := os.ReadFile(sysRoot)
die.If(err) die.If(err)
roots := x509.NewCertPool() roots := x509.NewCertPool()
@@ -61,7 +60,7 @@ func main() {
chain = append(chain, pem.EncodeToMemory(p)...) chain = append(chain, pem.EncodeToMemory(p)...)
} }
err = ioutil.WriteFile(site+".pem", chain, 0644) err = os.WriteFile(site+".pem", chain, 0644)
die.If(err) die.If(err)
fmt.Printf("[+] wrote %s.pem.\n", site) fmt.Printf("[+] wrote %s.pem.\n", site)
} }

31
cmd/subjhash/main.go
View File

@@ -57,16 +57,16 @@ func getSubjectInfoHash(cert *x509.Certificate, issuer bool) []byte {
} }
func printDigests(paths []string, issuer bool) { func printDigests(paths []string, issuer bool) {
for _, path := range paths { for _, path := range paths {
cert, err := certlib.LoadCertificate(path) cert, err := certlib.LoadCertificate(path)
if err != nil { if err != nil {
_, _ = lib.Warn(err, "failed to load certificate from %s", path) _, _ = lib.Warn(err, "failed to load certificate from %s", path)
continue continue
} }
digest := getSubjectInfoHash(cert, issuer) digest := getSubjectInfoHash(cert, issuer)
fmt.Printf("%x %s\n", digest, path) fmt.Printf("%x %s\n", digest, path)
} }
} }
func matchDigests(paths []string, issuer bool) { func matchDigests(paths []string, issuer bool) {
@@ -75,22 +75,21 @@ func matchDigests(paths []string, issuer bool) {
} }
var invalid int var invalid int
for { for len(paths) > 0 {
if len(paths) == 0 {
break
}
fst := paths[0] fst := paths[0]
snd := paths[1] snd := paths[1]
paths = paths[2:] paths = paths[2:]
fstCert, err := certlib.LoadCertificate(fst) fstCert, err := certlib.LoadCertificate(fst)
die.If(err) die.If(err)
sndCert, err := certlib.LoadCertificate(snd) sndCert, err := certlib.LoadCertificate(snd)
die.If(err) die.If(err)
if !bytes.Equal(getSubjectInfoHash(fstCert, issuer), getSubjectInfoHash(sndCert, issuer)) {
_, _ = lib.Warnx("certificates don't match: %s and %s", fst, snd) if !bytes.Equal(getSubjectInfoHash(fstCert, issuer), getSubjectInfoHash(sndCert, issuer)) {
invalid++ _, _ = lib.Warnx("certificates don't match: %s and %s", fst, snd)
} invalid++
}
} }
if invalid > 0 { if invalid > 0 {

1
cmd/tlsinfo/main.go
View File

@@ -37,7 +37,6 @@ func printConnectionDetails(state tls.ConnectionState) {
func tlsVersion(version uint16) string { func tlsVersion(version uint16) string {
switch version { switch version {
case tls.VersionTLS13: case tls.VersionTLS13:
return "TLS 1.3" return "TLS 1.3"
case tls.VersionTLS12: case tls.VersionTLS12:

167
cmd/tlskeypair/main.go
View File

@@ -1,19 +1,19 @@
package main package main
import ( import (
"bytes" "bytes"
"crypto" "crypto"
"crypto/ecdsa" "crypto/ecdsa"
"crypto/elliptic" "crypto/elliptic"
"crypto/rsa" "crypto/rsa"
"crypto/x509" "crypto/x509"
"encoding/pem" "encoding/pem"
"errors" "errors"
"flag" "flag"
"fmt" "fmt"
"os" "os"
"git.wntrmute.dev/kyle/goutils/die" "git.wntrmute.dev/kyle/goutils/die"
) )
var validPEMs = map[string]bool{ var validPEMs = map[string]bool{
@@ -30,7 +30,7 @@ const (
curveP521 curveP521
) )
func getECCurve(pub interface{}) int { func getECCurve(pub any) int {
switch pub := pub.(type) { switch pub := pub.(type) {
case *ecdsa.PublicKey: case *ecdsa.PublicKey:
switch pub.Curve { switch pub.Curve {
@@ -53,72 +53,72 @@ func getECCurve(pub interface{}) int {
// matchRSA compares an RSA public key from certificate against RSA public key from private key. // matchRSA compares an RSA public key from certificate against RSA public key from private key.
// It returns true on match. // It returns true on match.
func matchRSA(certPub *rsa.PublicKey, keyPub *rsa.PublicKey) bool { func matchRSA(certPub *rsa.PublicKey, keyPub *rsa.PublicKey) bool {
return keyPub.N.Cmp(certPub.N) == 0 && keyPub.E == certPub.E return keyPub.N.Cmp(certPub.N) == 0 && keyPub.E == certPub.E
} }
// matchECDSA compares ECDSA public keys for equality and compatible curve. // matchECDSA compares ECDSA public keys for equality and compatible curve.
// It returns match=true when they are on the same curve and have the same X/Y. // It returns match=true when they are on the same curve and have the same X/Y.
// If curves mismatch, match is false. // If curves mismatch, match is false.
func matchECDSA(certPub *ecdsa.PublicKey, keyPub *ecdsa.PublicKey) bool { func matchECDSA(certPub *ecdsa.PublicKey, keyPub *ecdsa.PublicKey) bool {
if getECCurve(certPub) != getECCurve(keyPub) { if getECCurve(certPub) != getECCurve(keyPub) {
return false return false
} }
if keyPub.X.Cmp(certPub.X) != 0 { if keyPub.X.Cmp(certPub.X) != 0 {
return false return false
} }
if keyPub.Y.Cmp(certPub.Y) != 0 { if keyPub.Y.Cmp(certPub.Y) != 0 {
return false return false
} }
return true return true
} }
// matchKeys determines whether the certificate's public key matches the given private key. // matchKeys determines whether the certificate's public key matches the given private key.
// It returns true if they match; otherwise, it returns false and a human-friendly reason. // It returns true if they match; otherwise, it returns false and a human-friendly reason.
func matchKeys(cert *x509.Certificate, priv crypto.Signer) (bool, string) { func matchKeys(cert *x509.Certificate, priv crypto.Signer) (bool, string) {
switch keyPub := priv.Public().(type) { switch keyPub := priv.Public().(type) {
case *rsa.PublicKey: case *rsa.PublicKey:
switch certPub := cert.PublicKey.(type) { switch certPub := cert.PublicKey.(type) {
case *rsa.PublicKey: case *rsa.PublicKey:
if matchRSA(certPub, keyPub) { if matchRSA(certPub, keyPub) {
return true, "" return true, ""
} }
return false, "public keys don't match" return false, "public keys don't match"
case *ecdsa.PublicKey: case *ecdsa.PublicKey:
return false, "RSA private key, EC public key" return false, "RSA private key, EC public key"
default: default:
return false, fmt.Sprintf("unsupported certificate public key type: %T", cert.PublicKey) return false, fmt.Sprintf("unsupported certificate public key type: %T", cert.PublicKey)
} }
case *ecdsa.PublicKey: case *ecdsa.PublicKey:
switch certPub := cert.PublicKey.(type) { switch certPub := cert.PublicKey.(type) {
case *ecdsa.PublicKey: case *ecdsa.PublicKey:
if matchECDSA(certPub, keyPub) { if matchECDSA(certPub, keyPub) {
return true, "" return true, ""
} }
// Determine a more precise reason // Determine a more precise reason
kc := getECCurve(keyPub) kc := getECCurve(keyPub)
cc := getECCurve(certPub) cc := getECCurve(certPub)
if kc == curveInvalid { if kc == curveInvalid {
return false, "invalid private key curve" return false, "invalid private key curve"
} }
if cc == curveRSA { if cc == curveRSA {
return false, "private key is EC, certificate is RSA" return false, "private key is EC, certificate is RSA"
} }
if kc != cc { if kc != cc {
return false, "EC curves don't match" return false, "EC curves don't match"
} }
return false, "public keys don't match" return false, "public keys don't match"
case *rsa.PublicKey: case *rsa.PublicKey:
return false, "private key is EC, certificate is RSA" return false, "private key is EC, certificate is RSA"
default: default:
return false, fmt.Sprintf("unsupported certificate public key type: %T", cert.PublicKey) return false, fmt.Sprintf("unsupported certificate public key type: %T", cert.PublicKey)
} }
default: default:
return false, fmt.Sprintf("unrecognised private key type: %T", priv.Public()) return false, fmt.Sprintf("unrecognised private key type: %T", priv.Public())
} }
} }
func loadKey(path string) (crypto.Signer, error) { func loadKey(path string) (crypto.Signer, error) {
in, err := os.ReadFile(path) in, err := os.ReadFile(path)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -132,7 +132,7 @@ func loadKey(path string) (crypto.Signer, error) {
in = p.Bytes in = p.Bytes
} }
priv, err := x509.ParsePKCS8PrivateKey(in) priv, err := x509.ParsePKCS8PrivateKey(in)
if err != nil { if err != nil {
priv, err = x509.ParsePKCS1PrivateKey(in) priv, err = x509.ParsePKCS1PrivateKey(in)
if err != nil { if err != nil {
@@ -143,16 +143,15 @@ func loadKey(path string) (crypto.Signer, error) {
} }
} }
switch p := priv.(type) { switch p := priv.(type) {
case *rsa.PrivateKey: case *rsa.PrivateKey:
return p, nil return p, nil
case *ecdsa.PrivateKey: case *ecdsa.PrivateKey:
return p, nil return p, nil
default: default:
// should never reach here // should never reach here
return nil, errors.New("invalid private key") return nil, errors.New("invalid private key")
} }
} }
func main() { func main() {
@@ -161,7 +160,7 @@ func main() {
flag.StringVar(&certFile, "c", "", "TLS `certificate` file") flag.StringVar(&certFile, "c", "", "TLS `certificate` file")
flag.Parse() flag.Parse()
in, err := os.ReadFile(certFile) in, err := os.ReadFile(certFile)
die.If(err) die.If(err)
p, _ := pem.Decode(in) p, _ := pem.Decode(in)
@@ -177,11 +176,11 @@ func main() {
priv, err := loadKey(keyFile) priv, err := loadKey(keyFile)
die.If(err) die.If(err)
matched, reason := matchKeys(cert, priv) matched, reason := matchKeys(cert, priv)
if matched { if matched {
fmt.Println("Match.") fmt.Println("Match.")
return return
} }
fmt.Printf("No match (%s).\n", reason) fmt.Printf("No match (%s).\n", reason)
os.Exit(1) os.Exit(1)
} }

4
cmd/utc/main.go
View File

@@ -201,10 +201,6 @@ func init() {
os.Exit(1) os.Exit(1)
} }
if fromLoc == time.UTC {
}
toLoc = time.UTC toLoc = time.UTC
} }

7
cmd/yamll/main.go
View File

@@ -4,7 +4,6 @@ import (
"flag" "flag"
"fmt" "fmt"
"io" "io"
"io/ioutil"
"os" "os"
"gopkg.in/yaml.v2" "gopkg.in/yaml.v2"
@@ -12,7 +11,7 @@ import (
type empty struct{} type empty struct{}
func errorf(format string, args ...interface{}) { func errorf(format string, args ...any) {
format += "\n" format += "\n"
fmt.Fprintf(os.Stderr, format, args...) fmt.Fprintf(os.Stderr, format, args...)
} }
@@ -44,7 +43,7 @@ func main() {
if flag.NArg() == 1 && flag.Arg(0) == "-" { if flag.NArg() == 1 && flag.Arg(0) == "-" {
path := "stdin" path := "stdin"
in, err := ioutil.ReadAll(os.Stdin) in, err := io.ReadAll(os.Stdin)
if err != nil { if err != nil {
errorf("%s FAILED: %s", path, err) errorf("%s FAILED: %s", path, err)
os.Exit(1) os.Exit(1)
@@ -65,7 +64,7 @@ func main() {
} }
for _, path := range flag.Args() { for _, path := range flag.Args() {
in, err := ioutil.ReadFile(path) in, err := os.ReadFile(path)
if err != nil { if err != nil {
errorf("%s FAILED: %s", path, err) errorf("%s FAILED: %s", path, err)
continue continue

4
cmd/zsearch/main.go
View File

@@ -18,7 +18,7 @@ import (
const defaultDirectory = ".git/objects" const defaultDirectory = ".git/objects"
func errorf(format string, a ...interface{}) { func errorf(format string, a ...any) {
fmt.Fprintf(os.Stderr, format, a...) fmt.Fprintf(os.Stderr, format, a...)
if format[len(format)-1] != '\n' { if format[len(format)-1] != '\n' {
fmt.Fprintf(os.Stderr, "\n") fmt.Fprintf(os.Stderr, "\n")
@@ -93,7 +93,7 @@ func searchFile(path string, search *regexp.Regexp) error {
} }
func buildWalker(searchExpr *regexp.Regexp) filepath.WalkFunc { func buildWalker(searchExpr *regexp.Regexp) filepath.WalkFunc {
return func(path string, info os.FileInfo, err error) error { return func(path string, info os.FileInfo, _ error) error {
if info.Mode().IsRegular() { if info.Mode().IsRegular() {
return searchFile(path, searchExpr) return searchFile(path, searchExpr)
} }

2
lib/ftime_bsd.go
View File

@@ -1,4 +1,4 @@
// +build freebsd darwin,386 netbsd //go:build bsd
package lib package lib

4
lib/ftime_unix.go
View File

@@ -1,4 +1,4 @@
// +build unix linux openbsd darwin,amd64 //go:build unix || linux || openbsd || (darwin && amd64)
package lib package lib
@@ -18,7 +18,7 @@ type FileTime struct {
func timeSpecToTime(ts unix.Timespec) time.Time { func timeSpecToTime(ts unix.Timespec) time.Time {
// The casts to int64 are needed because on 386, these are int32s. // The casts to int64 are needed because on 386, these are int32s.
return time.Unix(int64(ts.Sec), int64(ts.Nsec)) return time.Unix(ts.Sec, ts.Nsec)
} }
// LoadFileTime returns a FileTime associated with the file. // LoadFileTime returns a FileTime associated with the file.

42
lib/lib.go
View File

@@ -10,6 +10,12 @@ import (
var progname = filepath.Base(os.Args[0]) var progname = filepath.Base(os.Args[0])
const (
daysInYear = 365
digitWidth = 10
hoursInQuarterDay = 6
)
// ProgName returns what lib thinks the program name is, namely the // ProgName returns what lib thinks the program name is, namely the
// basename of argv0. // basename of argv0.
// //
@@ -20,7 +26,7 @@ func ProgName() string {
// Warnx displays a formatted error message to standard error, à la // Warnx displays a formatted error message to standard error, à la
// warnx(3). // warnx(3).
func Warnx(format string, a ...interface{}) (int, error) { func Warnx(format string, a ...any) (int, error) {
format = fmt.Sprintf("[%s] %s", progname, format) format = fmt.Sprintf("[%s] %s", progname, format)
format += "\n" format += "\n"
return fmt.Fprintf(os.Stderr, format, a...) return fmt.Fprintf(os.Stderr, format, a...)
@@ -28,7 +34,7 @@ func Warnx(format string, a ...interface{}) (int, error) {
// Warn displays a formatted error message to standard output, // Warn displays a formatted error message to standard output,
// appending the error string, à la warn(3). // appending the error string, à la warn(3).
func Warn(err error, format string, a ...interface{}) (int, error) { func Warn(err error, format string, a ...any) (int, error) {
format = fmt.Sprintf("[%s] %s", progname, format) format = fmt.Sprintf("[%s] %s", progname, format)
format += ": %v\n" format += ": %v\n"
a = append(a, err) a = append(a, err)
@@ -37,7 +43,7 @@ func Warn(err error, format string, a ...interface{}) (int, error) {
// Errx displays a formatted error message to standard error and exits // Errx displays a formatted error message to standard error and exits
// with the status code from `exit`, à la errx(3). // with the status code from `exit`, à la errx(3).
func Errx(exit int, format string, a ...interface{}) { func Errx(exit int, format string, a ...any) {
format = fmt.Sprintf("[%s] %s", progname, format) format = fmt.Sprintf("[%s] %s", progname, format)
format += "\n" format += "\n"
fmt.Fprintf(os.Stderr, format, a...) fmt.Fprintf(os.Stderr, format, a...)
@@ -47,7 +53,7 @@ func Errx(exit int, format string, a ...interface{}) {
// Err displays a formatting error message to standard error, // Err displays a formatting error message to standard error,
// appending the error string, and exits with the status code from // appending the error string, and exits with the status code from
// `exit`, à la err(3). // `exit`, à la err(3).
func Err(exit int, err error, format string, a ...interface{}) { func Err(exit int, err error, format string, a ...any) {
format = fmt.Sprintf("[%s] %s", progname, format) format = fmt.Sprintf("[%s] %s", progname, format)
format += ": %v\n" format += ": %v\n"
a = append(a, err) a = append(a, err)
@@ -62,31 +68,31 @@ func Itoa(i int, wid int) string {
// Assemble decimal in reverse order. // Assemble decimal in reverse order.
var b [20]byte var b [20]byte
bp := len(b) - 1 bp := len(b) - 1
for i >= 10 || wid > 1 { for i >= digitWidth || wid > 1 {
wid-- wid--
q := i / 10 q := i / digitWidth
b[bp] = byte('0' + i - q*10) b[bp] = byte('0' + i - q*digitWidth)
bp-- bp--
i = q i = q
} }
// i < 10
b[bp] = byte('0' + i) b[bp] = byte('0' + i)
return string(b[bp:]) return string(b[bp:])
} }
var ( var (
dayDuration = 24 * time.Hour dayDuration = 24 * time.Hour
yearDuration = (365 * dayDuration) + (6 * time.Hour) yearDuration = (daysInYear * dayDuration) + (hoursInQuarterDay * time.Hour)
) )
// Duration returns a prettier string for time.Durations. // Duration returns a prettier string for time.Durations.
func Duration(d time.Duration) string { func Duration(d time.Duration) string {
var s string var s string
if d >= yearDuration { if d >= yearDuration {
years := int64(d / yearDuration) years := int64(d / yearDuration)
s += fmt.Sprintf("%dy", years) s += fmt.Sprintf("%dy", years)
d -= time.Duration(years) * yearDuration d -= time.Duration(years) * yearDuration
} }
if d >= dayDuration { if d >= dayDuration {
days := d / dayDuration days := d / dayDuration
@@ -97,9 +103,9 @@ func Duration(d time.Duration) string {
return s return s
} }
d %= 1 * time.Second d %= 1 * time.Second
hours := int64(d / time.Hour) hours := int64(d / time.Hour)
d -= time.Duration(hours) * time.Hour d -= time.Duration(hours) * time.Hour
s += fmt.Sprintf("%dh%s", hours, d) s += fmt.Sprintf("%dh%s", hours, d)
return s return s
} }

32
logging/file.go
View File

@@ -1,9 +1,9 @@
package logging package logging
import ( import (
"errors" "errors"
"fmt" "fmt"
"os" "os"
) )
// File writes its logs to file. // File writes its logs to file.
@@ -60,12 +60,12 @@ func NewSplitFile(outpath, errpath string, overwrite bool) (*File, error) {
fl.fe, err = os.OpenFile(errpath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0600) fl.fe, err = os.OpenFile(errpath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0600)
} }
if err != nil { if err != nil {
if closeErr := fl.Close(); closeErr != nil { if closeErr := fl.Close(); closeErr != nil {
return nil, fmt.Errorf("failed to open error log: %w", errors.Join(closeErr, err)) return nil, fmt.Errorf("failed to open error log: %w", errors.Join(closeErr, err))
} }
return nil, fmt.Errorf("failed to open error log: %w", err) return nil, fmt.Errorf("failed to open error log: %w", err)
} }
fl.LogWriter = NewLogWriter(fl.fo, fl.fe) fl.LogWriter = NewLogWriter(fl.fo, fl.fe)
return fl, nil return fl, nil
@@ -95,13 +95,13 @@ func (fl *File) Flush() error {
} }
func (fl *File) Chmod(mode os.FileMode) error { func (fl *File) Chmod(mode os.FileMode) error {
if err := fl.fo.Chmod(mode); err != nil { if err := fl.fo.Chmod(mode); err != nil {
return fmt.Errorf("failed to chmod output log: %w", err) return fmt.Errorf("failed to chmod output log: %w", err)
} }
if err := fl.fe.Chmod(mode); err != nil { if err := fl.fe.Chmod(mode); err != nil {
return fmt.Errorf("failed to chmod error log: %w", err) return fmt.Errorf("failed to chmod error log: %w", err)
} }
return nil return nil
} }