keyring: support filesystem keyring with v1 encryption policies

Linux v5.4 and later allows fscrypt keys to be added/removed directly
to/from the filesystem via the new ioctls FS_IOC_ADD_ENCRYPTION_KEY and
FS_IOC_REMOVE_ENCRYPTION_KEY.  Among other benefits, these fix the key
visibility problems that many users have been running into, where system
services and containers can't access encrypted files.

Allow the user to opt-in to using these new ioctls for their existing
encrypted directories by setting in their /etc/fscrypt.conf:

"use_fs_keyring_for_v1_policies": true

Note that it can't really be on by default, since for v1 policies the
ioctls require root, whereas user keyrings don't.  I.e., setting this to
true means that users will need to use 'sudo fscrypt unlock', not
'fscrypt unlock'.  v2 policies won't have this restriction.

Add keyring package

In preparation for introducing support for the new filesystem-level
keyrings, move the existing user keyring management code from
security/keyring.go and crypto/crypto.go into a new package, 'keyring'.

This package provides functions AddEncryptionKey, RemoveEncryptionKey,
and GetEncryptionKeyStatus which delegate to either the filesystem
keyring (added by a later patch) or to the user keyring.  This provides
a common interface to both types of keyrings, to the extent possible.

README.md: document /etc/fscrypt.conf

keyring: fix permission denied accessing user keyring (#177)

When userKeyringIDLookup() looks up a user keyring, it links it into the
process keyring to ensure that the process retains the "possessor
privileges" over the user keyring, then caches the user keyring's ID.

Unfortunately, this use of the process keyring randomly fails because Go
creates threads before even init() and main() are run, and then can run
code on them later.  Since the kernel doesn't create the process keyring
until userspace requests it and the process keyring is actually a
per-thread property that's only inherited by new threads, different
threads in a Go process may see different process keyrings.

Fix this by removing the user keyring cache, switching from the process
keyring to the thread keyring, and using LockOSThread() to pin the
goroutine to an OS thread while needed to perform a keyring operation.

Resolves https://github.com/google/fscrypt/issues/176

README.md: update output to match reality

Update the example output in the README to match reality.

Also make a few other updates to the examples to take into account that
'fscrypt purge' now drops caches by default, and that the root
filesystem doesn't need to support encryption if the encrypted
directories are being created on a different filesystem.

Resolves https://github.com/google/fscrypt/issues/62

Merge pull request #172 from ebiggers/login-passphrase-doc-fix

README.md: remove obsolete warning about changing login passphrase

README.md: remove obsolete warning about changing login passphrase

For some time now, fscrypt actually does re-wrap a user's login
protector when their login passphrase changes, provided that the PAM
configuration is correct.  Remove the obsolete paragraph.

Update https://github.com/google/fscrypt/issues/51

cmd/fscrypt: preserve paragraphs in wrapText()

Preserve empty lines rather than squashing them into a single space.
This allows having command descriptions that contain multiple
paragraphs.  This also eliminates the need to have a special case for
ordered lists.

Rename some variables from 'target' to 'targetUser'

Refer to the target User as 'targetUser' rather than simply 'target'.
This will help avoid confusion when we add support for the filesystem
keyring, since then the Mount will also be a "target".

Use latest fscrypt declarations from sys/unix

Use the new name for fscrypt constants and structures which have been
given a new name.

Also use the named constant for the DIRECT_KEY fscrypt policy flag.

No change in behavior.  This is just preparing for future work.

Upgrade to latest golang.org/x/sys module

Upgrade to get the new fscrypt declarations from Linux v5.4.

cmd/fscrypt: adjust message when listing protector sources

Saying "Your data can be protected with one of the following sources" is
ambiguous because it could be interpreted to mean that an encrypted
directory can only have one type of protector.  In fact, an encrypted
directory can have multiple protectors, and they can be of any type.

Update https://github.com/google/fscrypt/issues/164

Allow filesystem links to contain leading/trailing whitespace

To make manually editing linked protectors slightly more user-friendly,
automatically strip any leading or trailing whitespace.  E.g. treat
"UUID=3a6d9a76-47f0-4f13-81bf-3332fbe984fb\n" the same as
"UUID=3a6d9a76-47f0-4f13-81bf-3332fbe984fb".

Update https://github.com/google/fscrypt/issues/115

travis: set GO111MODULE=on for 'go get'

Ensure that the environmental variable GO111MODULE is set to "on" when
running 'go get'.  This fixes a CI failure with Go 1.11 and 1.12.

Merge pull request #162 from josephlr/master

Add Code of Conduct

Add Code of Conduct

This project has always been under a CoC, but I forgot to incude the
file when creating the repo. See also: https://opensource.google/conduct/

Signed-off-by: Joe Richey <joerichey@google.com>

Merge pull request #154 from ebiggers/bind-mounts

Store fscrypt metadata in only one place per filesystem, so that bind
mounts don't get their own metadata directories (which was ambiguous,
as the same file may be accessible via multiple mounts).

