ipko

#!/bin/bash

debug=false
#-------------------------------------------------------------------------------
# error handling
#-------------------------------------------------------------------------------
stderr_log="/dev/shm/stderr.log.$$"
if $debug; then
    set -vx
else
    exec 2>"$stderr_log"
fi

exit_handler() {
    zenity --text-info \
        --title="Wystąpił błąd wewnętrzny:" \
        --width=600 --height=300 \
        --filename="$stderr_log" 2>/dev/null
    rm -fv "$stderr_log"
}
#trap exit_handler EXIT
#trap exit ERR

exit_err() {
    local msg=${1:-"Nieopisany błąd.\nProgram zostanie zakończony"}
    trap '' ERR
    trap '' EXIT
    zenity --error --text="$msg" 2>/dev/null
    rm -fv "$stderr_log"
    exit 1
}

give_up() {
    local -r ru='Rezygnacja użytkownika'
    trap '' ERR
    trap '' EXIT
    [[ $# -eq 0 ]] && zenity --info --text="$ru" 2>/dev/null
    rm -fv "$stderr_log"
    exit 2
}

#-------------------------------------------------------------------------------
# global vars
#-------------------------------------------------------------------------------
debug=true
crypted_file=''
secret_dir="$HOME/"

cipher='aes-256-cbc'
field_sep="$(printf '\t')"
font='Courier New 18'

usage() {
    echo "Usage: $0 [-d star_dir] [-f file_do_decrypt]" 1>&2
    exit 1
}

while getopts "d:f:" o; do
    case "${o}" in
        d) secret_dir=${OPTARG}'/' ;;
        f) crypted_file=${OPTARG} ;;
        *) usage ;;
    esac
done
shift $(($OPTIND-1))

#-------------------------------------------------------------------------------
# functions
#-------------------------------------------------------------------------------

