Received-SPF: pass (google.com: domain of linux-kernel+bounces-73862-linux.lists.archive=gmail.com@vger.kernel.org designates 147.75.80.249 as permitted sender) client-ip=147.75.80.249;
Date: Tue, 20 Feb 2024 19:25:58 -0500
From: Kent Overstreet <kent.overstreet@linux.dev>
To: James Bottomley <James.Bottomley@hansenpartnership.com>
Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, 
	lsf-pc@lists.linux-foundation.org, Christian Brauner <christian@brauner.io>, 
	=?utf-8?B?U3TDqXBoYW5l?= Graber <stgraber@stgraber.org>
Subject: Re: [LSF TOPIC] beyond uidmapping, & towards a better security model
Message-ID: <qlmv2hjwzgnkmtvjpyn6zdnnmja3a35tx4nh6ldl23tkzh5reb@r3dseusgs3x6>
References: <tixdzlcmitz2kvyamswcpnydeypunkify5aifsmfihpecvat7d@pmgcepiilpi6>
 <141b4c7ecda2a8c064586d064b8d1476d8de3617.camel@HansenPartnership.com>
Precedence: bulk
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline
In-Reply-To: <141b4c7ecda2a8c064586d064b8d1476d8de3617.camel@HansenPartnership.com>

On Mon, Feb 19, 2024 at 09:26:25AM -0500, James Bottomley wrote:
> On Sat, 2024-02-17 at 15:56 -0500, Kent Overstreet wrote:
> > AKA - integer identifiers considered harmful
> > 
> > Any time you've got a namespace that's just integers, if you ever end
> > up needing to subdivide it you're going to have a bad time.
> > 
> > This comes up all over the place - for another example, consider
> > ioctl numbering, where keeping them organized and collision free is a
> > major headache.
> > 
> > For UIDs, we need to be able to subdivide the UID namespace for e.g.
> > containers and mounting filesystems as an unprivileged user - but
> > since we just have an integer identifier, this requires complicated
> > remapping and updating and maintaining a global table.
> > 
> > Subdividing a UID to create new permissions domains should be a
> > cheap, easy operation, and it's not.
> > 
> > The solution (originally from plan9, of course) is - UIDs shouldn't
> > be numbers, they should be strings; and additionally, the strings
> > should be paths.
> > 
> > Then, if 'alice' is a user, 'alice.foo' and 'alice.bar' would be
> > subusers, created by alice without any privileged operations or
> > mucking with outside system state, and 'alice' would be superuser
> > w.r.t. 'alice.foo' and 'alice.bar'.
> > 
> > What's this get us?
> 
> I would have to say that changing kuid for a string doesn't really buy
> us anything except a load of complexity for no very real gain. 
> However, since the current kuid is u32 and exposed uid is u16 and there
> is already a proposal to make use of this somewhat in the way you
> envision,

Got a link to that proposal?

> there might be a possibility to re-express kuid as an array
> of u16s without much disruption.  Each adjacent pair could represent
> the owner at the top and the userns assigned uid underneath.  That
> would neatly solve the nesting problem the current upper 16 bits
> proposal has.

At a high level, there's no real difference between a variable length
integer, or a variable length array of integers, or a string.

But there's real advantages to getting rid of the string <-> integer
identifier mapping and plumbing strings all the way through:

 - creating a new sub-user can be done with nothing more than the new
   username version of setuid(); IOW, we can start a new named subuser
   for e.g. firefox without mucking with _any_ system state or tables

 - sharing filesystems between machines is always a pita because
   usernames might be the same but uids never are - let's kill that off,
   please

Doing anything as big as an array of integers is going to be a major
compatibiltiy break anyways, so we might as well do it right.

Either way we're going to need a mapping to 16 bit uids for
compatibility; doing this right gives userspace an incentive to get
_off_ that compatibility layer so we're not dealing with that impedence
mismatch forever.

> However, neither proposal would get us out of the problem of mount
> mapping because we'd have to keep the filesystem permission check on
> the owning uid unless told otherwise.

Not sure I follow?

We're always going to need mount mapping, but if the mount mapping is
just "usernames here get mapped to this subtree of the system username
namespace", then that potentially simplifies things quite a bit - the
mount mapping is no longer a _table_.

And it wouldn't have to be administrator assigned. Some administrator
assignment might be required for the username <-> 16 bit uid mapping,
but if those mappings are ephemeral (i.e. if we get filesystems
persistently storing usernames, which is easy enough with xattrs) then
that just becomes "reserve x range of the 16 bit uid space for ephemeral
translations".