rsaenc

#!/bin/bash
#
# RSA encryption/decryption script
#

set -e -o pipefail

LOCAL_RC_FILENAME="${HOME}/.rsaencrc"
[[ -f "${LOCAL_CONFIG_FILENAME}" ]] && source "${LOCAL_RC_FILENAME}" || :

VERSION="DEV"

usage() {

	cat << EOF
RSA encryption/decryption tool
Version: ${VERSION}
Usage: $0 [-h] [-v] [-f] [-e|-d|-E|-I|-P|-L|-D] [-g len] [-r keyname] [-k|-b keyname] [-i filename] [-s payload] [-a alias]

Actions:
    -e|--encrypt           Encrypt payload
    -d|--decrypt           Decrypt payload
    -E|--export-key        Export public key or public part
    -I|--import-pubkey     Import public key of a recipient
    -P|--import-privkey    Import private key for decryption
    -L|--list-keystorage   List imported keys
    -D|--set-default       Choose default private key to use
    -R|--remove-key        Remove a key

Options:
    -i|--input-filename    Input file for the selected action
    -s|--input-string      Input payload as a string
    -a|--key-alias         Alias of/for current key
    -k|--private-key       Private key to use
    -b|--public-key        Public key to use
    -r|--recipient         Recipient's public key name
    -g|--generate-random   Use a random string as input

Auxiliary:
    -f|--force             Force selected action
    -v|--verbose           Enable debug output
    -h|--help              Show help

EOF

}

timestamp() {
	date "+%F %T"
}

error() {
        
        [[ ! -z "${1}" ]] && msg="ERROR: ${1}" || msg="ERROR!"
        [[ ! -z "${2}" ]] && rc="${2}" || rc=1
        
        echo "[$(timestamp)] ${BASH_SOURCE[1]}: line ${BASH_LINENO[0]}: ${FUNCNAME[1]}: ${msg}" >&2
        exit "${rc}"
}

debug() {

	local msg="$1"
	local self_level=7
	local self_level_name="debug"

	if [[ "${self_level}" -le "${LOCAL_LOGLEVEL}" ]]; then	
		echo "[$(timestamp)] [${self_level_name}] [${FUNCNAME[1]}] $msg" >&2
		return 0
	fi
}

info() {

	local msg="$1"
	local self_level=3
	local self_level_name="info"

	if [[ "${self_level}" -le "${LOCAL_LOGLEVEL}" ]]; then	
		echo "[$(timestamp)] [${self_level_name}] [${FUNCNAME[1]}] $msg" >&2
		return 0
	fi
}

warning() {

	local msg="$1"
	local self_level=2
	local self_level_name="warning"

	if [[ "${self_level}" -le "${LOCAL_LOGLEVEL}" ]]; then	
		echo "[$(timestamp)] [${self_level_name}] [${FUNCNAME[1]}] $msg" >&2
		return 0
	fi
}

