build: keep setuid/setgid/sticky on unpacked directories

retrieveWorkspace created directories with MkdirAll(hdr.Name,
mode.Perm()). .Perm() masks to 0o777 and nothing applied the special
bits afterwards, so a directory the guest workspace has as 1777 or
2755 landed on the host as 0777 or 0755 and those bits never reached
the built apk. wolfi-baselayout chmods /tmp and /var/tmp to 1777, and
the published wolfi-baselayout apk records both as 0777.

Chmod the full mode after MkdirAll when the header carries any of
setuid/setgid/sticky. Directories without those bits are left alone,
so the melange-out directories melange pre-creates keep their current
handling. The regular file branch already passes the full mode to
OpenFile, so it needs no change.

The bubblewrap OCI layer extraction had the same shape, which left the
build environment's own /tmp non-sticky. os.MkdirAll there also applies
the umask, so plain 0777 was lost as well; passing mode.Perm()|special
to os.Chmod restores both.

Only the qemu runner retrieves a workspace tar -- bubblewrap and docker
bind-mount the workspace, where WorkspaceTar is a no-op.

Fixes #2642

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: smoser

pkg/build/build.go

@@ -1100,6 +1100,10 @@ func isValidPath(targetPath, baseDir string) error {
 	return nil
 }
 
+// specialModeBits are the mode bits that Mkdir/MkdirAll cannot set, since
+// they take only permission bits.
+const specialModeBits = os.ModeSetuid | os.ModeSetgid | os.ModeSticky
+
 // retrieveWorkspace retrieves the workspace from the container and unpacks it
 // to the workspace directory. The workspace retrieved from the runner is in a
 // tar stream containing the workspace contents rooted at ./melange-out
@@ -1159,10 +1163,19 @@ func (b *Build) retrieveWorkspace(ctx context.Context, fs apkofs.FullFS) error {
 				}
 			}
 
