From 09355c4e212080ff59091a17148f00b2c3a62d92 Mon Sep 17 00:00:00 2001 From: Toby Date: Wed, 23 Aug 2023 22:56:15 -0700 Subject: [PATCH] feat: wip update checker --- app/cmd/client.go | 3 ++ app/cmd/root.go | 23 ++++++--- app/cmd/server.go | 2 + app/cmd/update.go | 88 ++++++++++++++++++++++++++++++++++ app/cmd/version.go | 23 +++++++++ app/internal/utils/update.go | 92 ++++++++++++++++++++++++++++++++++++ hyperbole.py | 23 +++++++-- 7 files changed, 244 insertions(+), 10 deletions(-) create mode 100644 app/cmd/update.go create mode 100644 app/cmd/version.go create mode 100644 app/internal/utils/update.go diff --git a/app/cmd/client.go b/app/cmd/client.go index 8e7317a..97f20e4 100644 --- a/app/cmd/client.go +++ b/app/cmd/client.go @@ -367,6 +367,9 @@ func runClient(cmd *cobra.Command, args []string) { } defer c.Close() + // TODO: add option to disable update checking + go runCheckUpdateClient(c) // TODO: fix lazy mode + uri := config.URI() logger.Info("use this URI to share your server", zap.String("uri", uri)) if showQR { diff --git a/app/cmd/root.go b/app/cmd/root.go index a968b2f..0dc8764 100644 --- a/app/cmd/root.go +++ b/app/cmd/root.go @@ -26,13 +26,22 @@ const ( var ( // These values will be injected by the build system - appVersion = "Unknown" - appDate = "Unknown" - appType = "Unknown" - appCommit = "Unknown" + appVersion = "Unknown" + appDate = "Unknown" + appType = "Unknown" // aka channel + appCommit = "Unknown" + appPlatform = "Unknown" + appArch = "Unknown" - appVersionLong = fmt.Sprintf("Version:\t%s\nBuildDate:\t%s\nBuildType:\t%s\nCommitHash:\t%s", - appVersion, appDate, appType, appCommit) + appVersionLong = fmt.Sprintf("Version:\t%s\n"+ + "BuildDate:\t%s\n"+ + "BuildType:\t%s\n"+ + "CommitHash:\t%s\n"+ + "Platform:\t%s\n"+ + "Architecture:\t%s", + appVersion, appDate, appType, appCommit, appPlatform, appArch) + + appAboutLong = fmt.Sprintf("%s\n%s\n%s\n\n%s", appLogo, appDesc, appAuthors, appVersionLong) ) var logger *zap.Logger @@ -47,7 +56,7 @@ var ( var rootCmd = &cobra.Command{ Use: "hysteria", Short: appDesc, - Long: fmt.Sprintf("%s\n%s\n%s\n\n%s", appLogo, appDesc, appAuthors, appVersionLong), + Long: appAboutLong, Run: runClient, // Default to client mode } diff --git a/app/cmd/server.go b/app/cmd/server.go index 940a6a7..1d5ddf8 100644 --- a/app/cmd/server.go +++ b/app/cmd/server.go @@ -606,6 +606,8 @@ func runServer(cmd *cobra.Command, args []string) { } logger.Info("server up and running") + go runCheckUpdateServer() + if err := s.Serve(); err != nil { logger.Fatal("failed to serve", zap.Error(err)) } diff --git a/app/cmd/update.go b/app/cmd/update.go new file mode 100644 index 0000000..3b26740 --- /dev/null +++ b/app/cmd/update.go @@ -0,0 +1,88 @@ +package cmd + +import ( + "time" + + "github.com/spf13/cobra" + "go.uber.org/zap" + + "github.com/apernet/hysteria/app/internal/utils" + "github.com/apernet/hysteria/core/client" +) + +const ( + updateCheckInterval = 24 * time.Hour +) + +// checkUpdateCmd represents the checkUpdate command +var checkUpdateCmd = &cobra.Command{ + Use: "check-update", + Short: "Check for updates", + Long: "Check for updates.", + Run: runCheckUpdate, +} + +func init() { + rootCmd.AddCommand(checkUpdateCmd) +} + +func runCheckUpdate(cmd *cobra.Command, args []string) { + logger.Info("checking for updates", + zap.String("version", appVersion), + zap.String("platform", appPlatform), + zap.String("arch", appArch), + zap.String("channel", appType), + ) + + checker := utils.NewServerUpdateChecker(appVersion, appPlatform, appArch, appType) + resp, err := checker.Check() + if err != nil { + logger.Fatal("failed to check for updates", zap.Error(err)) + } + if resp.HasUpdate { + logger.Info("update available", + zap.String("version", resp.LatestVersion), + zap.String("url", resp.URL), + zap.Bool("urgent", resp.Urgent), + ) + } else { + logger.Info("no update available") + } +} + +// runCheckUpdateServer is the background update checking routine for server mode +func runCheckUpdateServer() { + checker := utils.NewServerUpdateChecker(appVersion, appPlatform, appArch, appType) + checkUpdateRoutine(checker) +} + +// runCheckUpdateClient is the background update checking routine for client mode +func runCheckUpdateClient(hyClient client.Client) { + checker := utils.NewClientUpdateChecker(appVersion, appPlatform, appArch, appType, hyClient) + checkUpdateRoutine(checker) +} + +func checkUpdateRoutine(checker *utils.UpdateChecker) { + ticker := time.NewTicker(updateCheckInterval) + for { + logger.Debug("checking for updates", + zap.String("version", appVersion), + zap.String("platform", appPlatform), + zap.String("arch", appArch), + zap.String("channel", appType), + ) + resp, err := checker.Check() + if err != nil { + logger.Debug("failed to check for updates", zap.Error(err)) + } else if resp.HasUpdate { + logger.Info("update available", + zap.String("version", resp.LatestVersion), + zap.String("url", resp.URL), + zap.Bool("urgent", resp.Urgent), + ) + } else { + logger.Debug("no update available") + } + <-ticker.C + } +} diff --git a/app/cmd/version.go b/app/cmd/version.go new file mode 100644 index 0000000..091aae1 --- /dev/null +++ b/app/cmd/version.go @@ -0,0 +1,23 @@ +package cmd + +import ( + "fmt" + + "github.com/spf13/cobra" +) + +// versionCmd represents the version command +var versionCmd = &cobra.Command{ + Use: "version", + Short: "Show version", + Long: "Show version.", + Run: runVersion, +} + +func init() { + rootCmd.AddCommand(versionCmd) +} + +func runVersion(cmd *cobra.Command, args []string) { + fmt.Println(appAboutLong) +} diff --git a/app/internal/utils/update.go b/app/internal/utils/update.go new file mode 100644 index 0000000..5377eeb --- /dev/null +++ b/app/internal/utils/update.go @@ -0,0 +1,92 @@ +package utils + +import ( + "context" + "encoding/json" + "fmt" + "net" + "net/http" + "time" + + "github.com/apernet/hysteria/core/client" +) + +const ( + updateCheckEndpoint = "https://api.hy2.io/v1/update" + updateCheckTimeout = 10 * time.Second +) + +type UpdateChecker struct { + CurrentVersion string + Platform string + Architecture string + Channel string + Client *http.Client +} + +func NewServerUpdateChecker(currentVersion, platform, architecture, channel string) *UpdateChecker { + return &UpdateChecker{ + CurrentVersion: currentVersion, + Platform: platform, + Architecture: architecture, + Channel: channel, + Client: &http.Client{ + Timeout: updateCheckTimeout, + }, + } +} + +// NewClientUpdateChecker ensures that update checks are routed through a HyClient, +// not being sent directly. This safeguard is CRITICAL, especially in scenarios where +// users use Hysteria to bypass censorship. Making direct HTTPS requests to the API +// endpoint could be easily spotted by censors (through SNI, for example), and could +// serve as a signal to identify and penalize Hysteria users. +func NewClientUpdateChecker(currentVersion, platform, architecture, channel string, hyClient client.Client) *UpdateChecker { + return &UpdateChecker{ + CurrentVersion: currentVersion, + Platform: platform, + Architecture: architecture, + Channel: channel, + Client: &http.Client{ + Timeout: updateCheckTimeout, + Transport: &http.Transport{ + DialContext: func(_ context.Context, network, addr string) (net.Conn, error) { + // Unfortunately HyClient doesn't support context for now + return hyClient.TCP(addr) + }, + }, + }, + } +} + +type UpdateResponse struct { + HasUpdate bool `json:"update"` + LatestVersion string `json:"lver"` + URL string `json:"url"` + Urgent bool `json:"urgent"` +} + +func (uc *UpdateChecker) Check() (*UpdateResponse, error) { + url := fmt.Sprintf("%s?cver=%s&plat=%s&arch=%s&chan=%s", + updateCheckEndpoint, + uc.CurrentVersion, + uc.Platform, + uc.Architecture, + uc.Channel, + ) + resp, err := uc.Client.Get(url) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode) + } + var uResp UpdateResponse + decoder := json.NewDecoder(resp.Body) + if err := decoder.Decode(&uResp); err != nil { + return nil, err + } + return &uResp, nil +} diff --git a/hyperbole.py b/hyperbole.py index 359c0c2..fe6699b 100755 --- a/hyperbole.py +++ b/hyperbole.py @@ -128,11 +128,16 @@ def get_app_commit(): return app_commit +def get_current_os_arch(): + d_os = subprocess.check_output(["go", "env", "GOOS"]).decode().strip() + d_arch = subprocess.check_output(["go", "env", "GOARCH"]).decode().strip() + return (d_os, d_arch) + + def get_app_platforms(): platforms = os.environ.get("HY_APP_PLATFORMS") if not platforms: - d_os = subprocess.check_output(["go", "env", "GOOS"]).decode().strip() - d_arch = subprocess.check_output(["go", "env", "GOARCH"]).decode().strip() + d_os, d_arch = get_current_os_arch() return [(d_os, d_arch)] result = [] @@ -190,13 +195,19 @@ def cmd_build(pprof=False, release=False): else: env["GOARCH"] = arch + plat_ldflags = ldflags.copy() + plat_ldflags.append("-X") + plat_ldflags.append(APP_SRC_CMD_PKG + ".appPlatform=" + os_name) + plat_ldflags.append("-X") + plat_ldflags.append(APP_SRC_CMD_PKG + ".appArch=" + arch) + cmd = [ "go", "build", "-o", os.path.join(BUILD_DIR, out_name), "-ldflags", - " ".join(ldflags), + " ".join(plat_ldflags), ] if pprof: cmd.append("-tags") @@ -222,6 +233,8 @@ def cmd_run(args, pprof=False): app_date = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ") app_commit = get_app_commit() + current_os, current_arch = get_current_os_arch() + ldflags = [ "-X", APP_SRC_CMD_PKG + ".appVersion=" + app_version, @@ -231,6 +244,10 @@ def cmd_run(args, pprof=False): APP_SRC_CMD_PKG + ".appType=dev-run", "-X", APP_SRC_CMD_PKG + ".appCommit=" + app_commit, + "-X", + APP_SRC_CMD_PKG + ".appPlatform=" + current_os, + "-X", + APP_SRC_CMD_PKG + ".appArch=" + current_arch, ] cmd = ["go", "run", "-ldflags", " ".join(ldflags)]