init_rc() {

	[[ -z "${LOCAL_PUBKEY_STORAGE}" ]] && LOCAL_PUBKEY_STORAGE="${HOME}/.local/rsaenc/keys"
	[[ ! -d "${LOCAL_PUBKEY_STORAGE}" ]] && mkdir -pv "${LOCAL_PUBKEY_STORAGE}"

	[[ -z "${LOCAL_PRIVATEKEY_TRASH}" ]] && LOCAL_PRIVATEKEY_TRASH="${HOME}/.local/rsaenc/trash/private"
	[[ ! -d "${LOCAL_PRIVATEKEY_TRASH}" ]] && mkdir -pv "${LOCAL_PRIVATEKEY_TRASH}"

	[[ -z "${LOCAL_PUBLICKEY_TRASH}" ]] && LOCAL_PUBLICKEY_TRASH="${HOME}/.local/rsaenc/trash/public"
	[[ ! -d "${LOCAL_PUBLICKEY_TRASH}" ]] && mkdir -pv "${LOCAL_PUBLICKEY_TRASH}"

	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && LOCAL_PRIVATEKEY_STORAGE="${HOME}/.local/rsaenc/private"
	[[ ! -d "${LOCAL_PRIVATEKEY_STORAGE}" ]] && mkdir -pv "${LOCAL_PRIVATEKEY_STORAGE}"
	[[ ! -f "${LOCAL_PRIVATEKEY_STORAGE}/.default" ]] && touch "${LOCAL_PRIVATEKEY_STORAGE}/.default"

	[[ -z "${LOCAL_PUBKEY_FILENAME}" ]] && LOCAL_PUBKEY_FILENAME="${HOME}/.ssh/id_rsa.pub"
	[[ -z "${LOCAL_PRIVATEKEY_FILENAME}" ]] && LOCAL_PRIVATEKEY_FILENAME="${LOCAL_PRIVATEKEY_STORAGE}/$( get_default_private_key )"
	[[ -z "${LOCAL_LOGLEVEL}" ]] && LOCAL_LOGLEVEL="5"

	case "$OSTYPE" in
		linux*) 
			BASE64_WRAP_PARAM=( -w 0 ) ;;
		darwin*)
			BASE64_WRAP_PARAM=( ) ;;
	esac

}

check_if_set_single() {
	
	local variables
	local found

	[[ ! -z "${@}" ]] && variables=( "${@}" ) || error "Please, set veriables to validate"

	for item in "${variables[@]}"; do

		if [[ ! -z "${item}" ]]; then

			if [[ "${found}" == "1" ]]; then
				return 1
			else
				found=1
			fi

		fi

	done

	return 0
}

generate_random_string() {

	[[ ! -z "${1}" ]] && length="${1}" || error "Please, set the random string length"
	[[ ! -z "${2}" ]] && use_special="${2}" || use_special=0

	openssl rand -base64 "${length}" | tr -d "\n"
}

export_pubkey() {

	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && return 2
	[[ -z "${LOCAL_PUBKEY_STORAGE}" ]] && return 2

	local key_name
	local key_type

	[[ ! -z "${1}" ]] && key_name="${1}" || error "Please, set the key name"
	[[ ! -z "${2}" ]] && key_type="${2}" || error "Please, set the key type"


	if [[ "${key_type}" == "public" ]]; then
		
		[[ ! -f "${LOCAL_PUBKEY_STORAGE}/${key_name}" ]] && error "No public keys found to export: '${key_name}'"

		echo "Exporting public key: ${key_name}"
		ssh-keygen -i -i -mPKCS8 -f "${LOCAL_PUBKEY_STORAGE}/${key_name}"
	
	elif [[ "${key_type}" == "private" ]]; then

		[[ ! -f "${LOCAL_PRIVATEKEY_STORAGE}/${key_name}" ]] && error "No private keys found to export: '${key_name}'"

		echo "Exporting private key: ${key_name}"
		ssh-keygen -f "${LOCAL_PRIVATEKEY_STORAGE}/${key_name}" -y
	
	else
		error "Unsupported key type: '${key_type}'"
	fi

}

encrypt_content() {

	[[ -z "${LOCAL_PUBKEY_STORAGE}" ]] && return 2

	local content
	local recipient_pubkey
	local input_source
	local input_source_type


	[[ ! -z "${1}" ]] && recipient_pubkey="${1}" || error "Please, set the recipient public key"
	[[ ! -z "${2}" ]] && input_source="${2}" || error "Please, set the input source with the content"
	[[ ! -z "${3}" ]] && input_source_type="${3}" || input_source_type="string"

	[[ ! -f "${LOCAL_PUBKEY_STORAGE}/${recipient_pubkey}" ]] && error "Can't open recipient pubkey file: '${recipient_pubkey}'"

	if [[ "${input_source_type}" == "string" ]]; then
		debug "Encrypting a sting"
		content="${input_source}"
	
	elif [[ "${input_source_type}" == "file" ]]; then
		[[ ! -f "${input_source}" ]] && error "Can't open file: '${input_source}'"
		content="$( cat "${input_source}" )"
	
	else
		error "Unsupported input source type: '${input_source_type}'"
	fi

	echo "${content}" | openssl rsautl -pubin -inkey "${LOCAL_PUBKEY_STORAGE}/${recipient_pubkey}" -oaep -encrypt | base64 "${BASE64_WRAP_PARAM[@]}"

}