-			if err := fs.MkdirAll(hdr.Name, hdr.FileInfo().Mode().Perm()); err != nil {
+			mode := hdr.FileInfo().Mode()
+			if err := fs.MkdirAll(hdr.Name, mode.Perm()); err != nil {
 				return fmt.Errorf("unable to create directory %s: %w", hdr.Name, err)
 			}
 
+			// MkdirAll carries only permission bits, so setuid/setgid/sticky
+			// have to be applied separately.
+			if special := mode & specialModeBits; special != 0 {
+				if err := fs.Chmod(hdr.Name, mode.Perm()|special); err != nil {
+					return fmt.Errorf("unable to chmod directory %s: %w", hdr.Name, err)
+				}
+			}
+
 			if err := fs.Chown(hdr.Name, uid, gid); err != nil {
 				return fmt.Errorf("unable to chown directory %s: %w", hdr.Name, err)
 			}

pkg/build/workspace_test.go

@@ -0,0 +1,121 @@
+// Copyright 2026 Chainguard, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package build
+
+import (
+	"archive/tar"
+	"bytes"
+	"context"
+	"io"
+	"os"
+	"testing"
+
+	apkofs "chainguard.dev/apko/pkg/apk/fs"
+	apko_build "chainguard.dev/apko/pkg/build"
+
+	"chainguard.dev/melange/pkg/config"
+	"chainguard.dev/melange/pkg/container"
+)
+
+// tarRunner is a container.Runner that only implements WorkspaceTar, returning
+// a canned tar stream.
+type tarRunner struct {
+	tarball []byte
+}
+
+func (t *tarRunner) WorkspaceTar(context.Context, *container.Config, []string) (io.ReadCloser, error) {
+	return io.NopCloser(bytes.NewReader(t.tarball)), nil
+}
+
+func (t *tarRunner) Close() error                                      { return nil }
+func (t *tarRunner) Name() string                                      { return "tar-runner" }
+func (t *tarRunner) TestUsability(context.Context) bool                { return true }
+func (t *tarRunner) OCIImageLoader() container.Loader                  { return nil }
+func (t *tarRunner) StartPod(context.Context, *container.Config) error { return nil }
+func (t *tarRunner) Run(context.Context, *container.Config, map[string]string, ...string) error {
+	return nil
+}
+func (t *tarRunner) TerminatePod(context.Context, *container.Config) error { return nil }
+func (t *tarRunner) TempDir() string                                       { return "" }
+func (t *tarRunner) GetReleaseData(context.Context, *container.Config) (*apko_build.ReleaseData, error) {
+	return nil, nil
+}
+
+var _ container.Runner = (*tarRunner)(nil)
+
+// TestRetrieveWorkspaceSpecialModeBits verifies that setuid, setgid and sticky
+// bits survive the trip through retrieveWorkspace. Regression test for
+// https://github.com/chainguard-dev/melange/issues/2642, where directories
+// were created with Mode().Perm() and nothing set the special bits after.
+func TestRetrieveWorkspaceSpecialModeBits(t *testing.T) {
+	entries := []struct {
+		name     string
+		typeflag byte
+		mode     int64
+	}{
+		{"melange-out/pkg/", tar.TypeDir, 0o755},
+		{"melange-out/pkg/tmp/", tar.TypeDir, 0o1777},
+		{"melange-out/pkg/var/", tar.TypeDir, 0o755},
+		{"melange-out/pkg/var/tmp/", tar.TypeDir, 0o1777},
+		{"melange-out/pkg/usr/", tar.TypeDir, 0o755},
+		{"melange-out/pkg/usr/mail/", tar.TypeDir, 0o2755},
+		{"melange-out/pkg/usr/setuid-dir/", tar.TypeDir, 0o4755},
+		{"melange-out/pkg/usr/postdrop", tar.TypeReg, 0o2755},
+	}
+
+	var buf bytes.Buffer
+	tw := tar.NewWriter(&buf)
+	for _, e := range entries {
+		if err := tw.WriteHeader(&tar.Header{
+			Name:     e.name,
+			Typeflag: e.typeflag,
+			Mode:     e.mode,
+		}); err != nil {
+			t.Fatalf("writing header %s: %v", e.name, err)
+		}
+	}
+	if err := tw.Close(); err != nil {
+		t.Fatalf("closing tar: %v", err)
+	}
+
+	ctx := context.Background()
+	workspaceDir := t.TempDir()
+	b := &Build{
+		Configuration: &config.Configuration{},
+		WorkspaceDir:  workspaceDir,
+		Runner:        &tarRunner{tarball: buf.Bytes()},
+	}
+	fsys := apkofs.DirFS(ctx, workspaceDir)
+
+	if err := b.retrieveWorkspace(ctx, fsys); err != nil {
+		t.Fatalf("retrieveWorkspace: %v", err)
+	}
+
+	for _, e := range entries {
+		// Let archive/tar do the mode conversion, so the expectation is in
+		// terms of os.ModeSetuid/Setgid/Sticky rather than raw octal.
+		hdr := tar.Header{Name: e.name, Typeflag: e.typeflag, Mode: e.mode}
+		want := hdr.FileInfo().Mode() & (os.ModePerm | specialModeBits)
+
+		fi, err := fsys.Stat(e.name)
+		if err != nil {
+			t.Errorf("stat %s: %v", e.name, err)
+			continue
+		}
+		if got := fi.Mode() & (os.ModePerm | specialModeBits); got != want {
+			t.Errorf("%s: got mode %v (%04o), want %v (%04o)", e.name, got, got.Perm(), want, want.Perm())
+		}
+	}
+}

pkg/container/bubblewrap_runner.go

@@ -42,6 +42,10 @@ var _ Debugger = (*bubblewrap)(nil)
 const (
 	BubblewrapName = "bubblewrap"
 	buildUserID    = "1000"
+
+	// specialModeBits are the mode bits that Mkdir/MkdirAll cannot set,
+	// since they take only permission bits.
+	specialModeBits = os.ModeSetuid | os.ModeSetgid | os.ModeSticky
 )
 
 // defaultCapabilities is the set of Linux capabilities granted by the
@@ -325,9 +329,17 @@ func (b *bubblewrapOCILoader) LoadImage(ctx context.Context, layer v1.Layer, arc
 		}
 		switch hdr.Typeflag {
 		case tar.TypeDir:
-			if err := os.MkdirAll(fullname, hdr.FileInfo().Mode().Perm()); err != nil {
+			mode := hdr.FileInfo().Mode()
+			if err := os.MkdirAll(fullname, mode.Perm()); err != nil {
 				return ref, fmt.Errorf("failed to create directory %s: %w", fullname, err)
 			}
+			// MkdirAll carries only permission bits (and applies the umask),
+			// so setuid/setgid/sticky have to be applied separately.
+			if special := mode & specialModeBits; special != 0 {
+				if err := os.Chmod(fullname, mode.Perm()|special); err != nil {
+					return ref, fmt.Errorf("failed to chmod directory %s: %w", fullname, err)
+				}
+			}
 			continue
 		case tar.TypeReg:
 			f, err := os.OpenFile(fullname, os.O_CREATE|os.O_WRONLY, hdr.FileInfo().Mode().Perm()) // #nosec G304 - Extracting OCI image layer file