Building 70 Projects ranging from beginner to advanced so anyone can β learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company π
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
fix(canary): webhook sender blocks SSRF to private/loopback/IMDS hosts
CarterPerez-dev2c033c58f2d9
diff --git a/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender.go b/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender.goindex a9aa47aa..3abc2820 100644--- a/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender.go+++ b/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender.go@@ -47,16 +47,20 @@ var ("webhook: webhook URL not configured",)ErrInvalidWebhookURL = errors.New("webhook: invalid url")- ErrWebhookAPI = errors.New("webhook: api error")+ ErrBlockedHost = errors.New(+ "webhook: host resolves to a blocked address range",+ )+ ErrWebhookAPI = errors.New("webhook: api error"))type Config struct {- ManageURL string- HMACSecret string- HTTPClient *http.Client- MaxTries uint- MaxElapsed time.Duration- InitialInterval time.Duration+ ManageURL string+ HMACSecret string+ HTTPClient *http.Client+ MaxTries uint+ MaxElapsed time.Duration+ InitialInterval time.Duration+ AllowPrivateHosts bool}type Option func(*Config)@@ -75,13 +79,18 @@ func WithHTTPClient(client *http.Client) Option {return func(c *Config) { c.HTTPClient = client }}+func WithAllowPrivateHosts(allow bool) Option {+ return func(c *Config) { c.AllowPrivateHosts = allow }+}+type Sender struct {- manageURL string- hmacSecret string- httpClient *http.Client- maxTries uint- maxElapsed time.Duration- initialInterval time.Duration+ manageURL string+ hmacSecret string+ httpClient *http.Client+ maxTries uint+ maxElapsed time.Duration+ initialInterval time.Duration+ allowPrivateHosts bool}func NewSender(cfg Config, opts ...Option) *Sender {@@ -89,7 +98,7 @@ func NewSender(cfg Config, opts ...Option) *Sender {o(&cfg)}if cfg.HTTPClient == nil {- cfg.HTTPClient = defaultHTTPClient()+ cfg.HTTPClient = defaultHTTPClient(cfg.AllowPrivateHosts)}if cfg.MaxTries == 0 {cfg.MaxTries = defaultMaxTries@@ -101,21 +110,45 @@ func NewSender(cfg Config, opts ...Option) *Sender {cfg.InitialInterval = defaultInitialInterval}return &Sender{- manageURL: strings.TrimRight(cfg.ManageURL, "/"),- hmacSecret: cfg.HMACSecret,- httpClient: cfg.HTTPClient,- maxTries: cfg.MaxTries,- maxElapsed: cfg.MaxElapsed,- initialInterval: cfg.InitialInterval,+ manageURL: strings.TrimRight(cfg.ManageURL, "/"),+ hmacSecret: cfg.HMACSecret,+ httpClient: cfg.HTTPClient,+ maxTries: cfg.MaxTries,+ maxElapsed: cfg.MaxElapsed,+ initialInterval: cfg.InitialInterval,+ allowPrivateHosts: cfg.AllowPrivateHosts,}}-func defaultHTTPClient() *http.Client {- dialer := &net.Dialer{Timeout: defaultDialTimeout}+func defaultHTTPClient(allowPrivateHosts bool) *http.Client {+ base := &net.Dialer{Timeout: defaultDialTimeout}+ dialFn := base.DialContext+ if !allowPrivateHosts {+ dialFn = func(+ ctx context.Context,+ network, addr string,+ ) (net.Conn, error) {+ if err := preDialIPCheck(addr); err != nil {+ return nil, err+ }+ conn, err := base.DialContext(ctx, network, addr)+ if err != nil {+ return nil, err+ }+ if err := postDialIPCheck(conn); err != nil {+ if cErr := conn.Close(); cErr != nil {+ slog.Warn("webhook: close blocked conn",+ "error", cErr)+ }+ return nil, err+ }+ return conn, nil+ }+ }return &http.Client{Timeout: defaultOverallTimeout,Transport: &http.Transport{- DialContext: dialer.DialContext,+ DialContext: dialFn,TLSHandshakeTimeout: defaultDialTimeout,ResponseHeaderTimeout: defaultOverallTimeout,ExpectContinueTimeout: time.Second,@@ -124,8 +157,38 @@ func defaultHTTPClient() *http.Client {}}+func preDialIPCheck(addr string) error {+ host, _, err := net.SplitHostPort(addr)+ if err != nil {+ return fmt.Errorf("webhook: split host port: %w", err)+ }+ ip := net.ParseIP(host)+ if ip == nil {+ return nil+ }+ if isBlockedIP(ip) {+ return fmt.Errorf("%w: dial blocked %s", ErrBlockedHost, ip)+ }+ return nil+}++func postDialIPCheck(conn net.Conn) error {+ tcpAddr, ok := conn.RemoteAddr().(*net.TCPAddr)+ if !ok {+ return nil+ }+ if isBlockedIP(tcpAddr.IP) {+ return fmt.Errorf("%w: dial blocked %s", ErrBlockedHost, tcpAddr.IP)+ }+ return nil+}+func (s *Sender) Channel() string { return Channel }+func (s *Sender) Validate(raw string) error {+ return validateURL(raw, s.allowPrivateHosts)+}+func (s *Sender) Send(ctx context.Context,info event.NotifyInfo,@@ -134,7 +197,7 @@ func (s *Sender) Send(if strings.TrimSpace(info.WebhookURL) == "" {return ErrChannelNotConfigured}- if err := validateURL(info.WebhookURL); err != nil {+ if err := validateURL(info.WebhookURL, s.allowPrivateHosts); err != nil {return err}@@ -215,7 +278,7 @@ func (s *Sender) doRequest(}}-func validateURL(raw string) error {+func validateURL(raw string, allowPrivateHosts bool) error {u, err := url.Parse(raw)if err != nil {return fmt.Errorf("%w: parse: %w", ErrInvalidWebhookURL, err)@@ -233,9 +296,67 @@ func validateURL(raw string) error {if u.User != nil {return fmt.Errorf("%w: userinfo not allowed", ErrInvalidWebhookURL)}+ if allowPrivateHosts {+ return nil+ }+ host := u.Hostname()+ if host == "" {+ return fmt.Errorf("%w: missing hostname", ErrInvalidWebhookURL)+ }+ if ip := net.ParseIP(host); ip != nil {+ if isBlockedIP(ip) {+ return fmt.Errorf("%w: %s", ErrBlockedHost, ip)+ }+ return nil+ }+ ips, lookupErr := net.LookupIP(host)+ if lookupErr != nil {+ return fmt.Errorf(+ "%w: lookup %s: %w",+ ErrInvalidWebhookURL, host, lookupErr,+ )+ }+ if len(ips) == 0 {+ return fmt.Errorf("%w: no IPs for %s", ErrInvalidWebhookURL, host)+ }+ for _, ip := range ips {+ if isBlockedIP(ip) {+ return fmt.Errorf("%w: %s -> %s", ErrBlockedHost, host, ip)+ }+ }return nil}+func isBlockedIP(ip net.IP) bool {+ if ip == nil {+ return true+ }+ if ip.IsLoopback() || ip.IsLinkLocalUnicast() ||+ ip.IsLinkLocalMulticast() || ip.IsMulticast() ||+ ip.IsUnspecified() {+ return true+ }+ if ip4 := ip.To4(); ip4 != nil {+ switch {+ case ip4[0] == 10:+ return true+ case ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31:+ return true+ case ip4[0] == 192 && ip4[1] == 168:+ return true+ case ip4[0] == 100 && ip4[1] >= 64 && ip4[1] <= 127:+ return true+ case ip4[0] == 169 && ip4[1] == 254:+ return true+ }+ return false+ }+ if len(ip) == net.IPv6len && ip[0]&0xfe == 0xfc {+ return true+ }+ return false+}+type envelope struct {Version string `json:"version"`Event string `json:"event"`diff --git a/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender_test.go b/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender_test.goindex c95cee3e..f2d53e7c 100644--- a/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender_test.go+++ b/PROJECTS/beginner/canary-token-generator/backend/internal/notify/webhook/sender_test.go@@ -98,10 +98,18 @@ func loadBody(t *testing.T, c *capture) []byte {func newSender(t *testing.T, opts ...webhook.Option) *webhook.Sender {t.Helper()return webhook.NewSender(webhook.Config{- ManageURL: "https://canary.example.com",+ ManageURL: "https://canary.example.com",+ AllowPrivateHosts: true,}, opts...)}+func newStrictSender(t *testing.T) *webhook.Sender {+ t.Helper()+ return webhook.NewSender(webhook.Config{+ ManageURL: "https://canary.example.com",+ })+}+func TestSender_Channel(t *testing.T) {t.Parallel()require.Equal(t, "webhook", newSender(t).Channel())@@ -197,8 +205,9 @@ func TestSender_Send_HMACSignatureWhenSecretSet(t *testing.T) {},)s := webhook.NewSender(webhook.Config{- ManageURL: "https://canary.example.com",- HMACSecret: secret,+ ManageURL: "https://canary.example.com",+ HMACSecret: secret,+ AllowPrivateHosts: true,})require.NoError(t,@@ -326,6 +335,77 @@ func TestSender_Send_AbortsAfterMaxTries(t *testing.T) {require.Equal(t, int32(3), attempts.Load())}+func TestSender_Validate_BlocksPrivateHosts(t *testing.T) {+ t.Parallel()+ s := newStrictSender(t)+ cases := []string{+ "http://127.0.0.1/",+ "http://127.0.0.1:6379/",+ "http://10.0.0.1/",+ "http://10.255.255.255/",+ "http://172.16.0.1/",+ "http://172.31.255.255/",+ "http://192.168.1.1/",+ "http://169.254.169.254/latest/meta-data/",+ "http://100.64.0.1/",+ "http://0.0.0.0/",+ "http://[::1]/",+ "http://[fd00::1]/",+ "http://[fe80::1]/",+ }+ for _, raw := range cases {+ raw := raw+ t.Run(raw, func(t *testing.T) {+ t.Parallel()+ err := s.Validate(raw)+ require.ErrorIsf(+ t,+ err,+ webhook.ErrBlockedHost,+ "expected ErrBlockedHost for %q",+ raw,+ )+ })+ }+}++func TestSender_Validate_AllowsPublicLiteralIPs(t *testing.T) {+ t.Parallel()+ s := newStrictSender(t)+ cases := []string{+ "https://8.8.8.8/",+ "https://1.1.1.1/",+ "http://203.0.113.45:8080/hook",+ "https://[2001:db8::1]/",+ }+ for _, raw := range cases {+ raw := raw+ t.Run(raw, func(t *testing.T) {+ t.Parallel()+ require.NoError(t, s.Validate(raw))+ })+ }+}++func TestSender_Send_BlocksPrivateHostByDefault(t *testing.T) {+ t.Parallel()+ srv := httptest.NewServer(+ http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(http.StatusOK)+ }),+ )+ t.Cleanup(srv.Close)++ s := newStrictSender(t)+ err := s.Send(context.Background(), sampleInfo(srv.URL), sampleEvent())+ require.ErrorIs(+ t,+ err,+ webhook.ErrBlockedHost,+ "strict sender must refuse to send to loopback URL",+ )+}+func TestSender_Send_RespectsContextCancel(t *testing.T) {t.Parallel()srv := httptest.NewServer(