decrypt_content() {

	[[ -z "${LOCAL_PRIVATEKEY_FILENAME}" ]] && return 2

	local content
	local input_source
	local input_source_type

	[[ ! -z "${1}" ]] && input_source="${1}" || error "Please, set the input source with the content"
	[[ ! -z "${2}" ]] && input_source_type="${2}" || input_source_type="string"

	if [[ "${input_source_type}" == "string" ]]; then
		debug "Encrypting a sting"
		content="${input_source}"
	
	elif [[ "${input_source_type}" == "file" ]]; then
		[[ ! -f "${input_source}" ]] && error "Can't open file: '${input_source}'"
		content="$( cat "${input_source}" )"
	
	else
		error "Unsupported input source type: '${input_source_type}'"
	fi

	echo "${content}" | base64 --decode | openssl rsautl -decrypt -oaep -inkey "${PRIVATE_KEY:-${LOCAL_PRIVATEKEY_FILENAME}}"

}

import_pubkey() {

	[[ -z "${LOCAL_PUBKEY_FILENAME}" ]] && return 2
	[[ -z "${LOCAL_PUBKEY_STORAGE}" ]] && return 2

	local input_source
	local input_source_type
	local pubkey_filename
	local pubkey_alias
	local tmp_pubkey_filename
	local pem_pubkey_filename
	local pem_pubkey_basename

	[[ ! -z "${1}" ]] && input_source="${1}" || error "Please, set the input source with a public key"
	[[ ! -z "${2}" ]] && input_source_type="${2}" || input_source_type="file"
	[[ ! -z "${3}" ]] && pubkey_alias="${3}"

	if [[ "${input_source_type}" == "string" ]]; then
		debug "Importing public key from a sting"
		debug "Preparing a tempfile"
		pubkey_filename=$(mktemp)
		echo "${input_source}" > "${pubkey_filename}"
		[[ -z "${pubkey_alias}" ]] && pubkey_alias="id_rsa_$(date +%s)"
	
	elif [[ "${input_source_type}" == "file" ]]; then
		[[ ! -f "${input_source}" ]] && error "Can't open public key file: '${input_source}'"
		pubkey_filename="${input_source}"
		[[ -z "${pubkey_alias}" ]] && pubkey_alias="${pubkey_filename##*/}"
	
	else
		error "Unsupported input source type: '${input_source_type}'"
	fi

	if [[ ! -z "${pubkey_alias}" ]]; then
		pem_pubkey_basename="${pubkey_alias}.pem"
	else
		pem_pubkey_basename="${LOCAL_PUBKEY_FILENAME##*/}.pem"
	fi

	pem_pubkey_filename="${LOCAL_PUBKEY_STORAGE}/${pem_pubkey_basename}"
	tmp_pubkey_filename="$(mktemp)"

	if [[ "${FORCE_ACTOIN}" != "1" ]] && [[ -f "${pem_pubkey_filename}" ]]; then
		error "Public key already exists: ${pem_pubkey_basename}"
	fi

	ssh-keygen -f "${pubkey_filename}" -e -m pem > "${tmp_pubkey_filename}"
	openssl rsa -in "${tmp_pubkey_filename}" -RSAPublicKey_in -pubout > "${pem_pubkey_filename}" 2>/dev/null
	rm "${tmp_pubkey_filename}"

	echo "Saved as '${pem_pubkey_basename}'"

}

