mirror of
https://github.com/Llewellynvdm/Tomb.git
synced 2024-11-22 12:35:13 +00:00
a7190eb2e2
As debated in issue #282 Zsh introduced a bug in v5.3.1 which briefly affected our mechanism for closing tombs. The bug is fixed, but while investigating the issue @aude realised there can be a better way to apply this regex for the detection of mounted volumes on distro dependent /run/media/$USER paths. This change drops usage of the regex optional module in Zsh to use the built-in =~ comparison and improves the match using round parenthesis. It may fix the close command on some distributions.
3132 lines
102 KiB
Bash
Executable File
3132 lines
102 KiB
Bash
Executable File
#!/usr/bin/env zsh
|
|
#
|
|
# Tomb, the Crypto Undertaker
|
|
#
|
|
# A commandline tool to easily operate encryption of secret data
|
|
#
|
|
|
|
# {{{ License
|
|
|
|
# Copyright (C) 2007-2017 Dyne.org Foundation
|
|
#
|
|
# Tomb is designed, written and maintained by Denis Roio <jaromil@dyne.org>
|
|
#
|
|
# With contributions by Anathema, Boyska, Hellekin O. Wolf and GDrooid
|
|
#
|
|
# Gettext internationalization and Spanish translation is contributed by
|
|
# GDrooid, French translation by Hellekin, Russian translation by fsLeg,
|
|
# German translation by x3nu.
|
|
#
|
|
# Testing, reviews and documentation are contributed by Dreamer, Shining
|
|
# the Translucent, Mancausoft, Asbesto Molesto, Nignux, Vlax, The Grugq,
|
|
# Reiven, GDrooid, Alphazo, Brian May, TheJH, fsLeg, JoelMon and the
|
|
# Linux Action Show!
|
|
#
|
|
# Tomb's artwork is contributed by Jordi aka Mon Mort and Logan VanCuren.
|
|
#
|
|
# Cryptsetup was developed by Christophe Saout and Clemens Fruhwirth.
|
|
|
|
# This source code is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This source code is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Please refer
|
|
# to the GNU Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Public License along with
|
|
# this source code; if not, write to: Free Software Foundation, Inc.,
|
|
# 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
# }}} - License
|
|
|
|
# {{{ Global variables
|
|
|
|
typeset VERSION="2.4"
|
|
typeset DATE="Apr/2017"
|
|
typeset TOMBEXEC=$0
|
|
typeset TMPPREFIX=${TMPPREFIX:-/tmp}
|
|
# TODO: configure which tmp dir to use from a cli flag
|
|
|
|
# Tomb is using some global variables set by the shell:
|
|
# TMPPREFIX, UID, GID, PATH, TTY, USERNAME
|
|
# You can grep 'global variable' to see where they are used.
|
|
|
|
# Keep a reference of the original command line arguments
|
|
typeset -a OLDARGS
|
|
for arg in "${(@)argv}"; do OLDARGS+=("$arg"); done
|
|
|
|
# Special command requirements
|
|
typeset -a DD WIPE PINENTRY
|
|
DD=(dd)
|
|
WIPE=(rm -f)
|
|
PINENTRY=(pinentry)
|
|
|
|
# load zsh regex module
|
|
zmodload zsh/mapfile
|
|
zmodload -F zsh/stat b:zstat
|
|
|
|
# make sure variables aren't exported
|
|
unsetopt allexport
|
|
|
|
# Flag optional commands if available (see _ensure_dependencies())
|
|
typeset -i KDF=1
|
|
typeset -i STEGHIDE=1
|
|
typeset -i RESIZER=1
|
|
typeset -i SWISH=1
|
|
typeset -i QRENCODE=1
|
|
|
|
# Default mount options
|
|
typeset MOUNTOPTS="rw,noatime,nodev"
|
|
|
|
# Makes glob matching case insensitive
|
|
unsetopt CASE_MATCH
|
|
|
|
typeset -AH OPTS # Command line options (see main())
|
|
|
|
# Command context (see _whoami())
|
|
typeset -H _USER # Running username
|
|
typeset -Hi _UID # Running user identifier
|
|
typeset -Hi _GID # Running user group identifier
|
|
typeset -H _TTY # Connected input terminal
|
|
|
|
# Tomb context (see _plot())
|
|
typeset -H TOMBPATH # Full path to the tomb
|
|
typeset -H TOMBDIR # Directory where the tomb is
|
|
typeset -H TOMBFILE # File name of the tomb
|
|
typeset -H TOMBNAME # Name of the tomb
|
|
|
|
# Tomb secrets
|
|
typeset -H TOMBKEY # Encrypted key contents (see forge_key(), recover_key())
|
|
typeset -H TOMBKEYFILE # Key file (ditto)
|
|
typeset -H TOMBSECRET # Raw deciphered key (see forge_key(), gpg_decrypt())
|
|
typeset -H TOMBPASSWORD # Raw tomb passphrase (see gen_key(), ask_key_password())
|
|
typeset -H TOMBTMP # Filename of secure temp just created (see _tmp_create())
|
|
|
|
typeset -aH TOMBTMPFILES # Keep track of temporary files
|
|
typeset -aH TOMBLOOPDEVS # Keep track of used loop devices
|
|
|
|
# Make sure sbin is in PATH (man zshparam)
|
|
path+=( /sbin /usr/sbin )
|
|
|
|
# For gettext
|
|
export TEXTDOMAIN=tomb
|
|
|
|
# }}}
|
|
|
|
# {{{ Safety functions
|
|
|
|
# Wrap sudo with a more visible message
|
|
_sudo() {
|
|
local sudo_eng="[sudo] Enter password for user ::1 user:: to gain superuser privileges"
|
|
local msg="$(gettext -s "$sudo_eng")"
|
|
msg=${(S)msg//::1*::/$USER}
|
|
sudo -p "
|
|
$msg
|
|
|
|
" ${@}
|
|
}
|
|
|
|
# Cleanup anything sensitive before exiting.
|
|
_endgame() {
|
|
|
|
# Prepare some random material to overwrite vars
|
|
local rr="$RANDOM"
|
|
while [[ ${#rr} -lt 500 ]]; do
|
|
rr+="$RANDOM"
|
|
done
|
|
|
|
# Ensure no information is left in unallocated memory
|
|
TOMBPATH="$rr"; unset TOMBPATH
|
|
TOMBDIR="$rr"; unset TOMBDIR
|
|
TOMBFILE="$rr"; unset TOMBFILE
|
|
TOMBNAME="$rr"; unset TOMBNAME
|
|
TOMBKEY="$rr"; unset TOMBKEY
|
|
TOMBKEYFILE="$rr"; unset TOMBKEYFILE
|
|
TOMBSECRET="$rr"; unset TOMBSECRET
|
|
TOMBPASSWORD="$rr"; unset TOMBPASSWORD
|
|
|
|
# Clear temporary files
|
|
for f in $TOMBTMPFILES; do
|
|
${=WIPE} "$f"
|
|
done
|
|
unset TOMBTMPFILES
|
|
|
|
# Detach loop devices
|
|
for l in $TOMBLOOPDEVS; do
|
|
_sudo losetup -d "$l"
|
|
done
|
|
unset TOMBLOOPDEVS
|
|
|
|
}
|
|
|
|
# Trap functions for the _endgame event
|
|
TRAPINT() { _endgame INT }
|
|
TRAPEXIT() { _endgame EXIT }
|
|
TRAPHUP() { _endgame HUP }
|
|
TRAPQUIT() { _endgame QUIT }
|
|
TRAPABRT() { _endgame ABORT }
|
|
TRAPKILL() { _endgame KILL }
|
|
TRAPPIPE() { _endgame PIPE }
|
|
TRAPTERM() { _endgame TERM }
|
|
TRAPSTOP() { _endgame STOP }
|
|
|
|
_cat() { local -a _arr;
|
|
# read file using mapfile, newline fix
|
|
_arr=("${(f@)${mapfile[${1}]%$'\n'}}"); print "$_arr"
|
|
}
|
|
|
|
_is_found() {
|
|
# returns 0 if binary is found in path
|
|
[[ "$1" = "" ]] && return 1
|
|
command -v "$1" 1>/dev/null 2>/dev/null
|
|
return $?
|
|
}
|
|
|
|
# Identify the running user
|
|
# Set global variables _UID, _GID, _TTY, and _USER, either from the
|
|
# command line, -U, -G, -T, respectively, or from the environment.
|
|
# Also update USERNAME and HOME to maintain consistency.
|
|
_whoami() {
|
|
|
|
# Set username from UID or environment
|
|
_USER=$SUDO_USER
|
|
[[ "$_USER" = "" ]] && { _USER=$USERNAME }
|
|
[[ "$_USER" = "" ]] && { _USER=$(id -u) }
|
|
[[ "$_USER" = "" ]] && {
|
|
_failure "Failing to identify the user who is calling us" }
|
|
|
|
# Get GID from option -G or the environment
|
|
option_is_set -G \
|
|
&& _GID=$(option_value -G) || _GID=$(id -g $_USER)
|
|
|
|
# Get UID from option -U or the environment
|
|
option_is_set -U \
|
|
&& _UID=$(option_value -U) || _UID=$(id -u $_USER)
|
|
|
|
_verbose "Identified caller: ::1 username:: (::2 UID:::::3 GID::)" $_USER $_UID $_GID
|
|
|
|
# Update USERNAME accordingly if possible
|
|
# [[ $EUID == 0 && $_USER != $USERNAME ]] && {
|
|
# _verbose "Updating USERNAME from '::1 USERNAME::' to '::2 _USER::')" $USERNAME $_USER
|
|
# USERNAME=$_USER
|
|
# }
|
|
|
|
# Force HOME to _USER's HOME if necessary
|
|
local home=$(awk -F: "/^$_USER:/ { print \$6 }" /etc/passwd 2>/dev/null)
|
|
[[ $home == $HOME ]] || {
|
|
_verbose "Updating HOME to match user's: ::1 home:: (was ::2 HOME::)" \
|
|
$home $HOME
|
|
HOME=$home }
|
|
|
|
# Get connecting TTY from option -T or the environment
|
|
option_is_set -T && _TTY=$(option_value -T)
|
|
[[ -z $_TTY ]] && _TTY=$TTY
|
|
|
|
}
|
|
|
|
# Define sepulture's plot (setup tomb-related arguments)
|
|
# Synopsis: _plot /path/to/the.tomb
|
|
# Set TOMB{PATH,DIR,FILE,NAME}
|
|
_plot() {
|
|
|
|
# We set global variables
|
|
typeset -g TOMBPATH TOMBDIR TOMBFILE TOMBNAME
|
|
|
|
TOMBPATH="$1"
|
|
|
|
TOMBDIR=$(dirname $TOMBPATH)
|
|
|
|
TOMBFILE=$(basename $TOMBPATH)
|
|
|
|
# The tomb name is TOMBFILE without an extension and underscores instead of spaces (for mount and cryptsetup)
|
|
# It can start with dots: ..foo bar baz.tomb -> ..foo_bar_baz
|
|
TOMBNAME=${${TOMBFILE// /_}%.*}
|
|
[[ -z $TOMBNAME ]] && {
|
|
_failure "Tomb won't work without a TOMBNAME." }
|
|
|
|
}
|
|
|
|
# Provide a random filename in shared memory
|
|
_tmp_create() {
|
|
[[ -d "$TMPPREFIX" ]] || {
|
|
# we create the tempdir with the sticky bit on
|
|
_sudo mkdir -m 1777 "$TMPPREFIX"
|
|
[[ $? == 0 ]] || _failure "Fatal error creating the temporary directory: ::1 temp dir::" "$TMPPREFIX"
|
|
}
|
|
|
|
# We're going to add one more $RANDOM for each time someone complains
|
|
# about this being too weak of a random.
|
|
tfile="${TMPPREFIX}/$RANDOM$RANDOM$RANDOM$RANDOM" # Temporary file
|
|
umask 066
|
|
[[ $? == 0 ]] || {
|
|
_failure "Fatal error setting the permission umask for temporary files" }
|
|
|
|
[[ -r "$tfile" ]] && {
|
|
_failure "Someone is messing up with us trying to hijack temporary files." }
|
|
|
|
touch "$tfile"
|
|
[[ $? == 0 ]] || {
|
|
_failure "Fatal error creating a temporary file: ::1 temp file::" "$tfile" }
|
|
|
|
_verbose "Created tempfile: ::1 temp file::" "$tfile"
|
|
TOMBTMP="$tfile"
|
|
TOMBTMPFILES+=("$tfile")
|
|
|
|
return 0
|
|
}
|
|
|
|
# Check if a *block* device is encrypted
|
|
# Synopsis: _is_encrypted_block /path/to/block/device
|
|
# Return 0 if it is an encrypted block device
|
|
_is_encrypted_block() {
|
|
local b=$1 # Path to a block device
|
|
local s="" # lsblk option -s (if available)
|
|
|
|
# Issue #163
|
|
# lsblk --inverse appeared in util-linux 2.22
|
|
# but --version is not consistent...
|
|
lsblk --help | grep -Fq -- --inverse
|
|
[[ $? -eq 0 ]] && s="--inverse"
|
|
|
|
sudo lsblk $s -o type -n $b 2>/dev/null \
|
|
| egrep -q '^crypt$'
|
|
|
|
return $?
|
|
}
|
|
|
|
# Check if swap is activated
|
|
# Return 0 if NO swap is used, 1 if swap is used.
|
|
# Return 1 if any of the swaps is not encrypted.
|
|
# Return 2 if swap(s) is(are) used, but ALL encrypted.
|
|
# Use _check_swap in functions. It will call this function and
|
|
# exit if unsafe swap is present.
|
|
_ensure_safe_swap() {
|
|
|
|
local -i r=1 # Return code: 0 no swap, 1 unsafe swap, 2 encrypted
|
|
local -a swaps # List of swap partitions
|
|
local bone is_crypt
|
|
|
|
swaps="$(awk '/^\// { print $1 }' /proc/swaps 2>/dev/null)"
|
|
[[ -z "$swaps" ]] && return 0 # No swap partition is active
|
|
|
|
_message "An active swap partition is detected..."
|
|
for s in $=swaps; do
|
|
if _is_encrypted_block $s; then
|
|
r=2;
|
|
else
|
|
# We're dealing with unencrypted stuff.
|
|
# Maybe it lives on an encrypted filesystem anyway.
|
|
# @todo: verify it's actually on an encrypted FS (see #163 and !189)
|
|
# Well, no: bail out.
|
|
r=1; break;
|
|
fi
|
|
done
|
|
|
|
if [[ $r -eq 2 ]]; then
|
|
_success "The undertaker found that all swap partitions are encrypted. Good."
|
|
else
|
|
_warning "This poses a security risk."
|
|
_warning "You can deactivate all swap partitions using the command:"
|
|
_warning " swapoff -a"
|
|
_warning "[#163] I may not detect plain swaps on an encrypted volume."
|
|
_warning "But if you want to proceed like this, use the -f (force) flag."
|
|
fi
|
|
return $r
|
|
|
|
}
|
|
|
|
# Wrapper to allow encrypted swap and remind the user about possible
|
|
# data leaks to disk if swap is on, which shouldn't be ignored. It could
|
|
# be run once in main(), but as swap evolves, it's better to run it
|
|
# whenever swap may be needed.
|
|
# Exit if unencrypted swap is active on the system.
|
|
_check_swap() {
|
|
if ! option_is_set -f && ! option_is_set --ignore-swap; then
|
|
_ensure_safe_swap
|
|
case $? in
|
|
0|2) # No, or encrypted swap
|
|
return 0
|
|
;;
|
|
*) # Unencrypted swap
|
|
_failure "Operation aborted."
|
|
;;
|
|
esac
|
|
fi
|
|
}
|
|
|
|
# Ask user for a password
|
|
# Wraps around the pinentry command, from the GnuPG project, as it
|
|
# provides better security and conveniently use the right toolkit.
|
|
ask_password() {
|
|
|
|
local description="$1"
|
|
local title="${2:-Enter tomb password.}"
|
|
local output
|
|
local password
|
|
local gtkrc
|
|
local theme
|
|
|
|
# Distributions have broken wrappers for pinentry: they do
|
|
# implement fallback, but they disrupt the output somehow. We are
|
|
# better off relying on less intermediaries, so we implement our
|
|
# own fallback mechanisms. Pinentry supported: curses, gtk-2, qt4
|
|
# and x11.
|
|
|
|
# make sure LANG is set, default to C
|
|
LANG=${LANG:-C}
|
|
|
|
_verbose "asking password with tty=$TTY lc-ctype=$LANG"
|
|
|
|
if [[ "$DISPLAY" = "" ]]; then
|
|
|
|
if _is_found "pinentry-curses"; then
|
|
_verbose "using pinentry-curses"
|
|
output=`cat <<EOF | pinentry-curses
|
|
OPTION ttyname=$TTY
|
|
OPTION lc-ctype=$LANG
|
|
SETTITLE $title
|
|
SETDESC $description
|
|
SETPROMPT Password:
|
|
GETPIN
|
|
EOF`
|
|
else
|
|
_failure "Cannot find pinentry-curses and no DISPLAY detected."
|
|
fi
|
|
|
|
else # a DISPLAY is found to be active
|
|
|
|
# customized gtk2 dialog with a skull (if extras are installed)
|
|
if _is_found "pinentry-gtk-2"; then
|
|
_verbose "using pinentry-gtk2"
|
|
|
|
gtkrc=""
|
|
theme=/share/themes/tomb/gtk-2.0-key/gtkrc
|
|
for i in /usr/local /usr; do
|
|
[[ -r $i/$theme ]] && {
|
|
gtkrc="$i/$theme"
|
|
break
|
|
}
|
|
done
|
|
[[ "$gtkrc" = "" ]] || {
|
|
gtkrc_old="$GTK2_RC_FILES"
|
|
export GTK2_RC_FILES="$gtkrc"
|
|
}
|
|
output=`cat <<EOF | pinentry-gtk-2
|
|
OPTION ttyname=$TTY
|
|
OPTION lc-ctype=$LANG
|
|
SETTITLE $title
|
|
SETDESC $description
|
|
SETPROMPT Password:
|
|
GETPIN
|
|
EOF`
|
|
[[ "$gtkrc" = "" ]] || export GTK2_RC_FILES="$gtkrc_old"
|
|
|
|
# TODO QT4 customization of dialog
|
|
elif _is_found "pinentry-qt4"; then
|
|
_verbose "using pinentry-qt4"
|
|
|
|
output=`cat <<EOF | pinentry-qt4
|
|
OPTION ttyname=$TTY
|
|
OPTION lc-ctype=$LANG
|
|
SETTITLE $title
|
|
SETDESC $description
|
|
SETPROMPT Password:
|
|
GETPIN
|
|
EOF`
|
|
|
|
# TODO X11 customization of dialog
|
|
elif _is_found "pinentry-x11"; then
|
|
_verbose "using pinentry-x11"
|
|
|
|
output=`cat <<EOF | pinentry-x11
|
|
OPTION ttyname=$TTY
|
|
OPTION lc-ctype=$LANG
|
|
SETTITLE $title
|
|
SETDESC $description
|
|
SETPROMPT Password:
|
|
GETPIN
|
|
EOF`
|
|
|
|
else
|
|
|
|
if _is_found "pinentry-curses"; then
|
|
_verbose "using pinentry-curses"
|
|
|
|
_warning "Detected DISPLAY, but only pinentry-curses is found."
|
|
output=`cat <<EOF | pinentry-curses
|
|
OPTION ttyname=$TTY
|
|
OPTION lc-ctype=$LANG
|
|
SETTITLE $title
|
|
SETDESC $description
|
|
SETPROMPT Password:
|
|
GETPIN
|
|
EOF`
|
|
else
|
|
_failure "Cannot find any pinentry: impossible to ask for password."
|
|
fi
|
|
|
|
fi
|
|
|
|
fi # end of DISPLAY block
|
|
|
|
# parse the pinentry output
|
|
for i in ${(f)output}; do
|
|
[[ "$i" =~ "^ERR.*" ]] && {
|
|
_warning "Pinentry error: ::1 error::" ${i[(w)3]}
|
|
print "canceled"
|
|
return 1
|
|
}
|
|
|
|
# here the password is found
|
|
[[ "$i" =~ "^D .*" ]] && password="${i##D }";
|
|
done
|
|
|
|
[[ "$password" = "" ]] && {
|
|
_warning "Empty password"
|
|
print "empty"
|
|
return 1
|
|
}
|
|
|
|
print "$password"
|
|
return 0
|
|
}
|
|
|
|
|
|
|
|
# Check if a filename is a valid tomb
|
|
is_valid_tomb() {
|
|
_verbose "is_valid_tomb ::1 tomb file::" $1
|
|
|
|
# First argument must be the path to a tomb
|
|
[[ -z "$1" ]] && {
|
|
_failure "Tomb file is missing from arguments." }
|
|
|
|
_fail=0
|
|
# Tomb file must be a readable, writable, non-empty regular file.
|
|
# If passed the "ro" mount option, the writable check is skipped.
|
|
[[ ! -w "$1" ]] && [[ $(option_value -o) != *"ro"* ]] && {
|
|
_warning "Tomb file is not writable: ::1 tomb file::" $1
|
|
_fail=1
|
|
}
|
|
_verbose "tomb file is readable"
|
|
|
|
[[ ! -f "$1" ]] && {
|
|
_warning "Tomb file is not a regular file: ::1 tomb file::" $1
|
|
_fail=1
|
|
}
|
|
_verbose "tomb file is a regular file"
|
|
|
|
[[ ! -s "$1" ]] && {
|
|
_warning "Tomb file is empty (zero length): ::1 tomb file::" $1
|
|
_fail=1
|
|
}
|
|
_verbose "tomb file is not empty"
|
|
|
|
# no more checking on the uid
|
|
# _uid="`zstat +uid $1`"
|
|
# [[ "$_uid" = "$UID" ]] || {
|
|
# _user="`zstat -s +uid $1`"
|
|
# _warning "Tomb file is owned by another user: ::1 tomb owner::" $_user
|
|
# }
|
|
# _verbose "tomb is not owned by another user"
|
|
|
|
[[ $_fail = 1 ]] && {
|
|
_failure "Tomb command failed: ::1 command name::" $subcommand
|
|
}
|
|
|
|
# TODO: split the rest of that function out.
|
|
# We already have a valid tomb, now we're checking
|
|
# whether we can alter it.
|
|
|
|
# Tomb file may be a LUKS FS (or we are creating it)
|
|
[[ "`file $1`" =~ "luks encrypted file" ]] || {
|
|
_warning "File is not yet a tomb: ::1 tomb file::" $1 }
|
|
|
|
_plot $1 # Set TOMB{PATH,DIR,FILE,NAME}
|
|
|
|
# Tomb already mounted (or we cannot alter it)
|
|
[[ "`mount -l |
|
|
awk -vtomb="[$TOMBNAME]" '
|
|
/^\/dev\/mapper\/tomb/ { if($7==tomb) print $1 }'`" = "" ]] || {
|
|
_failure "Tomb is currently in use: ::1 tomb name::" $TOMBNAME
|
|
}
|
|
_verbose "tomb file is not currently in use"
|
|
|
|
_message "Valid tomb file found: ::1 tomb path::" $TOMBPATH
|
|
|
|
return 0
|
|
}
|
|
|
|
# $1 is the tomb file to be lomounted
|
|
lo_mount() {
|
|
tpath="$1"
|
|
|
|
# check if we have support for loop mounting
|
|
_nstloop=`_sudo losetup -f`
|
|
[[ $? = 0 ]] || {
|
|
_warning "Loop mount of volumes is not possible on this machine, this error"
|
|
_warning "often occurs on VPS and kernels that don't provide the loop module."
|
|
_warning "It is impossible to use Tomb on this machine under these conditions."
|
|
_failure "Operation aborted."
|
|
}
|
|
|
|
_sudo losetup -f "$tpath" # allocates the next loopback for our file
|
|
|
|
TOMBLOOPDEVS+=("$_nstloop") # add to array of lodevs used
|
|
|
|
return 0
|
|
}
|
|
|
|
# print out latest loopback mounted
|
|
lo_new() { print - "${TOMBLOOPDEVS[${#TOMBLOOPDEVS}]}" }
|
|
|
|
# $1 is the path to the lodev to be preserved after quit
|
|
lo_preserve() {
|
|
_verbose "lo_preserve on ::1 path::" $1
|
|
# remove the lodev from the tomb_lodevs array
|
|
TOMBLOOPDEVS=("${(@)TOMBLOOPDEVS:#$1}")
|
|
}
|
|
|
|
# eventually used for debugging
|
|
dump_secrets() {
|
|
print "TOMBPATH: $TOMBPATH"
|
|
print "TOMBNAME: $TOMBNAME"
|
|
|
|
print "TOMBKEY len: ${#TOMBKEY}"
|
|
print "TOMBKEYFILE: $TOMBKEYFILE"
|
|
print "TOMBSECRET len: ${#TOMBSECRET}"
|
|
print "TOMBPASSWORD: $TOMBPASSWORD"
|
|
|
|
print "TOMBTMPFILES: ${(@)TOMBTMPFILES}"
|
|
print "TOMBLOOPDEVS: ${(@)TOMBLOOPDEVS}"
|
|
}
|
|
|
|
# }}}
|
|
|
|
# {{{ Commandline interaction
|
|
|
|
usage() {
|
|
_print "Syntax: tomb [options] command [arguments]"
|
|
_print "\000"
|
|
_print "Commands:"
|
|
_print "\000"
|
|
_print " // Creation:"
|
|
_print " dig create a new empty TOMB file of size -s in MiB"
|
|
_print " forge create a new KEY file and set its password"
|
|
_print " lock installs a lock on a TOMB to use it with KEY"
|
|
_print "\000"
|
|
_print " // Operations on tombs:"
|
|
_print " open open an existing TOMB (-k KEY file or - for stdin)"
|
|
_print " index update the search indexes of tombs"
|
|
_print " search looks for filenames matching text patterns"
|
|
_print " list list of open TOMBs and information on them"
|
|
_print " ps list of running processes inside open TOMBs"
|
|
_print " close close a specific TOMB (or 'all')"
|
|
_print " slam slam a TOMB killing all programs using it"
|
|
[[ $RESIZER == 1 ]] && {
|
|
_print " resize resize a TOMB to a new size -s (can only grow)"
|
|
}
|
|
_print "\000"
|
|
_print " // Operations on keys:"
|
|
_print " passwd change the password of a KEY (needs old pass)"
|
|
_print " setkey change the KEY locking a TOMB (needs old key and pass)"
|
|
_print "\000"
|
|
[[ $QRENCODE == 1 ]] && {
|
|
_print " // Backup on paper:"
|
|
_print " engrave makes a QR code of a KEY to be saved on paper"
|
|
}
|
|
_print "\000"
|
|
[[ $STEGHIDE == 1 ]] && {
|
|
_print " // Steganography:"
|
|
_print " bury hide a KEY inside a JPEG image (for use with -k)"
|
|
_print " exhume extract a KEY from a JPEG image (prints to stdout)"
|
|
}
|
|
_print "\000"
|
|
_print "Options:"
|
|
_print "\000"
|
|
_print " -s size of the tomb file when creating/resizing one (in MiB)"
|
|
_print " -k path to the key to be used ('-k -' to read from stdin)"
|
|
_print " -n don't process the hooks found in tomb"
|
|
_print " -o options passed to commands: open, lock, forge (see man)"
|
|
_print " -f force operation (i.e. even if swap is active)"
|
|
_print " -g use a GnuPG key to encrypt a tomb key"
|
|
_print " -r provide GnuPG recipients (separated by coma)"
|
|
_print " -R provide GnuPG hidden recipients (separated by coma)"
|
|
[[ $KDF == 1 ]] && {
|
|
_print " --kdf forge keys armored against dictionary attacks"
|
|
}
|
|
|
|
_print "\000"
|
|
_print " -h print this help"
|
|
_print " -v print version, license and list of available ciphers"
|
|
_print " -q run quietly without printing informations"
|
|
_print " -D print debugging information at runtime"
|
|
_print "\000"
|
|
_print "For more information on Tomb read the manual: man tomb"
|
|
_print "Please report bugs on <http://github.com/dyne/tomb/issues>."
|
|
}
|
|
|
|
|
|
# Check whether a commandline option is set.
|
|
#
|
|
# Synopsis: option_is_set -flag [out]
|
|
#
|
|
# First argument is the commandline flag (e.g., "-s").
|
|
# If the second argument is present and set to 'out', print out the
|
|
# result: either 'set' or 'unset' (useful for if conditions).
|
|
#
|
|
# Return 0 if is set, 1 otherwise
|
|
option_is_set() {
|
|
local -i r # the return code (0 = set, 1 = unset)
|
|
|
|
[[ -n ${(k)OPTS[$1]} ]];
|
|
r=$?
|
|
|
|
[[ $2 == "out" ]] && {
|
|
[[ $r == 0 ]] && { print 'set' } || { print 'unset' }
|
|
}
|
|
|
|
return $r;
|
|
}
|
|
|
|
# Print the option value matching the given flag
|
|
# Unique argument is the commandline flag (e.g., "-s").
|
|
option_value() {
|
|
print -n - "${OPTS[$1]}"
|
|
}
|
|
|
|
# Messaging function with pretty coloring
|
|
function _msg() {
|
|
local msg="$2"
|
|
local i
|
|
command -v gettext 1>/dev/null 2>/dev/null && msg="$(gettext -s "$2")"
|
|
for i in {3..${#}}; do
|
|
msg=${(S)msg//::$(($i - 2))*::/$*[$i]}
|
|
done
|
|
|
|
local command="print -P"
|
|
local progname="$fg[magenta]${TOMBEXEC##*/}$reset_color"
|
|
local message="$fg_bold[normal]$fg_no_bold[normal]$msg$reset_color"
|
|
local -i returncode
|
|
|
|
case "$1" in
|
|
inline)
|
|
command+=" -n"; pchars=" > "; pcolor="yellow"
|
|
;;
|
|
message)
|
|
pchars=" . "; pcolor="white"; message="$fg_no_bold[$pcolor]$msg$reset_color"
|
|
;;
|
|
verbose)
|
|
pchars="[D]"; pcolor="blue"
|
|
;;
|
|
success)
|
|
pchars="(*)"; pcolor="green"; message="$fg_no_bold[$pcolor]$msg$reset_color"
|
|
;;
|
|
warning)
|
|
pchars="[W]"; pcolor="yellow"; message="$fg_no_bold[$pcolor]$msg$reset_color"
|
|
;;
|
|
failure)
|
|
pchars="[E]"; pcolor="red"; message="$fg_no_bold[$pcolor]$msg$reset_color"
|
|
returncode=1
|
|
;;
|
|
print)
|
|
progname=""
|
|
;;
|
|
*)
|
|
pchars="[F]"; pcolor="red"
|
|
message="Developer oops! Usage: _msg MESSAGE_TYPE \"MESSAGE_CONTENT\""
|
|
returncode=127
|
|
;;
|
|
esac
|
|
${=command} "${progname} $fg_bold[$pcolor]$pchars$reset_color ${message}$color[reset_color]" >&2
|
|
return $returncode
|
|
}
|
|
|
|
function _message() {
|
|
local notice="message"
|
|
[[ "$1" = "-n" ]] && shift && notice="inline"
|
|
option_is_set -q || _msg "$notice" $@
|
|
return 0
|
|
}
|
|
|
|
function _verbose() {
|
|
option_is_set -D && _msg verbose $@
|
|
return 0
|
|
}
|
|
|
|
function _success() {
|
|
option_is_set -q || _msg success $@
|
|
return 0
|
|
}
|
|
|
|
function _warning() {
|
|
option_is_set -q || _msg warning $@
|
|
return 1
|
|
}
|
|
|
|
function _failure() {
|
|
typeset -i exitcode=${exitv:-1}
|
|
option_is_set -q || _msg failure $@
|
|
# be sure we forget the secrets we were told
|
|
exit $exitcode
|
|
}
|
|
|
|
function _print() {
|
|
option_is_set -q || _msg print $@
|
|
return 0
|
|
}
|
|
|
|
_list_optional_tools() {
|
|
typeset -a _deps
|
|
_deps=(gettext dcfldd wipe steghide)
|
|
_deps+=(resize2fs tomb-kdb-pbkdf2 qrencode swish-e unoconv lsof)
|
|
for d in $_deps; do
|
|
_print "`which $d`"
|
|
done
|
|
return 0
|
|
}
|
|
|
|
|
|
# Check program dependencies
|
|
#
|
|
# Tomb depends on system utilities that must be present, and other
|
|
# functionality that can be provided by various programs according to
|
|
# what's available on the system. If some required commands are
|
|
# missing, bail out.
|
|
_ensure_dependencies() {
|
|
|
|
# Check for required programs
|
|
for req in cryptsetup pinentry sudo gpg mkfs.ext4 e2fsck; do
|
|
command -v $req 1>/dev/null 2>/dev/null || {
|
|
_failure "Missing required dependency ::1 command::. Please install it." $req; }
|
|
done
|
|
|
|
# Ensure system binaries are available in the PATH
|
|
path+=(/sbin /usr/sbin) # zsh magic
|
|
|
|
# Which dd command to use
|
|
command -v dcfldd 1>/dev/null 2>/dev/null && DD=(dcfldd statusinterval=1)
|
|
|
|
# Which wipe command to use
|
|
command -v wipe 1>/dev/null 2>/dev/null && WIPE=(wipe -f -s)
|
|
|
|
# Check for lsof for slamming tombs
|
|
command -v lsof 1>/dev/null 2>/dev/null || LSOF=0
|
|
# Check for steghide
|
|
command -v steghide 1>/dev/null 2>/dev/null || STEGHIDE=0
|
|
# Check for resize
|
|
command -v resize2fs 1>/dev/null 2>/dev/null || RESIZER=0
|
|
# Check for KDF auxiliary tools
|
|
command -v tomb-kdb-pbkdf2 1>/dev/null 2>/dev/null || KDF=0
|
|
# Check for Swish-E file content indexer
|
|
command -v swish-e 1>/dev/null 2>/dev/null || SWISH=0
|
|
# Check for QREncode for paper backups of keys
|
|
command -v qrencode 1>/dev/null 2>/dev/null || QRENCODE=0
|
|
}
|
|
|
|
# }}} - Commandline interaction
|
|
|
|
# {{{ Key operations
|
|
|
|
# $@ is the list of all the recipient used to encrypt a tomb key
|
|
is_valid_recipients() {
|
|
typeset -a recipients
|
|
recipients=($@)
|
|
|
|
_verbose "is_valid_recipients"
|
|
|
|
# All the keys ID must be valid (the public keys must be present in the database)
|
|
for gpg_id in ${recipients[@]}; do
|
|
gpg --list-keys "$gpg_id" &> /dev/null
|
|
[[ $? != 0 ]] && {
|
|
_warning "Not a valid GPG key ID: ::1 gpgid:: " $gpg_id
|
|
return 1
|
|
}
|
|
done
|
|
|
|
# At least one private key must be present
|
|
for gpg_id in ${recipients[@]}; do
|
|
gpg --list-secret-keys "$gpg_id" &> /dev/null
|
|
[[ $? = 0 ]] && {
|
|
return 0
|
|
}
|
|
done
|
|
|
|
return 1
|
|
}
|
|
|
|
# $@ is the list of all the recipient used to encrypt a tomb key
|
|
# Print the recipient arg to be used in gpg.
|
|
_recipients_arg() {
|
|
local arg="$1"; shift
|
|
typeset -a recipients
|
|
recipients=($@)
|
|
|
|
for gpg_id in ${recipients[@]}; do
|
|
print -R -n "$arg $gpg_id "
|
|
done
|
|
return 0
|
|
}
|
|
|
|
# $1 is a GPG key recipient
|
|
# Print the fingerprint of the GPG key
|
|
_fingerprint() {
|
|
local recipient="$1"
|
|
gpg --with-colons --fingerprint "$recipient" | grep fpr | head -1 | cut -d ':' -f 10 | sed 's/.\{4\}/& /g'
|
|
}
|
|
|
|
|
|
# $1 is the encrypted key contents we are checking
|
|
is_valid_key() {
|
|
local key="$1" # Unique argument is an encrypted key to test
|
|
|
|
_verbose "is_valid_key"
|
|
|
|
[[ -z $key ]] && key=$TOMBKEY
|
|
[[ "$key" = "cleartext" ]] && {
|
|
{ option_is_set --unsafe } || {
|
|
_warning "cleartext key from stdin selected: this is unsafe."
|
|
exitv=127 _failure "please use --unsafe if you really want to do this."
|
|
}
|
|
_warning "received key in cleartext from stdin (unsafe mode)"
|
|
return 0 }
|
|
|
|
[[ -z $key ]] && {
|
|
_warning "is_valid_key() called without an argument."
|
|
return 1
|
|
}
|
|
|
|
# If the key file is an image don't check file header
|
|
[[ -r $TOMBKEYFILE ]] \
|
|
&& [[ $(file $TOMBKEYFILE) =~ "JP.G" ]] \
|
|
&& {
|
|
_message "Key is an image, it might be valid."
|
|
return 0 }
|
|
|
|
[[ $key =~ "BEGIN PGP" ]] && {
|
|
_message "Key is valid."
|
|
return 0 }
|
|
|
|
return 1
|
|
}
|
|
|
|
# $1 is a string containing an encrypted key
|
|
recover_key() {
|
|
local key="${1}" # Unique argument is an encrypted key
|
|
|
|
_warning "Attempting key recovery."
|
|
|
|
_head="${key[(f)1]}" # take the first line
|
|
|
|
TOMBKEY="" # Reset global variable
|
|
|
|
[[ $_head =~ "^_KDF_" ]] && TOMBKEY+="$_head\n"
|
|
|
|
TOMBKEY+="-----BEGIN PGP MESSAGE-----\n"
|
|
TOMBKEY+="$key\n"
|
|
TOMBKEY+="-----END PGP MESSAGE-----\n"
|
|
|
|
return 0
|
|
}
|
|
|
|
# Retrieve the tomb key from the file specified from the command line,
|
|
# or from stdin if -k - was selected. Run validity checks on the
|
|
# file. On success, return 0 and print out the full path of the key.
|
|
# Set global variables TOMBKEY and TOMBKEYFILE.
|
|
_load_key() {
|
|
local keyfile="$1" # Unique argument is an optional keyfile
|
|
|
|
[[ -z $keyfile ]] && keyfile=$(option_value -k)
|
|
[[ -z $keyfile ]] && {
|
|
_failure "This operation requires a key file to be specified using the -k option." }
|
|
|
|
if [[ $keyfile == "-" ]]; then
|
|
_verbose "load_key reading from stdin."
|
|
_message "Waiting for the key to be piped from stdin... "
|
|
TOMBKEYFILE=stdin
|
|
TOMBKEY=$(cat)
|
|
elif [[ $keyfile == "cleartext" ]]; then
|
|
_verbose "load_key reading SECRET from stdin"
|
|
_message "Waiting for the key to be piped from stdin... "
|
|
TOMBKEYFILE=cleartext
|
|
TOMBKEY=cleartext
|
|
TOMBSECRET=$(cat)
|
|
else
|
|
_verbose "load_key argument: ::1 key file::" $keyfile
|
|
[[ -r $keyfile ]] || _failure "Key not found, specify one using -k."
|
|
TOMBKEYFILE=$keyfile
|
|
TOMBKEY="${mapfile[$TOMBKEYFILE]}"
|
|
fi
|
|
|
|
_verbose "load_key: ::1 key::" $TOMBKEYFILE
|
|
|
|
[[ "$TOMBKEY" = "" ]] && {
|
|
# something went wrong, there is no key to load
|
|
# this occurs especially when piping from stdin and aborted
|
|
_failure "Key not found, specify one using -k."
|
|
}
|
|
|
|
is_valid_key $TOMBKEY || {
|
|
_warning "The key seems invalid or its format is not known by this version of Tomb."
|
|
recover_key $TOMBKEY
|
|
}
|
|
|
|
# Declared TOMBKEYFILE (path)
|
|
# Declared TOMBKEY (contents)
|
|
|
|
return 0
|
|
}
|
|
|
|
# takes two args just like get_lukskey
|
|
# prints out the decrypted content
|
|
# contains tweaks for different gpg versions
|
|
# support both symmetric and asymmetric encryption
|
|
gpg_decrypt() {
|
|
# fix for gpg 1.4.11 where the --status-* options don't work ;^/
|
|
local gpgver=$(gpg --version --no-permission-warning | awk '/^gpg/ {print $3}')
|
|
local gpgpass="$1\n$TOMBKEY"
|
|
local tmpres ret
|
|
typeset -a gpgopt
|
|
gpgpopt=(--batch --no-tty --passphrase-fd 0 --no-options)
|
|
|
|
{ option_is_set -g } && {
|
|
gpgpass="$TOMBKEY"
|
|
gpgpopt=(--yes)
|
|
|
|
# GPG option '--try-secret-key' exist since GPG 2.1
|
|
{ option_is_set -R } && [[ $gpgver =~ "2.1." ]] && {
|
|
typeset -a recipients
|
|
recipients=(${(s:,:)$(option_value -R)})
|
|
{ is_valid_recipients $recipients } || {
|
|
_failure "You set an invalid GPG ID."
|
|
}
|
|
gpgpopt+=(`_recipients_arg "--try-secret-key" $recipients`)
|
|
}
|
|
}
|
|
|
|
[[ $gpgver == "1.4.11" ]] && {
|
|
_verbose "GnuPG is version 1.4.11 - adopting status fix."
|
|
TOMBSECRET=`print - "$gpgpass" | \
|
|
gpg --decrypt ${gpgpopt[@]}`
|
|
ret=$?
|
|
unset gpgpass
|
|
return $ret
|
|
}
|
|
|
|
_tmp_create
|
|
tmpres=$TOMBTMP
|
|
TOMBSECRET=`print - "$gpgpass" | \
|
|
gpg --decrypt ${gpgpopt[@]} \
|
|
--status-fd 2 --no-mdc-warning --no-permission-warning \
|
|
--no-secmem-warning 2> $tmpres`
|
|
unset gpgpass
|
|
ret=1
|
|
for i in ${(f)"$(cat $tmpres)"}; do
|
|
_verbose "$i"
|
|
[[ "$i" =~ "DECRYPTION_OKAY" ]] && ret=0;
|
|
done
|
|
return $ret
|
|
|
|
}
|
|
|
|
|
|
# Gets a key file and a password, prints out the decoded contents to
|
|
# be used directly by Luks as a cryptographic key
|
|
get_lukskey() {
|
|
# $1 is the password
|
|
_verbose "get_lukskey"
|
|
|
|
_password="$1"
|
|
|
|
|
|
firstline="${TOMBKEY[(f)1]}"
|
|
|
|
# key is KDF encoded
|
|
if [[ $firstline =~ '^_KDF_' ]]; then
|
|
kdf_hash="${firstline[(ws:_:)2]}"
|
|
_verbose "KDF: ::1 kdf::" "$kdf_hash"
|
|
case "$kdf_hash" in
|
|
"pbkdf2sha1")
|
|
kdf_salt="${firstline[(ws:_:)3]}"
|
|
kdf_ic="${firstline[(ws:_:)4]}"
|
|
kdf_len="${firstline[(ws:_:)5]}"
|
|
_message "Unlocking KDF key protection (::1 kdf::)" $kdf_hash
|
|
_verbose "KDF salt: $kdf_salt"
|
|
_verbose "KDF ic: $kdf_ic"
|
|
_verbose "KDF len: $kdf_len"
|
|
_password=$(tomb-kdb-pbkdf2 $kdf_salt $kdf_ic $kdf_len 2>/dev/null <<<$_password)
|
|
;;
|
|
*)
|
|
_failure "No suitable program for KDF ::1 program::." $pbkdf_hash
|
|
unset _password
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
# key needs to be exhumed from an image
|
|
elif [[ -r $TOMBKEYFILE && $(file $TOMBKEYFILE) =~ "JP.G" ]]; then
|
|
if option_is_set -g; then
|
|
# When using a GPG key, the tomb key is buried using a steganography password
|
|
if option_is_set --tomb-pwd; then
|
|
_password="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $_password
|
|
else
|
|
_password=$(ask_password "Insert password to exhume key from $imagefile")
|
|
[[ $? != 0 ]] && {
|
|
_warning "User aborted password dialog."
|
|
return 1
|
|
}
|
|
fi
|
|
exhume_key $TOMBKEYFILE "$_password"
|
|
unset _password
|
|
else
|
|
exhume_key $TOMBKEYFILE "$_password"
|
|
fi
|
|
fi
|
|
|
|
gpg_decrypt "$_password" # Save decrypted contents into $TOMBSECRET
|
|
|
|
ret="$?"
|
|
|
|
_verbose "get_lukskey returns ::1::" $ret
|
|
return $ret
|
|
}
|
|
|
|
# This function asks the user for the password to use the key it tests
|
|
# it against the return code of gpg on success returns 0 and saves
|
|
# the password in the global variable $TOMBPASSWORD
|
|
ask_key_password() {
|
|
[[ -z "$TOMBKEYFILE" ]] && {
|
|
_failure "Internal error: ask_key_password() called before _load_key()." }
|
|
|
|
[[ "$TOMBKEYFILE" = "cleartext" ]] && {
|
|
_verbose "no password needed, using secret bytes from stdin"
|
|
return 0 }
|
|
|
|
if option_is_set -g; then
|
|
_verbose "no password needed, using GPG key"
|
|
get_lukskey
|
|
return $?
|
|
fi
|
|
|
|
_message "A password is required to use key ::1 key::" $TOMBKEYFILE
|
|
passok=0
|
|
tombpass=""
|
|
if [[ "$1" = "" ]]; then
|
|
|
|
for c in 1 2 3; do
|
|
if [[ $c == 1 ]]; then
|
|
tombpass=$(ask_password "Insert password to: $TOMBKEYFILE")
|
|
else
|
|
tombpass=$(ask_password "Insert password to: $TOMBKEYFILE (attempt $c)")
|
|
fi
|
|
[[ $? = 0 ]] || {
|
|
_warning "User aborted password dialog."
|
|
return 1
|
|
}
|
|
|
|
get_lukskey "$tombpass"
|
|
|
|
[[ $? = 0 ]] && {
|
|
passok=1; _message "Password OK."
|
|
break;
|
|
}
|
|
done
|
|
|
|
else
|
|
# if a second argument is present then the password is already known
|
|
tombpass="$1"
|
|
_verbose "ask_key_password with tombpass: ::1 tomb pass::" $tombpass
|
|
|
|
get_lukskey "$tombpass"
|
|
|
|
[[ $? = 0 ]] && {
|
|
passok=1; _message "Password OK."
|
|
}
|
|
|
|
fi
|
|
[[ $passok == 1 ]] || return 1
|
|
|
|
TOMBPASSWORD=$tombpass
|
|
return 0
|
|
}
|
|
|
|
# call cryptsetup with arguments using the currently known secret
|
|
# echo flags eliminate newline and disable escape (BSD_ECHO)
|
|
_cryptsetup() {
|
|
print -R -n - "$TOMBSECRET" | _sudo cryptsetup --key-file - ${@}
|
|
return $?
|
|
}
|
|
|
|
# change tomb key password
|
|
change_passwd() {
|
|
local tmpnewkey lukskey c tombpass tombpasstmp
|
|
|
|
_check_swap # Ensure swap is secure, if any
|
|
_load_key # Try loading key from option -k and set TOMBKEYFILE
|
|
|
|
{ option_is_set -g } && {
|
|
_message "Commanded to change GnuPG key for tomb key ::1 key::" $TOMBKEYFILE
|
|
} || {
|
|
_message "Commanded to change password for tomb key ::1 key::" $TOMBKEYFILE
|
|
}
|
|
|
|
_tmp_create
|
|
tmpnewkey=$TOMBTMP
|
|
|
|
if option_is_set --tomb-old-pwd; then
|
|
local tomboldpwd="`option_value --tomb-old-pwd`"
|
|
_verbose "tomb-old-pwd = ::1 old pass::" $tomboldpwd
|
|
ask_key_password "$tomboldpwd"
|
|
else
|
|
ask_key_password
|
|
fi
|
|
[[ $? == 0 ]] || _failure "No valid password supplied."
|
|
|
|
{ option_is_set -g } && {
|
|
_success "Changing GnuPG key for ::1 key file::" $TOMBKEYFILE
|
|
} || {
|
|
_success "Changing password for ::1 key file::" $TOMBKEYFILE
|
|
}
|
|
|
|
# Here $TOMBSECRET contains the key material in clear
|
|
|
|
{ option_is_set --tomb-pwd } && {
|
|
local tombpwd="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 new pass::" $tombpwd
|
|
gen_key "$tombpwd" >> "$tmpnewkey"
|
|
} || {
|
|
gen_key >> "$tmpnewkey"
|
|
}
|
|
|
|
{ is_valid_key "${mapfile[$tmpnewkey]}" } || {
|
|
_failure "Error: the newly generated keyfile does not seem valid." }
|
|
|
|
# Copy the new key as the original keyfile name
|
|
cp -f "${tmpnewkey}" $TOMBKEYFILE
|
|
{ option_is_set -g } && {
|
|
_success "Your GnuPG key was successfully changed"
|
|
} || {
|
|
_success "Your passphrase was successfully updated."
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
|
|
# takes care to encrypt a key
|
|
# honored options: --kdf --tomb-pwd -o -g -r
|
|
gen_key() {
|
|
# $1 the password to use; if not set ask user
|
|
# -o is the --cipher-algo to use (string taken by GnuPG)
|
|
local algopt="`option_value -o`"
|
|
local algo="${algopt:-AES256}"
|
|
local gpgpass opt
|
|
local recipients_opt
|
|
typeset -a gpgopt
|
|
# here user is prompted for key password
|
|
tombpass=""
|
|
tombpasstmp=""
|
|
|
|
{ option_is_set -g } && {
|
|
gpgopt=(--encrypt)
|
|
|
|
{ option_is_set -r || option_is_set -R } && {
|
|
typeset -a recipients
|
|
{ option_is_set -r } && {
|
|
recipients=(${(s:,:)$(option_value -r)})
|
|
recipients_opt="--recipient"
|
|
} || {
|
|
recipients=(${(s:,:)$(option_value -R)})
|
|
recipients_opt="--hidden-recipient"
|
|
}
|
|
|
|
{ is_valid_recipients $recipients } || {
|
|
_failure "You set an invalid GPG ID."
|
|
}
|
|
|
|
_warning "You are going to encrypt a tomb key with ::1 nrecipients:: recipient(s)." ${#recipients}
|
|
_warning "It is your responsibility to check these fingerprints."
|
|
_warning "The fingerprints are:"
|
|
for gpg_id in ${recipients[@]}; do
|
|
_warning " `_fingerprint "$gpg_id"`"
|
|
done
|
|
|
|
gpgopt+=(`_recipients_arg "$recipients_opt" $recipients`)
|
|
} || {
|
|
_message "No recipient specified, using default GPG key."
|
|
gpgopt+=("--default-recipient-self")
|
|
}
|
|
|
|
# Set gpg inputs and options
|
|
gpgpass="$TOMBSECRET"
|
|
opt=''
|
|
} || {
|
|
if [ "$1" = "" ]; then
|
|
while true; do
|
|
# 3 tries to write two times a matching password
|
|
tombpass=`ask_password "Type the new password to secure your key"`
|
|
if [[ $? != 0 ]]; then
|
|
_failure "User aborted."
|
|
fi
|
|
if [ -z $tombpass ]; then
|
|
_failure "You set empty password, which is not possible."
|
|
fi
|
|
tombpasstmp=$tombpass
|
|
tombpass=`ask_password "Type the new password to secure your key (again)"`
|
|
if [[ $? != 0 ]]; then
|
|
_failure "User aborted."
|
|
fi
|
|
if [ "$tombpasstmp" = "$tombpass" ]; then
|
|
break;
|
|
fi
|
|
unset tombpasstmp
|
|
unset tombpass
|
|
done
|
|
else
|
|
tombpass="$1"
|
|
_verbose "gen_key takes tombpass from CLI argument: ::1 tomb pass::" $tombpass
|
|
fi
|
|
|
|
header=""
|
|
[[ $KDF == 1 ]] && {
|
|
{ option_is_set --kdf } && {
|
|
# KDF is a new key strenghtening technique against brute forcing
|
|
# see: https://github.com/dyne/Tomb/issues/82
|
|
itertime="`option_value --kdf`"
|
|
# removing support of floating points because they can't be type checked well
|
|
if [[ "$itertime" != <-> ]]; then
|
|
unset tombpass
|
|
unset tombpasstmp
|
|
_warning "Wrong argument for --kdf: must be an integer number (iteration seconds)."
|
|
_failure "Depending on the speed of machines using this tomb, use 1 to 10, or more"
|
|
return 1
|
|
fi
|
|
# --kdf takes one parameter: iter time (on present machine) in seconds
|
|
local -i microseconds
|
|
microseconds=$(( itertime * 1000000 ))
|
|
_success "Using KDF, iteration time: ::1 microseconds::" $microseconds
|
|
_message "generating salt"
|
|
pbkdf2_salt=`tomb-kdb-pbkdf2-gensalt`
|
|
_message "calculating iterations"
|
|
pbkdf2_iter=`tomb-kdb-pbkdf2-getiter $microseconds`
|
|
_message "encoding the password"
|
|
# We use a length of 64bytes = 512bits (more than needed!?)
|
|
tombpass=`tomb-kdb-pbkdf2 $pbkdf2_salt $pbkdf2_iter 64 <<<"${tombpass}"`
|
|
|
|
header="_KDF_pbkdf2sha1_${pbkdf2_salt}_${pbkdf2_iter}_64\n"
|
|
}
|
|
}
|
|
print $header
|
|
|
|
# Set gpg inputs and options
|
|
gpgpass="${tombpass}\n$TOMBSECRET"
|
|
gpgopt=(--passphrase-fd 0 --symmetric --no-options)
|
|
opt='-n'
|
|
}
|
|
|
|
_tmp_create
|
|
local tmpres=$TOMBTMP
|
|
print $opt - "$gpgpass" \
|
|
| gpg --openpgp --force-mdc --cipher-algo ${algo} \
|
|
--batch --no-tty ${gpgopt[@]} \
|
|
--status-fd 2 -o - --armor 2> $tmpres
|
|
unset gpgpass
|
|
# check result of gpg operation
|
|
for i in ${(f)"$(cat $tmpres)"}; do
|
|
_verbose "$i"
|
|
done
|
|
|
|
# print -n "${tombpass}" \
|
|
# | gpg --openpgp --force-mdc --cipher-algo ${algo} \
|
|
# --batch --no-options --no-tty --passphrase-fd 0 --status-fd 2 \
|
|
# -o - -c -a ${lukskey}
|
|
|
|
TOMBPASSWORD="$tombpass" # Set global variable
|
|
unset tombpass
|
|
unset tombpasstmp
|
|
}
|
|
|
|
# prints an array of ciphers available in gnupg (to encrypt keys)
|
|
list_gnupg_ciphers() {
|
|
# prints an error if GnuPG is not found
|
|
which gpg 2>/dev/null || _failure "gpg (GnuPG) is not found, Tomb cannot function without it."
|
|
|
|
ciphers=(`gpg --version | awk '
|
|
BEGIN { ciphers=0 }
|
|
/^Cipher:/ { gsub(/,/,""); sub(/^Cipher:/,""); print; ciphers=1; next }
|
|
/^Hash:/ { ciphers=0 }
|
|
{ if(ciphers==0) { next } else { gsub(/,/,""); print; } }
|
|
'`)
|
|
print " ${ciphers}"
|
|
return 1
|
|
}
|
|
|
|
# Steganographic function to bury a key inside an image.
|
|
# Requires steghide(1) to be installed
|
|
bury_key() {
|
|
|
|
_load_key # Try loading key from option -k and set TOMBKEY
|
|
|
|
imagefile=$PARAM
|
|
|
|
[[ "`file $imagefile`" =~ "JPEG" ]] || {
|
|
_warning "Encode failed: ::1 image file:: is not a jpeg image." $imagefile
|
|
return 1
|
|
}
|
|
|
|
_success "Encoding key ::1 tomb key:: inside image ::2 image file::" $TOMBKEY $imagefile
|
|
{ option_is_set -g } && {
|
|
_message "Using GnuPG Key ID"
|
|
} || {
|
|
_message "Please confirm the key password for the encoding"
|
|
}
|
|
|
|
# We ask the password and test if it is the same encoding the
|
|
# base key, to insure that the same password is used for the
|
|
# encryption and the steganography. This is a standard enforced
|
|
# by Tomb, but it isn't strictly necessary (and having different
|
|
# password would enhance security). Nevertheless here we prefer
|
|
# usability.
|
|
# However, steganography cannot be done with GPG key. Therefore,
|
|
# if using a GPG key, we test if the user can decrypt the tomb
|
|
# with its key and we ask for a steganography password.
|
|
|
|
{ option_is_set --tomb-pwd } && { ! option_is_set -g } && {
|
|
local tombpwd="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $tombpwd
|
|
ask_key_password "$tombpwd"
|
|
} || {
|
|
ask_key_password
|
|
}
|
|
[[ $? != 0 ]] && {
|
|
_warning "Wrong password/GnuPG ID supplied."
|
|
_failure "You shall not bury a key whose password is unknown to you." }
|
|
|
|
if option_is_set -g && option_is_set --tomb-pwd; then
|
|
TOMBPASSWORD="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $TOMBPASSWORD
|
|
elif option_is_set -g; then
|
|
tombpass=""
|
|
tombpasstmp=""
|
|
while true; do
|
|
# 3 tries to write two times a matching password
|
|
tombpass=`ask_password "Type a password to bury your key"`
|
|
if [[ $? != 0 ]]; then
|
|
_failure "User aborted."
|
|
fi
|
|
if [ -z $tombpass ]; then
|
|
_failure "You set empty password, which is not possible."
|
|
fi
|
|
tombpasstmp=$tombpass
|
|
tombpass=`ask_password "Type a password to bury your key (again)"`
|
|
if [[ $? != 0 ]]; then
|
|
_failure "User aborted."
|
|
fi
|
|
if [ "$tombpasstmp" = "$tombpass" ]; then
|
|
break;
|
|
fi
|
|
unset tombpasstmp
|
|
unset tombpass
|
|
done
|
|
TOMBPASSWORD="$tombpass"
|
|
fi
|
|
|
|
# We omit armor strings since having them as constants can give
|
|
# ground to effective attacks on steganography
|
|
print - "$TOMBKEY" | awk '
|
|
/^-----/ {next}
|
|
/^Version/ {next}
|
|
{print $0}' \
|
|
| steghide embed --embedfile - --coverfile ${imagefile} \
|
|
-p $TOMBPASSWORD -z 9 -e serpent cbc
|
|
if [ $? != 0 ]; then
|
|
_warning "Encoding error: steghide reports problems."
|
|
res=1
|
|
else
|
|
_success "Tomb key encoded succesfully into image ::1 image file::" $imagefile
|
|
res=0
|
|
fi
|
|
|
|
return $res
|
|
}
|
|
|
|
# mandatory 1st arg: the image file where key is supposed to be
|
|
# optional 2nd arg: the password to use (same as key, internal use)
|
|
# optional 3rd arg: the key where to save the result (- for stdout)
|
|
exhume_key() {
|
|
[[ "$1" = "" ]] && {
|
|
_failure "Exhume failed, no image specified" }
|
|
|
|
local imagefile="$1" # The image file where to look for the key
|
|
local tombpass="$2" # (Optional) the password to use (internal use)
|
|
local destkey="$3" # (Optional) the key file where to save the
|
|
# result (- for stdout)
|
|
local r=1 # Return code (default: fail)
|
|
|
|
# Ensure the image file is a readable JPEG
|
|
[[ ! -r $imagefile ]] && {
|
|
_failure "Exhume failed, image file not found: ::1 image file::" "${imagefile:-none}" }
|
|
[[ ! $(file "$imagefile") =~ "JP.G" ]] && {
|
|
_failure "Exhume failed: ::1 image file:: is not a jpeg image." $imagefile }
|
|
|
|
# When a password is passed as argument then always print out
|
|
# the exhumed key on stdout without further checks (internal use)
|
|
[[ -n "$tombpass" ]] && {
|
|
TOMBKEY=$(steghide extract -sf $imagefile -p $tombpass -xf -)
|
|
[[ $? != 0 ]] && {
|
|
_failure "Wrong password or no steganographic key found" }
|
|
|
|
recover_key $TOMBKEY
|
|
|
|
return 0
|
|
}
|
|
|
|
# Ensure we have a valid destination for the key
|
|
[[ -z $destkey ]] && { option_is_set -k } && destkey=$(option_value -k)
|
|
[[ -z $destkey ]] && {
|
|
destkey="-" # No key was specified: fallback to stdout
|
|
_message "printing exhumed key on stdout" }
|
|
|
|
# Bail out if destination exists, unless -f (force) was passed
|
|
[[ $destkey != "-" && -s $destkey ]] && {
|
|
_warning "File exists: ::1 tomb key::" $destkey
|
|
{ option_is_set -f } && {
|
|
_warning "Use of --force selected: overwriting."
|
|
rm -f $destkey
|
|
} || {
|
|
_warning "Make explicit use of --force to overwrite."
|
|
_failure "Refusing to overwrite file. Operation aborted." }
|
|
}
|
|
|
|
_message "Trying to exhume a key out of image ::1 image file::" $imagefile
|
|
{ option_is_set --tomb-pwd } && {
|
|
tombpass=$(option_value --tomb-pwd)
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $tombpass
|
|
} || {
|
|
[[ -n $TOMBPASSWORD ]] && tombpass=$TOMBPASSWORD
|
|
} || {
|
|
tombpass=$(ask_password "Insert password to exhume key from $imagefile")
|
|
[[ $? != 0 ]] && {
|
|
_warning "User aborted password dialog."
|
|
return 1
|
|
}
|
|
}
|
|
|
|
# Extract the key from the image
|
|
steghide extract -sf $imagefile -p ${tombpass} -xf $destkey
|
|
r=$?
|
|
|
|
# Report to the user
|
|
[[ "$destkey" = "-" ]] && destkey="stdout"
|
|
[[ $r == 0 ]] && {
|
|
_success "Key succesfully exhumed to ::1 key::." $destkey
|
|
} || {
|
|
_warning "Nothing found in ::1 image file::" $imagefile
|
|
}
|
|
|
|
return $r
|
|
}
|
|
|
|
# Produces a printable image of the key contents so a backup on paper
|
|
# can be made and hidden in books etc.
|
|
engrave_key() {
|
|
|
|
_load_key # Try loading key from option -k and set TOMBKEYFILE
|
|
|
|
local keyname=$(basename $TOMBKEYFILE)
|
|
local pngname="$keyname.qr.png"
|
|
|
|
_success "Rendering a printable QRCode for key: ::1 tomb key file::" $TOMBKEYFILE
|
|
# we omit armor strings to save space
|
|
awk '/^-----/ {next}; /^Version/ {next}; {print $0}' $TOMBKEYFILE \
|
|
| qrencode --size 4 --level H --casesensitive -o $pngname
|
|
[[ $? != 0 ]] && {
|
|
_failure "QREncode reported an error." }
|
|
|
|
_success "Operation successful:"
|
|
# TODO: only if verbose and/or not silent
|
|
ls -lh $pngname
|
|
file $pngname
|
|
}
|
|
|
|
# }}} - Key handling
|
|
|
|
# {{{ Create
|
|
|
|
# Since version 1.5.3, tomb creation is a three-step process that replaces create_tomb():
|
|
#
|
|
# * dig a .tomb (the large file) using /dev/urandom (takes some minutes at least)
|
|
#
|
|
# * forge a .key (the small file) using /dev/random (good entropy needed)
|
|
#
|
|
# * lock the .tomb file with the key, binding the key to the tomb (requires dm_crypt format)
|
|
|
|
# Step one - Dig a tomb
|
|
#
|
|
# Synopsis: dig_tomb /path/to/tomb -s sizemebibytes
|
|
#
|
|
# It will create an empty file to be formatted as a loopback
|
|
# filesystem. Initially the file is filled with random data taken
|
|
# from /dev/urandom to improve overall tomb's security and prevent
|
|
# some attacks aiming at detecting how much data is in the tomb, or
|
|
# which blocks in the filesystem contain that data.
|
|
|
|
dig_tomb() {
|
|
local tombpath="$1" # Path to tomb
|
|
# Require the specification of the size of the tomb (-s) in MiB
|
|
local -i tombsize=$(option_value -s)
|
|
|
|
_message "Commanded to dig tomb ::1 tomb path::" $tombpath
|
|
|
|
[[ -n "$tombpath" ]] || _failure "Missing path to tomb"
|
|
[[ -n "$tombsize" ]] || _failure "Size argument missing, use -s"
|
|
[[ $tombsize == <-> ]] || _failure "Size must be an integer (mebibytes)"
|
|
[[ $tombsize -ge 10 ]] || _failure "Tombs can't be smaller than 10 mebibytes"
|
|
|
|
_plot $tombpath # Set TOMB{PATH,DIR,FILE,NAME}
|
|
|
|
[[ -e $TOMBPATH ]] && {
|
|
_warning "A tomb exists already. I'm not digging here:"
|
|
ls -lh $TOMBPATH
|
|
return 1
|
|
}
|
|
|
|
_success "Creating a new tomb in ::1 tomb path::" $TOMBPATH
|
|
|
|
_message "Generating ::1 tomb file:: of ::2 size::MiB" $TOMBFILE $tombsize
|
|
|
|
# Ensure that file permissions are safe even if interrupted
|
|
touch $TOMBPATH
|
|
[[ $? = 0 ]] || {
|
|
_warning "Error creating the tomb ::1 tomb path::" $TOMBPATH
|
|
_failure "Operation aborted."
|
|
}
|
|
chmod 0600 $TOMBPATH
|
|
|
|
_verbose "Data dump using ::1:: from /dev/urandom" ${DD[1]}
|
|
${=DD} if=/dev/urandom bs=1048576 count=$tombsize of=$TOMBPATH
|
|
|
|
[[ $? == 0 && -e $TOMBPATH ]] && {
|
|
ls -lh $TOMBPATH
|
|
} || {
|
|
_warning "Error creating the tomb ::1 tomb path::" $TOMBPATH
|
|
_failure "Operation aborted."
|
|
}
|
|
|
|
_success "Done digging ::1 tomb name::" $TOMBNAME
|
|
_message "Your tomb is not yet ready, you need to forge a key and lock it:"
|
|
_message "tomb forge ::1 tomb path::.key" $TOMBPATH
|
|
_message "tomb lock ::1 tomb path:: -k ::1 tomb path::.key" $TOMBPATH
|
|
|
|
return 0
|
|
}
|
|
|
|
# Step two -- Create a detached key to lock a tomb with
|
|
#
|
|
# Synopsis: forge_key [destkey|-k destkey] [-o cipher] [-r|-R gpgid]
|
|
#
|
|
# Arguments:
|
|
# -k path to destination keyfile
|
|
# -o Use an alternate algorithm
|
|
# -r GPG recipients to be used
|
|
#
|
|
forge_key() {
|
|
# can be specified both as simple argument or using -k
|
|
local destkey="$1"
|
|
{ option_is_set -k } && { destkey=$(option_value -k) }
|
|
|
|
local algo="AES256" # Default encryption algorithm
|
|
|
|
[[ -z "$destkey" ]] && {
|
|
_failure "A filename needs to be specified using -k to forge a new key." }
|
|
|
|
# _message "Commanded to forge key ::1 key::" $destkey
|
|
|
|
_check_swap # Ensure the available memory is safe to use
|
|
|
|
# Ensure GnuPG won't exit with an error before first run
|
|
[[ -r $HOME/.gnupg/pubring.gpg ]] || {
|
|
mkdir -m 0700 $HOME/.gnupg
|
|
touch $HOME/.gnupg/pubring.gpg }
|
|
|
|
# Do not overwrite any files accidentally
|
|
[[ -r "$destkey" ]] && {
|
|
ls -lh $destkey
|
|
_failure "Forging this key would overwrite an existing file. Operation aborted." }
|
|
|
|
touch $destkey
|
|
[[ $? == 0 ]] || {
|
|
_warning "Cannot generate encryption key."
|
|
_failure "Operation aborted." }
|
|
chmod 0600 $destkey
|
|
|
|
# Update algorithm if it was passed on the command line with -o
|
|
{ option_is_set -o } && algopt="$(option_value -o)"
|
|
[[ -n "$algopt" ]] && algo=$algopt
|
|
|
|
_message "Commanded to forge key ::1 key:: with cipher algorithm ::2 algorithm::" \
|
|
$destkey $algo
|
|
|
|
[[ $KDF == 1 ]] && { ! option_is_set -g } && {
|
|
_message "Using KDF to protect the key password (`option_value --kdf` rounds)"
|
|
}
|
|
|
|
TOMBKEYFILE="$destkey" # Set global variable
|
|
|
|
_warning "This operation takes time. Keep using this computer on other tasks."
|
|
_warning "Once done you will be asked to choose a password for your tomb."
|
|
_warning "To make it faster you can move the mouse around."
|
|
_warning "If you are on a server, you can use an Entropy Generation Daemon."
|
|
|
|
# Use /dev/random as the entropy source, unless --use-urandom is specified
|
|
local random_source=/dev/random
|
|
{ option_is_set --use-urandom } && random_source=/dev/urandom
|
|
|
|
_verbose "Data dump using ::1:: from ::2 source::" ${DD[1]} $random_source
|
|
TOMBSECRET=$(${=DD} bs=1 count=512 if=$random_source)
|
|
[[ $? == 0 ]] || {
|
|
_warning "Cannot generate encryption key."
|
|
_failure "Operation aborted." }
|
|
|
|
# Here the global variable TOMBSECRET contains the naked secret
|
|
|
|
{ option_is_set -g } && {
|
|
_success "Using GnuPG key(s) to encrypt your key: ::1 tomb key::" $TOMBKEYFILE
|
|
} || {
|
|
_success "Choose the password of your key: ::1 tomb key::" $TOMBKEYFILE
|
|
}
|
|
_message "(You can also change it later using 'tomb passwd'.)"
|
|
# _user_file $TOMBKEYFILE
|
|
|
|
tombname="$TOMBKEYFILE" # XXX ???
|
|
# the gen_key() function takes care of the new key's encryption
|
|
{ option_is_set --tomb-pwd } && {
|
|
local tombpwd="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 new pass::" $tombpwd
|
|
gen_key "$tombpwd" >> $TOMBKEYFILE
|
|
} || {
|
|
gen_key >> $TOMBKEYFILE
|
|
}
|
|
|
|
# load the key contents (set global variable)
|
|
TOMBKEY="${mapfile[$TOMBKEYFILE]}"
|
|
|
|
# this does a check on the file header
|
|
is_valid_key $TOMBKEY || {
|
|
_warning "The key does not seem to be valid."
|
|
_warning "Dumping contents to screen:"
|
|
print "${mapfile[$TOMBKEY]}"
|
|
_warning "--"
|
|
_sudo umount ${keytmp}
|
|
rm -r $keytmp
|
|
_failure "Operation aborted."
|
|
}
|
|
|
|
_message "Done forging ::1 key file::" $TOMBKEYFILE
|
|
_success "Your key is ready:"
|
|
ls -lh $TOMBKEYFILE
|
|
}
|
|
|
|
# Step three -- Lock tomb
|
|
#
|
|
# Synopsis: tomb_lock file.tomb file.tomb.key [-o cipher] [-r gpgid]
|
|
#
|
|
# Lock the given tomb with the given key file, in fact formatting the
|
|
# loopback volume as a LUKS device.
|
|
# Default cipher 'aes-xts-plain64:sha256'can be overridden with -o
|
|
lock_tomb_with_key() {
|
|
# old default was aes-cbc-essiv:sha256
|
|
# Override with -o
|
|
# for more alternatives refer to cryptsetup(8)
|
|
local cipher="aes-xts-plain64:sha256"
|
|
|
|
local tombpath="$1" # First argument is the path to the tomb
|
|
|
|
[[ -n $tombpath ]] || {
|
|
_warning "No tomb specified for locking."
|
|
_warning "Usage: tomb lock file.tomb file.tomb.key"
|
|
return 1
|
|
}
|
|
|
|
_plot $tombpath
|
|
|
|
_message "Commanded to lock tomb ::1 tomb file::" $TOMBFILE
|
|
|
|
[[ -f $TOMBPATH ]] || {
|
|
_failure "There is no tomb here. You have to dig it first." }
|
|
|
|
_verbose "Tomb found: ::1 tomb path::" $TOMBPATH
|
|
|
|
lo_mount $TOMBPATH
|
|
nstloop=`lo_new`
|
|
|
|
_verbose "Loop mounted on ::1 mount point::" $nstloop
|
|
|
|
_message "Checking if the tomb is empty (we never step on somebody else's bones)."
|
|
_sudo cryptsetup isLuks ${nstloop}
|
|
if [ $? = 0 ]; then
|
|
# is it a LUKS encrypted nest? then bail out and avoid reformatting it
|
|
_warning "The tomb was already locked with another key."
|
|
_failure "Operation aborted. I cannot lock an already locked tomb. Go dig a new one."
|
|
else
|
|
_message "Fine, this tomb seems empty."
|
|
fi
|
|
|
|
_load_key # Try loading key from option -k and set TOMBKEYFILE
|
|
|
|
# the encryption cipher for a tomb can be set when locking using -c
|
|
{ option_is_set -o } && algopt="$(option_value -o)"
|
|
[[ -n "$algopt" ]] && cipher=$algopt
|
|
_message "Locking using cipher: ::1 cipher::" $cipher
|
|
|
|
# get the pass from the user and check it
|
|
if option_is_set --tomb-pwd; then
|
|
tomb_pwd="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $tomb_pwd
|
|
ask_key_password "$tomb_pwd"
|
|
else
|
|
ask_key_password
|
|
fi
|
|
[[ $? == 0 ]] || _failure "No valid password supplied."
|
|
|
|
_success "Locking ::1 tomb file:: with ::2 tomb key file::" $TOMBFILE $TOMBKEYFILE
|
|
|
|
_message "Formatting Luks mapped device."
|
|
_cryptsetup --batch-mode \
|
|
--cipher ${cipher} --key-size 512 --key-slot 0 \
|
|
luksFormat ${nstloop}
|
|
[[ $? == 0 ]] || {
|
|
_warning "cryptsetup luksFormat returned an error."
|
|
_failure "Operation aborted." }
|
|
|
|
_cryptsetup --cipher ${cipher} luksOpen ${nstloop} tomb.tmp
|
|
[[ $? == 0 ]] || {
|
|
_warning "cryptsetup luksOpen returned an error."
|
|
_failure "Operation aborted." }
|
|
|
|
_message "Formatting your Tomb with Ext3/Ext4 filesystem."
|
|
_sudo mkfs.ext4 -q -F -j -L $TOMBNAME /dev/mapper/tomb.tmp
|
|
|
|
[[ $? == 0 ]] || {
|
|
_warning "Tomb format returned an error."
|
|
_warning "Your tomb ::1 tomb file:: may be corrupted." $TOMBFILE }
|
|
|
|
# Sync
|
|
_sudo cryptsetup luksClose tomb.tmp
|
|
|
|
_message "Done locking ::1 tomb name:: using Luks dm-crypt ::2 cipher::" $TOMBNAME $cipher
|
|
_success "Your tomb is ready in ::1 tomb path:: and secured with key ::2 tomb key::" \
|
|
$TOMBPATH $TOMBKEYFILE
|
|
|
|
}
|
|
|
|
# This function changes the key that locks a tomb
|
|
change_tomb_key() {
|
|
local tombkey="$1" # Path to the tomb's key file
|
|
local tombpath="$2" # Path to the tomb
|
|
|
|
_message "Commanded to reset key for tomb ::1 tomb path::" $tombpath
|
|
|
|
[[ -z "$tombpath" ]] && {
|
|
_warning "Command 'setkey' needs two arguments: the old key file and the tomb."
|
|
_warning "I.e: tomb -k new.tomb.key old.tomb.key secret.tomb"
|
|
_failure "Execution aborted."
|
|
}
|
|
|
|
_check_swap
|
|
|
|
# this also calls _plot()
|
|
is_valid_tomb $tombpath
|
|
|
|
lo_mount $TOMBPATH
|
|
nstloop=`lo_new`
|
|
_sudo cryptsetup isLuks ${nstloop}
|
|
# is it a LUKS encrypted nest? we check one more time
|
|
[[ $? == 0 ]] || {
|
|
_failure "Not a valid LUKS encrypted volume: ::1 volume::" $TOMBPATH }
|
|
|
|
_load_key $tombkey # Try loading given key and set TOMBKEY and
|
|
# TOMBKEYFILE
|
|
local oldkey=$TOMBKEY
|
|
local oldkeyfile=$TOMBKEYFILE
|
|
|
|
# we have everything, prepare to mount
|
|
_success "Changing lock on tomb ::1 tomb name::" $TOMBNAME
|
|
_message "Old key: ::1 old key::" $oldkeyfile
|
|
|
|
# render the mapper
|
|
mapdate=`date +%s`
|
|
# save date of mount in minutes since 1970
|
|
mapper="tomb.$TOMBNAME.$mapdate.$(basename $nstloop)"
|
|
|
|
# load the old key
|
|
if option_is_set --tomb-old-pwd; then
|
|
tomb_old_pwd="`option_value --tomb-old-pwd`"
|
|
_verbose "tomb-old-pwd = ::1 old pass::" $tomb_old_pwd
|
|
ask_key_password "$tomb_old_pwd"
|
|
else
|
|
ask_key_password
|
|
fi
|
|
[[ $? == 0 ]] || {
|
|
_failure "No valid password supplied for the old key." }
|
|
old_secret=$TOMBSECRET
|
|
|
|
# luksOpen the tomb (not really mounting, just on the loopback)
|
|
print -R -n - "$old_secret" | _sudo cryptsetup --key-file - \
|
|
luksOpen ${nstloop} ${mapper}
|
|
[[ $? == 0 ]] || _failure "Unexpected error in luksOpen."
|
|
|
|
_load_key # Try loading new key from option -k and set TOMBKEYFILE
|
|
|
|
_message "New key: ::1 key file::" $TOMBKEYFILE
|
|
|
|
if option_is_set --tomb-pwd; then
|
|
tomb_new_pwd="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $tomb_new_pwd
|
|
ask_key_password "$tomb_new_pwd"
|
|
else
|
|
ask_key_password
|
|
fi
|
|
[[ $? == 0 ]] || {
|
|
_failure "No valid password supplied for the new key." }
|
|
|
|
_tmp_create
|
|
tmpnewkey=$TOMBTMP
|
|
print -R -n - "$TOMBSECRET" >> $tmpnewkey
|
|
|
|
print -R -n - "$old_secret" | _sudo cryptsetup --key-file - \
|
|
luksChangeKey "$nstloop" "$tmpnewkey"
|
|
|
|
[[ $? == 0 ]] || _failure "Unexpected error in luksChangeKey."
|
|
|
|
_sudo cryptsetup luksClose "${mapper}" || _failure "Unexpected error in luksClose."
|
|
|
|
_success "Succesfully changed key for tomb: ::1 tomb file::" $TOMBFILE
|
|
_message "The new key is: ::1 new key::" $TOMBKEYFILE
|
|
|
|
return 0
|
|
}
|
|
|
|
# }}} - Creation
|
|
|
|
# {{{ Open
|
|
|
|
# $1 = tombfile $2(optional) = mountpoint
|
|
mount_tomb() {
|
|
local tombpath="$1" # First argument is the path to the tomb
|
|
[[ -n "$tombpath" ]] || _failure "No tomb name specified for opening."
|
|
|
|
_message "Commanded to open tomb ::1 tomb name::" $tombpath
|
|
|
|
_check_swap
|
|
|
|
# this also calls _plot()
|
|
is_valid_tomb $tombpath
|
|
|
|
_load_key # Try loading new key from option -k and set TOMBKEYFILE
|
|
|
|
tombmount="$2"
|
|
[[ "$tombmount" = "" ]] && {
|
|
tombmount=/media/$TOMBNAME
|
|
[[ -d /media ]] || { # no /media found, adopting /run/media/$USER (udisks2 compat)
|
|
tombmount=/run/media/$_USER/$TOMBNAME
|
|
}
|
|
_message "Mountpoint not specified, using default: ::1 mount point::" $tombmount
|
|
}
|
|
|
|
_success "Opening ::1 tomb file:: on ::2 mount point::" $TOMBNAME $tombmount
|
|
|
|
lo_mount $TOMBPATH
|
|
nstloop=`lo_new`
|
|
|
|
_sudo cryptsetup isLuks ${nstloop} || {
|
|
# is it a LUKS encrypted nest? see cryptsetup(1)
|
|
_failure "::1 tomb file:: is not a valid Luks encrypted storage file." $TOMBFILE }
|
|
|
|
_message "This tomb is a valid LUKS encrypted device."
|
|
|
|
luksdump="`_sudo cryptsetup luksDump ${nstloop}`"
|
|
tombdump=(`print $luksdump | awk '
|
|
/^Cipher name/ {print $3}
|
|
/^Cipher mode/ {print $3}
|
|
/^Hash spec/ {print $3}'`)
|
|
_message "Cipher is \"::1 cipher::\" mode \"::2 mode::\" hash \"::3 hash::\"" $tombdump[1] $tombdump[2] $tombdump[3]
|
|
|
|
slotwarn=`print $luksdump | awk '
|
|
BEGIN { zero=0 }
|
|
/^Key slot 0/ { zero=1 }
|
|
/^Key slot.*ENABLED/ { if(zero==1) print "WARN" }'`
|
|
[[ "$slotwarn" == "WARN" ]] && {
|
|
_warning "Multiple key slots are enabled on this tomb. Beware: there can be a backdoor." }
|
|
|
|
# save date of mount in minutes since 1970
|
|
mapdate=`date +%s`
|
|
|
|
mapper="tomb.$TOMBNAME.$mapdate.$(basename $nstloop)"
|
|
|
|
_verbose "dev mapper device: ::1 mapper::" $mapper
|
|
_verbose "Tomb key: ::1 key file::" $TOMBKEYFILE
|
|
|
|
# take the name only, strip extensions
|
|
_verbose "Tomb name: ::1 tomb name:: (to be engraved)" $TOMBNAME
|
|
|
|
{ option_is_set --tomb-pwd } && { ! option_is_set -g } && {
|
|
tomb_pwd="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $tomb_pwd
|
|
ask_key_password "$tomb_pwd"
|
|
} || {
|
|
ask_key_password
|
|
}
|
|
[[ $? == 0 ]] || _failure "No valid password supplied."
|
|
|
|
_cryptsetup luksOpen ${nstloop} ${mapper}
|
|
[[ $? = 0 ]] || {
|
|
_failure "Failure mounting the encrypted file." }
|
|
|
|
# preserve the loopdev after exit
|
|
lo_preserve "$nstloop"
|
|
|
|
# array: [ cipher, keysize, loopdevice ]
|
|
tombstat=(`_sudo cryptsetup status ${mapper} | awk '
|
|
/cipher:/ {print $2}
|
|
/keysize:/ {print $2}
|
|
/device:/ {print $2}'`)
|
|
_success "Success unlocking tomb ::1 tomb name::" $TOMBNAME
|
|
_verbose "Key size is ::1 size:: for cipher ::2 cipher::" $tombstat[2] $tombstat[1]
|
|
|
|
_message "Checking filesystem via ::1::" $tombstat[3]
|
|
_sudo fsck -p -C0 /dev/mapper/${mapper}
|
|
_verbose "Tomb engraved as ::1 tomb name::" $TOMBNAME
|
|
_sudo tune2fs -L $TOMBNAME /dev/mapper/${mapper} > /dev/null
|
|
|
|
# we need root from here on
|
|
_sudo mkdir -p $tombmount
|
|
|
|
# Default mount options are overridden with the -o switch
|
|
{ option_is_set -o } && {
|
|
local oldmountopts=$MOUNTOPTS
|
|
MOUNTOPTS="$(option_value -o)" }
|
|
|
|
# TODO: safety check MOUNTOPTS
|
|
# safe_mount_options && \
|
|
_sudo mount -o $MOUNTOPTS /dev/mapper/${mapper} ${tombmount}
|
|
# Clean up if the mount failed
|
|
[[ $? == 0 ]] || {
|
|
_warning "Error mounting ::1 mapper:: on ::2 tombmount::" $mapper $tombmount
|
|
[[ $oldmountopts != $MOUNTOPTS ]] && \
|
|
_warning "Are mount options '::1 mount options::' valid?" $MOUNTOPTS
|
|
# TODO: move cleanup to _endgame()
|
|
[[ -d $tombmount ]] && _sudo rmdir $tombmount
|
|
[[ -e /dev/mapper/$mapper ]] && _sudo cryptsetup luksClose $mapper
|
|
# The loop is taken care of in _endgame()
|
|
_failure "Cannot mount ::1 tomb name::" $TOMBNAME
|
|
}
|
|
|
|
# we do not change ownership anymore when mounting tombs
|
|
# _sudo chown $UID:$GID ${tombmount}
|
|
# _sudo chmod 0711 ${tombmount}
|
|
|
|
_success "Success opening ::1 tomb file:: on ::2 mount point::" $TOMBFILE $tombmount
|
|
|
|
local tombtty tombhost tombuid tombuser
|
|
|
|
# print out when it was opened the last time, by whom and where
|
|
[[ -r ${tombmount}/.last ]] && {
|
|
tombsince=$(_cat ${tombmount}/.last)
|
|
tombsince=$(date --date=@$tombsince +%c)
|
|
tombtty=$(_cat ${tombmount}/.tty)
|
|
tombhost=$(_cat ${tombmount}/.host)
|
|
tomblast=$(_cat ${tombmount}/.last)
|
|
tombuid=$(_cat ${tombmount}/.uid | tr -d ' ')
|
|
|
|
tombuser=$(getent passwd $tombuid)
|
|
tombuser=${tombuser[(ws@:@)1]}
|
|
|
|
_message "Last visit by ::1 user::(::2 tomb build::) from ::3 tty:: on ::4 host::" $tombuser $tombuid $tombtty $tombhost
|
|
_message "on date ::1 date::" $tombsince
|
|
}
|
|
# write down the UID and TTY that opened the tomb
|
|
rm -f ${tombmount}/.uid
|
|
print $_UID > ${tombmount}/.uid
|
|
rm -f ${tombmount}/.tty
|
|
print $_TTY > ${tombmount}/.tty
|
|
# also the hostname
|
|
rm -f ${tombmount}/.host
|
|
hostname > ${tombmount}/.host
|
|
# and the "last time opened" information
|
|
# in minutes since 1970, this is printed at next open
|
|
rm -f ${tombmount}/.last
|
|
date +%s > ${tombmount}/.last
|
|
# human readable: date --date=@"`cat .last`" +%c
|
|
|
|
|
|
# process bind-hooks (mount -o bind of directories)
|
|
# and exec-hooks (execute on open)
|
|
option_is_set -n || {
|
|
exec_safe_bind_hooks ${tombmount}
|
|
exec_safe_func_hooks open ${tombmount}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
## HOOKS EXECUTION
|
|
#
|
|
# Execution of code inside a tomb may present a security risk, e.g.,
|
|
# if the tomb is shared or compromised, an attacker could embed
|
|
# malicious code. When in doubt, open the tomb with the -n switch in
|
|
# order to skip this feature and verify the files mount-hooks and
|
|
# bind-hooks inside the tomb yourself before letting them run.
|
|
|
|
# Mount files and directories from the tomb to the current user's HOME.
|
|
#
|
|
# Synopsis: exec_safe_bind_hooks /path/to/mounted/tomb
|
|
#
|
|
# This can be a security risk if you share tombs with untrusted people.
|
|
# In that case, use the -n switch to turn off this feature.
|
|
exec_safe_bind_hooks() {
|
|
local mnt="$1" # First argument is the mount point of the tomb
|
|
|
|
# Default mount options are overridden with the -o switch
|
|
[[ -n ${(k)OPTS[-o]} ]] && MOUNTOPTS=${OPTS[-o]}
|
|
|
|
# No HOME set? Note: this should never happen again.
|
|
[[ -z $HOME ]] && {
|
|
_warning "How pitiful! A tomb, and no HOME."
|
|
return 1 }
|
|
|
|
[[ -z $mnt || ! -d $mnt ]] && {
|
|
_warning "Cannot exec bind hooks without a mounted tomb."
|
|
return 1 }
|
|
|
|
[[ -r "$mnt/bind-hooks" ]] || {
|
|
_verbose "bind-hooks not found in ::1 mount point::" $mnt
|
|
return 0 }
|
|
|
|
typeset -Al maps # Maps of files and directories to mount
|
|
typeset -al mounted # Track already mounted files and directories
|
|
|
|
# better parsing for bind hooks checks for two separated words on
|
|
# each line, using zsh word separator array subscript
|
|
_bindhooks="${mapfile[${mnt}/bind-hooks]}"
|
|
for h in ${(f)_bindhooks}; do
|
|
s="${h[(w)1]}"
|
|
d="${h[(w)2]}"
|
|
[[ "$s" = "" ]] && { _warning "bind-hooks file is broken"; return 1 }
|
|
[[ "$d" = "" ]] && { _warning "bind-hooks file is broken"; return 1 }
|
|
maps+=($s $d)
|
|
_verbose "bind-hook found: $s -> $d"
|
|
done
|
|
unset _bindhooks
|
|
|
|
for dir in ${(k)maps}; do
|
|
[[ "${dir[1]}" == "/" || "${dir[1,2]}" == ".." ]] && {
|
|
_warning "bind-hooks map format: local/to/tomb local/to/\$HOME"
|
|
continue }
|
|
|
|
[[ "${${maps[$dir]}[1]}" == "/" || "${${maps[$dir]}[1,2]}" == ".." ]] && {
|
|
_warning "bind-hooks map format: local/to/tomb local/to/\$HOME. Rolling back"
|
|
for dir in ${mounted}; do _sudo umount $dir; done
|
|
return 0 }
|
|
|
|
if [[ ! -r "$HOME/${maps[$dir]}" ]]; then
|
|
_warning "bind-hook target not existent, skipping ::1 home::/::2 subdir::" $HOME ${maps[$dir]}
|
|
elif [[ ! -r "$mnt/$dir" ]]; then
|
|
_warning "bind-hook source not found in tomb, skipping ::1 mount point::/::2 subdir::" $mnt $dir
|
|
else
|
|
_sudo mount -o bind,$MOUNTOPTS $mnt/$dir $HOME/${maps[$dir]} \
|
|
&& mounted+=("$HOME/${maps[$dir]}")
|
|
fi
|
|
done
|
|
}
|
|
|
|
# Execute automated actions configured in the tomb.
|
|
#
|
|
# Synopsis: exec_safe_func_hooks /path/to/mounted/tomb
|
|
#
|
|
# If an executable file named 'exec-hooks' is found inside the tomb,
|
|
# run it as a user. This might need a dialog for security on what is
|
|
# being run, however we expect you know well what is inside your tomb.
|
|
# If you're mounting an untrusted tomb, be safe and use the -n switch
|
|
# to verify what it would run if you let it. This feature opens the
|
|
# possibility to make encrypted executables.
|
|
exec_safe_func_hooks() {
|
|
# Only run if post-hooks has the executable bit set
|
|
[[ -x $mnt/exec-hooks ]] && {
|
|
_success "Exec hook: ::1 exec hook:: ::2 action:: ::3 argument::" \
|
|
"${mnt}/exec-hooks" "$1" "$2"
|
|
$mnt/exec-hooks "$1" "$2"
|
|
return $?
|
|
}
|
|
return 0
|
|
}
|
|
|
|
# }}} - Tomb open
|
|
|
|
# {{{ List
|
|
|
|
# list all tombs mounted in a readable format
|
|
# $1 is optional, to specify a tomb
|
|
list_tombs() {
|
|
|
|
local tombname tombmount tombfs tombfsopts tombloop
|
|
local ts tombtot tombused tombavail tombpercent tombp tombsince
|
|
local tombtty tombhost tombuid tombuser
|
|
# list all open tombs
|
|
mounted_tombs=(`list_tomb_mounts $1`)
|
|
[[ ${#mounted_tombs} == 0 ]] && {
|
|
_failure "I can't see any ::1 status:: tomb, may they all rest in peace." ${1:-open} }
|
|
|
|
for t in ${mounted_tombs}; do
|
|
mapper=`basename ${t[(ws:;:)1]}`
|
|
tombname=${t[(ws:;:)5]}
|
|
tombmount=${t[(ws:;:)2]}
|
|
tombfs=${t[(ws:;:)3]}
|
|
tombfsopts=${t[(ws:;:)4]}
|
|
tombloop=${mapper[(ws:.:)4]}
|
|
|
|
# calculate tomb size
|
|
ts=`df -hP /dev/mapper/$mapper |
|
|
awk "/mapper/"' { print $2 ";" $3 ";" $4 ";" $5 }'`
|
|
tombtot=${ts[(ws:;:)1]}
|
|
tombused=${ts[(ws:;:)2]}
|
|
tombavail=${ts[(ws:;:)3]}
|
|
tombpercent=${ts[(ws:;:)4]}
|
|
tombp=${tombpercent%%%}
|
|
|
|
# obsolete way to get the last open date from /dev/mapper
|
|
# which doesn't work when tomb filename contain dots
|
|
# tombsince=`date --date=@${mapper[(ws:.:)3]} +%c`
|
|
|
|
# find out who opens it from where
|
|
[[ -r ${tombmount}/.tty ]] && {
|
|
tombsince=$(_cat ${tombmount}/.last)
|
|
tombsince=$(date --date=@$tombsince +%c)
|
|
tombtty=$(_cat ${tombmount}/.tty)
|
|
tombhost=$(_cat ${tombmount}/.host)
|
|
tombuid=$(_cat ${tombmount}/.uid | tr -d ' ')
|
|
|
|
tombuser=$(getent passwd $tombuid)
|
|
tombuser=${tombuser[(ws@:@)1]}
|
|
}
|
|
|
|
{ option_is_set --get-mountpoint } && { print $tombmount; continue }
|
|
|
|
_message "::1 tombname:: open on ::2 tombmount:: using ::3 tombfsopts::" \
|
|
$tombname $tombmount $tombfsopts
|
|
|
|
_verbose "::1 tombname:: /dev/::2 tombloop:: device mounted (detach with losetup -d)" $tombname $tombloop
|
|
|
|
_message "::1 tombname:: open since ::2 tombsince::" $tombname $tombsince
|
|
|
|
[[ -z "$tombtty" ]] || {
|
|
_message "::1 tombname:: open by ::2 tombuser:: from ::3 tombtty:: on ::4 tombhost::" \
|
|
$tombname $tombuser $tombtty $tombhost
|
|
}
|
|
|
|
_message "::1 tombname:: size ::2 tombtot:: of which ::3 tombused:: (::5 tombpercent::%) is used: ::4 tombavail:: free " \
|
|
$tombname $tombtot $tombused $tombavail $tombpercent
|
|
|
|
[[ ${tombp} -ge 90 ]] && {
|
|
_warning "::1 tombname:: warning: your tomb is almost full!" $tombname
|
|
}
|
|
|
|
# Now check hooks
|
|
mounted_hooks=(`list_tomb_binds $tombname $tombmount`)
|
|
for h in ${mounted_hooks}; do
|
|
_message "::1 tombname:: hooks ::2 hookname:: on ::3 hookdest::" \
|
|
$tombname "`basename ${h[(ws:;:)1]}`" ${h[(ws:;:)2]}
|
|
done
|
|
done
|
|
}
|
|
|
|
|
|
# Print out an array of mounted tombs (internal use)
|
|
# Format is semi-colon separated list of attributes
|
|
# if 1st arg is supplied, then list only that tomb
|
|
#
|
|
# String positions in the semicolon separated array:
|
|
#
|
|
# 1. full mapper path
|
|
#
|
|
# 2. mountpoint
|
|
#
|
|
# 3. filesystem type
|
|
#
|
|
# 4. mount options
|
|
#
|
|
# 5. tomb name
|
|
list_tomb_mounts() {
|
|
[[ -z "$1" ]] && {
|
|
# list all open tombs
|
|
mount -l \
|
|
| awk '
|
|
BEGIN { main="" }
|
|
/^\/dev\/mapper\/tomb/ {
|
|
if(main==$1) next;
|
|
print $1 ";" $3 ";" $5 ";" $6 ";" $7
|
|
main=$1
|
|
}
|
|
'
|
|
} || { # list a specific tomb
|
|
# add square parens if not present
|
|
local tname
|
|
if [[ "${1[1]}" = "[" ]]; then tname=$1
|
|
else tname="[$1]"; fi
|
|
mount -l \
|
|
| awk -vtomb="$tname" '
|
|
BEGIN { main="" }
|
|
/^\/dev\/mapper\/tomb/ {
|
|
if($7!=tomb) next;
|
|
if(main==$1) next;
|
|
print $1 ";" $3 ";" $5 ";" $6 ";" $7
|
|
main=$1
|
|
}
|
|
'
|
|
}
|
|
}
|
|
|
|
# list_tomb_binds
|
|
# print out an array of mounted bind hooks (internal use)
|
|
# format is semi-colon separated list of attributes
|
|
# needs two arguments: name of tomb whose hooks belong
|
|
# mount tomb
|
|
list_tomb_binds() {
|
|
[[ -z "$2" ]] && {
|
|
_failure "Internal error: list_tomb_binds called without argument." }
|
|
|
|
# OK well, prepare for some insanity: parsing the mount table on GNU/Linux
|
|
# is like combing a Wookie while he is riding a speedbike down a valley.
|
|
|
|
typeset -A tombs
|
|
typeset -a binds
|
|
for t in "${(f)$(mount -l | grep '/dev/mapper/tomb.*]$')}"; do
|
|
len="${(w)#t}"
|
|
[[ "${t[(w)$len]}" = "$1" ]] || continue
|
|
tombs+=( ${t[(w)1]} ${t[(w)$len]} )
|
|
|
|
done
|
|
|
|
for m in ${(k)tombs}; do
|
|
for p in "${(f)$(cat /proc/mounts):s/\\040(deleted)/}"; do
|
|
# Debian's kernel appends a '\040(deleted)' to the mountpoint in /proc/mounts
|
|
# so if we parse the string as-is then this will break the parsing. How nice of them!
|
|
# Some bugs related to this are more than 10yrs old. Such Debian! Much stable! Very parsing!
|
|
# Bug #711183 umount parser for /proc/mounts broken on stale nfs mount (gets renamed to "/mnt/point (deleted)")
|
|
# Bug #711184 mount should not stat mountpoints on mount
|
|
# Bug #711187 linux-image-3.2.0-4-amd64: kernel should not rename mountpoint if nfs server is dead/unreachable
|
|
[[ "${p[(w)1]}" = "$m" ]] && {
|
|
[[ "${(q)p[(w)2]}" != "${(q)2}" ]] && {
|
|
# Our output format:
|
|
# mapper;mountpoint;fs;flags;name
|
|
binds+=("$m;${(q)p[(w)2]};${p[(w)3]};${p[(w)4]};${tombs[$m]}") }
|
|
}
|
|
done
|
|
done
|
|
|
|
# print the results out line by line
|
|
for b in $binds; do print - "$b"; done
|
|
}
|
|
|
|
# }}} - Tomb list
|
|
|
|
# {{{ Index and search
|
|
|
|
# index files in all tombs for search
|
|
# $1 is optional, to specify a tomb
|
|
index_tombs() {
|
|
{ command -v updatedb 1>/dev/null 2>/dev/null } || {
|
|
_failure "Cannot index tombs on this system: updatedb (mlocate) not installed." }
|
|
|
|
updatedbver=`updatedb --version | grep '^updatedb'`
|
|
[[ "$updatedbver" =~ "GNU findutils" ]] && {
|
|
_warning "Cannot use GNU findutils for index/search commands." }
|
|
[[ "$updatedbver" =~ "mlocate" ]] || {
|
|
_failure "Index command needs 'mlocate' to be installed." }
|
|
|
|
_verbose "$updatedbver"
|
|
|
|
mounted_tombs=(`list_tomb_mounts $1`)
|
|
[[ ${#mounted_tombs} == 0 ]] && {
|
|
# Considering one tomb
|
|
[[ -n "$1" ]] && {
|
|
_failure "There seems to be no open tomb engraved as [::1::]" $1 }
|
|
# Or more
|
|
_failure "I can't see any open tomb, may they all rest in peace." }
|
|
|
|
_success "Creating and updating search indexes."
|
|
|
|
# start the LibreOffice document converter if installed
|
|
{ command -v unoconv 1>/dev/null 2>/dev/null } && {
|
|
unoconv -l 2>/dev/null &
|
|
_verbose "unoconv listener launched."
|
|
sleep 1 }
|
|
|
|
for t in ${mounted_tombs}; do
|
|
mapper=`basename ${t[(ws:;:)1]}`
|
|
tombname=${t[(ws:;:)5]}
|
|
tombmount=${t[(ws:;:)2]}
|
|
[[ -r ${tombmount}/.noindex ]] && {
|
|
_message "Skipping ::1 tomb name:: (.noindex found)." $tombname
|
|
continue }
|
|
_message "Indexing ::1 tomb name:: filenames..." $tombname
|
|
updatedb -l 0 -o ${tombmount}/.updatedb -U ${tombmount}
|
|
|
|
# here we use swish to index file contents
|
|
[[ $SWISH == 1 ]] && {
|
|
_message "Indexing ::1 tomb name:: contents..." $tombname
|
|
rm -f ${tombmount}/.swishrc
|
|
_message "Generating a new swish-e configuration file: ::1 swish conf::" ${tombmount}/.swishrc
|
|
cat <<EOF > ${tombmount}/.swishrc
|
|
# index directives
|
|
DefaultContents TXT*
|
|
IndexDir $tombmount
|
|
IndexFile $tombmount/.swish
|
|
# exclude images
|
|
FileRules filename regex /\.jp.?g/i
|
|
FileRules filename regex /\.png/i
|
|
FileRules filename regex /\.gif/i
|
|
FileRules filename regex /\.tiff/i
|
|
FileRules filename regex /\.svg/i
|
|
FileRules filename regex /\.xcf/i
|
|
FileRules filename regex /\.eps/i
|
|
FileRules filename regex /\.ttf/i
|
|
# exclude audio
|
|
FileRules filename regex /\.mp3/i
|
|
FileRules filename regex /\.ogg/i
|
|
FileRules filename regex /\.wav/i
|
|
FileRules filename regex /\.mod/i
|
|
FileRules filename regex /\.xm/i
|
|
# exclude video
|
|
FileRules filename regex /\.mp4/i
|
|
FileRules filename regex /\.avi/i
|
|
FileRules filename regex /\.ogv/i
|
|
FileRules filename regex /\.ogm/i
|
|
FileRules filename regex /\.mkv/i
|
|
FileRules filename regex /\.mov/i
|
|
FileRules filename regex /\.flv/i
|
|
FileRules filename regex /\.webm/i
|
|
# exclude system
|
|
FileRules filename is ok
|
|
FileRules filename is lock
|
|
FileRules filename is control
|
|
FileRules filename is status
|
|
FileRules filename is proc
|
|
FileRules filename is sys
|
|
FileRules filename is supervise
|
|
FileRules filename regex /\.asc$/i
|
|
FileRules filename regex /\.gpg$/i
|
|
# pdf and postscript
|
|
FileFilter .pdf pdftotext "'%p' -"
|
|
FileFilter .ps ps2txt "'%p' -"
|
|
# compressed files
|
|
FileFilterMatch lesspipe "%p" /\.tgz$/i
|
|
FileFilterMatch lesspipe "%p" /\.zip$/i
|
|
FileFilterMatch lesspipe "%p" /\.gz$/i
|
|
FileFilterMatch lesspipe "%p" /\.bz2$/i
|
|
FileFilterMatch lesspipe "%p" /\.Z$/
|
|
# spreadsheets
|
|
FileFilterMatch unoconv "-d spreadsheet -f csv --stdout %P" /\.xls.*/i
|
|
FileFilterMatch unoconv "-d spreadsheet -f csv --stdout %P" /\.xlt.*/i
|
|
FileFilter .ods unoconv "-d spreadsheet -f csv --stdout %P"
|
|
FileFilter .ots unoconv "-d spreadsheet -f csv --stdout %P"
|
|
FileFilter .dbf unoconv "-d spreadsheet -f csv --stdout %P"
|
|
FileFilter .dif unoconv "-d spreadsheet -f csv --stdout %P"
|
|
FileFilter .uos unoconv "-d spreadsheet -f csv --stdout %P"
|
|
FileFilter .sxc unoconv "-d spreadsheet -f csv --stdout %P"
|
|
# word documents
|
|
FileFilterMatch unoconv "-d document -f txt --stdout %P" /\.doc.*/i
|
|
FileFilterMatch unoconv "-d document -f txt --stdout %P" /\.odt.*/i
|
|
FileFilterMatch unoconv "-d document -f txt --stdout %P" /\.rtf.*/i
|
|
FileFilterMatch unoconv "-d document -f txt --stdout %P" /\.tex$/i
|
|
# native html support
|
|
IndexContents HTML* .htm .html .shtml
|
|
IndexContents XML* .xml
|
|
EOF
|
|
|
|
swish-e -c ${tombmount}/.swishrc -S fs -v3
|
|
}
|
|
_message "Search index updated."
|
|
done
|
|
}
|
|
|
|
search_tombs() {
|
|
{ command -v locate 1>/dev/null 2>/dev/null } || {
|
|
_failure "Cannot index tombs on this system: updatedb (mlocate) not installed." }
|
|
|
|
updatedbver=`updatedb --version | grep '^updatedb'`
|
|
[[ "$updatedbver" =~ "GNU findutils" ]] && {
|
|
_warning "Cannot use GNU findutils for index/search commands." }
|
|
[[ "$updatedbver" =~ "mlocate" ]] || {
|
|
_failure "Index command needs 'mlocate' to be installed." }
|
|
|
|
_verbose "$updatedbver"
|
|
|
|
# list all open tombs
|
|
mounted_tombs=(`list_tomb_mounts`)
|
|
[[ ${#mounted_tombs} == 0 ]] && {
|
|
_failure "I can't see any open tomb, may they all rest in peace." }
|
|
|
|
_success "Searching for: ::1::" ${(f)@}
|
|
for t in ${mounted_tombs}; do
|
|
_verbose "Checking for index: ::1::" ${t}
|
|
mapper=`basename ${t[(ws:;:)1]}`
|
|
tombname=${t[(ws:;:)5]}
|
|
tombmount=${t[(ws:;:)2]}
|
|
[[ -r ${tombmount}/.updatedb ]] && {
|
|
# Use mlocate to search hits on filenames
|
|
_message "Searching filenames in tomb ::1 tomb name::" $tombname
|
|
locate -d ${tombmount}/.updatedb -e -i "${(f)@}"
|
|
_message "Matches found: ::1 matches::" \
|
|
$(locate -d ${tombmount}/.updatedb -e -i -c ${(f)@})
|
|
|
|
# Use swish-e to search over contents
|
|
[[ $SWISH == 1 && -r $tombmount/.swish ]] && {
|
|
_message "Searching contents in tomb ::1 tomb name::" $tombname
|
|
swish-e -w ${@} -f $tombmount/.swish -H0 }
|
|
} || {
|
|
_warning "Skipping tomb ::1 tomb name::: not indexed." $tombname
|
|
_warning "Run 'tomb index' to create indexes." }
|
|
done
|
|
_message "Search completed."
|
|
}
|
|
|
|
# }}} - Index and search
|
|
|
|
# {{{ Resize
|
|
|
|
# resize tomb file size
|
|
resize_tomb() {
|
|
local tombpath="$1" # First argument is the path to the tomb
|
|
|
|
_message "Commanded to resize tomb ::1 tomb name:: to ::2 size:: mebibytes." $1 $OPTS[-s]
|
|
|
|
[[ -z "$tombpath" ]] && _failure "No tomb name specified for resizing."
|
|
[[ ! -r $tombpath ]] && _failure "Cannot find ::1::" $tombpath
|
|
|
|
newtombsize="`option_value -s`"
|
|
[[ -z "$newtombsize" ]] && {
|
|
_failure "Aborting operations: new size was not specified, use -s" }
|
|
|
|
# this also calls _plot()
|
|
is_valid_tomb $tombpath
|
|
|
|
_load_key # Try loading new key from option -k and set TOMBKEYFILE
|
|
|
|
local oldtombsize=$(( `stat -c %s "$TOMBPATH" 2>/dev/null` / 1048576 ))
|
|
local mounted_tomb=`mount -l |
|
|
awk -vtomb="[$TOMBNAME]" '/^\/dev\/mapper\/tomb/ { if($7==tomb) print $1 }'`
|
|
|
|
# Tomb must not be open
|
|
[[ -z "$mounted_tomb" ]] || {
|
|
_failure "Please close the tomb ::1 tomb name:: before trying to resize it." $TOMBNAME }
|
|
# New tomb size must be specified
|
|
[[ -n "$newtombsize" ]] || {
|
|
_failure "You must specify the new size of ::1 tomb name::" $TOMBNAME }
|
|
# New tomb size must be an integer
|
|
[[ $newtombsize == <-> ]] || _failure "Size is not an integer."
|
|
|
|
# Tombs can only grow in size
|
|
if [[ "$newtombsize" -gt "$oldtombsize" ]]; then
|
|
|
|
delta="$(( $newtombsize - $oldtombsize ))"
|
|
|
|
_message "Generating ::1 tomb file:: of ::2 size::MiB" $TOMBFILE $newtombsize
|
|
|
|
_verbose "Data dump using ::1:: from /dev/urandom" ${DD[1]}
|
|
${=DD} if=/dev/urandom bs=1048576 count=${delta} >> $TOMBPATH
|
|
[[ $? == 0 ]] || {
|
|
_failure "Error creating the extra resize ::1 size::, operation aborted." \
|
|
$tmp_resize }
|
|
|
|
# If same size this allows to re-launch resize if pinentry expires
|
|
# so that it will continue resizing without appending more space.
|
|
# Resizing the partition to the file size cannot harm data anyway.
|
|
elif [[ "$newtombsize" = "$oldtombsize" ]]; then
|
|
_message "Tomb seems resized already, operating filesystem stretch"
|
|
else
|
|
_failure "The new size must be greater then old tomb size."
|
|
fi
|
|
|
|
{ option_is_set --tomb-pwd } && {
|
|
tomb_pwd="`option_value --tomb-pwd`"
|
|
_verbose "tomb-pwd = ::1 tomb pass::" $tomb_pwd
|
|
ask_key_password "$tomb_pwd"
|
|
} || {
|
|
ask_key_password
|
|
}
|
|
[[ $? == 0 ]] || _failure "No valid password supplied."
|
|
|
|
lo_mount "$TOMBPATH"
|
|
nstloop=`lo_new`
|
|
|
|
mapdate=`date +%s`
|
|
mapper="tomb.$TOMBNAME.$mapdate.$(basename $nstloop)"
|
|
|
|
_message "opening tomb"
|
|
_cryptsetup luksOpen ${nstloop} ${mapper} || {
|
|
_failure "Failure mounting the encrypted file." }
|
|
|
|
_sudo cryptsetup resize "${mapper}" || {
|
|
_failure "cryptsetup failed to resize ::1 mapper::" $mapper }
|
|
|
|
_sudo e2fsck -p -f /dev/mapper/${mapper} || {
|
|
_failure "e2fsck failed to check ::1 mapper::" $mapper }
|
|
|
|
_sudo resize2fs /dev/mapper/${mapper} || {
|
|
_failure "resize2fs failed to resize ::1 mapper::" $mapper }
|
|
|
|
# close and free the loop device
|
|
_sudo cryptsetup luksClose "${mapper}"
|
|
|
|
return 0
|
|
}
|
|
|
|
# }}}
|
|
|
|
# {{{ Close
|
|
|
|
umount_tomb() {
|
|
local tombs how_many_tombs
|
|
local pathmap mapper tombname tombmount loopdev
|
|
local ans pidk pname
|
|
|
|
if [ "$1" = "all" ]; then
|
|
mounted_tombs=(`list_tomb_mounts`)
|
|
else
|
|
mounted_tombs=(`list_tomb_mounts $1`)
|
|
fi
|
|
|
|
[[ ${#mounted_tombs} == 0 ]] && {
|
|
_failure "There is no open tomb to be closed." }
|
|
|
|
[[ ${#mounted_tombs} -gt 1 && -z "$1" ]] && {
|
|
_warning "Too many tombs mounted, please specify one (see tomb list)"
|
|
_warning "or issue the command 'tomb close all' to close them all."
|
|
_failure "Operation aborted." }
|
|
|
|
for t in ${mounted_tombs}; do
|
|
mapper=`basename ${t[(ws:;:)1]}`
|
|
|
|
tombname=${t[(ws:;:)5]}
|
|
tombmount=${t[(ws:;:)2]}
|
|
tombfs=${t[(ws:;:)3]}
|
|
tombfsopts=${t[(ws:;:)4]}
|
|
tombloop=${mapper[(ws:.:)4]}
|
|
|
|
_verbose "Name: ::1 tomb name::" $tombname
|
|
_verbose "Mount: ::1 mount point::" $tombmount
|
|
_verbose "Loop: ::1 mount loop::" $tombloop
|
|
_verbose "Mapper: ::1 mapper::" $mapper
|
|
|
|
[[ -e "$mapper" ]] && {
|
|
_warning "Tomb not found: ::1 tomb file::" $1
|
|
_warning "Please specify an existing tomb."
|
|
return 0 }
|
|
|
|
option_is_set -n || {
|
|
exec_safe_func_hooks \
|
|
close "$tombmount" "$tombname" "$tombloop" "$mapper"
|
|
exec_hook_res=$?
|
|
[[ $exec_hook_res = 0 ]] || {
|
|
_warning "close exec-hook returns a non-zero error code: ::1 error::" $exec_hook_res
|
|
_failure "Operation aborted"
|
|
}
|
|
}
|
|
|
|
_message "Closing tomb ::1 tomb name:: mounted on ::2 mount point::" \
|
|
$tombname $tombmount
|
|
|
|
# check if there are binded dirs and close them
|
|
bind_tombs=(`list_tomb_binds $tombname $tombmount`)
|
|
for b in ${(f)"$(list_tomb_binds $tombname $tombmount)"}; do
|
|
bind_mapper="${b[(ws:;:)1]}"
|
|
bind_mount="${b[(ws:;:)2]}"
|
|
_message "Closing tomb bind hook: ::1 hook::" $bind_mount
|
|
_sudo umount $bind_mount ||
|
|
_failure "Tomb bind hook ::1 hook:: is busy, cannot close tomb." $bind_mount
|
|
done
|
|
|
|
# check if the tomb is actually still mounted. Background:
|
|
# When mounted on a binded directory in appears twice in 'list_tomb_binds'
|
|
# and will get umounted automatically through the above function
|
|
# causing an error and a remaining (decrypted!) loop device
|
|
# posing a security risk.
|
|
# See https://github.com/dyne/Tomb/issues/273
|
|
|
|
# checking for tombs
|
|
mount | grep -w "$tombmount" >/dev/null
|
|
mount_status=$?
|
|
# return value of 0 for grep means it found at least one entry
|
|
# return value of 1 means nothing was found, implying, the tomb
|
|
# mount was already umounted.
|
|
if [ $mount_status = 0 ]; then
|
|
# Tomb was not umounted through the above command
|
|
# Will do so now
|
|
_verbose "Performing umount of ::1 mount point::" $tombmount
|
|
_sudo umount ${tombmount}
|
|
[[ $? = 0 ]] || { _failure "Tomb is busy, cannot umount!" }
|
|
else
|
|
# Tomb was already umounted, will not do it again
|
|
_warning "Tomb was already umounted, possibly through a binded directory"
|
|
fi
|
|
|
|
# If we used a default mountpoint and is now empty, delete it
|
|
tombname_regex=${tombname//\[/}
|
|
tombname_regex=${tombname_regex//\]/}
|
|
|
|
[[ "$tombmount" =~ "(/run)?/media(/$_USER)?/$tombname_regex" ]] && {
|
|
_sudo rmdir $tombmount }
|
|
|
|
_sudo cryptsetup luksClose $mapper ||
|
|
_failure "Error occurred in cryptsetup luksClose ::1 mapper::" $mapper
|
|
|
|
# Normally the loopback device is detached when unused
|
|
[[ -e "/dev/$tombloop" ]] && {
|
|
_sudo losetup -d "/dev/$tombloop" ||
|
|
_verbose "/dev/$tombloop was already closed."
|
|
}
|
|
|
|
_success "Tomb ::1 tomb name:: closed: your bones will rest in peace." $tombname
|
|
|
|
done # loop across mounted tombs
|
|
|
|
return 0
|
|
}
|
|
|
|
list_processes() {
|
|
# $1 = (optional) name of tomb
|
|
# returns a list of process UIDs, one per line
|
|
local mounted_tombs i
|
|
local pnum puid pcmd powner found
|
|
found=0
|
|
mounted_tombs=(`list_tomb_mounts $1`)
|
|
if [[ "${#mounted_tombs}" -gt 0 ]]; then
|
|
if [[ "$1" = "" ]]; then
|
|
_success "Listing processes running inside all open tombs..."
|
|
else
|
|
_success "Listing processes running inside tomb '::1 tombname::'..." "$1"
|
|
fi
|
|
|
|
for i in ${mounted_tombs}; do
|
|
_verbose "scanning tomb: ::1 tombmount::" $i
|
|
tombmount=${i[(ws:;:)2]}
|
|
tombname=${i[(ws:;:)5]}
|
|
for pnum in ${(f)"$(_sudo lsof -t +D $tombmount)"}; do
|
|
found=$(($found + 1))
|
|
_verbose "process found: $pnum"
|
|
puid=$(_cat /proc/${pnum}/loginuid)
|
|
pcmd=$(_cat /proc/${pnum}/cmdline)
|
|
powner=$(getent passwd $puid)
|
|
powner=${powner[(ws@:@)1]}
|
|
_verbose "process found: $pnum $pcmd ($powner)"
|
|
_message "::1 tombname:: ::2 cmd:: (::3 owner::)" \
|
|
$tombname $pcmd $powner
|
|
done
|
|
done
|
|
fi
|
|
_message "::1 foundproc:: running processes found inside ::2 numtombs:: open tombs" \
|
|
$found ${#mounted_tombs}
|
|
}
|
|
|
|
# Kill all processes using the tomb
|
|
slam_tomb() {
|
|
# $1 = (optional) name of tomb to slam, or "all" if more mounted
|
|
|
|
if [ "$1" = "all" ]; then
|
|
mounted_tombs=(`list_tomb_mounts`)
|
|
else
|
|
mounted_tombs=(`list_tomb_mounts $1`)
|
|
fi
|
|
|
|
[[ ${#mounted_tombs} == 0 ]] && {
|
|
_failure "There is no open tomb to be closed." }
|
|
|
|
[[ ${#mounted_tombs} -gt 1 && -z "$1" ]] && {
|
|
_warning "Too many tombs mounted, please specify one (see tomb list)"
|
|
_warning "or issue the command 'tomb close all' to close them all."
|
|
_failure "Operation aborted." }
|
|
|
|
local pnum puid pcmd powner result
|
|
result=0
|
|
# iterate through all mounted tomb affected
|
|
for i in ${mounted_tombs}; do
|
|
tombname=${i[(ws:;:)5]}
|
|
tombmount=${i[(ws:;:)2]}
|
|
_success "Slamming tomb ::1 tombname:: mounted on ::2 tombmount::" \
|
|
${tombname} ${tombmount}
|
|
# iterate through all processes running in mounted tombs
|
|
for pnum in ${(f)"$(_sudo lsof -t +D $tombmount)"}; do
|
|
puid=$(_cat /proc/${pnum}/loginuid)
|
|
pcmd=$(_cat /proc/${pnum}/cmdline)
|
|
powner=$(getent passwd $puid)
|
|
powner=${powner[(ws@:@)1]}
|
|
_verbose "process found: $pnum $pcmd ($powner)"
|
|
# iterate through 3 different signals to send, break on success
|
|
for s in TERM HUP KILL; do
|
|
_message "::1 tombname:: sending ::2 sig:: to ::3 cmd:: (::4 uid::)" \
|
|
${tombname} ${s} ${pcmd} ${powner}
|
|
_sudo kill -$s $pnum
|
|
# give some time to the process for a clean quit
|
|
sleep .5
|
|
# stop sending other signals if kill was succesfull
|
|
[[ -r /proc/$pnum ]] || break
|
|
done
|
|
# if process still running then signal failure
|
|
[[ -r /proc/$pnum ]] && {
|
|
_warning "Can't kill ::1 process:: ::2 pcmd:: (::3 powner::)" \
|
|
$pnum $pcmd $powner
|
|
result=1 }
|
|
done
|
|
# if it failed killing a process, report it
|
|
[[ $result = 0 ]] && umount_tomb $tombname
|
|
done
|
|
return $result
|
|
}
|
|
|
|
# }}} - Tomb close
|
|
|
|
# {{{ Main routine
|
|
|
|
main() {
|
|
|
|
_ensure_dependencies # Check dependencies are present or bail out
|
|
|
|
local -A subcommands_opts
|
|
### Options configuration
|
|
#
|
|
# Hi, dear developer! Are you trying to add a new subcommand, or
|
|
# to add some options? Well, keep in mind that option names are
|
|
# global: they cannot bear a different meaning or behaviour across
|
|
# subcommands. The only exception is "-o" which means: "options
|
|
# passed to the local subcommand", and thus can bear a different
|
|
# meaning for different subcommands.
|
|
#
|
|
# For example, "-s" means "size" and accepts one argument. If you
|
|
# are tempted to add an alternate option "-s" (e.g., to mean
|
|
# "silent", and that doesn't accept any argument) DON'T DO IT!
|
|
#
|
|
# There are two reasons for that:
|
|
# I. Usability; users expect that "-s" is "size"
|
|
# II. Option parsing WILL EXPLODE if you do this kind of bad
|
|
# things (it will complain: "option defined more than once")
|
|
#
|
|
# If you want to use the same option in multiple commands then you
|
|
# can only use the non-abbreviated long-option version like:
|
|
# -force and NOT -f
|
|
#
|
|
main_opts=(q -quiet=q D -debug=D h -help=h v -version=v f -force=f -tmp: U: G: T: -no-color -unsafe g -gpgkey=g)
|
|
subcommands_opts[__default]=""
|
|
# -o in open and mount is used to pass alternate mount options
|
|
subcommands_opts[open]="n -nohook=n k: -kdf: o: -ignore-swap -tomb-pwd: r: R: "
|
|
subcommands_opts[mount]=${subcommands_opts[open]}
|
|
|
|
subcommands_opts[create]="" # deprecated, will issue warning
|
|
|
|
# -o in forge and lock is used to pass an alternate cipher.
|
|
subcommands_opts[forge]="-ignore-swap k: -kdf: o: -tomb-pwd: -use-urandom r: R: "
|
|
subcommands_opts[dig]="-ignore-swap s: -size=s "
|
|
subcommands_opts[lock]="-ignore-swap k: -kdf: o: -tomb-pwd: r: R: "
|
|
subcommands_opts[setkey]="k: -ignore-swap -kdf: -tomb-old-pwd: -tomb-pwd: r: R: "
|
|
subcommands_opts[engrave]="k: "
|
|
|
|
subcommands_opts[passwd]="k: -ignore-swap -kdf: -tomb-old-pwd: -tomb-pwd: r: R: "
|
|
subcommands_opts[close]=""
|
|
subcommands_opts[help]=""
|
|
subcommands_opts[slam]=""
|
|
subcommands_opts[ps]=""
|
|
subcommands_opts[list]="-get-mountpoint "
|
|
|
|
subcommands_opts[index]=""
|
|
subcommands_opts[search]=""
|
|
|
|
subcommands_opts[help]=""
|
|
subcommands_opts[bury]="k: -tomb-pwd: r: R: "
|
|
subcommands_opts[exhume]="k: -tomb-pwd: r: R: "
|
|
# subcommands_opts[decompose]=""
|
|
# subcommands_opts[recompose]=""
|
|
# subcommands_opts[install]=""
|
|
subcommands_opts[askpass]=""
|
|
subcommands_opts[source]=""
|
|
subcommands_opts[resize]="-ignore-swap s: -size=s k: -tomb-pwd: r: R: "
|
|
subcommands_opts[check]="-ignore-swap "
|
|
# subcommands_opts[translate]=""
|
|
|
|
### Detect subcommand
|
|
local -aU every_opts #every_opts behave like a set; that is, an array with unique elements
|
|
for optspec in $subcommands_opts$main_opts; do
|
|
for opt in ${=optspec}; do
|
|
every_opts+=${opt}
|
|
done
|
|
done
|
|
local -a oldstar
|
|
oldstar=("${(@)argv}")
|
|
#### detect early: useful for --option-parsing
|
|
zparseopts -M -D -Adiscardme ${every_opts}
|
|
if [[ -n ${(k)discardme[--option-parsing]} ]]; then
|
|
print $1
|
|
if [[ -n "$1" ]]; then
|
|
return 1
|
|
fi
|
|
return 0
|
|
fi
|
|
unset discardme
|
|
if ! zparseopts -M -E -D -Adiscardme ${every_opts}; then
|
|
_failure "Error parsing."
|
|
return 127
|
|
fi
|
|
unset discardme
|
|
subcommand=$1
|
|
if [[ -z $subcommand ]]; then
|
|
subcommand="__default"
|
|
fi
|
|
|
|
if [[ -z ${(k)subcommands_opts[$subcommand]} ]]; then
|
|
_warning "There's no such command \"::1 subcommand::\"." $subcommand
|
|
exitv=127 _failure "Please try -h for help."
|
|
fi
|
|
argv=("${(@)oldstar}")
|
|
unset oldstar
|
|
|
|
### Parsing global + command-specific options
|
|
# zsh magic: ${=string} will split to multiple arguments when spaces occur
|
|
set -A cmd_opts ${main_opts} ${=subcommands_opts[$subcommand]}
|
|
# if there is no option, we don't need parsing
|
|
if [[ -n $cmd_opts ]]; then
|
|
zparseopts -M -E -D -AOPTS ${cmd_opts}
|
|
if [[ $? != 0 ]]; then
|
|
_warning "Some error occurred during option processing."
|
|
exitv=127 _failure "See \"tomb help\" for more info."
|
|
fi
|
|
fi
|
|
#build PARAM (array of arguments) and check if there are unrecognized options
|
|
ok=0
|
|
PARAM=()
|
|
for arg in $*; do
|
|
if [[ $arg == '--' || $arg == '-' ]]; then
|
|
ok=1
|
|
continue #it shouldn't be appended to PARAM
|
|
elif [[ $arg[1] == '-' ]]; then
|
|
if [[ $ok == 0 ]]; then
|
|
exitv=127 _failure "Unrecognized option ::1 arg:: for subcommand ::2 subcommand::" $arg $subcommand
|
|
fi
|
|
fi
|
|
PARAM+=$arg
|
|
done
|
|
# First parameter actually is the subcommand: delete it and shift
|
|
[[ $subcommand != '__default' ]] && { PARAM[1]=(); shift }
|
|
|
|
### End parsing command-specific options
|
|
|
|
# Use colors unless told not to
|
|
{ ! option_is_set --no-color } && { autoload -Uz colors && colors }
|
|
# Some options are only available during insecure mode
|
|
{ ! option_is_set --unsafe } && {
|
|
for opt in --tomb-pwd --use-urandom --tomb-old-pwd; do
|
|
{ option_is_set $opt } && {
|
|
exitv=127 _failure "You specified option ::1 option::, which is DANGEROUS and should only be used for testing\nIf you really want so, add --unsafe" $opt }
|
|
done
|
|
}
|
|
# read -t or --tmp flags to set a custom temporary directory
|
|
option_is_set --tmp && TMPPREFIX=$(option_value --tmp)
|
|
|
|
|
|
# When we run as root, we remember the original uid:gid to set
|
|
# permissions for the calling user and drop privileges
|
|
_whoami # Reset _UID, _GID, _TTY
|
|
|
|
[[ "$PARAM" == "" ]] && {
|
|
_verbose "Tomb command: ::1 subcommand::" $subcommand
|
|
} || {
|
|
_verbose "Tomb command: ::1 subcommand:: ::2 param::" $subcommand $PARAM
|
|
}
|
|
|
|
[[ -z $_UID ]] || {
|
|
_verbose "Caller: uid[::1 uid::], gid[::2 gid::], tty[::3 tty::]." \
|
|
$_UID $_GID $_TTY
|
|
}
|
|
|
|
_verbose "Temporary directory: $TMPPREFIX"
|
|
|
|
# Process subcommand
|
|
case "$subcommand" in
|
|
|
|
# USAGE
|
|
help)
|
|
usage
|
|
;;
|
|
|
|
# DEPRECATION notice (leave here as 'create' is still present in old docs)
|
|
create)
|
|
_warning "The create command is deprecated, please use dig, forge and lock instead."
|
|
_warning "For more informations see Tomb's manual page (man tomb)."
|
|
_failure "Operation aborted."
|
|
;;
|
|
|
|
# CREATE Step 1: dig -s NN file.tomb
|
|
dig)
|
|
dig_tomb $PARAM
|
|
;;
|
|
|
|
# CREATE Step 2: forge file.tomb.key
|
|
forge)
|
|
forge_key $PARAM
|
|
;;
|
|
|
|
# CREATE Step 2: lock -k file.tomb.key file.tomb
|
|
lock)
|
|
lock_tomb_with_key $PARAM
|
|
;;
|
|
|
|
# Open the tomb
|
|
mount|open)
|
|
mount_tomb $PARAM
|
|
;;
|
|
|
|
# List all processes using a tomb
|
|
ps)
|
|
list_processes $PARAM
|
|
;;
|
|
|
|
# Slam a tomb killing all processes running inside
|
|
slam)
|
|
slam_tomb $PARAM
|
|
;;
|
|
|
|
# Close the tomb
|
|
# `slam` is used to force closing.
|
|
umount|close)
|
|
[[ "$subcommand" == "slam" ]] && {
|
|
SLAM=1
|
|
[[ $LSOF == 0 ]] && {
|
|
unset SLAM
|
|
_warning "lsof not installed: cannot slam tombs."
|
|
_warning "Trying a regular close." }}
|
|
umount_tomb $PARAM[1]
|
|
;;
|
|
|
|
# Grow tomb's size
|
|
resize)
|
|
[[ $RESIZER == 0 ]] && {
|
|
_failure "Resize2fs not installed: cannot resize tombs." }
|
|
resize_tomb $PARAM[1]
|
|
;;
|
|
|
|
## Contents manipulation
|
|
|
|
# Index tomb contents
|
|
index)
|
|
index_tombs $PARAM[1]
|
|
;;
|
|
|
|
# List tombs
|
|
list)
|
|
list_tombs $PARAM[1]
|
|
;;
|
|
|
|
# Search tomb contents
|
|
search)
|
|
search_tombs $PARAM
|
|
;;
|
|
|
|
## Locking operations
|
|
|
|
# Export key to QR Code
|
|
engrave)
|
|
[[ $QRENCODE == 0 ]] && {
|
|
_failure "QREncode not installed: cannot engrave keys on paper." }
|
|
engrave_key $PARAM
|
|
;;
|
|
|
|
# Change password on existing key
|
|
passwd)
|
|
change_passwd $PARAM[1]
|
|
;;
|
|
|
|
# Change tomb key
|
|
setkey)
|
|
change_tomb_key $PARAM
|
|
;;
|
|
|
|
# STEGANOGRAPHY: hide key inside an image
|
|
bury)
|
|
[[ $STEGHIDE == 0 ]] && {
|
|
_failure "Steghide not installed: cannot bury keys into images." }
|
|
bury_key $PARAM[1]
|
|
;;
|
|
|
|
# STEGANOGRAPHY: read key hidden in an image
|
|
exhume)
|
|
[[ $STEGHIDE == 0 ]] && {
|
|
_failure "Steghide not installed: cannot exhume keys from images." }
|
|
exhume_key $PARAM[1]
|
|
;;
|
|
|
|
## Internal commands useful to developers
|
|
|
|
# Make tomb functions available to the calling shell or script
|
|
'source') return 0 ;;
|
|
|
|
# Ask user for a password interactively
|
|
askpass) ask_password $PARAM[1] $PARAM[2] ;;
|
|
|
|
# Default operation: presentation, or version information with -v
|
|
__default)
|
|
_print "Tomb ::1 version:: - a strong and gentle undertaker for your secrets" $VERSION
|
|
_print "\000"
|
|
_print " Copyright (C) 2007-2017 Dyne.org Foundation, License GNU GPL v3+"
|
|
_print " This is free software: you are free to change and redistribute it"
|
|
_print " For the latest sourcecode go to <http://dyne.org/software/tomb>"
|
|
_print "\000"
|
|
option_is_set -v && {
|
|
local langwas=$LANG
|
|
LANG=en
|
|
_print " This source code is distributed in the hope that it will be useful,"
|
|
_print " but WITHOUT ANY WARRANTY; without even the implied warranty of"
|
|
_print " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
|
|
LANG=$langwas
|
|
_print " When in need please refer to <http://dyne.org/support>."
|
|
_print "\000"
|
|
_print "System utils:"
|
|
_print "\000"
|
|
cat <<EOF
|
|
`sudo -V | head -n1`
|
|
`cryptsetup --version`
|
|
`pinentry --version`
|
|
`gpg --version | head -n1` - key forging algorithms (GnuPG symmetric ciphers):
|
|
`list_gnupg_ciphers`
|
|
EOF
|
|
_print "\000"
|
|
_print "Optional utils:"
|
|
_print "\000"
|
|
_list_optional_tools version
|
|
return 0
|
|
}
|
|
usage
|
|
;;
|
|
|
|
# Reject unknown command and suggest help
|
|
*)
|
|
_warning "Command \"::1 subcommand::\" not recognized." $subcommand
|
|
_message "Try -h for help."
|
|
return 1
|
|
;;
|
|
esac
|
|
return $?
|
|
}
|
|
|
|
# }}}
|
|
|
|
# {{{ Run
|
|
|
|
main "$@" || exit $? # Prevent `source tomb source` from exiting
|
|
|
|
# }}}
|
|
|
|
# -*- tab-width: 4; indent-tabs-mode:nil; -*-
|
|
# vim: set shiftwidth=4 expandtab:
|