Also correctly set the source device for root filesystems mounted via
the kernel command line, and fix creating linked protectors to such
filesystems.

filesystem: add unit tests for loadMountInfo()

Add a version of loadMountInfo() that takes an io.Reader parameter to
allow injecting a custom mountinfo file, then add some unit tests.

filesystem: handle bind mounts properly

Currently, fscrypt treats bind mounts as separate filesystems.  This is
broken because fscrypt will look for a directory's encryption policy in
different places depending on which mount it's accessed through.  This
forces users to create an fscrypt metadata directory at every bind
mount, and to copy fscrypt metadata around between mounts.

Fix this by storing fscrypt metadata only at the root of the filesystem.

To accomplish this:

- Make mountsByDevice store only a single Mount per filesystem, rather
  than multiple.  For this Mount, choose a mount of the full filesystem
  if available, preferably a read-write mount.  If the filesystem has
  only bind mounts, store a nil entry in mountsByDevice so we can show a
  proper error message later.

- Change FindMount() and GetMount() to look up the Mount by device
  number rather than by path, so that they don't return different Mounts
  depending on which path is used.

- Change AllFilesystems() to not return bind mounts.

- Due to the above changes, the mountsByPath map is no longer needed
  outside of loadMountInfo().  So make it a local variable there.

Resolves https://github.com/google/fscrypt/issues/59

filesystem: make link handling more robust

The previous patch fixed making linked protectors to /dev/root, by
setting Mount.Device to the real device node rather than /dev/root.

That's good, but it also hints that the linked protector handling is
unnecessarily fragile, as it relies on the device node name matching
exactly.  The Linux kernel allows the same device to have multiple
device nodes, and path comparisons are slow and error-prone in general.

Change it to compare the device number instead.

filesystem: get correct device for kernel-mounted rootfs

A root filesystem mounted via the kernel command line always has a
source of "/dev/root", which isn't a real device node.  This makes
fscrypt think this filesystem doesn't have a source device, which breaks
creating login passphrase-protected directories on other filesystems:

    fscrypt encrypt: filesystem /: no device for mount "/": system error: cannot create filesystem link

This also makes 'fscrypt status' show a blank source device:

    MOUNTPOINT  DEVICE          FILESYSTEM  ENCRYPTION     FSCRYPT
    /                           ext4        supported      Yes

To fix this case, update loadMountInfo() to map the device number to the
device name via sysfs rather than use the mount source field.

filesystem: add device number utilities

Add a utility type and functions for handling device numbers.

filesystem: skip unnecessary mountpoint canonicalization

The kernel always shows mountpoints as absolute paths without symlinks,
so there's no need to canonicalize them in userspace.

filesystem: switch to using /proc/self/mountinfo

Change loadMountInfo() to load the mounts directly from
/proc/self/mountinfo, rather than use the mntent.h C library calls.