import_private_key() {

	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && return 2

	local private_key_filename
	local private_key_alias
	local private_key_basename
	local pem_privatekey_filename
	local default_private_key
	local new_passphrase_param
	
	[[ ! -z "${1}" ]] && private_key_filename="${1}" || error "Please, set the input source with a public key"
	[[ ! -z "${2}" ]] && private_key_alias="${2}"


	if [[ ! -z "${private_key_alias}" ]]; then
		private_key_basename="${private_key_alias}.pem"
	else
		private_key_basename="${private_key_filename##*/}.pem"
	fi

	pem_privatekey_filename="${LOCAL_PRIVATEKEY_STORAGE}/${private_key_basename}"
	
	if [[ "${FORCE_ACTOIN}" != "1" ]] && [[ -f "${pem_privatekey_filename}" ]]; then
		error "Private key already exists: ${pem_privatekey_filename}"
	fi

	if ssh-keygen -P "" -yf "${private_key_filename}" > /dev/null 2>&1; then
		new_passphrase_param=( "-N" "")
	else
		new_passphrase_param=( )
	fi

	cp "${private_key_filename}" "${pem_privatekey_filename}"
	ssh-keygen "${new_passphrase_param[@]}" -p -m PEM -f "${pem_privatekey_filename}"

	echo "Saved as '${pem_privatekey_filename}'"

	default_private_key=$( get_default_private_key )

	if [[ -z "${default_private_key}" ]]; then
		set_default_private_key "${private_key_basename}" 
	fi

}

remove_private_key() {
	
	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && return 2
	[[ -z "${LOCAL_PRIVATEKEY_TRASH}" ]] && return 2
	
	local private_key
	local confirmation

	[[ ! -z "${1}" ]] && private_key="${1}" || error "Please, set private key name"

	if [[ -f "${LOCAL_PRIVATEKEY_STORAGE}/${private_key}" ]]; then

		if [[ "${FORCE_ACTOIN}" == "1" ]]; then
			confirmation="y"
		else
			read -p "Delete '${private_key}' (y/n)? " -r confirmation
			echo ""
		fi

		case "${confirmation}" in 
			y|Y)
				rm "${LOCAL_PRIVATEKEY_STORAGE}/${private_key}"
				echo "Successfully removed private key: ${private_key}"
				;;

			n|N)
				echo "Nothing to do."
				;;
			* )
				error "Invalid choice."
				;;
		esac

	else
		error "Can't locate private key: ${private_key}"
	fi

}

remove_public_key() {
	
	[[ -z "${LOCAL_PUBKEY_STORAGE}" ]] && return 2
	[[ -z "${LOCAL_PUBLICKEY_TRASH}" ]] && return 2
	
	local public_key

	[[ ! -z "${1}" ]] && public_key="${1}" || error "Please, set public key name"
	
	if [[ -f "${LOCAL_PUBKEY_STORAGE}/${public_key}" ]]; then
		rm "${LOCAL_PUBKEY_STORAGE}/${public_key}"
		echo "Successfully removed public key: ${public_key}"
	else
		error "Can't locate private key: ${public_key}"
	fi
}

get_oldest_private_key(){

	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && return 2

	ls -tr "${LOCAL_PRIVATEKEY_STORAGE}" | head -1

}

get_default_private_key() {
	
	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && return 2

	local default_private_key

	[[ ! -f "${LOCAL_PRIVATEKEY_STORAGE}/.default" ]] && touch "${LOCAL_PRIVATEKEY_STORAGE}/.default"
	default_private_key=$(cat "${LOCAL_PRIVATEKEY_STORAGE}/.default")
	
	if [[ -z "${default_private_key}" ]]; then
		debug "Default private key was never set."
		oldest_private_key=$( get_oldest_private_key )

		if [[ -z "${oldest_private_key}" ]]; then
			echo ""
			return 0
		
		else
			echo "${oldest_private_key}" > "${LOCAL_PRIVATEKEY_STORAGE}/.default"
			echo "${oldest_private_key}"
			return 0
		fi
	
	else 

		if [[ -f "${LOCAL_PRIVATEKEY_STORAGE}/${default_private_key}" ]]; then
			echo "${default_private_key}"
			return 0
		else
			get_oldest_private_key > "${LOCAL_PRIVATEKEY_STORAGE}/.default"
			cat "${LOCAL_PRIVATEKEY_STORAGE}/.default"
			return 0
		fi

	fi

}

