Llewellyn/Tomb
1
0
Fork 0
mirror of https://github.com/Llewellynvdm/Tomb.git synced 2024-11-22 12:35:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

updated extras/gtomb to latest by parazyd

Browse Source
This commit is contained in:
Jaromil 2016-12-29 17:29:15 +01:00
parent 7b72f07f96
commit 88f5a926f0
3 changed files with 310 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
extras/gtomb/LICENSE
View File

@ -1,11 +1,12 @@
gtomb - A GUI wrapper for Tomb, the crypto undertaker
Copyright (C) 2015 Parazyd <parazyd AT dyne DOT org>
Copyright (C) 2015-2016 Parazyd <parazyd@dyne.org>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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. See the

4
extras/gtomb/README.md
View File

@ -11,7 +11,7 @@ list and the script will run it for you. Easy-peasy.
### Random notes
* If you type in your sudo password once correctly, in the next 5 (or whatever your sudoers timeout is) minutes, you can type in the wrong password as well.
* The function for catching cancellation sometimes fails because of bad ps syntax. No idea why yet.
* The function for catching cancellation sometimes fails because of bad ps syntax. (Possibly fixed, needs more testing)
## Dependencies
* [tomb](https://github.com/dyne/Tomb) (also get tomb's dependencies)
@ -19,8 +19,8 @@ list and the script will run it for you. Easy-peasy.
## TODO
* Complete error checking
* Figure out why ps fails sometimes
* and more stuff
## What you need to do
* Be patient or help with coding :)
* Request features

574
extras/gtomb/gtomb
View File