#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  vat2tab
#   DESCRIPTION:  konwertuje zmienną łańcuchową do "tabelki" wygodnej do wyświe-
#                 tlenia w zenity
#    PARAMETERS:  var - zmienna do konwersji
#                 rval - wartość zwracana (przez "wskaźnik")
#       RETURNS:  
#-------------------------------------------------------------------------------
var2tab() {
    local var="$1"
    local rval=$2
    local col_heads='|'
    local col_bar='+'
    local col_content='|'
    local content cur_char
    for ((i=1; $i<=${#var}; i++)); do
        cur_char="${var:i-1:1}"
        if [ "$cur_char" == " " ]; then
            cur_char='_ _|'
        else
            cur_char=" $cur_char |"
        fi
        [[ $i -gt 9 ]] && col_heads+=" $i|" || col_heads+=" $i |"
        col_bar+='---+'
        col_content+="$cur_char"
    done 
    content=$"$col_heads\n$col_bar\n$col_content\n"
    eval $rval="'$content'"
}

#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  get_file
#   DESCRIPTION:  
#    PARAMETERS:  
#       RETURNS:  
#-------------------------------------------------------------------------------
get_file() {
    local rval="$1"
    local file_filter=""
    shift
    until [ -z "$1" ]
    do
        file_filter+="$1 "
        shift
    done

    [[ -z "$file_filter" ]] && file_filter="*"
    local file_name=$(zenity --file-selection \
                        --filename=$secret_dir \
                        --file-filter="$file_filter") 2>/dev/null
    [[ -z "$file_name" ]] && give_up
    eval $rval="'$file_name'"
}

#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  split_base_ext
#   DESCRIPTION:  .file -> '' 'file'
#                 file  -> 'file' ''
#                 file. -> 'file' ''
#                 file.na me.ext ension -> 'file.na me' 'ext ension'
#    PARAMETERS:  
#       RETURNS:  
#-------------------------------------------------------------------------------
split_base_ext() {
    local file="$1"
    local file_base=$2
    local file_ext=$3
    local file_array ext base oIFS dots last_char

    last_char=${file: -1}
    if [ "." = "$last_char" ]; then
        base=${file:0:-1}
        ext=''
    else
        dots=$(grep -o '\.' <<<"$file" | grep -c .)
        if [ $dots -eq 0 ]; then
            base=$file
            ext=''
        else
            oIFS=$IFS
            IFS='.' file_array=($file)
            IFS=$oIFS
            i=$((${#file_array[@]} - 1))        # last element
            ext=${file_array[$i]}
            l=${#ext}                           # ext length
            base=${file:0:-(($l + 1 ))}
        fi
    fi

    eval $file_base="'$base'"
    eval $file_ext="'$ext'"
}

#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  get_pass
#   DESCRIPTION:  
#    PARAMETERS:  
#       RETURNS:  
#-------------------------------------------------------------------------------
get_pass() {
    local pass1=$1              # hasło deszyfrujące (1,3) lub treść do zaszyfrowania (4)
    local pass2=$2              # hasło szyfrujące (2,4)
    local -r mode=$3            # tryb pracy [1|2|3|4]
    local rval=$4
    local pass pass_array field1 field2 field3 oIFS tabs
    local -r pp=$"\nPonowić próbę?"

    case $mode in
        1)                                      # hasło
            pass=$(zenity --password 2>/dev/null)
            ;;
        2)                                      # nowe hasło + powtórzenie
            pass=$(zenity --forms \
                --title "Szyfrowanie pliku" \
                --text="Wprowadź hasło szyfrujące" \
                --add-password="Hasło" \
                --add-password="Powtórz hasło" \
                --separator="$field_sep" 2>/dev/null)
            ;;
        3)                                      # stare hasło; nowe hasło + powtórzenie
            pass=$(zenity --forms \
                --title "Zmiana hasła" \
                --text="Zmiana hasła do pliku" \
                --add-password="Stare hasło" \
                --add-password="Nowe hasło" \
                --add-password="Powtórz nowe hasło" \
                --separator="$field_sep" 2>/dev/null)
            ;;
        4)                                      # treść pliku; nowe hasło + powtórzenie
            pass=$(zenity --forms \
                --title "Zaszyfruj treść" \
                --text="Nowy zaszyfrowany plik z hasłem" \
                --add-entry="Treść do zaszyfrowania" \
                --add-password="Hasło" \
                --add-password="Powtórz hasło" \
                --separator="$field_sep" 2>/dev/null)
            ;;
        *)
            exit_err "Funkcja: ${FUNCNAME[0]}: błąd parametru"
            ;;
    esac
    [[ $? -eq 0 ]] || give_up

    # tylko hasło deszyfrujące
    if [ $mode -eq 1 ]; then
        eval $pass1="'$pass'"
        eval $rval='"true"'
        return
    fi

    tabs=$(grep -o "$field_sep" <<<"$pass" | grep -c .)
    oIFS=$IFS
    IFS="$field_sep" pass_array=($pass)
    IFS=$oIFS

    case $mode in
        2)                                      # nowe hasło + powtórzenie
            [[ $tabs -gt 1 ]] && exit_err "??? tabs=$tabs"
            field1=''
            field2=${pass_array[0]}
            field3=${pass_array[1]}
            ;;
        3|4)                                      # stare hasło; nowe hasło + powtórzenie
            [[ $tabs -gt 2 ]] && exit_err "??? tabs=$tabs"
            field1=${pass_array[0]}
            field2=${pass_array[1]}
            field3=${pass_array[2]}
            ;;
    esac

    local _rval=true
    if [ "$field2" != "$field3" ]; then
        zenity --question \
            --title="Niezgodność haseł" \
            --text="Niepoprawnie powtórzone hasło.$pp" 2>/dev/null
        [[ $? -eq 0 ]] && _rval=false || give_up 0
    fi

    if [ -z "$field2" ]; then
        zenity --question \
            --title="Puste hasło" \
            --text="Hasło nie może być \"puste\".$pp" 2>/dev/null
        [[ $? -eq 0 ]] && _rval=false || give_up 0
    fi

    eval $pass1="'$field1'"
    eval $pass2="'$field2'"
    eval $rval='"$_rval"'
}

#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  show_pass_file
#   DESCRIPTION:  wyświetla treść zaszyfrowanego pliku
#    PARAMETERS:  
#       RETURNS:  
#-------------------------------------------------------------------------------
show_pass_file() {
    local passwd cmd file_contain display_text file

    [[ -n "$crypted_file" ]] && file="$crypted_file" || get_file file "*.enc"

    get_pass passwd dummy 1 dummy

    cmd="openssl enc -d -$cipher -in \"$file\" -salt -k \"$passwd\" 2>/dev/null"
    file_contain=$(eval "$cmd") ||  exit_err "Niepoprawne hasło"

    set -f
        var2tab "$file_contain" display_text
        echo -ne ${display_text} | \
            zenity --text-info \
                --title="Top Secret!" \
                --width=1024 \
                --height=300 \
                --font="$font" 2>/dev/null
    set +f
    true
    return
}

#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  new_pass_file
#   DESCRIPTION:  tworzy nowy plik z zaszyfrowaną treścią
#    PARAMETERS:  
#       RETURNS:  
#-------------------------------------------------------------------------------
new_pass_file ()
{
    local passwd cmd file_contain file

    local get_pass_ok=false
    until $get_pass_ok; do
        get_pass file_contain passwd 4 get_pass_ok
    done

    local file_ok=false
    until $file_ok; do
        file=$(zenity --file-selection \
                    --filename="$secret_dir" \
                    --save 2>/dev/null)
        [[ -z "$file" ]] && give_up
        file+=".enc"
        [[ -f "$file" ]] && {
            zenity --question \
                --text="$file\nistnieje. Nadpisać?" 2>/dev/null
            [[ $? -eq 0 ]] && file_ok=true
            true                                # WTF???
        } || {
            file_ok=true
        }
    done

    cmd="echo \"$file_contain\" | openssl enc -e -$cipher -out \"$file\" -salt -k \"$passwd\""
    eval "$cmd"
        
}