set_default_private_key() {

	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && return 2

	local private_key_filename

	[[ ! -z "${1}" ]] && private_key_filename="${1}" || error "Please, set the input source with a private key"

	[[ ! -f "${LOCAL_PRIVATEKEY_STORAGE}/${private_key_filename}" ]] && error "Private key not found: '${private_key_filename}'"
	echo "${private_key_filename}" > "${LOCAL_PRIVATEKEY_STORAGE}/.default"

	echo "Default private key: '$(get_default_private_key)'"

}

list_keystorage() {

	[[ -z "${LOCAL_PUBKEY_STORAGE}" ]] && return 2
	[[ -z "${LOCAL_PRIVATEKEY_STORAGE}" ]] && return 2

	[[ ! -d "${LOCAL_PUBKEY_STORAGE}" ]] && error "Please, make sure your key storage is initialised: ${LOCAL_PUBKEY_STORAGE}"
	[[ ! -d "${LOCAL_PRIVATEKEY_STORAGE}" ]] && error "Please, make sure your key storage is initialised: ${LOCAL_PRIVATEKEY_STORAGE}"
	
	local default_private_key

	default_private_key=$( get_default_private_key )

	echo "PUBLIC KEYS:"
	ls "${LOCAL_PUBKEY_STORAGE}" | cat -n | while read line; do
		echo "${line}"
	done
	
	echo ""	
	echo "PRIVATE KEYS:"
	ls "${LOCAL_PRIVATEKEY_STORAGE}" | cat -n | while read line; do
		echo "${line}"
	done

	echo ""
	echo "DEFAULT: ${default_private_key}"
}