@ -1,43 +1,32 @@
#!/usr/bin/env zsh
#
# gtomb - a GUI wrapper for Tomb
# Copyright (c) 2015-2016 parazyd
# gtomb is written and maintained by parazyd <parazyd@dyne.org>
#
# Maintained and written by parazyd <parazyd AT dyne DOT org>
# https://github.com/parazyd/gtomb
# https://github.com/dyne/Tomb
# This file is part of gtomb
#
# gtomb is experimental software. It still does not work completely as
# intended and should be used with caution.
#
# {{{ License
# gtomb - A GUI wrapper for Tomb, the crypto undertaker
# Copyright (C) 2015 Parazyd <parazyd AT dyne DOT org>
#
# This program is free software: you can redistribute it and/or modify
# This source code is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# This software 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. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see http://www.gnu.org/licenses/
#
# }}}
# along with this source code. If not, see <http://www.gnu.org/licenses/>.
#set -x
#set -v
ver="0.6.2"
TOMBPATH="/usr/bin/tomb" # Set this to your tomb executable's path
KDFPATH="/usr/bin/" # Set this to the path of your KDF binaries (if you're using them)
ver="0.8"
TOMBPATH="/usr/local/bin/tomb" # Set this to your tomb executable's path
KDFPATH="/usr/local/bin/" # Set this to the path of your KDF binaries (if you're using them)
# The ones below should not need changing
HEXENC="$KDFPATH/tomb-kdb-hexencode"
GENSALT="$KDFPATH/tomb-kdb-pbkdf2-gensalt"
GETITER="$KDFPATH/tomb-kdb-pbkdf2-getiter"
PBKDF="$KDFPATH/tomb-kdb-pbkdf2"
_DD=/bin/dd
# {{{ monmort icon
MONMORT="/tmp/monmort.png"
@ -52,15 +41,19 @@ b2RpZnkAMjAxMS0wMS0xMlQwOTozNDoyNCswMTowMNKiZVMAAAAASUVORK5CYII="
echo -e "$ICONB64" | base64 --decode > $MONMORT
# }}}
function _ { _clean } # I like cleaning :)
# {{{ sudo functions
function _sudo {
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
}
# {{{ sudo function
function _sudowrong {
if [[ $? == 1 ]]; then
[[ $? = 0 ]] || {
sudoassword=$(ask_password "Wrong password. Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
fi
}
}
# }}}
@ -71,7 +64,6 @@ function _zenques {
--question \
--text="$1"
}
function _fsel {
zenity \
--window-icon="$MONMORT" \
@ -93,6 +85,21 @@ function _zenwarn {
--title="$1" \
--text="$2"
}
function _info {
which notify-send > /dev/null
if [[ $? == "0" ]]; then
_zenotif $*
else
_zeninfo $*
fi
}
function _zenotif {
zenity \
--window-icon="$MONMORT" \
--notification \
--title="$1" \
--text="$2"
}
function _zeninfo {
zenity \
--window-icon="$MONMORT" \
@ -141,7 +148,6 @@ function _zenentry {
# 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
@ -299,22 +305,19 @@ function _failure die() {
# {{{ _clean - Clean function, removes sensitive stuff from memory
function _clean {
echo "Cleaning..." # For debugging.
unset $?
local rr="$RANDOM"
while [[ ${#rr} -lt 500 ]]; do
rr+="$RANDOM"
done
command="$rr"; unset command
cmnd="$rr"; unset cmnd
tombname="$rr"; unset tombname
tombsize="$rr"; unset tombsize
keyfile="$rr"; unset keyfile
sudoassword="$rr"; unset sudoassword
tombtmp=/tmp/tombtmp
if [ -f $tombtmp ]
then
tombtmp="/tmp/tombtmp"
if [ -f $tombtmp ]; then
dd if=/dev/urandom of=$tombtmp bs=800 count=1
rm -f $tombtmp
fi
@ -327,7 +330,7 @@ function _clean {
# {{{ _main - Main window
function _main {
_clean
command=`zenity \
cmnd=`zenity \
--window-icon="$MONMORT" \
--title="gtomb" \
--width=640 \
@ -353,222 +356,157 @@ function _main {
"engrave" "Generates a QR code of a key to be saved on paper" \
"bury" "Hide a key inside a JPEG image" \
"exhume" "Extract a key from a JPEG image"`
eval "_$command"
eval "_$cmnd"
}
# }}}
# {{{ dig - Dig a new tomb
function _dig {
tombname=`_fsave "Choose where to dig your tomb" "secret.tomb"`
res=$?
if [[ -f $tombname ]]; then
if [[ -f "$tombname" ]]; then
_zenerr "Error" "This tomb already exists. I am not digging here."
exec _main
elif [[ $tombname == "" ]]; then
_zenwarn "Warning" "Try again."
elif [[ -z "$tombname" ]]; then
_info "gtomb" "Cancelled"
exec _main
fi
case $res in
0)
tombsize=`_zenentry "Tomb digging" "Enter the size of your tomb in MiB (min. 10 MiB)" "10"`
[[ $res = 0 ]] || exec _main
tombsize=`_zenentry "Tomb digging" "Enter the size of your tomb in MiB (min. 10 MiB)" "10"`
res=$?
re='^[0-9]+$'
if ! [[ $tombsize =~ $re ]]; then
_zenerr "Error" "Please choose a valid number."
exec _main
elif [[ $tombsize == "" ]]; then
_zenwarn "Warning" "Try again."
elif [[ -z $tombsize ]]; then
_info "gtomb" "Cancelled"
exec _main
fi
case $res in
0)
$TOMBPATH dig -s $tombsize $tombname | \
[[ $res = 0 ]] || { _zenwarn "Warning" "Tomb digging canceled." ; exec _main }
"$TOMBPATH" dig -s "$tombsize" "$tombname" | \
_zenprog "Digging new tomb" "Please wait while your tomb is being dug..." &
PID_ZEN=$(ps -C zenity h -o pid,command | grep "Digging new tomb" | awk '{print $1}')
while [ "$PID_ZEN" != "" ]; do
PID_ZEN=$(ps -C zenity h -o pid,command | awk '/Digging new tomb/ {print $1}')
while [ -n "$PID_ZEN" ]; do
PID_ZEN=$(ps h -o pid -p ${PID_ZEN})
PID_DD=$(ps -C dd h -o pid,command | grep "$tombname" | awk '{print $1}')
PID_DD=$(ps -C $_DD h -o pid,command | awk -v tombtmp="$tombname" '$0~tombtmp{print $1}')
sleep 1
done
if [[ "$PID_DD" != "" && "$PID_ZEN" == "" ]]; then
[[ -n "$PID_DD" && -z "$PID_ZEN" ]] && {
kill -9 $PID_DD
_zenwarn "Warning" "Tomb digging canceled."
rm -f $tombname
_zenwarn "Warning" "Tomb digging cancelled."
rm -f "$tombname"
exec _main
fi
}
_clean
_zeninfo "Success" "Your tomb has been dug."
_info "Success" "Your tomb has been dug in $tombname"
exec _main
;;
1)
_zenwarn "Warning" "Tomb digging canceled."
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ forge - Forge a new key
function _forge {
keyfile=`_fsave "Choose where to forge your key" "secret.tomb.key"`
res=$?
if [[ -f $keyfile ]]; then
_zenerr "Error" "This key already exists. I am not overwriting."
exec _main
elif [[ $keyfile == "" ]]; then
_zenwarn "Warning" "Try again."
elif [[ -z $keyfile ]]; then
_info "gtomb" "Canceled"
exec _main
fi
if [[ -f $HEXENC ]] && [[ -f $GENSALT ]] && [[ -f $GETITER ]] && [[ -f $PBKDF ]]; then
kdf=""
kdfiter=""
if [[ -x $HEXENC ]] && [[ -x $GENSALT ]] && [[ -x $GETITER ]] && [[ -x $PBKDF ]]; then
_zenques "Do you want to use KDF? (Generates passwords armored against dictionary attacks)"
if [[ $? == "0" ]]; then
[[ $? == "0" ]] && {
kdf="--kdf"
kdfiter=`_zenentry "Iterations" "Enter the delay (itertime) in seconds for each time this key is used:" "2"`
kdfiter=`_zenentry "Iterations" "Enter the delay (itertime) in seconds for each time \n\
this key is used:" "2"`
re='^[0-9]+$'
if ! [[ $kdfiter =~ $re ]]; then
_zenerr "Error" "Please choose a valid number."
exec _main
elif [[ -z $kdfiter ]]; then
_info "gtomb" "Canceled"
exec _main
fi
}
else
_zenotif "gtomb" "KDF binaries not found."
fi
case $res in
0)
$TOMBPATH forge $keyfile $kdf $kdfiter | \
[[ $? = 0 ]] || exec _main
"$TOMBPATH" forge "$keyfile" "$kdf" "$kdfiter" | \
_zenprog "Forging key" "Please wait while your key is being forged...\n\
You can move your mouse around and use your computer to speed up the process." &
PID_ZEN=$(ps -C zenity h -o pid,command | grep "Forging key" | awk '{print $1}')
while [ "$PID_ZEN" != "" ]; do
PID_ZEN=$(ps -C zenity h -o pid,command | awk '/Forging key/ {print $1}')
while [ -n "$PID_ZEN" ]; do
PID_ZEN=$(ps h -o pid -p ${PID_ZEN})
PID_DD=$(ps -C dd h -o pid,command | grep " if=" | awk '{print $1}')
PID_DD=$(ps -C $_DD h -o pid,command | awk '/ if/ {print $1}')
sleep 1
done
if [[ "$PID_DD" != "" && "$PID_ZEN" == "" ]]; then
[[ -n "$PID_DD" && -z "$PID_ZEN" ]] && {
kill -9 $PID_DD
_zenwarn "Warning" "Forging canceled."
_zenwarn "Warning" "Forging cancelled."
rm -f $keyfile
exec _main
fi
}
_clean
_zeninfo "Success" "Your key is now forged."
_info "Success" "Your key is now forged in $keyfile"
exec _main
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ lock - Lock a non-locked tomb
function _lock {
tombname=`_fsel "Select a tomb to lock"`
[[ -n $tombname ]] || { _zenotif "gtomb" "Cancelled" ; exec _main }
[[ $? = 0 ]] || exec _main
res=$?
if [[ $tombname == "" ]]; then
_zenwarn "Warning" "Try again."
exec _main
fi
case $res in
0)
keyfile=`_fsel "Choose the key for your tomb"`
[[ -n $keyfile ]] || { _zenotif "gtomb" "Cancelled" ; exec _main }
[[ $? = 0 ]] || exec _main
res=$?
if [[ $keyfile == "" ]]; then
_zenwarn "Warning" "Try again."
exec _main
fi
case $res in
0)
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
$TOMBPATH lock $tombname -k $keyfile | \
_sudo
"$TOMBPATH" lock "$tombname" -k "$keyfile" | \
_zenprognc "Locking your tomb" "Please wait while your tomb is being locked..."
_clean # Clean sensitive stuff from memory
_zeninfo "Success" "Your tomb is now locked."
_info "Success" "Your tomb is now locked."
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ open - Open an existing tomb
function _open {
tombname=`_fsel "Choose a tomb to open"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
keyfile=`_fsel "Choose the key for your tomb"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
$TOMBPATH open $tombname -k $keyfile
_clean # Clean sensitive stuff from memory
_zeninfo "Success" "Your tomb is now open."
_sudo
"$TOMBPATH" open "$tombname" -k "$keyfile"
_info "Success" "Your tomb is now open."
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ list - list all open tombs, along with their mountpoint
function _list {
tombtmp="/tmp/tombtmp"
$TOMBPATH list --get-mountpoint > $tombtmp
"$TOMBPATH" list --get-mountpoint > $tombtmp
tombname=`cat $tombtmp | \
sed 's/.*\/\([^\/]*\)$/\1\n &/' | \
zenity \
@ -580,9 +518,10 @@ function _list {
--column=Tomb \
--column=Path `
res=$?
case $res in
0)
tombname=`echo "$tombname" | cut -c1-16`
[[ $? = 0 ]] || exec _main
listchoice=`zenity \
--title="Choose action" \
--window-icon="$MONMORT" \
@ -598,70 +537,56 @@ function _list {
"binds" "Edit current bind-hooks." \
"posts" "Edit current post-hooks."`
if [[ $? == 1 ]]; then
exec _main
fi
[[ $? = 0 ]] || exec _main
case $listchoice in
close)
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
$TOMBPATH close $tombname
_sudo
"$TOMBPATH" close "$tombname"
_zeninfo "Success" "Tomb closed successfully!"
exec _main
;;
slam)
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
$TOMBPATH slam $tombname
_zeninfo "Success" "Tomb slammed successfully!"
_sudo
"$TOMBPATH" slam "$tombname"
_info "Success" "$tombname slammed successfully!"
exec _main
;;
disindex)
tombloc=`$TOMBPATH list $tombname --get-mountpoint`
tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
touch "$tombloc/.noindex"
_zeninfo "Success" "Indexing disabled for this tomb."
_info "Success" "Indexing disabled for this tomb."
exec _main
;;
enindex)
tombloc=`$TOMBPATH list $tombname --get-mountpoint`
rm "$tombloc/.noindex"
_zeninfo "Success" "Indexing of this tomb is enabled."
tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
rm -f "$tombloc/.noindex"
_info "Success" "Indexing of this tomb is now enabled."
exec _main
;;
binds)
tombloc=`$TOMBPATH list $tombname --get-mountpoint`
tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
bindhooks=`zenity \
--text-info \
--filename="$tombloc/bind-hooks" \
--editable`
if [[ $? == "0" ]]; then
[[ $? = 0 ]] && {
echo "$bindhooks" > "$tombloc/bind-hooks"
fi
_info "gtomb" "bind-hooks saved"
}
exec _main
;;
posts)
tombloc=`$TOMBPATH list $tombname --get-mountpoint`
tombloc=`"$TOMBPATH" list "$tombname" --get-mountpoint`
posthooks=`zenity \
--text-info \
--filename="$tombloc/post-hooks" \
--editable`
if [[ $? == "0" ]]; then
[[ $? = 0 ]] && {
echo "$posthooks" > "$tombloc/post-hooks"
chmod +x $tombloc/post-hooks
fi
exec _main
;;
# See what else to add
esac
;;
1)
chmod +x "$tombloc/post-hooks"
_info "gtomb" "post-hooks saved"
}
exec _main
;;
esac
@ -671,7 +596,7 @@ function _list {
# {{{ close - Close open tomb(s)
function _close {
tombtmp="/tmp/tombtmp"
$TOMBPATH list --get-mountpoint > $tombtmp
"$TOMBPATH" list --get-mountpoint > $tombtmp
echo "/all" >> $tombtmp
tombname=`cat $tombtmp | \
sed 's/.*\/\([^\/]*\)$/\1\n &/' | \
@ -683,30 +608,20 @@ function _close {
--column=Tomb \
--column=Path `
res=$?
case $res in
0)
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
[[ $? = 0 ]] || exec _main
$TOMBPATH close $tombname
_clean # Clean sensitive stuff from memory
_zeninfo "Success" "Tomb(s) closed successfully!"
_sudo
tombname=`echo "$tombname" | cut -c1-16`
"$TOMBPATH" close "$tombname"
_info "Success" "Closed successfully!"
exec _main
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ slam - Slam open tombs
function _slam {
tombtmp="/tmp/tombtmp"
$TOMBPATH list --get-mountpoint > $tombtmp
"$TOMBPATH" list --get-mountpoint > $tombtmp
echo "/all" >> $tombtmp
tombname=`cat $tombtmp | \
sed 's/.*\/\([^\/]*\)$/\1\n &/' | \
@ -718,237 +633,136 @@ function _slam {
--column=Tomb \
--column=Path `
res=$?
case $res in
0)
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
[[ $? = 0 ]] || exec _main
$TOMBPATH slam $tombname
_clean # Clean sensitive stuff from memory
_zeninfo "Success" "Tomb(s) slammed successfully!"
_sudo
tombname=`echo "$tombname" | cut -c1-16`
"$TOMBPATH" slam "$tombname"
_info "Success" "Slammed successfully!"
exec _main
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ resize - Resize an existing *closed* tomb
function _resize {
tombname=`_fsel "Choose a tomb to resize"`
res=$?
case $res in
0)
_zenques "Is your tomb closed?"
[[ $? = 0 ]] || { _zenwarn "gtomb" "Please close the tomb before resizing." ; exec _main }
[[ $res = 0 ]] || exec _main
tombsize=`_zenentry "New tomb size" "Enter the new size of your tomb in MiB. Must be higher than the current size." "100"`
[[ -n $tombsize ]] || _zenotif "gtomb" "Cancelled"
re='^[0-9]+$'
if ! [[ $tombsize =~ $re ]]; then
_zenerr "Error" "Please choose a valid number."
exec _main
elif [[ -z $tombsize ]]; then
_info "gtomb" "Cancelled"
exec _main
fi
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
keyfile=`_fsel "Choose according keyfile"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
sudoassword=$(ask_password "Insert sudo password for user $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
$TOMBPATH resize $tombname -s $tombsize -k $keyfile | \
_sudo
"$TOMBPATH" resize "$tombname" -s "$tombsize" -k "$keyfile" | \
_zenprognc "Resizing tomb." "Please wait while your tomb is being resized..."
_clean # Clean sensitive stuff from memory
_zeninfo "Success" "Tomb resized successfully!"
_info "Success" "Tomb resized successfully!"
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ passwd - Change existing key's passphrase
function _passwd {
keyfile=`_fsel "Choose a keyfile"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
$TOMBPATH passwd -k $keyfile | \
"$TOMBPATH" passwd -k "$keyfile" | \
_zenprognc "Changing passphrase" "Please wait while your key's passphrase is being changed..."
_clean # Clean sensitive stuff from memory
_zeninfo "Success" "Passphrase changed successfully!"
_info "Success" "$keyfile passphrase changed successfully!"
exec _main
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ setkey - Change a tomb's keyfile
function _setkey {
tombname=`_fsel "Choose a tomb to change its keyfile"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
keyfile=`_fsel "Chosse your tomb's old keyfile"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
newkey=`_fsel "Choose your tomb's new keyfile"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
sudoassword=$(ask_password "Insert sudo password for $USER")
echo -e "$sudoassword\n" | sudo -S -v
_sudowrong
$TOMBPATH setkey -k $newkey $keyfile $tombname | \
_sudo
"$TOMBPATH" setkey -k "$newkey" "$keyfile" "$tombname" | \
_zenprognc "Changing key" "Please wait while your tomb's key is being changed..."
_clean
_zeninfo "Success" "Tomb's keyfile successfully changed!"
_info "Success" "$tombname keyfile successfully changed! Now using $newkey"
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ engrave - generate QR code of a key
function _engrave {
which qrencode || _zenwarn "Warning" "qrencode is not installed. Install it and try again" && exec _main
which qrencode || _zenwarn "Warning" "qrencode is not installed. Install it and try again"
keyfile=`_fsel "Choose a keyfile to engrave"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
jpegfile=`_fsave "Choose where to save your keyfile (PNG format)"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
awk '/^-----/ {next}; /^Version/ {next}; {print $0}' $keyfile \
| qrencode --size 4 --level H --casesensitive -o $jpegfile
_zeninfo "Success" "QR code generated in $jpegfile"
_info "Success" "QR code generated in $jpegfile"
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ bury - hide a keyfile in a JPEG image
function _bury {
which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again" && exec _main
which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again"
keyfile=`_fsel "Choose keyfile"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
jpegfile=`_fsel "Choose JPEG file"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
$TOMBPATH bury -k $keyfile $jpegfile
_zeninfo "Success" "Your key is now hidden in $jpegfile"
_clean # Clean sensitive stuff from memory
"$TOMBPATH" bury -k "$keyfile" "$jpegfile"
_info "Success" "Your key is now hidden in $jpegfile"
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ exhume - extract keyfile from JPEG
function _exhume {
which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again" && exec _main
which steghide || _zenwarn "Warning" "steghide is not installed. Install it and try again"
jpegfile=`_fsel "Choose JPEG file"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
keyfile=`_fsave "Choose where to extract your key"`
[[ $? = 0 ]] || exec _main
res=$?
case $res in
0)
$TOMBPATH exhume -k $keyfile $jpegfile
_zeninfo "Success" "Your keyfile is extracted to $keyfile"
_clean # Clean sensitive stuff from memory
"$TOMBPATH" exhume -k "$keyfile" "$jpegfile"
_info "Success" "Your keyfile is extracted to $keyfile"
exec _main
;;
1)
exec _main
;;
esac
;;
1)
exec _main
;;
esac
}
# }}}
# {{{ index - index the contents of open tombs
function _index {
which mlocate || _zenwarn "Warning" "mlocate is not installed. Install it and try again" && exec _main
$TOMBPATH index | _zenprognc "Indexing" "Please wait while the open tombs are being indexed..."
_zeninfo "Success" "Tombs indexed!"
which locate || _zenwarn "Warning" "mlocate is not installed. Install it and try again"
"$TOMBPATH" index | _zenprognc "Indexing" "Please wait while the open tombs are being indexed..."
_info "Success" "Tombs indexed!"
exec _main
}
# }}}
@ -956,30 +770,36 @@ function _index {
# {{{ search - searches the contents of indexed tombs
function _search {
strings=""
_searchstring
exec _main
}
function _searchstring {
function _searchstring {
srchstring=`_zenentry "Search" "Enter an argument to search. Cancel to finish."`
res=$?
strings="$strings $srchstring"
if [[ $res == "1" ]]; then
if [[ $res = 1 ]]; then
tombtmp="/tmp/tombtmp"
$TOMBPATH search $strings > $tombtmp
#cat $tombtmp | \
_info "Success" "Search complete!"
"$TOMBPATH" search "$strings" > $tombtmp
zenity \
--text-info \
--width=800 --height=640 \
--title="Search results" \
--filename=$tombtmp
else
_searchstring
fi
}
_searchstring
}
# }}}
if [ ! -f $TOMBPATH ]; then
_zenwarn "Warning" "Tomb binary is nonexistent in the current path. Install it or edit the script to point to the correct path."
else
_main
fi
function _ { _clean } # I like cleaning :)
[[ -x $TOMBPATH ]] || {
_zenwarn "Warning" "Tomb binary is not executable or doesn't exist in the current path. Install it or edit the script to point to the correct path."
exit 1 }
_main