This is needed for correct handling of bind mounts and of "/dev/root",
since /proc/self/mountinfo has extra fields which show the mounted
subtree and the filesystem's device number.  /proc/mounts lacks these
fields, and the C library calls can't provide them.

To start, this patch just switches to using /proc/self/mountinfo,
without doing anything with the extra fields yet.

As a bonus, this eliminates all C code in mountpoint.go.

filesystem: rename getMountInfo() to loadMountInfo()

Make it clearer that this function loads data into global data
structures, and doesn't return anything.

filesystem: remove Mount.Options

fscrypt doesn't currently do anything with the mount options, so remove
them from the Mount structure for now.

filesystem: rename Mount.Filesystem to Mount.FilesystemType

Make it clear that this refers to a type of filesystem such as "ext4",
rather than to a specific filesystem instance.

Manage tool versioning with Go modules (#161)

See: https://github.com/golang/go/wiki/Modules#how-can-i-track-tool-dependencies-for-a-module

The tool code is never actually built, but the versions are still lock
in `go.mod` and `go.sum`. We can also simplify the Makefile.

Delete vendored code and update CI to Go 1.13 (#158)

As the Go community transitions to using the modules ecosystem,
we want to only support one way of managing dependencies.
So this change moves to only using Go modules for dependency management.

This means that our effective minimum Go version increases to Go 1.11.
To account for this, we also update:
  - the documentation
  - Makefile
  - CI scripts

Added capacity to slice creation, when capacity is known (#159)

Simple optimization to reduce memory allocations and copying when appending.

actions/config: ensure config file is created with mode 0644 (#152)

If the user has set a restrictive umask, e.g. 0077, then
/etc/fscrypt.conf would be created without the world-readable bit set.
Fix it by overriding the umask when creating the file.

Resolves https://github.com/google/fscrypt/issues/151

Merge pull request #150 from ebiggers/allow-metadata-symlink

filesystem: allow .fscrypt to be a symlink

filesystem: Move test-only code to test files

This makes it easier to understand which code is actually invoked by the
command-line tool.

filesystem: allow .fscrypt to be a symlink

Support the case where the user has a read-only root filesystem (e.g.
with OSTree) and had previously created a symlink /.fscrypt pointing to
a writable location, so that login protectors can be created there.

Resolves https://github.com/google/fscrypt/issues/131

cmd/fscrypt: make 'fscrypt setup' create /.fscrypt (#149)

Make the global setup command also create the metadata directory at
/.fscrypt, since that's where login protectors are placed, even when the
actual encrypted directories are on a different filesystem.

Resolves https://github.com/google/fscrypt/issues/129

Prepare v0.2.5 (#147)

Also add go version attrubute to go.mod

cmd/fscrypt: show encryption options with 'fscrypt status DIR' (#145)

Show the encryption options when running 'fscrypt status' on a
directory.  E.g.:

Policy:   490515286453d3f7
Options:  padding:32 contents:Adiantum filenames:Adiantum
Unlocked: Yes

writeDataAtomic() fixes (#140)

* filesystem: ensure data is persisted before returning success

Sync the temporary file before renaming it, to ensure that after a
crash, the destination file isn't zero-length or otherwise incomplete.

Also sync the directory after the rename, to ensure the rename has been
persisted before returning success.

* filesystem: don't use fixed temporary file name

Using a fixed temporary file name in a world-writable sticky directory
is problematic since another user can create the file first.

Use ioutil.TempFile() to do it properly.  It uses O_EXCL under the hood
to ensure the file is newly created.

Fix various typos and grammatical errors (#141)

These were found by a combination of manual review and a custom script
that checks for common errors.

Also removed an outdated sentence from the comment for setupBefore().

.gitignore: add tags file (#144)

Add the tags file to .gitignore, for developers using
https://github.com/jstemmer/gotags.

Merge pull request #142 from ebiggers/goimports

Fix 'make format'-related CI failure

Run 'make format' with latest version of goimports

This fixes a CI failure, caused by goimports changing how it formats the
imports.

Makefile: exclude generated files from 'make format'

Due to a goimports update, 'make format' is now changing metadata.pb.go.
But this fix can't be committed because this file is generated by
'make gen'.

Fix this by not formatting generated files.

README.md: improve documentation for moving files into encrypted dirs (#138)

Resolves https://github.com/google/fscrypt/issues/124

README.md: improve documentation for kernel and filesystem support (#137)

Resolves https://github.com/google/fscrypt/issues/117
Resolves https://github.com/google/fscrypt/issues/127

README.md: improve documentation of GRUB limitation (#136)

Resolves https://github.com/google/fscrypt/issues/58

cmd/fscrypt: give newly encrypted directories mode 0700 (#134)

Resolves https://github.com/google/fscrypt/issues/132

Update Travis to use Ubuntu 18.04 and Go 1.12 (#135)

Fixes CI issues

Merge pull request #122 from google/pam

Install pam modules/configs to the right location

Update the README with correct install information

Install pam modules/configs to the right location

Per the FHS, manually installed programs should go under /usr/local.
This change also makes it easier to change the global installation
prefix. For example, package managers should set PREFIX=/usr

Merge pull request #119 from ebiggers/adiantum

Add support for the Adiantum encryption mode

Merge pull request #120 from google/tools

Makefile: migrate from megacheck to staticcheck

Makefile: migrate from megacheck to staticcheck

This fixes travis issues as well as moving us off of deprecated tooling

Add support for the Adiantum encryption mode

Add Adiantum support to the fscrypt userspace tool.  Supported in the
kernel since v5.0-rc1, Adiantum is a length-preserving encryption mode
based primarily on XChaCha12.  It is fast even on CPUs without AES
instructions.  Unlike XTS it is also a wide-block encryption mode.
Adiantum is supported for both contents and filenames encryption.

For Adiantum encryption policies, also make the fscrypt tool provide the
new DIRECT_KEY flag, which further improves performance by requesting
that all files be encrypted directly with the policy key.  This takes
advantage of Adiantum's support for long tweaks.

See the kernel commit "fscrypt: add Adiantum support"
(https://git.kernel.org/torvalds/c/8094c3ceb21ad938) for more details.

Merge pull request #114 from ebiggers/fix-make-gen

Makefile: use a specific protoc-gen-go version

Makefile: use a specific protoc-gen-go version

'make gen' no longer works because it uses the git version of
protoc-gen-go, which is no longer compatible with the latest released
version of github.com/golang/protobuf/proto, which we're using.  Freeze
the protoc-gen-go version so that it keeps working.

Merge pull request #110 from wjt/patch-1

README: fix "Debain" typo

README: fix "Debain" typo

Merge pull request #106 from fristonio/spell-check

feat(spell-check): add make command for spell check.

feat(spell-check): add make command for spell check.

* Remove spelling mistakes in the repository
* Add travis script to check for typos.
* Add command to Makefile to check for typos.
* Fixes #71

Merge pull request #107 from google/mod

Use Go Modules and support Go 1.11 building

Update Travis to use go 1.10 and go 1.11

Bump Travis Version

Fix golint to not need a special fork

Go 1.11 gofmt updatae

Use proto.Equal instead of reflect.DeepEquals

Update Protoc Compiler to 3.6.1

Update dependancies to lastest version

Don't vendor helper tooling

Remove dep from documentation and travis build

Transition from dep to golang's module system

Merge pull request #105 from google/release

Release: v0.2.4

Release: v0.2.4

Merge pull request #103 from google/pam

Cleanup privilege dropping/raising in pam_fscrypt

Improve debug and error output for pam_fscrypt

Ensure keyring privilege changes are reversible

This change makes sure that, when we set the ruid and euid in order to
get the user keyring linked into the current process keyring, we will
always be able to reverse these changes (using a suid of 0).

This fixes an issue where "su <user>" would result in a system error
when called by an unprivileged user. It also explains exactly how and
why we are making these privilege changes.

Ensure setting user privileges is reversible

This change makes sure after dropping then elevating privileges for a
process, the euid, guid, and groups are all the same as they were
originally. This significantly simplifies the privilege logic.

This fixes CVE-2018-6558, which allowed an unprivleged user to gain
membership in the root group (gid 0) due to the groups not being
properly reset in the process.

Merge pull request #104 from google/travis

Fix Travis to only use Go 1.10

Update docs to indicate v1.10 is required

Fix Travis to only use Go 1.10

Merge pull request #102 from google/mips

Use proper sizes when casting to Go slice

Use proper sizes when casting to Go slice

Addresses most of the issues in #101.

The following commands now succeed:
    GOARCH=mips go build github.com/google/fscrypt/util
    GOARCH=mipsle go build github.com/google/fscrypt/util

Merge pull request #97 from ebiggers/privileges_fix

security: drop and regain privileges in all threads

Merge pull request #96 from ebiggers/unset_item_fix

pam: return error when PAM info item is unset

security: drop and regain privileges in all threads

After enabling pam_fscrypt for "session" and creating a directory
protected with a login protector, I was no longer able to log in as that
user.  The problem is that the Go runtime is creating threads after
pam_fscrypt drops privileges, but pam_fscrypt is not re-acquiring
privileges on those threads because the Go wrappers for setreuid(),
setregid(), and setgroups() in the "sys/unix" package are using the raw
syscalls which operate on the calling thread only.

This violates glibc's assumption that all threads have the same uids and
gids, causing it to abort() the process when a later module in the PAM
stack (pam_mail in my case) tries to drop privileges using the glibc
functions.

Fix it by dropping and regaining privileges using the glibc functions
rather than the "sys/unix" functions.

This also avoids any possibility that privileges could be changed in a
thread other than the "main" one for pam_fscrypt, since the Go runtime
does not guarantee which OS-level thread runs what.

It would be nice to also exit all Go worker threads before returning
from pam_fscrypt, but the Go runtime doesn't seem to support that.

pam: return error when PAM info item is unset

pam_fscrypt is crashing with a segfault in copyIntoSecret() when using
Ctrl-C to interrupt a 'sudo' prompt.  It is dereferencing a NULL pointer
that is supposed point to the PAM_AUTHTOK item.  The problem is that the
Go code assumes pam_get_item() returns a non-success status if the item
is unset, when actually it sets the data pointer to NULL and returns
PAM_SUCCESS.

Fix it by making pam.Handle.GetItem() return an error in that case.

Clarify how to run integration tests

Also clarifies some other minor points.

Makefile: arch command is not portable

According to:
https://www.gnu.org/software/coreutils/manual/html_node/arch-invocation.html
the arch command isn't portable, so we switch to uname.

Makefile: Go/Protoc don't support arm64 big endian

Protoc: https://github.com/google/protobuf/blob/a711e3d5b4ee1dd7f9d21197dca8432a5819a64e/protoc-artifacts/build-protoc.sh#L82-L83
Go: https://github.com/golang/sys/blob/37707fdb30a5b38865cfb95e5aab41707daec7fd/unix/linux/mkall.go#L43-L79

Makefile: Fix archetecture detection

Using "arch" instead of "go env GOARCH" is more standard and doesn't
generate a warning on "sudo make install".

Merge pull request #91 from google/version

Release: v0.2.3

Release: v0.2.3

Merge pull request #90 from google/travis

travis: Fix travis bug

travis: Fix travis bug

Merge pull request #89 from google/proto

Makefile: bump protoc to most recent version

metadata: regenerate .pb.go

Makefile: bump protoc to most recent version

Merge pull request #88 from google/key

travis: Upload encrypted API key

travis: Upload encrypted API key