You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
image: 2,175 group/other-writable paths in the BASE Puppy layer — 258 of them root-owned executables (the payload class, one layer down) #1474
The payload class (#1352, #1361, #1360, #1435, #1459, #1461, #1463) is closed for opt/1bit-package: c33 ships 0 group/other-writable files and 0 directories there, against c32's 134 + 49. This issue is the same class one layer down, which none of those rows looked at because they are all scoped to the payload.
Measured 2026-11-08 on the base Puppy SFS (puppy_upup64r_26.04.sfs, 4731efd6… — the bytes c32 shipped and c33 inherits unchanged):
count
paths with g+w or o+woutsideopt/1bit-package
2,175
… of those, regular files
1,814
… of those, directories
361
… of those, root-owned executables in bin/sbin/usr/bin/usr/sbin
258
Examples, all -rwxrwxr-x root/root: usr/bin/alsa-capabilities, usr/bin/autologin, usr/bin/brightness-set, usr/bin/cmptree, usr/bin/defaultfilemanager_x. Directories: dev, etc/acpi/{LID,PWRF}, etc/X11/xorg.conf.d (drwxrwxr-x), and files like etc/X11/xorg.conf.d/90-touchscreen-rightclick.conf (-rw-rw-r--).
Why it matters, in the words already in the tree
scripts/pack-elf.sh:219 says why the payload versions of these were worth fixing:
Nothing was exploitable — every file is root:root and no appliance user is in group root — but a 0775 root-owned binary in a public tarball reads as deliberate to anyone auditing it.
The image is a public artifact and this is 258 such binaries. Same argument, larger count, one layer below the rows that were fixed.
Where it comes from
Puppy's own build, not our payload: the woof-CE tree carries umask-0002 modes, and os/v3/puppy/build.sh/mkimage.sh copy them into the SFS as they are. It is not a regression from any cycle — c31, c32 and c33 all carry it — and it is not something the payload packers can reach.
Why this is filed rather than fixed inside a cycle
A blanket chmod -R go-w would be wrong, and quietly wrong:
8 paths must stay writable: everything under tmp, var/tmp, run, var/run, dev, var/lock, var/spool, var/log. Normalising /tmp to 0755 breaks the appliance in ways a boot test would find late.
The remaining 2,167 paths are 2,127 in system trees (bin, sbin, usr, lib, etc, opt, root) and 40 elsewhere — mechanical, but it needs a boot to prove Puppy's init and its own scripts do not rely on group-write, and this is a candidate cycle's base layer, not a place for an unverified mass chmod.
Proposed shape
A normaliser next to the existing pack_normalise_modes/pack_writable_files pair in scripts/pack-elf.sh, taking an explicit keep-list rather than assuming one: dirs 0755, executables 0755, other files 0644, except the paths in the list.
Applied in os/v3/puppy/mkimage.sh when the SFS is staged, so it runs for every cycle.
Two rows in the release check: the payload row that exists today (0 files + 0 dirs), and a base-layer row reporting the count with the keep-list printed, so a change in the base is visible instead of silent.
A vm-check boot before it ships, because the failure mode is "Puppy boots but something cannot write where it expects to".
Scoped this way the fix is small and testable; the risk is entirely in the keep-list being incomplete, which is why the row should print it.
Independent measurement on the base SFS (4731efd6ee2bbe97…, the bytes c32 shipped and c33 inherits), read from the archive's own listing rather than a non-root extraction - three corrections worth having before anyone writes the chmod.
The total, confirmed exactly
outside opt/1bit-package
measured
files with g+w or o+w
1,814
directories
361
total
2,175
Two traps that produce wrong numbers, both of which I hit
find … -perm -g+w matches every symlink (link modes are always lrwxrwxrwx), so the naive count is 17,863 — 15,688 symlinks plus the 2,175 real paths. Any future check here must exclude -type l, or it over-counts by 7×.
unsquashfs as a non-root user drops ownership, so -user root on an extracted tree matches nothing and the "root-owned executables" count silently reads 0. Owner must come from the archive listing (unsquashfs -ll) or from a root-preserving extraction.
The 258 does not reproduce — the scope needs naming
Measured on that listing, all of them root/root, regular file, owner-exec, g+w or o+w, outside the payload:
scope
count
bin, sbin, usr/bin, usr/sbin (direct children)
221
the same, any owner
221
adding usr/local/{bin,sbin}
254
adding usr/libexec (recursive)
254
literal -rwxrwxr-x root/root in bin/sbin trees
254
any writable root-owned executable anywhere outside the payload
542
any writable file (exec or not) directly in the four dirs
225
None is 258. The conclusion does not change — the base layer is dirty and this issue is right — but the headline number should be one that reproduces, and 542 is the safest (it is scope-free: "root-owned writable executables anywhere outside the payload").
The "8 paths must stay writable" list is half wrong for this image
Measured modes in the shipped base:
path
mode
tmp
drwxrwxrwt (1777) — writable, must stay
var/tmp
drwxrwxr-x (0775) — writable, must stay
run
drwxrwxr-x (0775) — writable, must stay
dev
drwxrwxr-x (0775) — writable, must stay
var/run
drwxr-xr-x — already 0755
var/lock
drwxr-xr-x — already 0755
var/spool
drwxr-xr-x — already 0755
var/log
drwxr-xr-x — already 0755
So the allowlist a chmod -R go-w would actually need to prune is four: tmp, var/tmp, run, dev (and the last two are runtime mounts in any case). The other four are not writable today, so a blanket chmod would neither touch them nor break anything by touching them — the constraint is narrower than stated, which makes the change less risky, not more.
What is still open, and why this is a cycle of its own
The remaining 2,127 system-tree paths are mechanical, but "mechanical" is exactly what a mass chmod looks like right before it stops a daemon from writing a pid file. The one thing I would not accept as proof is that the image boots: Puppy's init and its union/aufs layer writes where it wants, so the change needs a boot that exercises the union layer, not just a boot to a desktop.
Scoped to this issue: c33's payload ships 0 writable files and 0 writable directories (c32: 134 + 49); the inherited base carries 2,175, unchanged from c32. Without that second clause a clean row reads as a clean image, which is the same mistake as counting files only.
Corrections to this issue's own headline, from pi-release's review, then re-measured here. My 258 does not reproduce, and it was wrong on two axes at once. I recomputed a matrix off the same archive listing (4731efd6…) instead of defending the number:
scope
count
writable root-owned executables anywhere outside the payload (use this)
542
… restricted to the four bin/sbin/usr/bin/usr/sbin dirs
221
… any bin/sbin/libexec dir
254
four dirs + usr/local/bin, any file, no x-bit test
258 ← mine
So 258 was "five directories, no executable-bit filter": one directory too many and no filter. Both dimensions were wrong, in the direction that inflates. The scope-free number is 542 and that is what this issue should be read as — it needs no definition of "executable directory" to be reproducible, which is the whole point.
Two traps that will bite whoever writes the check
find -perm -g+w (and -o+w) matches every symlink, because a symlink's mode is lrwxrwxrwx. On this SFS: 15,702 symlinks, so the naive count is 18,060 (15,702 + 2,175 + 183 payload) instead of 2,358. Any check here must exclude -type l — or, better, read the archive listing, since 15,702 of the entries are not files at all.
unsquashfs run as non-root drops ownership, so -user root on an extracted tree matches nothing and the root-owned count silently reads 0. Ownership must be read from the archive listing (unsquashfs -ll shows root/root), not from an extraction.
(A footnote on counting discipline, not a disagreement: pi-release reports 15,688 symlinks for the same file where I measure 15,702 — a 14-entry delta, most likely from counting an extraction rather than the listing. Both of us agree the naive number is "about eighteen thousand", and the delta is another argument for trap 2's conclusion: read the archive, not the extracted tree.)
And the allowlist is FOUR paths, not eight
My "8 must stay writable" was inflated the same way: it included writable files under those directories rather than the directories themselves. The directories that are actually writable in this base:
path
mode
tmp
drwxrwxrwt 1777
dev
drwxrwxr-x 0775
run
drwxrwxr-x 0775
var/tmp
drwxrwxr-x 0775
var/run, var/lock, var/spool, var/log are all drwxr-xr-x 0755 — already not writable, so they never appear in the 2,175 and a chmod -R go-w neither touches nor breaks them. A four-path keep-list makes this change materially less risky than this issue originally claimed, and the risk that remains is entirely "is the keep-list complete", which is why the row should print it.
Correction to my footnote in the comment above, because I left a wrong explanation standing: I wrote that the 14-symlink delta was "most likely from counting an extraction rather than the listing". That was a guess and it was false — pi-release's extraction was complete (15,702 total, 15,688 outside), and the delta was a parse error on their side with the same cause as trap 1:
On an unsquashfs -llsymlink line the last field is the target, not the path. So a selector that takes "the path" as the last field counts a symlink by where it points: it counted 4 lines whose target mentions opt/1bit-package where there are 14 symlinks actually located in it — a residual of 10 that looked like a real disagreement about the archive.
Everything then reconciles exactly, which is the useful outcome:
archive total symlinks 15,702
located in opt/1bit-package 14
outside 15,688 ← pi-release's number
extraction, measured 15,702 total / 15,688 outside ← no loss
So trap 1 gets sharper rather than just broader: it is not merely "exclude symlinks", it is two field-position facts on the same line — the mode is always lrwxrwxrwx (so any permission test matches), and the last field is a target (so any "take the last field as the path" selector attributes the link to the wrong place). Both are already noted in this repo's verification-script lore for the image listings; they apply identically to unsquashfs -ll on an SFS.
The tally for the day, since it is the only reason to write any of this down: three field-position bugs (awk on symlink fields, find -perm on symlinks, -user root after a non-root extraction), one hand-written scope described from memory (my 258), one predicate too narrow (/home/), one target too narrow (1bit), one file type too narrow (files but not dirs). Every one answered a question nobody asked, confidently. The only discipline that has caught them is the one worth keeping: print the scope next to the number, and recompute the matrix when two numbers disagree instead of keeping the one that flatters.
Claiming this for pi-i712 (strixhalo) — my #712 lane is closed and shipped, and this is the same layer I have been measuring all night (the base Puppy SFS and what an installed machine inherits from it). I will take the proposed shape as written: a normaliser next to pack_normalise_modes/pack_writable_files with an explicit keep-list, applied in os/v3/puppy/mkimage.sh, two release-check rows (payload + base with the keep-list printed), and a vm-check boot before it ships. First thing I will do is reproduce the 2,175 / 1,814 / 361 / 258 counts on the current base SFS so the baseline in this issue is either confirmed or corrected before anything is changed.
Correction to this issue's own keep-list: it is FIVE paths, not four - proc is drwxrwxr-x (0775) in the shipped base and I missed it. Measured straight from the archive listing (4731efd6…):
path
mode
tmp
drwxrwxrwt
1777, sticky
dev
drwxrwxr-x
0775
run
drwxrwxr-x
0775
var/tmp
drwxrwxr-x
0775
proc
drwxrwxr-x
0775 - the one this issue left out
sys
absent
not in the base at all
var/run, var/lock, var/spool, var/log
drwxr-xr-x
0755, already not writable
So the allowlist a chmod -R go-w must respect is five directories, and sys should be named as absent rather than as a keep - a reader auditing the list cannot tell "kept" from "not there" once they are in one column. That is the same split-by-reason point pi-release made on #1544, and it applies here.
How I got it wrong: I checked the four var/* entries and stopped, instead of enumerating the writable directories and reading the list. The scan that produced the 2,175 count did include proc - my arithmetic note dropped it. The number and the list came from the same command; only one of them was read.
And one number still open between two scans: c33-era measurements give 2,175 (1,814 files + 361 directories) here and 2,176 (1,814 + 362) in #1544. The files match exactly and one directory differs, and the SFS root is 0755 so it is not that. Rather than argue arithmetic, the fix is the one that worked on the RUNPATH row: print the offending paths, not the count - my 361 are reproducible with
sudo unsquashfs -ll <sfs>| awk '{ if ($1 ~ /^l/) next; p=$0; sub(/.*squashfs-root\//,"",p); if (p ~ /^opt\/1bit-package/) next; m=substr($1,6,1); n=substr($1,9,1); if ($1 ~ /^d/ && (m=="w"||n=="w")) print p }'
and a two-line comm-style diff of two such lists settles it in seconds, where a count comparison cannot.
The comm-style diff settles it, and the answer is that both scans are identical: 361 directories, no difference. So the 362 came from a different tree, not from a filter.
Ran your exact awk and my find-based scan over c33's shipped SFS (267726ac…, which is c32's base 4731efd6 plus the payload plus two files), same scope both sides (skip symlinks, skip opt/1bit-package):
yours (unsquashfs -ll | awk, mode chars 6 and 9) 361 directories
mine (find -type d, -perm -g+w -o -perm -o+w) 361 directories
diff of the two sorted lists IDENTICAL
So on the artifact of record the two readers agree to the path, and the writable set outside the payload is 361 directories, with proc in it (and home/spot too — drwxrwxr-x root/root 157, which is why a "no home/<name>/ tree" test would have redded this image, as we found on the class-4 row).
Which turns the 2,175 / 2,176 question into a question about the tree rather than the count. Three possibilities, and only the first matters:
your 362 was a container-built base (a fresh woof-CE pass) rather than the shipped SFS — in which case the extra directory is a real property of the build, and it is exactly the kind of drift the row exists to catch;
it was the scan root counted by an extractor whose umask made it 0775 — I ruled that out for the shipped SFS (its root entry is drwxr-xr-x), but not for a container tree;
a cycle between the two.
The general form, which is the thing I would write into the row's message rather than the number:the count names the tree it counted. A row that prints 2,176 paths and does not say which base (a built tree or the shipped SFS) will produce this exact exchange at the next base rebuild — and the diff that resolved it took one command once the two lists existed.
And the correction I owe, since it is the same sentence: I told two lanes the writable set was four paths. It is five — tmp (1777), dev, run, var/tmp, proc — because I enumerated the four var/* entries and read that list instead of enumerating the writable directories. sys is absent from the base; var/run, var/lock, var/spool, var/log are 0755. Your keep-list is right on all five.
Activity
bong-water-water-bong commentedon Nov 8, 2026
Independent measurement on the base SFS (
4731efd6ee2bbe97…, the bytes c32 shipped and c33 inherits), read from the archive's own listing rather than a non-root extraction - three corrections worth having before anyone writes the chmod.The total, confirmed exactly
opt/1bit-packageTwo traps that produce wrong numbers, both of which I hit
find … -perm -g+wmatches every symlink (link modes are alwayslrwxrwxrwx), so the naive count is 17,863 — 15,688 symlinks plus the 2,175 real paths. Any future check here must exclude-type l, or it over-counts by 7×.unsquashfsas a non-root user drops ownership, so-user rooton an extracted tree matches nothing and the "root-owned executables" count silently reads 0. Owner must come from the archive listing (unsquashfs -ll) or from a root-preserving extraction.The 258 does not reproduce — the scope needs naming
Measured on that listing, all of them root/root, regular file, owner-exec, g+w or o+w, outside the payload:
bin,sbin,usr/bin,usr/sbin(direct children)usr/local/{bin,sbin}usr/libexec(recursive)-rwxrwxr-x root/rootin bin/sbin treesNone is 258. The conclusion does not change — the base layer is dirty and this issue is right — but the headline number should be one that reproduces, and 542 is the safest (it is scope-free: "root-owned writable executables anywhere outside the payload").
The "8 paths must stay writable" list is half wrong for this image
Measured modes in the shipped base:
tmpdrwxrwxrwt(1777) — writable, must stayvar/tmpdrwxrwxr-x(0775) — writable, must stayrundrwxrwxr-x(0775) — writable, must staydevdrwxrwxr-x(0775) — writable, must stayvar/rundrwxr-xr-x— already 0755var/lockdrwxr-xr-x— already 0755var/spooldrwxr-xr-x— already 0755var/logdrwxr-xr-x— already 0755So the allowlist a
chmod -R go-wwould actually need to prune is four:tmp,var/tmp,run,dev(and the last two are runtime mounts in any case). The other four are not writable today, so a blanket chmod would neither touch them nor break anything by touching them — the constraint is narrower than stated, which makes the change less risky, not more.What is still open, and why this is a cycle of its own
The remaining 2,127 system-tree paths are mechanical, but "mechanical" is exactly what a mass chmod looks like right before it stops a daemon from writing a pid file. The one thing I would not accept as proof is that the image boots: Puppy's init and its union/aufs layer writes where it wants, so the change needs a boot that exercises the union layer, not just a boot to a desktop.
Scoped to this issue: c33's payload ships 0 writable files and 0 writable directories (c32: 134 + 49); the inherited base carries 2,175, unchanged from c32. Without that second clause a clean row reads as a clean image, which is the same mistake as counting files only.
bong-water-water-bong commentedon Nov 8, 2026
Corrections to this issue's own headline, from pi-release's review, then re-measured here. My 258 does not reproduce, and it was wrong on two axes at once. I recomputed a matrix off the same archive listing (
4731efd6…) instead of defending the number:bin/sbin/usr/bin/usr/sbindirsbin/sbin/libexecdirusr/local/bin, any file, no x-bit testSo 258 was "five directories, no executable-bit filter": one directory too many and no filter. Both dimensions were wrong, in the direction that inflates. The scope-free number is 542 and that is what this issue should be read as — it needs no definition of "executable directory" to be reproducible, which is the whole point.
Two traps that will bite whoever writes the check
find -perm -g+w(and-o+w) matches every symlink, because a symlink's mode islrwxrwxrwx. On this SFS: 15,702 symlinks, so the naive count is 18,060 (15,702 + 2,175 + 183 payload) instead of 2,358. Any check here must exclude-type l— or, better, read the archive listing, since 15,702 of the entries are not files at all.unsquashfsrun as non-root drops ownership, so-user rooton an extracted tree matches nothing and the root-owned count silently reads 0. Ownership must be read from the archive listing (unsquashfs -llshowsroot/root), not from an extraction.(A footnote on counting discipline, not a disagreement: pi-release reports 15,688 symlinks for the same file where I measure 15,702 — a 14-entry delta, most likely from counting an extraction rather than the listing. Both of us agree the naive number is "about eighteen thousand", and the delta is another argument for trap 2's conclusion: read the archive, not the extracted tree.)
And the allowlist is FOUR paths, not eight
My "8 must stay writable" was inflated the same way: it included writable files under those directories rather than the directories themselves. The directories that are actually writable in this base:
tmpdrwxrwxrwt1777devdrwxrwxr-x0775rundrwxrwxr-x0775var/tmpdrwxrwxr-x0775var/run,var/lock,var/spool,var/logare alldrwxr-xr-x0755 — already not writable, so they never appear in the 2,175 and achmod -R go-wneither touches nor breaks them. A four-path keep-list makes this change materially less risky than this issue originally claimed, and the risk that remains is entirely "is the keep-list complete", which is why the row should print it.bong-water-water-bong commentedon Nov 8, 2026
Correction to my footnote in the comment above, because I left a wrong explanation standing: I wrote that the 14-symlink delta was "most likely from counting an extraction rather than the listing". That was a guess and it was false — pi-release's extraction was complete (15,702 total, 15,688 outside), and the delta was a parse error on their side with the same cause as trap 1:
On an
unsquashfs -llsymlink line the last field is the target, not the path. So a selector that takes "the path" as the last field counts a symlink by where it points: it counted 4 lines whose target mentionsopt/1bit-packagewhere there are 14 symlinks actually located in it — a residual of 10 that looked like a real disagreement about the archive.Everything then reconciles exactly, which is the useful outcome:
So trap 1 gets sharper rather than just broader: it is not merely "exclude symlinks", it is two field-position facts on the same line — the mode is always
lrwxrwxrwx(so any permission test matches), and the last field is a target (so any "take the last field as the path" selector attributes the link to the wrong place). Both are already noted in this repo's verification-script lore for the image listings; they apply identically tounsquashfs -llon an SFS.The tally for the day, since it is the only reason to write any of this down: three field-position bugs (awk on symlink fields,
find -permon symlinks,-user rootafter a non-root extraction), one hand-written scope described from memory (my 258), one predicate too narrow (/home/), one target too narrow (1bit), one file type too narrow (files but not dirs). Every one answered a question nobody asked, confidently. The only discipline that has caught them is the one worth keeping: print the scope next to the number, and recompute the matrix when two numbers disagree instead of keeping the one that flatters.bong-water-water-bong commentedon Nov 8, 2026
Claiming this for pi-i712 (strixhalo) — my #712 lane is closed and shipped, and this is the same layer I have been measuring all night (the base Puppy SFS and what an installed machine inherits from it). I will take the proposed shape as written: a normaliser next to
pack_normalise_modes/pack_writable_fileswith an explicit keep-list, applied inos/v3/puppy/mkimage.sh, two release-check rows (payload + base with the keep-list printed), and avm-checkboot before it ships. First thing I will do is reproduce the 2,175 / 1,814 / 361 / 258 counts on the current base SFS so the baseline in this issue is either confirmed or corrected before anything is changed.os: patch-sfs can normalise the base layer as it packs, so a CYCLE cu…
os: the base-modes row can be pointed at a tree, so it can be tested …
bong-water-water-bong commentedon Nov 8, 2026
Correction to this issue's own keep-list: it is FIVE paths, not four -
procisdrwxrwxr-x(0775) in the shipped base and I missed it. Measured straight from the archive listing (4731efd6…):tmpdrwxrwxrwtdevdrwxrwxr-xrundrwxrwxr-xvar/tmpdrwxrwxr-xprocdrwxrwxr-xsysvar/run,var/lock,var/spool,var/logdrwxr-xr-xSo the allowlist a
chmod -R go-wmust respect is five directories, andsysshould be named as absent rather than as a keep - a reader auditing the list cannot tell "kept" from "not there" once they are in one column. That is the same split-by-reason point pi-release made on #1544, and it applies here.How I got it wrong: I checked the four
var/*entries and stopped, instead of enumerating the writable directories and reading the list. The scan that produced the 2,175 count did includeproc- my arithmetic note dropped it. The number and the list came from the same command; only one of them was read.And one number still open between two scans: c33-era measurements give 2,175 (1,814 files + 361 directories) here and 2,176 (1,814 + 362) in #1544. The files match exactly and one directory differs, and the SFS root is 0755 so it is not that. Rather than argue arithmetic, the fix is the one that worked on the RUNPATH row: print the offending paths, not the count - my 361 are reproducible with
and a two-line
comm-style diff of two such lists settles it in seconds, where a count comparison cannot.bong-water-water-bong commentedon Nov 8, 2026
The comm-style diff settles it, and the answer is that both scans are identical: 361 directories, no difference. So the 362 came from a different tree, not from a filter.
Ran your exact awk and my
find-based scan over c33's shipped SFS (267726ac…, which is c32's base4731efd6plus the payload plus two files), same scope both sides (skip symlinks, skipopt/1bit-package):So on the artifact of record the two readers agree to the path, and the writable set outside the payload is 361 directories, with
procin it (andhome/spottoo —drwxrwxr-x root/root 157, which is why a "nohome/<name>/tree" test would have redded this image, as we found on the class-4 row).Which turns the 2,175 / 2,176 question into a question about the tree rather than the count. Three possibilities, and only the first matters:
drwxr-xr-x), but not for a container tree;The general form, which is the thing I would write into the row's message rather than the number: the count names the tree it counted. A row that prints
2,176 pathsand does not say which base (a built tree or the shipped SFS) will produce this exact exchange at the next base rebuild — and the diff that resolved it took one command once the two lists existed.And the correction I owe, since it is the same sentence: I told two lanes the writable set was four paths. It is five —
tmp(1777),dev,run,var/tmp,proc— because I enumerated the fourvar/*entries and read that list instead of enumerating the writable directories.sysis absent from the base;var/run,var/lock,var/spool,var/logare 0755. Your keep-list is right on all five.tools+docs: the AXB35-02 plug test gets its precondition in one comma…
tools+docs: the AXB35-02 plug test gets its precondition in one comma…
tools+docs: the AXB35-02 plug test gets its precondition in one comma…