Advisory

GHSA-4jvg-4jfx-fmhc

Details, part 2 of 2. The advisory

Details

Attacker-owned Sentry project slug → span data for other applications is exported to an attacker-controlled Sentry project, leaking operational telemetry.
The collector fetches the DSN/keys for the attacker's slug and subsequently forwards legitimate traces/logs to the attacker-controlled destination.

Threat model

  • Attacker capabilities: remote OTLP trace sender (application-level span emission).
  • Operator capabilities: configures Sentry DSN, bearer token, base URL; sets up receiver pipeline.
  • The attacker does NOT control operator YAML. The attacker DOES control resource attribute values on spans they emit.

Realistic deployment

  • Kubernetes cluster with OpenTelemetry Collector forwarding traces from multiple applications to Sentry SaaS or self-hosted Sentry.
  • One compromised or malicious application reaches the collector via OTLP.
  • The collector is configured with a valid Sentry bearer token for the organization.

Remediation

Apply the existing projectSlugRegexp to runtime-derived slugs, not only to operator config mappings:

  import "regexp"                           

  var runtimeSlugPattern = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)
                                          
  func (s *endpointState) extractProjectSlug(attrs pcommon.Map) string {
      attrValue, exists := attrs.Get(s.attributeKey)                                                                                                          
      if !exists || attrValue.Type() != pcommon.ValueTypeStr {
          return ""                                                                                                                                           
      }                                     
      serviceName := attrValue.Str()                                                                                                                          
      if serviceName == "" {
          return ""                                                                                                                                           
      }                                     
      if s.projectMapping != nil {
          if mappedSlug, ok := s.projectMapping[serviceName]; ok {                                                                                            
              return mappedSlug
          }                                                                                                                                                   
      }                                     
      if !runtimeSlugPattern.MatchString(serviceName) {
          return "" // reject; drop the span or use a fallback default project
      }
      return serviceName                                                                                                                                      
  }
                                                                                                                                                              
  Alternatively, reject at URL construction:  
                                          
  func (c *sentryClient) GetProjectKeys(ctx context.Context, orgSlug, projectSlug string) ([]projectKey, error) {
      if !runtimeSlugPattern.MatchString(projectSlug) {                                                                                                       
          return nil, fmt.Errorf("invalid project slug: %q", projectSlug)
      }                                                                                                                                                       
      baseURL := fmt.Sprintf("%s/api/0/projects/%s/%s/keys/", c.baseURL, orgSlug, projectSlug)
      // ...                                                                                                                                                  
  }                                       

Apply the runtime regex to ALL slug-derived URL components (including orgSlug if it can ever be attacker-influenced), not just to config-time validation.

Credit

Reported by independent security research by Martin Brodeur.

Sources & licences