# ----------  end of function new_pass_file  ----------
#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  file_de_en_crypt
#   DESCRIPTION:  szyfrowanie/deszyfracja pliku
#    PARAMETERS:  
#       RETURNS:  
#-------------------------------------------------------------------------------
file_de_en_crypt() {
    local -r mode=$1
    local ext file new_file selected_file passwd cmd msg1 msg2

    case $mode in
        e) 
            ext=''
            msg1='Nieznany błąd szyfrowania pliku.'
            msg2='niezaszyfrowany'
            ;;
        d) 
            ext='*.enc'
            msg1="Błędne hasło lub\nnieznany błąd deszyfracji pliku."
            msg2='zaszyfrowany'
            ;;
        *) 
            exit_err "${FUNCNAME[*]}: błąd parametru"
            ;;
    esac

    get_file file $ext
    if [ $mode == "d" ]; then                   # deszyfracja
        split_base_ext "$file" new_file dummy
        get_pass passwd dummy 1 dummy
    else                                        # szyfrowanie
        new_file="$file.enc"
        local get_pass_ok=false
        until $get_pass_ok; do
            get_pass dummy passwd 2 get_pass_ok
        done
    fi

    if [ -e "$new_file" ] ; then
        selected_file=$(zenity --file-selection \
                        --filename="$new_file" \
                        --save \
                        --confirm-overwrite) 2>/dev/null
        [[ $? -eq 0 ]] && new_file="$selected_file" || give_up
    fi

    cmd="openssl enc -$mode -$cipher -in \"$file\" -out \"$new_file\" -salt -k \"$passwd\""
    eval "$cmd" || exit_err "$msg1"

    zenity --question \
        --title "Usunąć $msg2 plik?" \
        --text="Usunąć plik:\n$file" 2>/dev/null
    if [ $? -eq 0 ]; then
        cmd="rm -fv \"$file\""
        zenity --info --text="$(eval ${cmd})" 2>/dev/null
    fi
}


#---  FUNCTION  ----------------------------------------------------------------
#          NAME:  pwchange
#   DESCRIPTION:  zmiana hasła do pliku
#    PARAMETERS:  
#       RETURNS:  
#-------------------------------------------------------------------------------
pwchange()
{
    local oldpass newpass file cmd file_contain

    get_file file "*.enc"

    local get_pass_ok=false
    until $get_pass_ok; do
        get_pass oldpass newpass 3 get_pass_ok
    done

    cmd="openssl enc -d -$cipher -in \"$file\" -salt -k \"$oldpass\" 2>/dev/null"
    file_contain=$(eval "$cmd") ||  exit_err "Niepoprawne stare hasło"

    cmd="echo \"$file_contain\" | openssl enc -e -$cipher -out \"$file\" -salt -k \"$newpass\""
    eval "$cmd"
    zenity --info \
        --text="Hasło do pliku:\n$file\nzostało pomyślnie zmienione." 2>/dev/null
}    # ----------  end of function pwchange  ----------
#-------------------------------------------------------------------------------

[[ -n "$crypted_file" ]] && {
    trap exit_handler EXIT
    trap exit ERR
    show_pass_file
    give_up 0
}

ans=$(zenity  \
    --list  \
    --title "" \
    --text "Wybierz czynność" \
    --radiolist  \
    --hide-header \
    --column "Wybierz" \
    --column "hidden" \
    --column "Czynność" \
    TRUE "show_pass_file" "Wyświetl hasło z zaszyfrowanego pliku" \
    FALSE "new_pass_file" "Nowy zaszyfrowany plik z hasłem" \
    FALSE "decrypt" "Odszyfruj plik" \
    FALSE "crypt" "Zaszyfruj plik" \
    FALSE "pwchange" "Zmiana hasła do pliku" \
    --hide-column=2 \
    --width=351 \
    --height=200 2>/dev/null)

trap exit_handler EXIT
trap exit ERR

case $ans in
    show_pass_file)
        show_pass_file
        ;;
    new_pass_file)
        new_pass_file
        ;;
    decrypt)
        file_de_en_crypt 'd'
        ;;
    crypt)
        file_de_en_crypt 'e'
        ;;
    pwchange)
#        zenity --info --text="zmiana hasła do pliku"
        pwchange
        ;;
    *)
        give_up 0
        ;;
esac

give_up 0