From 3fb8efde3a35872dddbd9d79909457d71ef9b8be Mon Sep 17 00:00:00 2001 From: Rys Sommefeldt Date: Wed, 15 Nov 2023 23:53:59 +0000 Subject: [PATCH] DDRM 1.0 --- .gitignore | 6 + LICENSE | 7 + README.md | 213 +++++++++++++++++++++ build.sh | 54 ++++++ ddrm-config.go | 351 ++++++++++++++++++++++++++++++++++ ddrm-dns.go | 108 +++++++++++ ddrm-email.go | 118 ++++++++++++ ddrm-processor.go | 119 ++++++++++++ ddrm-redis.go | 93 +++++++++ ddrm-tui.go | 195 +++++++++++++++++++ ddrm.go | 43 +++++ doc/ddrm-records.conf-example | 7 + doc/ddrm.conf-example | 19 ++ doc/email-screenshot.png | Bin 0 -> 124587 bytes doc/tui-screenshot.png | Bin 0 -> 52675 bytes go.mod | 59 ++++++ go.sum | 209 ++++++++++++++++++++ 17 files changed, 1601 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100755 build.sh create mode 100644 ddrm-config.go create mode 100644 ddrm-dns.go create mode 100644 ddrm-email.go create mode 100644 ddrm-processor.go create mode 100644 ddrm-redis.go create mode 100644 ddrm-tui.go create mode 100644 ddrm.go create mode 100755 doc/ddrm-records.conf-example create mode 100755 doc/ddrm.conf-example create mode 100644 doc/email-screenshot.png create mode 100644 doc/tui-screenshot.png create mode 100644 go.mod create mode 100644 go.sum diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fd64e30 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +.vscode/ +bin/* +dist/* +ddrm.conf +ddrm-records.conf +error.log \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..5bf21eb --- /dev/null +++ b/LICENSE @@ -0,0 +1,7 @@ +Copyright © 2023 Rys Sommefeldt + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..3d3785f --- /dev/null +++ b/README.md @@ -0,0 +1,213 @@ +# DDRM + +DDRM is a DNS record monitor written in [golang](https://go.dev/) that notifies you via email when it detects that records have changed. It's designed to be very easy to configure if you need to deviate from the sensible defaults, and easy to operate. + +## How DDRM works + +Through configuration, you supply DDRM with fully-qualified domain names (FQDN), resource record (RR) types, and expected values. DDRM then asks a designated DNS server for the value(s) for that FQDN+RR pair, checks them against your expected values, and emails you if anything is different. + +DDRM can optionally cache record state, using Redis, so that state can persist across different executions of DDRM. + +After a record change has been recorded and an email notification is sent, when using the cache, DDRM considers the changed value as the one to monitor for changes to in the future. That lets it handle the case where a record changes for some reason, and then maybe changes back to the original expected value. + +It sleeps between record fetches in the configuration set, and then sleeps for a different amount of time after it has checked all records. + +As it is working, you can watch the current state of processing with DDRM's terminal UI. By default the UI updates once a second, asynchronously to the processing of records. Using the UI is optional if you want to run DDRM as a headless service. + +![screenshot of TUI](./doc/tui-screenshot.png "screenshot of TUI") + +## Operating DDRM + +DDRM builds into a statically linked single binary that's easy to deploy on any supported platform: just copy it to the target host machine and place it somewhere in the `$PATH`. Release binaries are pre-built for FreeBSD, Linux and macOS for both amd64 and arm64 processor architectures. + +It's designed to be run in a [screen](https://www.gnu.org/software/screen/) or [tmux](https://github.com/tmux/tmux) session with its user interface running, showing you the results of the record checks, however it can also be run without the UI as a headless service. + +DDRM writes log messages to `stdout` if the UI is disabled, or to `stderr` if the UI is enabled. In UI mode it's recommended that you send `stderr` somewhere useful. For example: + +`ddrm-client-release-darwin-x86_64 -config ./ddrm.conf -records ./ddrm-records.conf -cache -ui 2&>>error.log` + +By default, unless you pass `-insecure` when starting DDRM, it will refuse to read configuration files that aren't mode `0400` (`-r--`, read-only for the current user), because the main runtime configuration contains mailserver credentials. + +## Redis as a runtime cache + +It is highly recommended that you give DDRM access to a Redis database so that it can use it to memorise runtime state. That allows DDRM to keep going from the last known state if you need to restart it. + +By default, keys are prefixed with `ddrm` and are [Redis sets](https://redis.io/docs/data-types/sets/) that store all of the returned query data. Sorting is performed in the DDRM client, rather than using Redis sorted sets. + +Key names are in the form `::`, for example, `ddrm:sommefeldt.com:A`. + +Without the cache, DDRM won't currently update its default expected values with the results of queries. + +## Terminal UI + +The terminal UI (TUI) is simple and designed to show you at-a-glance information about the processing state without showing you the full information for every record. + +An `x` in the first column before the FQDN indicates that the record is about to be processed again. The final three columns indicate whether an email was sent about a change, whether there was a change, or whether there was an error processing that record update. + +Errors don't trigger any behaviour other than an entry in the debug log. + +`-uirate` controls how often the UI updates. When the UI is active, press `x` to toggle a "fullscreen" mode that hides all other terminal text. Press `q` to exit the TUI and DDRM completely. + +## Configuring DDRM + +You configure DDRM by editing and securing two JSON configuration files. The first one ([`ddrm.conf`](./doc/ddrm.conf-example)) provides the main configuration that lets DDRM know how it should send email and who it should send email to, which DNS server it should use for queries, and how to talk to Redis if you're using it as a cache. + +The second configuration file ([`ddrm-records.conf`](./doc/ddrm-records.conf-example)) contains the list of records you want to check, each consisting of a fully qualified domain name, a DNS resource record type, and an optional set of expected values to check against. + +If you don't provide any expected values to start with, DDRM will check against the first query results returned and start from there instead. + +DDRM also supports a number of command line parameters for configuring various other bits of useful runtime state away from the hopefully sensible defaults. + +### [`ddrm.conf`](./doc/ddrm.conf-example) [JSON](https://json.org/) configuration values + +A single JSON object containing the following members: + +- `email_user` + - `string`, username for authenticating with the configured mailserver +- `email_password` + - `string`, password for authenticating with the configured mailserver +- `email_server_hostname` + - `string`, hostname of the configured mailserver +- `email_server_port` + - `string`, port number of the configured mailserver +- `email_user_name` + - `string`, name that emails should appear to be sent from in the SMTP envelope +- `dns_server_1` + - `string`, nameserver to query in `:` format. For example: `1.1.1.1:53` +- `dns_server_2` + - `string`, nameserver to query in `:` format. For example: `9.9.9.9:53`. Only used if configured and if `dns_server_1` returns an error. Leave blank to never use it. +- `email_sender_name` + - `string`, name that appears in the body text of the email +- `email_link` + - `string`, link that appears in clickable form at the bottom of the email +- `email_logo` + - `string`, URL to an image to show as the logo in the email body +- `email_subject` + - `string`, subject line of the email that is sent on a detected record change +- `redis_database` + - `number`, integer value for the Redis database to use (defaults to `0`) +- `redis_password` + - `string`, password to use when connecting to the Redis instance +- `redis_server` + - `string`, Redis server to use in `:` format (defaults to `localhost:6379`) +- `redis_key_prefix` + - `string`, prefix to use when reading and writing Redis keys (defaults to `ddrm`) + +See the [`ddrm.conf`](./doc/ddrm.conf-example) example. + +### [`ddrm-records.conf`](./doc/ddrm-records.conf-example) [JSON](https://json.org/) configuration values + +An array of JSON objects, containing the following members. + +- `fqdn` + - `string`, fully-qualified domain name to ask for a resource record for +- `type` + - `string`, the resource record type to ask for values for. For example, `CNAME`, `A`, or `TXT` +- `expected_values` + - An array (`[]`) of `string` values, separated by comma (`,`) if multiple values should be checked. Multiple values are lexically sorted before comparison and so they can be defined in any order. + +See the [`ddrm-records.conf`](./doc/ddrm-records.conf-example) example. + +To see the full list of resource record types that DDRM knows how to interpret, please see the `ddrmRecordType` constants in [the source code](./ddrm-dns.go#15). + +### Command line arguments for adjusting runtime state + +``` + -4 Use IPv4 for DNS resolution (default true) + -6 Use IPv6 for DNS resolution + -cache + Use Redis for persistent rolling update cache + -config string + Config file path (default "ddrm.conf") + -debug + Enabled debug mode + -expand + Expand tabs and quoted characters in results + -imprecise + Allow imprecise string matches + -insecure + Allow an insecure config + -logrecords + Log record processing results + -plaintext + Send plaintext email + -quieter + Be quieter on output + -records string + Records config file path (default "ddrm-records.conf") + -sleep duration + Seconds to sleep between checks (default 1m0s) + -tabs int + Number of spaces to expand tabs to (default 4) + -tcp + Use TCP instead of UDP for DNS resolution + -testdns + Test the DNS client and exit(3) + -testemail + Send a test email and exit(2) + -timeout duration + Seconds to wait for DNS client reponses before moving on (default 2s) + -ui + Render the terminal UI + -uirate duration + Seconds between UI updates (default 1s) +``` + +Look at [`parseCliFlags()`](./ddrm-config.go#292) in `ddrm-config.go` to see what state values are set by each flag. You can see how they're used in the codebase if you need more details. + +`-imprecise` can help when a record query might return a value with a trailing `.` character, which is the correct notation for domain names in the domain name system. Using it asks the record processor to ignore it, so that you can write the config without having to remember it. + +`-expand` will expand any tab characters it finds in records returned from DNS, to a specific number of spaces (default is 4, use `-tabs` to adjust that). + +`-debug` is very useful if you're struggling to configure or operate DDRM. It's required to see the output of `-testdns`. + +`-testdns` checks the `MX`, `A`, `SOA` and `TXT` records of `sommefeldt.com`, prints the data, and then `exit(3)`s. + +## Email example + +Currently DDRM supports a fixed email template that looks like this on a record change notification. Future versions might allow for more customisation of the look and feel: + +![email example](./doc/email-screenshot.png "email screenshot") + +## Standing on the shoulders of giants + +DDRM is a composition of various excellent libraries and infrastructure software that do all of the interesting heavy lifting, allowing DDRM to focus on its value: marshalling the record checks and letting you know if anything has changed. + +It uses the following great libraries and other software: + +| What | Why | +| ---- | --- | +| [Bubbletea](https://github.com/charmbracelet/bubbletea) | golang Terminal UI library | +| [Lipgloss](https://github.com/charmbracelet/lipgloss) | golang Terminal UI styling | +| [Hermes](https://github.com/matcornic/hermes) | golang HTML email generator | +| [dns](https://github.com/miekg/dns) | golang DNS queries | +| [go-redis](https://github.com/redis/go-redis) | golang Redis client | +| [zerolog](https://github.com/rs/zerolog) | golang zero alloc logger | +| [go-cron](https://github.com/go-co-op/gocron) | golang cron-like asynchronous task library | +| [Redis](https://redis.io) | Optional runtime cache | + +## Mini possible roadmap for new features + +Future versions of DDRM _may_ do the following: + +- [ ] support passing in the password credential outside of the JSON config +- [ ] allow you to detach the UI and go headless while it still operates +- [ ] allow you to reattach to a headless client (maybe with a caught signal?) +- [ ] support a Web UI +- [ ] support reconfiguration using the terminal or Web UIs +- [ ] support checking multiple DNS servers and reporting if they disagree with each other +- [ ] more email template theming +- [ ] support the runtime cached "follow along" mode without using Redis +- [ ] make `-imprecise` default to true +- [ ] collect multiple record reports into the same digest email +- [ ] report on the number of email sending errors in the TUI + +## License + +DDRM is [MIT licensed](./LICENSE). + +## What does DDRM stand for? + +DDRM stands for Dave's DNS Record Monitor, in honour of my good friend Dave, who mused one day that he'd love a free DNS record monitoring system. + +This one is for you, Dave. \ No newline at end of file diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..3babd6a --- /dev/null +++ b/build.sh @@ -0,0 +1,54 @@ +#!/usr/local/bin/zsh + +DDRM_GIT_SHA=$(git rev-parse --short HEAD) +DDRM_GIT_TAG=$(git describe --tags 2>/dev/null) +DDRM_GIT_DATE=$(git log -1 --format=%cd --date=short) + +[[ -z ${DDRM_GIT_TAG} ]] && DDRM_GIT_TAG=dev + +DDRM_OS=$(uname) +DDRM_ARCH=$(uname -m) + +DDRM_BIN_PATH=./bin/${DDRM_GIT_TAG} +DDRM_DIST_PATH=./dist + +DDRM_CLIENT_BIN="ddrm-client-${DDRM_GIT_TAG}-${DDRM_OS:l}-${DDRM_ARCH:l}" + +DDRM_BUILD_USER=${USER} + +[[ -f ${DDRM_BIN_PATH}/${DDRM_CLIENT_BIN} ]] && rm -f ${DDRM_BIN_PATH}/${DDRM_CLIENT_BIN} && echo "Removed existing ${DDRM_BIN_PATH}/${DDRM_CLIENT_BIN}" + +LDFLAGS="-X main.BuildVersion=${DDRM_GIT_TAG} -X main.BuildDate=${DDRM_GIT_DATE} -X main.GitRev=${DDRM_GIT_SHA} -X main.BuildUser=${DDRM_BUILD_USER}" + +[[ $DDRM_GIT_TAG != "dev" ]] && echo "Not packaging a dev build, stripping symbol table and debug info" && LDFLAGS="${LDFLAGS} -s -w" + +if [ -v "SKIP_BUILD" ]; then + echo "Skipping build" +else + GOOS=linux GOARCH=amd64 go build -ldflags ${LDFLAGS} -tags client -o ${DDRM_BIN_PATH}/ddrm-client-${DDRM_GIT_TAG}-linux-amd64 + GOOS=darwin GOARCH=amd64 go build -ldflags ${LDFLAGS} -tags client -o ${DDRM_BIN_PATH}/ddrm-client-${DDRM_GIT_TAG}-darwin-x86_64 + GOOS=freebsd GOARCH=amd64 go build -ldflags ${LDFLAGS} -tags client -o ${DDRM_BIN_PATH}/ddrm-client-${DDRM_GIT_TAG}-freebsd-amd64 + GOOS=linux GOARCH=arm64 go build -ldflags ${LDFLAGS} -tags client -o ${DDRM_BIN_PATH}/ddrm-client-${DDRM_GIT_TAG}-linux-arm64 + GOOS=darwin GOARCH=arm64 go build -ldflags ${LDFLAGS} -tags client -o ${DDRM_BIN_PATH}/ddrm-client-${DDRM_GIT_TAG}-darwin-arm64 + GOOS=freebsd GOARCH=arm64 go build -ldflags ${LDFLAGS} -tags client -o ${DDRM_BIN_PATH}/ddrm-client-${DDRM_GIT_TAG}-freebsd-arm64 +fi + +[[ ! -f ${DDRM_BIN_PATH}/${DDRM_CLIENT_BIN} ]] && echo "Didn't build client binary for ${DDRM_OS:l}-${DDRM_ARCH:l}: ${DDRM_CLIENT_BIN}" +[[ -f ${DDRM_BIN_PATH}/${DDRM_CLIENT_BIN} ]] && echo "Built client binary for ${DDRM_OS:l}-${DDRM_ARCH:l}: ${DDRM_BIN_PATH}/${DDRM_CLIENT_BIN}" + +if [ -v "CREATE_PACKAGE" ]; then + for i (linux-amd64 darwin-x86_64 freebsd-amd64 linux-arm64 darwin-arm64 freebsd-arm64) do + rel=ddrm-client-${DDRM_GIT_TAG}-${i} + echo "Packaging ${rel}" + out=${DDRM_DIST_PATH}/${rel} + mkdir -p ${out}/doc + mkdir -p ${out}/bin + cp ./doc/ddrm.conf-example ${out}/doc + cp ./doc/ddrm-records.conf-example ${out}/doc + cp ./README.md ${out} + cp ./LICENSE ${out} + cp ${DDRM_BIN_PATH}/${rel} ${out}/bin + tar czf ${out}.tar.gz -C ${DDRM_DIST_PATH} ${rel} + rm -rf ${out} + done +fi \ No newline at end of file diff --git a/ddrm-config.go b/ddrm-config.go new file mode 100644 index 0000000..a86795b --- /dev/null +++ b/ddrm-config.go @@ -0,0 +1,351 @@ +//go:build client +// +build client + +package main + +import ( + "encoding/json" + "flag" + "fmt" + "os" + "time" + + "github.com/go-co-op/gocron/v2" + "github.com/rs/zerolog" +) + +// Type to describe the JSON app config on disk +type DdrmAppConfig struct { + EmailUser string `json:"email_user"` + EmailUserName string `json:"email_user_name"` + EmailPassword string `json:"email_password"` + EmailServerHostname string `json:"email_server_hostname"` + EmailServerPort string `json:"email_server_port"` + EmailTo string `json:"email_to"` + EmailToName string `json:"email_to_name"` + DnsServer1 string `json:"dns_server_1"` + DnsServer2 string `json:"dns_server_2"` + EmailSenderName string `json:"email_sender_name"` + EmailLink string `json:"email_link"` + EmailLogo string `json:"email_logo"` + EmailSubject string `json:"email_subject"` + RedisDatabase int `json:"redis_database"` + RedisPassword string `json:"redis_password"` + RedisServer string `json:"redis_server"` + RedisKeyPrefix string `json:"redis_key_prefix"` +} + +// Type to describe the record checking JSON config on disk +type DdrmRecordConfig struct { + FQDN string `json:"fqdn"` + Type DdrmRecordType `json:"type"` + ExpectedValues []string `json:"expected_values"` +} + +// State constants +const ( + ddrmConfigFilePath string = "ddrm.conf" + ddrmRecordsConfigFilePath string = "ddrm-records.conf" + ddrmEmailTemplatePath string = "ddrm-email-template.txt" + ddrmStartupBanner string = "DNS Spy Record Monitor %s %s (git %s) built by %s" + ddrmConfigPathBanner string = "config path: %s" + ddrmRecordsPathBanner string = "records config path: %s" + ddrmDebugMode string = "debug mode enabled" +) + +// Error messages +const ( + ddrmErrorNoConfigPath string = "no configuration file at path: %s" + ddrmErrorNoRecordsPath string = "no records configuration file at path %s" + ddrmErrorUnableToReadFile string = "unable to read file: %s %#v" + ddrmErrorUnableToStatFile string = "unable to stat file: %s %#v" + ddrmErrorInsecureConfig string = "insecure config: %s %#v" + ddrmErrorSendingMail string = "unable to send email" + ddrmErrorUnableToGenerateEmail string = "unable to generate email report to send" + ddrmErrorUnableToUnmarshalJSON string = "unable to unmarshal JSON from %s %#v" + ddrmErrorUnableToRunLoop string = "unable to process main run loop" + ddrmErrorUnableToFetchRecord string = "unable to fetch record data for %s %s" +) + +// Debug messages +const ( + ddrmDebugStartProcessing string = " processing records for: %s %s" + ddrmDebugRetrievedDataFrom string = "fetched record data from: %s" + ddrmDebugEndProcessing string = " end of processing for: %s %s" + ddrmDebugTryingCache string = " trying cache for: %s %s" + ddrmDebugNoCache string = " no cached values for: %s %s" + ddrmDebugUsingStartupConfig string = "using startup config for: %s %s" +) + +// Success and reporting messages +const ( + ddrmSuccessSentMail string = "sent email report successfully" + ddrmReportReadingConfig string = "reading config: %s" + ddrmReportReadConfig string = "successfully read config: %s" + ddrmReportReadRecords string = "read %d record(s) to process" + ddrmReportDNSClientErr string = "error asking %s for %s %s record: %#v" + ddrmSuccessSetupCronJob string = "setup periodic processing for %s (%s): %s" +) + +// os.Exit() return codes to indicate exit state on error +const ( + ddrmExitOK = iota + ddrmExitDuringConfig + ddrmExitAfterMailTest + ddrmExitAfterDNSClientTest + ddrmExitErrorRunningTUI + ddrmExitErrorCreatingScheduler + ddrmExitErrorCreatingUIUpdateJob + ddrmExitErrorCreatingRecordProcessorJob +) + +// Application runtime state +var ( + stateDebug bool = false + stateSimplerLogging bool = false + stateInsecureConfig bool = false + statePlainTextEmail bool = false + stateSendTestEmail bool = false + stateIPV4 bool = true + stateIPV6 bool = false + stateTCP bool = false + stateSleep time.Duration = 60 * time.Second + stateDNSClientTest bool = false + stateDNSTimeout time.Duration = 2 * time.Second + stateConfigFilePath string = ddrmConfigFilePath + stateRecordsConfigFilePath string = ddrmRecordsConfigFilePath + stateAllowImpreciseMatch bool = false + stateExpand bool = false + stateTabsToSpaces int = 4 + stateUseRedis bool = false + stateUI bool = false + stateLogRecordProcessing bool = false + stateUITickRate time.Duration = 1 * time.Second + stateAltScreenMode bool = false + statePrintVersion bool = false +) + +// unmarshalled application config +var ddrmAppConfig DdrmAppConfig + +// unmarshalled record configs +var ddrmRecordConfig []DdrmRecordConfig + +// logger and scheduler objects +var ( + ddrmLog zerolog.Logger + cronScheduler gocron.Scheduler +) + +// Defensively try and read a config file and return the raw bytes +// Full os.Exit() if it fails +func readFileReturningBytes(filePath string) []byte { + + var config []byte + + if filePath != "" { + // check if the file exists and we can stat it + if _, err := os.Stat(filePath); os.IsNotExist(err) { + dbgf(ddrmErrorUnableToReadFile, filePath, err) + os.Exit(ddrmExitDuringConfig) + } + + stat, err := os.Lstat(filePath) + + if err != nil { + dbgf(ddrmErrorUnableToStatFile, filePath, err) + os.Exit(ddrmExitDuringConfig) + } + + if stat.Mode() != 0400 { + if !stateInsecureConfig { + dbgf(ddrmErrorInsecureConfig, filePath, stat.Mode().Perm().String()) + os.Exit(ddrmExitDuringConfig) + } + } + + dbgf(ddrmReportReadingConfig, filePath) + + config, err = os.ReadFile(filePath) + if err != nil { + dbgf(ddrmErrorUnableToReadFile, filePath, err) + os.Exit(ddrmExitDuringConfig) + } + + } else { + dbgf(ddrmErrorNoConfigPath, filePath) + os.Exit(ddrmExitDuringConfig) + } + + return config +} + +func readAppConfig() { + if stateConfigFilePath != "" { + + config := readFileReturningBytes(stateConfigFilePath) + + err := json.Unmarshal(config, &ddrmAppConfig) + + if err != nil { + dbgf(ddrmErrorUnableToUnmarshalJSON, stateConfigFilePath, err) + os.Exit(ddrmExitDuringConfig) + } + + dbgf(ddrmReportReadConfig, stateConfigFilePath) + + } else { + dbgf(ddrmErrorNoConfigPath, stateConfigFilePath) + os.Exit(ddrmExitDuringConfig) + } +} + +func readRecordsConfig() { + ddrmRecordStates = make(map[string]DdrmRecordState, 0) + + if stateRecordsConfigFilePath != "" { + + config := readFileReturningBytes(stateRecordsConfigFilePath) + + err := json.Unmarshal(config, &ddrmRecordConfig) + + if err != nil { + dbgf(ddrmErrorUnableToUnmarshalJSON, stateRecordsConfigFilePath, err) + os.Exit(ddrmExitDuringConfig) + } + + dbgf(ddrmReportReadRecords, len(ddrmRecordConfig)) + dbgf(ddrmReportReadConfig, stateRecordsConfigFilePath) + + // Re-initialise the map to hold fresh state now we know how big it should be + ddrmRecordStates := map[string]DdrmRecordState{} + for _, record := range ddrmRecordConfig { + ddrmRecordStates[record.FQDN+":"+string(record.Type)] = DdrmRecordState{} + } + + } else { + dbgf(ddrmErrorNoConfigPath, stateRecordsConfigFilePath) + os.Exit(ddrmExitDuringConfig) + } +} + +func setupLogger() { + zerolog.TimeFieldFormat = zerolog.TimeFormatUnix + + logger := zerolog.ConsoleWriter{Out: os.Stdout} + + if stateUI { + // log to stderr instead in UI mode, without colours + logger = zerolog.ConsoleWriter{Out: os.Stderr} + logger.NoColor = true + } + + // remove some bits of the output so that it looks nicer + if stateSimplerLogging { + logger.FormatLevel = func(i interface{}) string { + return "" + } + + logger.FormatTimestamp = func(i interface{}) string { + return "" + } + } + + ddrmLog = zerolog.New(logger).With().Timestamp().Logger() +} + +func setupPeriodicTasks() { + cron, err := gocron.NewScheduler() + + if err != nil { + os.Exit(ddrmExitErrorCreatingScheduler) + } + + job, err := cron.NewJob( + gocron.DurationJob(stateUITickRate), + gocron.NewTask(sendUpdateUIMsg), + ) + + dbgf(ddrmSuccessSetupCronJob, "updating UI", stateUITickRate.String(), job.ID().String()) + + if err != nil { + os.Exit(ddrmExitErrorCreatingUIUpdateJob) + } + + job, err = cron.NewJob( + gocron.DurationJob(stateSleep), + gocron.NewTask(processRecords), + ) + + dbgf(ddrmSuccessSetupCronJob, "processing records", stateSleep.String(), job.ID().String()) + + if err != nil { + os.Exit(ddrmExitErrorCreatingRecordProcessorJob) + } + + cronScheduler = cron + cronScheduler.Start() +} + +func parseCliFlags() { + flag.BoolVar(&stateDebug, "debug", stateDebug, "Enabled debug mode") + flag.BoolVar(&stateSimplerLogging, "quieter", stateSimplerLogging, "Be quieter on output") + flag.BoolVar(&stateInsecureConfig, "insecure", stateInsecureConfig, "Allow an insecure config") + flag.BoolVar(&statePlainTextEmail, "plaintext", statePlainTextEmail, "Send plaintext email") + flag.BoolVar(&stateSendTestEmail, "testemail", stateSendTestEmail, "Send a test email and exit(2)") + flag.BoolVar(&stateIPV4, "4", stateIPV4, "Use IPv4 for DNS resolution") + flag.BoolVar(&stateIPV6, "6", stateIPV6, "Use IPv6 for DNS resolution") + flag.BoolVar(&stateTCP, "tcp", stateTCP, "Use TCP instead of UDP for DNS resolution") + flag.DurationVar(&stateSleep, "sleep", stateSleep, "Seconds to sleep between checks") + flag.DurationVar(&stateDNSTimeout, "timeout", stateDNSTimeout, "Seconds to wait for DNS client reponses before moving on") + flag.BoolVar(&stateDNSClientTest, "testdns", stateDNSClientTest, "Test the DNS client and exit(3)") + flag.StringVar(&stateConfigFilePath, "config", ddrmConfigFilePath, "Config file path") + flag.StringVar(&stateRecordsConfigFilePath, "records", ddrmRecordsConfigFilePath, "Records config file path") + flag.BoolVar(&stateAllowImpreciseMatch, "imprecise", stateAllowImpreciseMatch, "Allow imprecise string matches") + flag.BoolVar(&stateExpand, "expand", stateExpand, "Expand tabs and quoted characters in results") + flag.IntVar(&stateTabsToSpaces, "tabs", stateTabsToSpaces, "Number of spaces to expand tabs to") + flag.BoolVar(&stateUseRedis, "cache", stateUseRedis, "Use Redis for persistent rolling update cache") + flag.BoolVar(&stateUI, "ui", stateUI, "Draw the UI") + flag.BoolVar(&stateLogRecordProcessing, "logrecords", stateLogRecordProcessing, "Log record processing results") + flag.DurationVar(&stateUITickRate, "uirate", stateUITickRate, "Seconds between UI updates") + flag.BoolVar(&statePrintVersion, "version", statePrintVersion, "Print version and exit") + flag.Parse() +} + +func runLoop() { + // If we get here there's either no TUI, or the TUI decided we're quitting + // If there's no TUI then we don't want to quit, we just want to run without it + // select {} is a low CPU usage non-blocking operation that yields nicely + if !stateUI { + select {} + } +} + +func printStartupBanner() { + if statePrintVersion { + fmt.Printf(ddrmStartupBanner, BuildVersion, BuildDate, GitRev, BuildUser) + os.Exit(ddrmExitOK) + } + + dbgf(ddrmStartupBanner, BuildVersion, BuildDate, GitRev, BuildUser) + dbg(ddrmDebugMode) +} + +// utility methods to more easily write debug log texts +func dbgf(format string, v ...interface{}) { + if stateDebug { + ddrmLog.Debug().Msgf(format, v...) + } +} + +func dbg(msg string) { + if stateDebug { + ddrmLog.Debug().Msg(msg) + } +} + +func dbgp(v ...interface{}) { + if stateDebug { + ddrmLog.Print(v...) + } +} diff --git a/ddrm-dns.go b/ddrm-dns.go new file mode 100644 index 0000000..d7b6ce1 --- /dev/null +++ b/ddrm-dns.go @@ -0,0 +1,108 @@ +//go:build client +// +build client + +package main + +import ( + "os" + + "github.com/miekg/dns" +) + +// Simple record type to help make the JSON parsing easier +type DdrmRecordType string + +const ( + //lint:ignore U1000 Ignore unused types: they are used during JSON parsing but go-staticcheck gets upset because it can't know that + ddrmRecordTypeA DdrmRecordType = "A" + ddrmRecordTypeAAAA DdrmRecordType = "AAAA" + ddrmRecordTypeTXT DdrmRecordType = "TXT" + ddrmRecordTypeMX DdrmRecordType = "MX" + ddrmRecordTypeCAA DdrmRecordType = "CAA" + ddrmRecordTypeCNAME DdrmRecordType = "CNAME" + ddrmRecordTypeNS DdrmRecordType = "NS" + ddrmRecordTypePTR DdrmRecordType = "PTR" + ddrmRecordTypeSOA DdrmRecordType = "SOA" + ddrmRecordTypeSRV DdrmRecordType = "SRV" +) + +// try and ask a question to get a record's records +func getRecordData(fqdn string, recordtype DdrmRecordType) (answer []string) { + dnsclient := new(dns.Client) + dnsclient.Net = "udp" + + if stateTCP { + dnsclient.Net = "tcp" + } + + if stateIPV4 { + dnsclient.Net += "4" + } + + if stateIPV6 { + dnsclient.Net += "6" + } + + dnsclient.Timeout = stateDNSTimeout + + dnsType := dns.StringToType[string(recordtype)] + + msg := new(dns.Msg) + msg.SetQuestion(dns.Fqdn(fqdn), dnsType) + + in, _, err := dnsclient.Exchange(msg, ddrmAppConfig.DnsServer1) + + if err != nil { + dbgf(ddrmReportDNSClientErr, ddrmAppConfig.DnsServer1, fqdn, recordtype, err) + + // try the second configured DNS server if it's configured + if len(ddrmAppConfig.DnsServer2) > 0 { + in, _, err = dnsclient.Exchange(msg, ddrmAppConfig.DnsServer2) + } + + if err != nil { + return nil + } + } + + answer = []string{} + + for _, r := range in.Answer { + switch t := r.(type) { + case *dns.A: + answer = append(answer, stringProcessor(t.A.String())) + case *dns.AAAA: + answer = append(answer, stringProcessor(t.AAAA.String())) + case *dns.CNAME: + answer = append(answer, stringProcessor(t.Target)) + case *dns.CAA: + answer = append(answer, stringProcessor(t.Value)) + case *dns.MX: + answer = append(answer, stringProcessor(t.Mx)) + case *dns.TXT: + for _, txt := range t.Txt { + answer = append(answer, stringProcessor(txt)) + } + case *dns.NS: + answer = append(answer, stringProcessor(t.Ns)) + case *dns.PTR: + answer = append(answer, stringProcessor(t.Ptr)) + case *dns.SRV: + answer = append(answer, stringProcessor(t.Target)) + case *dns.SOA: + answer = append(answer, stringProcessor(t.String())) + } + } + + return answer +} + +func testDnsClient() { + if stateDNSClientTest { + dbgp(getRecordData("sommefeldt.com", "MX")) + dbgp(getRecordData("sommefeldt.com", "A")) + dbgp(getRecordData("sommefeldt.com", "SOA")) + dbgp(getRecordData("sommefeldt.com", "TXT")) + os.Exit(ddrmExitAfterDNSClientTest) + } +} diff --git a/ddrm-email.go b/ddrm-email.go new file mode 100644 index 0000000..603a6f3 --- /dev/null +++ b/ddrm-email.go @@ -0,0 +1,118 @@ +//go:build client +// +build client + +package main + +import ( + "fmt" + "net/smtp" + "os" + "strings" + "time" + + "github.com/matcornic/hermes/v2" +) + +func sendTestEmail() { + if stateSendTestEmail { + mockFetched := []string{"1.1.1.1"} + mockCached := []string{"2.2.2.2"} + sent := sendEmail("example.com", ddrmRecordTypeA, mockFetched, mockCached) + if sent { + dbgf(ddrmSuccessSentMail) + } else { + dbgf(ddrmErrorSendingMail) + } + os.Exit(ddrmExitAfterMailTest) + } +} + +// try and send an email report with records +// it's not defensive and will just return to the caller with nil if sending fails +func sendEmail(fqdn string, recordType DdrmRecordType, fetched []string, cached []string) (sent bool) { + sent = false + + now := time.Now() + + hermesMailer := hermes.Hermes{ + Product: hermes.Product{ + Name: ddrmAppConfig.EmailSenderName, + Link: ddrmAppConfig.EmailLink, + Logo: ddrmAppConfig.EmailLogo, + Copyright: "Copyright (c) " + now.Format("2006") + " " + ddrmAppConfig.EmailSenderName, + }, + } + + // prepare a hermes.Entry record for the data table + entry := [][]hermes.Entry{ + { + {Key: "FQDN", Value: fqdn}, + {Key: "Record", Value: string(recordType)}, + {Key: "Expected", Value: strings.Join(cached, ", ")}, + {Key: "Currently", Value: strings.Join(fetched, ", ")}, + }, + } + + // prepare a hermes.Email object with configured Body, Intros, Outros and the data table for record showing + email := hermes.Email{ + Body: hermes.Body{ + Name: ddrmAppConfig.EmailToName, + Intros: []string{ + ddrmAppConfig.EmailSenderName + " has detected a record change.", + }, + Outros: []string{ + "The detection was recorded on " + now.Format(time.RFC1123), + "Detected by " + fmt.Sprintf(ddrmStartupBanner, BuildVersion, BuildDate, GitRev, BuildUser), + }, + Table: hermes.Table{ + Data: entry, + Columns: hermes.Columns{ + CustomWidth: map[string]string{ + "FQDN": "15%", + "Record": "15%", + "Expected": "35%", + "Currently": "35%", + }, + }, + }, + }, + } + + emailBody, err := hermesMailer.GenerateHTML(email) + + if statePlainTextEmail { + emailBody, err = hermesMailer.GeneratePlainText(email) + } + + if err != nil { + dbg(ddrmErrorUnableToGenerateEmail) + return + } + + dateString := fmt.Sprintf("Date: %s\r\n", now.Format(time.RFC1123)) + + to := []string{ + ddrmAppConfig.EmailTo, + } + + envelope := []byte( + "To: " + ddrmAppConfig.EmailToName + "<" + ddrmAppConfig.EmailTo + ">\r\n" + + "From: " + ddrmAppConfig.EmailUserName + "<" + ddrmAppConfig.EmailUser + ">\r\n" + + "Subject: " + ddrmAppConfig.EmailSubject + "\r\n" + + "MIME-version: 1.0;\nContent-Type: text/html; charset=\"UTF-8\";\r\n" + + dateString + "\r\n") + + message := append(envelope, []byte(emailBody)...) + + auth := smtp.PlainAuth("", ddrmAppConfig.EmailUser, ddrmAppConfig.EmailPassword, ddrmAppConfig.EmailServerHostname) + err = smtp.SendMail(ddrmAppConfig.EmailServerHostname+":"+ddrmAppConfig.EmailServerPort, auth, ddrmAppConfig.EmailUser, to, message) + + if err != nil { + dbg(ddrmErrorSendingMail) + } else { + sent = true + dbg(ddrmSuccessSentMail) + } + + return +} diff --git a/ddrm-processor.go b/ddrm-processor.go new file mode 100644 index 0000000..7a2804c --- /dev/null +++ b/ddrm-processor.go @@ -0,0 +1,119 @@ +//go:build client +// +build client + +package main + +import ( + "fmt" + "slices" + "strings" +) + +// Type to store currently fetched record state +type DdrmRecordState struct { + FQDN string + Type DdrmRecordType + CurrentValues []string + PriorValues []string + Changed bool + SentEmail bool + Errored bool + Processing bool +} + +// current in-memory record states +var ddrmRecordStates map[string]DdrmRecordState + +func checkRecordDataForChanges(fqdn string, recordType DdrmRecordType, answer []string) (changed bool, fetched []string, cached []string, compare int) { + changed = false + + cache := getCachedValues(fqdn, recordType) + + expectedConfigs := make(map[string]DdrmRecordConfig) + + for _, recordConfig := range ddrmRecordConfig { + expectedConfigs[recordConfig.FQDN+":"+string(recordConfig.Type)] = recordConfig + } + + if len(cache) == 0 { + // fall back to the startup config + cache = expectedConfigs[fqdn+":"+string(recordType)].ExpectedValues + } + + // sort both and compare + slices.Sort(cache) + slices.Sort(answer) + + compare = slices.Compare(cache, answer) + changed = compare != 0 + fetched = answer + cached = cache + + _ = setCachedValues(fqdn, recordType, answer) + + return +} + +func stringProcessor(s string) string { + if stateExpand { + s = strings.ReplaceAll(s, "\t", strings.Repeat(" ", stateTabsToSpaces)) + return s + } + if stateAllowImpreciseMatch { + s = strings.TrimSuffix(s, ".") + } + + return s +} + +func processRecords() { + for _, record := range ddrmRecordConfig { + // indicate processing state for everything + state := ddrmRecordStates[record.FQDN+":"+string(record.Type)] + state.Processing = true + state.SentEmail = false + state.Errored = false + state.Changed = false + ddrmRecordStates[record.FQDN+":"+string(record.Type)] = state + } + + for _, record := range ddrmRecordConfig { + data := getRecordData(record.FQDN, record.Type) + + if len(data) == 0 { + dbgf(ddrmErrorUnableToFetchRecord, record.FQDN, string(record.Type)) + + // set the error state but don't remove the the current + expected so they can be shown in the UI + state := ddrmRecordStates[record.FQDN+":"+string(record.Type)] + state.Errored = true + state.Processing = false + ddrmRecordStates[record.FQDN+":"+string(record.Type)] = state + } else { + changed, fetched, cached, compare := checkRecordDataForChanges(record.FQDN, record.Type, data) + + // update the running state + state := ddrmRecordStates[record.FQDN+":"+string(record.Type)] + state.Changed = changed + state.CurrentValues = fetched + state.PriorValues = cached + state.Errored = false + state.FQDN = record.FQDN + state.Type = record.Type + state.Processing = false + + if stateLogRecordProcessing { + dbg("changed = " + fmt.Sprint(changed)) + dbg("compare = " + fmt.Sprint(compare)) + dbg("fetched = " + fmt.Sprint(fetched)) + dbg("cached = " + fmt.Sprint(cached)) + dbg("data = " + fmt.Sprint(data)) + } + if changed { + state.SentEmail = sendEmail(record.FQDN, record.Type, fetched, cached) + } + + ddrmRecordStates[record.FQDN+":"+string(record.Type)] = state + } + dbg("") + } +} diff --git a/ddrm-redis.go b/ddrm-redis.go new file mode 100644 index 0000000..9a1fe17 --- /dev/null +++ b/ddrm-redis.go @@ -0,0 +1,93 @@ +//go:build client +// +build client + +package main + +import ( + "context" + + "github.com/redis/go-redis/v9" +) + +// Redis runtime context and database objects +var ( + ctx = context.Background() + // We reinitialise this client if a startup config is present + rdb = redis.NewClient(&redis.Options{ + Addr: "localhost:6379", + Password: "", + DB: 0, + }) +) + +func reinitRedis() (reinitialised bool) { + reinitialised = false + + if ddrmAppConfig.RedisServer != rdb.Options().Addr { + rdb = redis.NewClient(&redis.Options{ + Addr: ddrmAppConfig.RedisServer, + Password: ddrmAppConfig.RedisPassword, + DB: ddrmAppConfig.RedisDatabase, + }) + + reinitialised = true + } + + return +} + +func cacheKey(fqdn string, recordType DdrmRecordType) string { + return ddrmAppConfig.RedisKeyPrefix + ":" + fqdn + ":" + string(recordType) +} + +// check Redis for current cached data +func getCachedValues(fqdn string, recordType DdrmRecordType) (answer []string) { + dbgf(ddrmDebugTryingCache, fqdn, string(recordType)) + + answer = []string{} + + if stateUseRedis { + + cachedKey := cacheKey(fqdn, recordType) + members, err := rdb.SMembers(ctx, cachedKey).Result() + + if err != nil { + return answer + } + + answer = members + return + } + + dbgf(ddrmDebugNoCache, fqdn, string(recordType)) + + return +} + +// save values in Redis as sets +func setCachedValues(fqdn string, recordType DdrmRecordType, answer []string) (success bool) { + success = false + + if stateUseRedis { + cachedKey := cacheKey(fqdn, recordType) + + // delete the key so we can reuse it + err := rdb.Del(ctx, cachedKey).Err() + + if err != nil { + return + } + + // add each answer one at a time because SAdd appears to be bugged + for _, a := range answer { + err = rdb.SAdd(ctx, cachedKey, a).Err() + if err != nil { + return + } + } + + success = true + } + + return +} diff --git a/ddrm-tui.go b/ddrm-tui.go new file mode 100644 index 0000000..d7ecb72 --- /dev/null +++ b/ddrm-tui.go @@ -0,0 +1,195 @@ +//go:build client +// +build client + +package main + +import ( + "fmt" + "os" + "slices" + + "github.com/charmbracelet/bubbles/table" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" + "github.com/muesli/termenv" +) + +// TUI state +type UiModel struct { + recordTable table.Model +} + +// TUI msg struct that supports String() +type uiProcessRecords struct { + process bool +} + +func (r uiProcessRecords) String() string { + return "" +} + +// TUI runtime objects +var ( + ddrmTui *tea.Program + + uiBaseStyle = lipgloss.NewStyle(). + BorderStyle(lipgloss.NormalBorder()). + BorderForeground(lipgloss.Color("240")) + + uiTermColor = termenv.EnvColorProfile().Color + + helpText = termenv.Style{}.Foreground(uiTermColor("241")).Styled + highlightText = termenv.Style{}.Foreground(uiTermColor("204")).Background(uiTermColor("235")).Styled +) + +func (ui UiModel) Init() tea.Cmd { + return nil +} + +func (ui UiModel) View() string { + return uiBaseStyle.Render(ui.recordTable.View()) + "\n\n" + + helpText("q: exit • x: toggle altscreen mode ") + highlightText(fmt.Sprint(len(ddrmRecordStates))+" records\n") +} + +func (ui UiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + switch msg := msg.(type) { + case tea.KeyMsg: + switch msg.String() { + case "q", "ctrl+c", "esc": + cronScheduler.Shutdown() + return ui, tea.Quit + case "x": + var cmd tea.Cmd + if stateAltScreenMode { + cmd = tea.ExitAltScreen + } else { + cmd = tea.EnterAltScreen + } + stateAltScreenMode = !stateAltScreenMode + return ui, cmd + } + case uiProcessRecords: + return updateUi(), nil + } + + return updateUi(), nil +} + +func updateUi() UiModel { + columns := []table.Column{ + {Title: "-", Width: 1}, + {Title: "FQDN", Width: 30}, + {Title: "RR", Width: 4}, + {Title: "Expected", Width: 20}, + {Title: "Currently", Width: 20}, + {Title: "✉︎", Width: 1}, + {Title: "↓", Width: 1}, + {Title: "⚠️", Width: 1}, + } + + rows := []table.Row{} + + // golang doesn't have an ordered map type, so we need to extract the keys, + // sort those, and then index into the record states map with the sorted key + keys := make([]string, 0) + for k := range ddrmRecordStates { + keys = append(keys, k) + } + + slices.Sort(keys) + + // turn each record state into a row + for _, k := range keys { + rowState := ddrmRecordStates[k] + + processing := "" + if rowState.Processing { + processing = "x" + } + + email := "" + if rowState.SentEmail { + email = "x" + } + + changed := "" + if rowState.Changed { + changed = "x" + } + + errored := "" + if rowState.Errored { + errored = "x" + } + + prior := "" + if len(rowState.PriorValues) == 1 { + prior = rowState.PriorValues[0] + } else if len(rowState.PriorValues) > 1 { + prior = rowState.PriorValues[0] + ", ..." + } + + current := "" + if len(rowState.CurrentValues) == 1 { + current = rowState.CurrentValues[0] + } else if len(rowState.CurrentValues) > 1 { + current = rowState.CurrentValues[0] + ", ..." + } + + row := table.Row{ + processing, + rowState.FQDN, + string(rowState.Type), + prior, + current, + email, + changed, + errored, + } + + rows = append(rows, row) + } + + t := table.New( + table.WithColumns(columns), + table.WithRows(rows), + table.WithFocused(true), + table.WithHeight(len(rows)), + ) + + style := table.DefaultStyles() + style.Header = style.Header.BorderStyle(lipgloss.NormalBorder()). + BorderForeground(lipgloss.Color("240")). + BorderBottom(true). + Bold(false) + + style.Selected = style.Selected.Foreground(lipgloss.Color("229")). + Background(lipgloss.Color("57")). + Bold(false) + + t.SetStyles(style) + + uiModel := UiModel{t} + + return uiModel +} + +func sendUpdateUIMsg() { + if stateUI { + ddrmTui.Send(uiProcessRecords{process: true}) + } +} + +func setupTui() { + if stateUI { + ddrmTui = tea.NewProgram(updateUi()) + } +} + +func runTui() { + if stateUI { + if _, err := ddrmTui.Run(); err != nil { + os.Exit(ddrmExitErrorRunningTUI) + } + } +} diff --git a/ddrm.go b/ddrm.go new file mode 100644 index 0000000..dac0620 --- /dev/null +++ b/ddrm.go @@ -0,0 +1,43 @@ +//go:build client +// +build client + +package main + +// Build time information +var ( + BuildVersion string + BuildDate string + GitRev string + BuildUser string +) + +func main() { + // Initial application setup + parseCliFlags() + setupLogger() + printStartupBanner() + + // Read configuration of app state and records to process + readAppConfig() + readRecordsConfig() + + // Re-initialise the Redis cache if needed + reinitRedis() + + // Run some tests and exit if requested + sendTestEmail() + testDnsClient() + + // Setup the TUI if needed, along with the periodic tasks + setupTui() + setupPeriodicTasks() + + // Run the record processor once outside the periodic scheduler just to prime the state + processRecords() + + // Run the TUI, which has its own run loop + runTui() + + // Run the main non-TUI loop if the TUI isn't needed + runLoop() +} diff --git a/doc/ddrm-records.conf-example b/doc/ddrm-records.conf-example new file mode 100755 index 0000000..66574cd --- /dev/null +++ b/doc/ddrm-records.conf-example @@ -0,0 +1,7 @@ +[ + { + "fqdn": "sommefeldt.com", + "type": "A", + "expected_values": [""] + } +] \ No newline at end of file diff --git a/doc/ddrm.conf-example b/doc/ddrm.conf-example new file mode 100755 index 0000000..d147cfa --- /dev/null +++ b/doc/ddrm.conf-example @@ -0,0 +1,19 @@ +{ + "email_user": "", + "email_password": "", + "email_server_hostname": "", + "email_server_port": "587", + "email_user_name": "DDRM Record Monitor", + "email_to": "rys@sommefeldt.com", + "email_to_name": "Rys Sommefeldt", + "dns_server_1": "8.8.8.8:53", + "dns_server_2": "1.1.1.1:53", + "email_sender_name": "DDRM Record Monitor", + "email_link": "https://rys.sommefeldt.com/", + "email_logo": "", + "email_subject": "DDRM - Detected Record Change", + "redis_database": 0, + "redis_password", "", + "redis_server": "localhost:6379". + "redis_key_prefix": "ddrm" +} \ No newline at end of file diff --git a/doc/email-screenshot.png b/doc/email-screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..e645b67dc25b1eba687222dffc11920bf378b9b1 GIT binary patch literal 124587 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 bkda+pE=4i@mA64qF5rV&*qRg1xnlkc@*>h~ literal 0 HcmV?d00001 diff --git a/doc/tui-screenshot.png b/doc/tui-screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..b47530ccd4ffcbce17d9e349c40a19f7fb7d0142 GIT binary patch literal 52675 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 literal 0 HcmV?d00001 diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..343cf9a --- /dev/null +++ b/go.mod @@ -0,0 +1,59 @@ +module github.com/rys/ddrm + +go 1.21.4 + +require ( + github.com/charmbracelet/bubbles v0.16.1 + github.com/charmbracelet/bubbletea v0.24.2 + github.com/charmbracelet/lipgloss v0.9.1 + github.com/go-co-op/gocron/v2 v2.0.0 + github.com/matcornic/hermes/v2 v2.1.0 + github.com/miekg/dns v1.1.56 + github.com/muesli/termenv v0.15.2 + github.com/redis/go-redis/v9 v9.3.0 + github.com/rs/zerolog v1.31.0 +) + +require ( + github.com/Masterminds/goutils v1.1.1 // indirect + github.com/Masterminds/semver v1.5.0 // indirect + github.com/Masterminds/sprig v2.22.0+incompatible // indirect + github.com/PuerkitoBio/goquery v1.8.1 // indirect + github.com/andybalholm/cascadia v1.3.2 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/google/uuid v1.4.0 // indirect + github.com/gorilla/css v1.0.1 // indirect + github.com/huandu/xstrings v1.4.0 // indirect + github.com/imdario/mergo v0.3.16 // indirect + github.com/jaytaylor/html2text v0.0.0-20230321000545-74c2419ad056 // indirect + github.com/jonboulle/clockwork v0.4.0 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.19 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.15 // indirect + github.com/mitchellh/copystructure v1.2.0 // indirect + github.com/mitchellh/reflectwalk v1.0.2 // indirect + github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b // indirect + github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/olekukonko/tablewriter v0.0.5 // indirect + github.com/rivo/uniseg v0.4.4 // indirect + github.com/robfig/cron/v3 v3.0.1 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf // indirect + github.com/vanng822/css v1.0.1 // indirect + github.com/vanng822/go-premailer v1.20.2 // indirect + golang.org/x/crypto v0.16.0 // indirect + golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb // indirect + golang.org/x/mod v0.14.0 // indirect + golang.org/x/net v0.19.0 // indirect + golang.org/x/sync v0.5.0 // indirect + golang.org/x/sys v0.15.0 // indirect + golang.org/x/term v0.15.0 // indirect + golang.org/x/text v0.14.0 // indirect + golang.org/x/tools v0.16.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..2252636 --- /dev/null +++ b/go.sum @@ -0,0 +1,209 @@ +github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI= +github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU= +github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= +github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww= +github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= +github.com/Masterminds/sprig v2.16.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o= +github.com/Masterminds/sprig v2.22.0+incompatible h1:z4yfnGrZ7netVz+0EDJ0Wi+5VZCSYp4Z0m2dk6cEM60= +github.com/Masterminds/sprig v2.22.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o= +github.com/PuerkitoBio/goquery v1.5.0/go.mod h1:qD2PgZ9lccMbQlc7eEOjaeRlFQON7xY8kdmcsrnKqMg= +github.com/PuerkitoBio/goquery v1.5.1/go.mod h1:GsLWisAFVj4WgDibEWF4pvYnkVQBpKBKeU+7zCJoLcc= +github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM= +github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ= +github.com/andybalholm/cascadia v1.0.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y= +github.com/andybalholm/cascadia v1.1.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y= +github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA= +github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss= +github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU= +github.com/aokoli/goutils v1.0.1/go.mod h1:SijmP0QR8LtwsmDs8Yii5Z/S4trXFGFC2oO5g9DP+DQ= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY= +github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc= +github.com/charmbracelet/bubbletea v0.24.2 h1:uaQIKx9Ai6Gdh5zpTbGiWpytMU+CfsPp06RaW2cx/SY= +github.com/charmbracelet/bubbletea v0.24.2/go.mod h1:XdrNrV4J8GiyshTtx3DNuYkR1FDaJmO3l2nejekbsgg= +github.com/charmbracelet/lipgloss v0.9.1 h1:PNyd3jvaJbg4jRHKWXnCj1akQm4rh8dbEzN1p/u1KWg= +github.com/charmbracelet/lipgloss v0.9.1/go.mod h1:1mPmG4cxScwUQALAAnacHaigiiHB9Pmr+v1VEawJl6I= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM= +github.com/go-co-op/gocron/v2 v2.0.0 h1:wVB5Bh+665+r/zQ+ErsyUypyPWGozEnNV7EEZ8D0HIU= +github.com/go-co-op/gocron/v2 v2.0.0/go.mod h1:DodDqurAedt8cj/dbFM8obVSgPv0Vch80eF7neNVwmg= +github.com/go-gomail/gomail v0.0.0-20160411212932-81ebce5c23df/go.mod h1:GJr+FCSXshIwgHBtLglIg9M2l2kQSi6QjVAngtzI08Y= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= +github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c= +github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8= +github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0= +github.com/huandu/xstrings v1.2.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4= +github.com/huandu/xstrings v1.4.0 h1:D17IlohoQq4UcpqD7fDk80P7l+lwAmlFaBHgOipl2FU= +github.com/huandu/xstrings v1.4.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= +github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= +github.com/imdario/mergo v0.3.16 h1:wwQJbIsHYGMUyLSPrEq1CT16AhnhNJQ51+4fdHUnCl4= +github.com/imdario/mergo v0.3.16/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= +github.com/jaytaylor/html2text v0.0.0-20180606194806-57d518f124b0/go.mod h1:CVKlgaMiht+LXvHG173ujK6JUhZXKb2u/BQtjPDIvyk= +github.com/jaytaylor/html2text v0.0.0-20230321000545-74c2419ad056 h1:iCHtR9CQyktQ5+f3dMVZfwD2KWJUgm7M0gdL9NGr8KA= +github.com/jaytaylor/html2text v0.0.0-20230321000545-74c2419ad056/go.mod h1:CVKlgaMiht+LXvHG173ujK6JUhZXKb2u/BQtjPDIvyk= +github.com/jonboulle/clockwork v0.4.0 h1:p4Cf1aMWXnXAUh8lVfewRBx1zaTSYKrKMF2g3ST4RZ4= +github.com/jonboulle/clockwork v0.4.0/go.mod h1:xgRqUGwRcjKCO1vbZUEtSLrqKoPSsUpK7fnezOII0kc= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= +github.com/matcornic/hermes/v2 v2.1.0 h1:9TDYFBPFv6mcXanaDmRDEp/RTWj0dTTi+LpFnnnfNWc= +github.com/matcornic/hermes/v2 v2.1.0/go.mod h1:2+ziJeoyRfaLiATIL8VZ7f9hpzH4oDHqTmn0bhrsgVI= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= +github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= +github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/miekg/dns v1.1.56 h1:5imZaSeoRNvpM9SzWNhEcP9QliKiz20/dA2QabIGVnE= +github.com/miekg/dns v1.1.56/go.mod h1:cRm6Oo2C8TY9ZS/TqsSrseAcncm74lfK5G+ikN2SWWY= +github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw= +github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= +github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= +github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b h1:1XF24mVaiu7u+CFywTdcDo2ie1pzzhwjt6RHqzpMU34= +github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho= +github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= +github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo= +github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8= +github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.3.0 h1:RiVDjmig62jIWp7Kk4XVLs0hzV6pI3PyTnnL0cnn0u0= +github.com/redis/go-redis/v9 v9.3.0/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= +github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs= +github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro= +github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/zerolog v1.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A= +github.com/rs/zerolog v1.31.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf h1:pvbZ0lM0XWPBqUKqFU8cmavspvIl9nulOYwdy6IFRRo= +github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf/go.mod h1:RJID2RhlZKId02nZ62WenDCkgHFerpIOmW0iT7GKmXM= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/unrolled/render v1.0.3/go.mod h1:gN9T0NhL4Bfbwu8ann7Ry/TGHYfosul+J0obPf6NBdM= +github.com/vanng822/css v0.0.0-20190504095207-a21e860bcd04/go.mod h1:tcnB1voG49QhCrwq1W0w5hhGasvOg+VQp9i9H1rCM1w= +github.com/vanng822/css v1.0.1 h1:10yiXc4e8NI8ldU6mSrWmSWMuyWgPr9DZ63RSlsgDw8= +github.com/vanng822/css v1.0.1/go.mod h1:tcnB1voG49QhCrwq1W0w5hhGasvOg+VQp9i9H1rCM1w= +github.com/vanng822/go-premailer v0.0.0-20191214114701-be27abe028fe/go.mod h1:JTFJA/t820uFDoyPpErFQ3rb3amdZoPtxcKervG0OE4= +github.com/vanng822/go-premailer v1.20.2 h1:vKs4VdtfXDqL7IXC2pkiBObc1bXM9bYH3Wa+wYw2DnI= +github.com/vanng822/go-premailer v1.20.2/go.mod h1:RAxbRFp6M/B171gsKu8dsyq+Y5NGsUUvYfg+WQWusbE= +github.com/vanng822/r2router v0.0.0-20150523112421-1023140a4f30/go.mod h1:1BVq8p2jVr55Ost2PkZWDrG86PiJ/0lxqcXoAcGxvWU= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +golang.org/x/crypto v0.0.0-20181029175232-7e6ffbd03851/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.16.0 h1:mMMrFzRSCF0GvB7Ne27XVtVAaXLrPmgPC7/v0tkwHaY= +golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= +golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb h1:c0vyKkb6yr3KR7jEfJaOSv4lG7xPkbN6r52aJz1d8a8= +golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200904194848-62affa334b73/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c= +golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190225065934-cc5685c2db12/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= +golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4= +golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.16.0 h1:GO788SKMRunPIBCXiQyo2AaexLstOrVhuAL5YwsckQM= +golang.org/x/tools v0.16.0/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=