main() {

	local CLI_RECIPIENT_PUBKEY
	local CLI_INPUT_FILENAME
	local CLI_INPUT_STRING
	local CLI_PRIVATE_KEY
	local CLI_PUBLIC_KEY
	local CLI_ENCRYPT
	local CLI_DECRYPT
	local CLI_EXPORT_PUBKEY
	local CLI_REMOVE_KEY
	local CLI_SET_DEFAULT
	local CLI_IMPORT_PUBKEY
	local CLI_IMPORT_PRIVKEY
	local CLI_KEY_ALIAS
	local CLI_LIST_KEYSTORAGE
	local CLI_FORCE
	local CLI_VERBOSE

	[[ "$#" -eq 0 ]] && { usage; exit 0; }

	while [[ "$#" -gt 0 ]]; do 
		case "${1}" in
			-r|--recipient-pubkey)
				[[ -z "${CLI_RECIPIENT_PUBKEY}" ]] && CLI_RECIPIENT_PUBKEY="${2}" || error "Argument already set: -r"; shift; shift;;

			-i|--input-filename)
				[[ -z "${CLI_INPUT_FILENAME}" ]] && CLI_INPUT_FILENAME="${2}" || error "Argument already set: -i"; shift; shift;;

			-s|--input-string)
				[[ -z "${CLI_INPUT_STRING}" ]] && CLI_INPUT_STRING="${2}" || error "Argument already set: -s"; shift; shift;;

			-k|--private-key)
				[[ -z "${CLI_PRIVATE_KEY}" ]] && CLI_PRIVATE_KEY="${2}" || error "Argument already set: -k"; shift; shift;;

			-b|--public-key)
				[[ -z "${CLI_PUBLIC_KEY}" ]] && CLI_PUBLIC_KEY="${2}" || error "Argument already set: -b"; shift; shift;;

			-a|--key-alias)
				[[ -z "${CLI_KEY_ALIAS}" ]] && CLI_KEY_ALIAS="${2}" || error "Argument already set: -a"; shift; shift;;

			-g|--generate-random)
				[[ -z "${CLI_GENERATE_RANDOM}" ]] && CLI_GENERATE_RANDOM="${2}" || error "Argument already set: -g"; shift; shift;;

			-e|--encrypt)
				[[ -z "${CLI_ENCRYPT}" ]] && CLI_ENCRYPT=1 || error "Parameter already set: -e"; shift;;

			-d|--decrypt)
				[[ -z "${CLI_DECRYPT}" ]] && CLI_DECRYPT=1 || error "Parameter already set: -d"; shift;;

			-E|--export-pubkey)
				[[ -z "${CLI_EXPORT_PUBKEY}" ]] && CLI_EXPORT_PUBKEY=1 || error "Parameter already set: -E"; shift;;

			-R|--remove-key)
				[[ -z "${CLI_REMOVE_KEY}" ]] && CLI_REMOVE_KEY=1 || error "Parameter already set: -R"; shift;;

			-D|--set-default)
				[[ -z "${CLI_SET_DEFAULT}" ]] && CLI_SET_DEFAULT=1 || error "Parameter already set: -D"; shift;;

			-I|--import-pubkey)
				[[ -z "${CLI_IMPORT_PUBKEY}" ]] && CLI_IMPORT_PUBKEY=1 || error "Parameter already set: -I"; shift;;

			-P|--import-privkey)
				[[ -z "${CLI_IMPORT_PRIVKEY}" ]] && CLI_IMPORT_PRIVKEY=1 || error "Parameter already set: -P"; shift;;

			-L|--list-keystorage)
				[[ -z "${CLI_LIST_KEYSTORAGE}" ]] && CLI_LIST_KEYSTORAGE=1 || error "Parameter already set: -L"; shift;;

			-f|--force)
				[[ -z "${CLI_FORCE}" ]] && CLI_FORCE=1 || error "Parameter already set: -f"; shift;;

			-v|--verbose)
				[[ -z "${CLI_VERBOSE}" ]] && CLI_VERBOSE=1 || error "Parameter already set: -v"; shift;;

			-h|--help) usage; exit 0;;
			
			*) error "Unknown parameter passed: '${1}'"; shift; shift;;
		esac 
	done

	if [[ "${CLI_FORCE}" == "1" ]]; then
		export FORCE_ACTOIN=1
	fi

	if [[ ! -z "${CLI_PRIVATE_KEY}" ]]; then
		export PRIVATE_KEY="${LOCAL_PRIVATEKEY_STORAGE}/${CLI_PRIVATE_KEY}"
	fi

	COLLIDING_ACTIONS=(
		"${CLI_ENCRYPT}"        "${CLI_DECRYPT}"     "${CLI_EXPORT_PUBKEY}"
		"${CLI_REMOVE_KEY}"     "${CLI_SET_DEFAULT}" "${CLI_IMPORT_PUBKEY}"
		"${CLI_IMPORT_PRIVKEY}"
	)

	if ! check_if_set_single "${COLLIDING_ACTIONS[@]}"; then
		error "You can use only one cation at a time"
	fi

	if [[ "${CLI_LIST_KEYSTORAGE}" == "1" ]]; then
		debug "Listing keystorage"
		list_keystorage
	fi

	if [[ "${CLI_EXPORT_PUBKEY}" == "1" ]]; then

		if ! check_if_set_single "${CLI_PUBLIC_KEY}" "${CLI_PRIVATE_KEY}"; then
			error "You only can use one: private key or public key"

		elif [[ ! -z "${CLI_PRIVATE_KEY}" ]]; then
			export_pubkey "${CLI_PRIVATE_KEY}" "private"

		elif [[ ! -z "${CLI_PUBLIC_KEY}" ]]; then
			export_pubkey "${CLI_PUBLIC_KEY}" "public"
		fi

	fi

	if [[ "${CLI_IMPORT_PRIVKEY}" == "1" ]]; then
		debug "Exporting your public key"
		import_private_key "${CLI_INPUT_FILENAME}"
	fi

	if [[ "${CLI_SET_DEFAULT}" == "1" ]]; then
		debug "Setting a default private key"
		
		[[ -z "${CLI_PRIVATE_KEY}" ]] && error "Please, set a private key to make as default."
		set_default_private_key "${CLI_PRIVATE_KEY}"
	fi

	if [[ "${CLI_IMPORT_PUBKEY}" == "1" ]]; then

		if ! check_if_set_single "${CLI_INPUT_FILENAME}" "${CLI_INPUT_STRING}"; then
			error "You only can use one: input file or input string"

		elif [[ ! -z "${CLI_INPUT_FILENAME}" ]]; then
			debug "Importing public key from file ${CLI_INPUT_FILENAME} (alias '${CLI_KEY_ALIAS}')"
			import_pubkey "${CLI_INPUT_FILENAME}" "file" "${CLI_KEY_ALIAS}"

		elif [[ ! -z "${CLI_INPUT_STRING}" ]]; then
			debug "Importing public key from string (alias '${CLI_KEY_ALIAS}')"
			import_pubkey "${CLI_INPUT_STRING}" "string" "${CLI_KEY_ALIAS}"

		fi
	fi

	if [[ "${CLI_DECRYPT}" == "1" ]]; then

		if ! check_if_set_single "${CLI_INPUT_FILENAME}" "${CLI_INPUT_STRING}"; then
			error "You only can use one: input file or input string"

		elif [[ ! -z "${CLI_INPUT_FILENAME}" ]]; then
			debug "Importing public key from file ${CLI_INPUT_FILENAME} (alias '${CLI_KEY_ALIAS}')"
			decrypt_content "${CLI_INPUT_FILENAME}" "file" "${CLI_KEY_ALIAS}"

		elif [[ ! -z "${CLI_INPUT_STRING}" ]]; then
			debug "Importing public key from string (alias '${CLI_KEY_ALIAS}')"
			decrypt_content "${CLI_INPUT_STRING}" "string" "${CLI_KEY_ALIAS}"

		fi
	fi

	if [[ "${CLI_ENCRYPT}" == "1" ]]; then

		if [[ -z "${CLI_RECIPIENT_PUBKEY}" ]]; then
			error "Please, set the recipient public key"
		fi

		if ! check_if_set_single "${CLI_INPUT_FILENAME}" "${CLI_INPUT_STRING}" "${CLI_GENERATE_RANDOM}"; then
			error "You only can use one: input file or input string"

		elif [[ ! -z "${CLI_INPUT_FILENAME}" ]]; then
			encrypt_content "${CLI_RECIPIENT_PUBKEY}" "${CLI_INPUT_FILENAME}" "file"

		elif [[ ! -z "${CLI_INPUT_STRING}" ]]; then
			encrypt_content "${CLI_RECIPIENT_PUBKEY}" "${CLI_INPUT_STRING}" "string"

		elif [[ ! -z "${CLI_GENERATE_RANDOM}" ]]; then
			RANDOM_STRING=$( generate_random_string "${CLI_GENERATE_RANDOM}" )
			echo "${RANDOM_STRING}" >&2
			encrypt_content "${CLI_RECIPIENT_PUBKEY}" "${RANDOM_STRING}" "string"
		fi
	fi

	if [[ "${CLI_REMOVE_KEY}" == "1" ]]; then

		if ! check_if_set_single "${CLI_PUBLIC_KEY}" "${CLI_PRIVATE_KEY}"; then
			error "You only can use one: private key or public key"

		elif [[ ! -z "${CLI_PRIVATE_KEY}" ]]; then
			remove_private_key "${CLI_PRIVATE_KEY}"

		elif [[ ! -z "${CLI_PUBLIC_KEY}" ]]; then
			remove_public_key "${CLI_PUBLIC_KEY}"

		fi
	fi

}

init_rc
main "$@"