chris
eef48a9c8d
unzip -tq on a password-protected archive tries to open /dev/tty to
prompt for the password. Inside a tmux session this generates SIGTTIN,
which stops the process (ps state T). A stopped process cannot receive
SIGTERM, so timeout waited indefinitely for a child that would never exit.
Fix: wrap all unzip calls with setsid so the process runs in a new
session without a controlling terminal. The /dev/tty open then fails
immediately with ENXIO and unzip exits with a non-zero code instead of
blocking. Additional hardening:
- timeout -k 5: send SIGKILL 5 s after SIGTERM as a last resort
- < /dev/null: also cut off stdin as a secondary safeguard
- exit 137 (128+9, SIGKILL) treated as timeout alongside 124
- error output matching "password"/"encrypt"/"need PK compat" reported
as UNVERIFIED instead of INVALID
Affects: recover_bad_signature.sh, restore_bad_signature.sh,
recreate_bad_signature.sh
1644 lines
57 KiB
Bash
Executable File
1644 lines
57 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
CUR_IFS=$IFS
|
|
|
|
script_name="$(basename $(realpath $0))"
|
|
script_dir="$(dirname $(realpath $0))"
|
|
|
|
conf_dir="${script_dir}/conf"
|
|
snippet_dir="${script_dir}/snippets"
|
|
report_dir="${script_dir}/reports"
|
|
|
|
# - Das Recovery-Verzeichnis wird bewusst NICHT unter script_dir
|
|
# - angelegt: liegen die Scripte z.B. unter /root/..., kann der
|
|
# - www-data-Prozess (der die entschluesselten Dateien tatsaechlich
|
|
# - schreibt) /root gar nicht erst durchqueren (Modus 700), selbst
|
|
# - wenn der Zielordner selbst an www-data gechownt wird - jedes
|
|
# - fopen() dort wuerde mit einem Fehler fehlschlagen. Stattdessen ein
|
|
# - eigener Pfad ausserhalb von /root und ausserhalb des Web-Docroots,
|
|
# - per conf-Datei ueberschreibbar (RECOVERY_BASE_DIR).
|
|
# -
|
|
DEFAULT_RECOVERY_BASE_DIR="/var/nc-recovery"
|
|
|
|
declare -a unsorted_website_arr
|
|
declare -a website_arr
|
|
|
|
declare -a unsorted_account_arr
|
|
declare -a account_arr
|
|
|
|
declare -a unsorted_selected_user_arr
|
|
declare -a selected_user_arr
|
|
|
|
LOCK_DIR="/tmp/${script_name%%.*}.LOCK"
|
|
log_file="${LOCK_DIR}/${script_name%%.*}.log"
|
|
|
|
run_date=$(date +%Y-%m-%d-%H%M)
|
|
|
|
_encryption_flag_changed=false
|
|
_orig_skip_check=""
|
|
|
|
|
|
# =============
|
|
# --- Some functions
|
|
# =============
|
|
|
|
usage() {
|
|
|
|
[[ -n "$1" ]] && error "$1"
|
|
|
|
[[ $terminal ]] && echo -e "
|
|
\033[1mUsage:\033[m
|
|
|
|
$(basename $0) -s <website>
|
|
|
|
\033[1mDescription\033[m
|
|
|
|
Attempts to recover files that were reported as 'Bad Signature' by
|
|
scan_bad_signature.sh, by temporarily ignoring the Server-Side
|
|
Encryption signature check (Nextcloud's own
|
|
'encryption_skip_signature_check' config switch) and decrypting the
|
|
affected files anyway.
|
|
|
|
This only works for files whose signature check fails due to a
|
|
computation mismatch, NOT for files whose encrypted content itself
|
|
is corrupted on disk - those will still produce garbage. Every
|
|
recovered file is therefore validated afterwards (file-type magic
|
|
bytes, PDF/zip integrity where possible) so you can tell the two
|
|
cases apart.
|
|
|
|
IMPORTANT:
|
|
- Original files are NEVER touched, modified or deleted. Every
|
|
recovered file is written to a SEPARATE directory outside of
|
|
Nextcloud's own storage (default: ${DEFAULT_RECOVERY_BASE_DIR}/<website>,
|
|
override with RECOVERY_BASE_DIR in the conf file) - the exact
|
|
path is shown before the confirmation prompt.
|
|
- The 'encryption_skip_signature_check' config switch is set
|
|
instance-wide for the duration of this script and restored to
|
|
its previous value afterwards (also on interrupt/error).
|
|
- Recovered files may contain unencrypted personal data outside
|
|
of Nextcloud's storage - handle and delete the recovery
|
|
directory accordingly once you are done reviewing it.
|
|
|
|
Unless '-V' is given on the command line, you will be asked
|
|
interactively whether to run a normal recovery or a revalidate-only
|
|
pass (see '-V' below). You will then be asked which existing scan
|
|
report (produced by scan_bad_signature.sh) to use, and then which
|
|
account(s) from that report to attempt recovery for:
|
|
|
|
- a blank separated list of account names
|
|
- or 'all' to attempt every account found in the report
|
|
|
|
\033[1mOptions\033[m
|
|
|
|
-s <website>
|
|
The site of the nextcloud instance.
|
|
|
|
-V
|
|
Revalidate-only mode: does NOT touch 'encryption_skip_signature_check'
|
|
and does NOT decrypt anything again. Instead it re-runs the
|
|
(possibly improved) validation checks against files that were
|
|
already recovered by a previous, normal run - useful after this
|
|
script gained new file-type checks, without repeating the
|
|
instance-wide signature-skip window. Passing it here skips the
|
|
interactive mode question mentioned above.
|
|
|
|
\033[1mExample:\033[m
|
|
|
|
Runs this script on system 'cloud-01.oopen.de'
|
|
|
|
$(basename $0) -s cloud-01.oopen.de
|
|
|
|
Re-validates already recovered files on 'cloud-01.oopen.de' with
|
|
the current checks, without decrypting anything again:
|
|
|
|
$(basename $0) -V -s cloud-01.oopen.de
|
|
"
|
|
|
|
clean_up 1
|
|
|
|
}
|
|
|
|
|
|
restore_encryption_flag() {
|
|
|
|
# - Setzt encryption_skip_signature_check auf den Ursprungswert
|
|
# - zurueck, egal ob das Skript normal durchlaeuft oder
|
|
# - unterbrochen wird. Kein-Op, falls das Flag nie geaendert wurde.
|
|
# -
|
|
if [[ "$_encryption_flag_changed" = true ]] ; then
|
|
echononl " Restoring encryption_skip_signature_check.."
|
|
if [[ -z "$_orig_skip_check" ]] ; then
|
|
su -c "$PHP_BIN $INSTALL_DIR/occ config:system:delete encryption_skip_signature_check" -s /bin/bash $HTTP_USER > /dev/null 2> "$log_file"
|
|
else
|
|
su -c "$PHP_BIN $INSTALL_DIR/occ config:system:set encryption_skip_signature_check --value=$_orig_skip_check --type=boolean" -s /bin/bash $HTTP_USER > /dev/null 2> "$log_file"
|
|
fi
|
|
|
|
if [[ $? -eq 0 ]] ; then
|
|
echo_ok
|
|
_encryption_flag_changed=false
|
|
else
|
|
echo_failed
|
|
error "Could not restore encryption_skip_signature_check automatically! Please check/fix manually on the server: occ config:system:get encryption_skip_signature_check (should be '${_orig_skip_check:-<not set>}'). $(cat "$log_file")"
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
|
|
clean_up() {
|
|
|
|
# Perform program exit housekeeping
|
|
restore_encryption_flag
|
|
[[ -n "$recovery_php_file" ]] && rm -f "$recovery_php_file" 2> /dev/null
|
|
rm -rf "$LOCK_DIR"
|
|
blank_line
|
|
exit $1
|
|
}
|
|
|
|
is_number() {
|
|
|
|
return $(test ! -z "${1##*[!0-9]*}" > /dev/null 2>&1);
|
|
}
|
|
|
|
echononl(){
|
|
if $terminal ; then
|
|
echo X\\c > /tmp/shprompt$$
|
|
if [ `wc -c /tmp/shprompt$$ | awk '{print $1}'` -eq 1 ]; then
|
|
echo -e -n "$*\\c" 1>&2
|
|
else
|
|
echo -e -n "$*" 1>&2
|
|
fi
|
|
rm /tmp/shprompt$$
|
|
fi
|
|
}
|
|
echo_done() {
|
|
if $terminal ; then
|
|
echo -e "\033[75G[ \033[32mdone\033[m ]"
|
|
fi
|
|
}
|
|
echo_ok() {
|
|
if $terminal ; then
|
|
echo -e "\033[75G[ \033[32mok\033[m ]"
|
|
fi
|
|
}
|
|
echo_warning() {
|
|
if $terminal ; then
|
|
echo -e "\033[75G[ \033[33m\033[1mwarn\033[m ]"
|
|
fi
|
|
}
|
|
echo_failed(){
|
|
if $terminal ; then
|
|
echo -e "\033[75G[ \033[1;31mfailed\033[m ]"
|
|
fi
|
|
}
|
|
echo_skipped() {
|
|
if $terminal ; then
|
|
echo -e "\033[75G[ \033[37mskipped\033[m ]"
|
|
fi
|
|
}
|
|
|
|
fatal (){
|
|
echo ""
|
|
echo ""
|
|
if $terminal ; then
|
|
echo -e " [ \033[31m\033[1mFatal\033[m ]: \033[37m\033[1m$*\033[m"
|
|
echo ""
|
|
echo -e " \033[31m\033[1mScript will be interrupted..\033[m!"
|
|
else
|
|
echo " [ Fatal ]: $*"
|
|
echo ""
|
|
echo " Script was terminated...."
|
|
fi
|
|
clean_up 1
|
|
}
|
|
|
|
error(){
|
|
echo ""
|
|
if $terminal ; then
|
|
echo -e " [ \033[31m\033[1mError\033[m ]: $*"
|
|
else
|
|
echo " [ Error ]: $*"
|
|
fi
|
|
echo ""
|
|
}
|
|
|
|
warn (){
|
|
if $terminal ; then
|
|
echo ""
|
|
echo -e " [ \033[33m\033[1mWarning\033[m ]: $*"
|
|
echo ""
|
|
fi
|
|
}
|
|
|
|
info (){
|
|
if $terminal ; then
|
|
echo ""
|
|
echo -e " [ \033[32m\033[1mInfo\033[m ]: $*"
|
|
echo ""
|
|
fi
|
|
}
|
|
|
|
# - Remove leading/trailling whitespaces
|
|
# -
|
|
trim() {
|
|
local var="$*"
|
|
var="${var#"${var%%[![:space:]]*}"}" # remove leading whitespace characters
|
|
var="${var%"${var##*[![:space:]]}"}" # remove trailing whitespace characters
|
|
echo -n "$var"
|
|
}
|
|
|
|
## - Check if a given array (parameter 2) contains a given string (parameter 1)
|
|
## -
|
|
containsElement () {
|
|
local e
|
|
for e in "${@:2}"; do [[ "$e" == "$1" ]] && return 0; done
|
|
return 1
|
|
}
|
|
|
|
## - Percentage (1 decimal) of parameter 1 (part) against parameter 2 (total)
|
|
## - Returns "0.0" if total is empty, zero or non-numeric.
|
|
## -
|
|
calc_percent() {
|
|
local _part="$1"
|
|
local _total="$2"
|
|
if [[ -z "$_total" ]] || ! [[ "$_total" =~ ^[0-9]+$ ]] || [[ "$_total" -eq 0 ]] ; then
|
|
echo "0.0"
|
|
else
|
|
awk -v b="$_part" -v t="$_total" 'BEGIN { printf "%.1f", (b/t)*100 }'
|
|
fi
|
|
}
|
|
|
|
## - Best-effort structural validation of a recovered (signature-skip
|
|
## - decrypted) file. Dispatches primarily on the original file
|
|
## - extension; falls back to content-based detection (libmagic /
|
|
## - 'file') for unknown or missing extensions, or as a last resort
|
|
## - a text/binary heuristic + size comparison. Prints "CLASS|detail" -
|
|
## - CLASS is one of VALID / INVALID / UNVERIFIED.
|
|
## -
|
|
validate_recovered_file() {
|
|
local _f="$1" _origpath="$2" _origsize="$3"
|
|
local _base="$(basename -- "$_origpath")"
|
|
local _ext=""
|
|
if [[ "$_base" == *.* ]] ; then
|
|
_ext="${_origpath##*.}"
|
|
_ext="$(echo "$_ext" | tr '[:upper:]' '[:lower:]')"
|
|
fi
|
|
local _size
|
|
_size=$(stat -c%s "$_f" 2> /dev/null)
|
|
[[ -z "$_size" ]] && _size=0
|
|
|
|
case "$_ext" in
|
|
pdf)
|
|
if _pdf_check "$_f" ; then
|
|
echo "VALID|$_pdf_check_detail"
|
|
else
|
|
echo "INVALID|$_pdf_check_detail"
|
|
fi
|
|
;;
|
|
jpg|jpeg)
|
|
if _jpeg_check "$_f" ; then
|
|
echo "VALID|$_jpeg_check_detail"
|
|
else
|
|
echo "INVALID|$_jpeg_check_detail"
|
|
fi
|
|
;;
|
|
png)
|
|
local _head
|
|
_head="$(head -c8 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_head" = "89504e470d0a1a0a" ]] ; then
|
|
echo "VALID|PNG signature ok"
|
|
else
|
|
echo "INVALID|PNG signature missing"
|
|
fi
|
|
;;
|
|
gif)
|
|
local _head6
|
|
_head6="$(head -c6 "$_f" 2> /dev/null)"
|
|
if [[ "$_head6" = "GIF87a" || "$_head6" = "GIF89a" ]] ; then
|
|
echo "VALID|GIF signature ok"
|
|
else
|
|
echo "INVALID|GIF signature missing"
|
|
fi
|
|
;;
|
|
bmp)
|
|
if [[ "$(head -c2 "$_f" 2> /dev/null)" = "BM" ]] ; then
|
|
echo "VALID|BMP signature ok"
|
|
else
|
|
echo "INVALID|BMP signature missing"
|
|
fi
|
|
;;
|
|
tif|tiff)
|
|
local _head4
|
|
_head4="$(head -c4 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_head4" = "49492a00" || "$_head4" = "4d4d002a" ]] ; then
|
|
echo "VALID|TIFF signature ok"
|
|
else
|
|
echo "INVALID|TIFF signature missing"
|
|
fi
|
|
;;
|
|
pnm|pgm|ppm|pbm)
|
|
local _head2
|
|
_head2="$(head -c2 "$_f" 2> /dev/null)"
|
|
if [[ "$_head2" =~ ^P[1-6]$ ]] ; then
|
|
echo "VALID|PNM/PGM/PPM magic ok"
|
|
else
|
|
echo "INVALID|PNM/PGM/PPM magic (P1-P6) missing"
|
|
fi
|
|
;;
|
|
odt|ods|odp|odg|odf|ott|ots|otp|otg|docx|xlsx|pptx|docm|xlsm|pptm|dotm|xltm|potm|ppsm|ppsx|zip|epub)
|
|
# A password-protected MS Office file (Standard/Agile encryption,
|
|
# MS-OFFCRYPTO) is NOT a zip at all, regardless of its docx/xlsx/
|
|
# pptx extension: the whole package is wrapped in an OLE2/CFBF
|
|
# compound-file container (the same format legacy .doc/.xls/.ppt
|
|
# use), with the real zip payload encrypted inside an internal
|
|
# stream. 'unzip -t' correctly fails on that - not because
|
|
# anything is corrupt, but because it is legitimately not a zip
|
|
# file. Recognize this case before treating a failed zip check
|
|
# as corruption.
|
|
local _head8o
|
|
_head8o="$(head -c8 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_head8o" = "d0cf11e0a1b11ae1" ]] ; then
|
|
echo "VALID|OLE2/CFBF container signature ok - this is a password-protected Office file (encrypted package), not a plain zip, so the zip check does not apply; open it with the password to verify content"
|
|
elif command -v unzip > /dev/null 2>&1 ; then
|
|
# Run unzip inside setsid so it has no controlling terminal.
|
|
# Without setsid, a password-protected ZIP causes unzip to try
|
|
# opening /dev/tty to prompt for the password. When running in
|
|
# the background of a tmux session this generates SIGTTIN, which
|
|
# STOPS the process (ps state T). A stopped process cannot receive
|
|
# SIGTERM, so timeout hangs indefinitely waiting for a child that
|
|
# will never exit. With setsid the /dev/tty open fails immediately
|
|
# with ENXIO and unzip exits with a non-zero code instead.
|
|
# -k 5: send SIGKILL 5 s after SIGTERM in case the process is
|
|
# still alive (e.g. stopped or in uninterruptible sleep).
|
|
local _unzip_exit
|
|
timeout -k 5 120 setsid unzip -tq "$_f" < /dev/null > /dev/null 2>&1
|
|
_unzip_exit=$?
|
|
if [[ $_unzip_exit -eq 0 ]] ; then
|
|
echo "VALID|zip integrity ok"
|
|
elif [[ $_unzip_exit -eq 124 || $_unzip_exit -eq 137 ]] ; then
|
|
# 124 = killed by SIGTERM after timeout, 137 = killed by SIGKILL (128+9)
|
|
echo "UNVERIFIED|zip integrity check timed out after 120 s (file may be very large or corrupt; check manually with: unzip -t \"$_f\")"
|
|
else
|
|
local _badentry
|
|
_badentry="$(trim "$(timeout -k 5 120 setsid unzip -t "$_f" < /dev/null 2>&1 | grep -v '^Archive:' | grep -v '^[[:space:]]*$' | head -1)")"
|
|
if echo "$_badentry" | grep -qi "password\|encrypt\|need PK compat" ; then
|
|
echo "UNVERIFIED|zip is password-protected (cannot verify without password${_badentry:+; unzip says: ${_badentry}})"
|
|
else
|
|
echo "INVALID|zip integrity check failed${_badentry:+ (${_badentry})}"
|
|
fi
|
|
fi
|
|
else
|
|
echo "UNVERIFIED|unzip not installed"
|
|
fi
|
|
;;
|
|
mp4|mov|m4v)
|
|
if head -c 64 "$_f" 2> /dev/null | grep -aq "ftyp" ; then
|
|
echo "VALID|mp4 ftyp box found"
|
|
else
|
|
echo "INVALID|mp4 ftyp box not found"
|
|
fi
|
|
;;
|
|
doc|xls|ppt|ole|msi)
|
|
local _head8
|
|
_head8="$(head -c8 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_head8" = "d0cf11e0a1b11ae1" ]] ; then
|
|
echo "VALID|OLE2 Compound File signature ok (legacy Office)"
|
|
else
|
|
echo "INVALID|OLE2 Compound File signature missing"
|
|
fi
|
|
;;
|
|
azw3|mobi|prc)
|
|
# PalmDOC/Mobipocket container: 8-byte type/creator id
|
|
# 'BOOKMOBI' at fixed offset 60 in the header.
|
|
local _sig
|
|
_sig="$(dd if="$_f" bs=1 skip=60 count=8 2> /dev/null)"
|
|
if [[ "$_sig" = "BOOKMOBI" ]] ; then
|
|
echo "VALID|BOOKMOBI (Kindle/Mobi) signature ok"
|
|
else
|
|
echo "INVALID|BOOKMOBI signature missing at offset 60"
|
|
fi
|
|
;;
|
|
ai)
|
|
# Modern Illustrator files are PDF-compatible by default;
|
|
# older ones are plain PostScript/EPS.
|
|
if [[ "$(head -c5 "$_f" 2> /dev/null)" = "%PDF-" ]] ; then
|
|
if _pdf_check "$_f" ; then
|
|
echo "VALID|AI (PDF-compatible) - $_pdf_check_detail"
|
|
else
|
|
echo "UNVERIFIED|AI (PDF-compatible) but $_pdf_check_detail"
|
|
fi
|
|
elif head -c 12 "$_f" 2> /dev/null | grep -qa '^%!PS-Adobe' ; then
|
|
echo "VALID|AI (legacy PostScript/EPS) header ok"
|
|
else
|
|
echo "INVALID|neither PDF- nor %!PS-Adobe header found"
|
|
fi
|
|
;;
|
|
htm|html)
|
|
if head -c 512 "$_f" 2> /dev/null | tr '[:upper:]' '[:lower:]' | grep -qE '<html|<!doctype html' ; then
|
|
echo "VALID|HTML tag found near start"
|
|
else
|
|
echo "INVALID|no <html>/<!DOCTYPE html> found near start"
|
|
fi
|
|
;;
|
|
css)
|
|
# Plain text + balanced braces is a solid signal: decryption
|
|
# garbage is essentially never valid, balanced-brace text.
|
|
if LC_ALL=C grep -qP '[\x00-\x08\x0E-\x1F\x7F]' "$_f" 2> /dev/null ; then
|
|
echo "INVALID|contains binary/control bytes, not plausible CSS text"
|
|
else
|
|
local _open _close
|
|
_open=$(grep -o '{' "$_f" 2> /dev/null | wc -l)
|
|
_close=$(grep -o '}' "$_f" 2> /dev/null | wc -l)
|
|
if [[ "$_open" -gt 0 && "$_open" -eq "$_close" ]] ; then
|
|
echo "VALID|plain text, ${_open} matching { } pairs"
|
|
else
|
|
echo "INVALID|plain text but { (${_open}) / } (${_close}) counts don't match"
|
|
fi
|
|
fi
|
|
;;
|
|
ttf|otf)
|
|
local _head4f
|
|
_head4f="$(head -c4 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
# 00010000 = TrueType, 4F54544F = 'OTTO' (OpenType/CFF),
|
|
# 74727565 = 'true' (old Mac TrueType), 74746366 = 'ttcf' (collection)
|
|
if [[ "$_head4f" = "00010000" || "$_head4f" = "4f54544f" || "$_head4f" = "74727565" || "$_head4f" = "74746366" ]] ; then
|
|
echo "VALID|TrueType/OpenType font signature ok"
|
|
else
|
|
echo "INVALID|TrueType/OpenType font signature missing (head=$_head4f)"
|
|
fi
|
|
;;
|
|
woff)
|
|
if [[ "$(head -c4 "$_f" 2> /dev/null)" = "wOFF" ]] ; then
|
|
echo "VALID|WOFF font signature ok"
|
|
else
|
|
echo "INVALID|WOFF font signature missing"
|
|
fi
|
|
;;
|
|
woff2)
|
|
if [[ "$(head -c4 "$_f" 2> /dev/null)" = "wOF2" ]] ; then
|
|
echo "VALID|WOFF2 font signature ok"
|
|
else
|
|
echo "INVALID|WOFF2 font signature missing"
|
|
fi
|
|
;;
|
|
psd)
|
|
if [[ "$(head -c4 "$_f" 2> /dev/null)" = "8BPS" ]] ; then
|
|
echo "VALID|Photoshop (8BPS) signature ok"
|
|
else
|
|
echo "INVALID|Photoshop (8BPS) signature missing"
|
|
fi
|
|
;;
|
|
xcf)
|
|
if head -c 9 "$_f" 2> /dev/null | grep -qa '^gimp xcf' ; then
|
|
echo "VALID|GIMP (gimp xcf) signature ok"
|
|
else
|
|
echo "INVALID|GIMP (gimp xcf) signature missing"
|
|
fi
|
|
;;
|
|
wav)
|
|
local _riff _wave
|
|
_riff="$(head -c4 "$_f" 2> /dev/null)"
|
|
_wave="$(dd if="$_f" bs=1 skip=8 count=4 2> /dev/null)"
|
|
if [[ "$_riff" = "RIFF" && "$_wave" = "WAVE" ]] ; then
|
|
echo "VALID|RIFF/WAVE signature ok"
|
|
else
|
|
echo "INVALID|RIFF/WAVE signature missing"
|
|
fi
|
|
;;
|
|
ico)
|
|
local _head4i
|
|
_head4i="$(head -c4 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_head4i" = "00000100" ]] ; then
|
|
echo "VALID|ICO signature ok"
|
|
else
|
|
echo "INVALID|ICO signature missing (head=$_head4i)"
|
|
fi
|
|
;;
|
|
rtf)
|
|
if head -c 6 "$_f" 2> /dev/null | grep -qa '^{\\rtf' ; then
|
|
echo "VALID|RTF signature ok"
|
|
else
|
|
echo "INVALID|RTF signature missing"
|
|
fi
|
|
;;
|
|
exe|dll|sys|scr|ocx|cpl)
|
|
# Windows PE: 'MZ' at offset 0, then at the offset stored (as a
|
|
# little-endian uint32) at 0x3C there must be a 'PE\0\0' signature.
|
|
local _mz _pe_off_hex _pe_off _pe_sig
|
|
_mz="$(head -c2 "$_f" 2> /dev/null)"
|
|
if [[ "$_mz" != "MZ" ]] ; then
|
|
echo "INVALID|PE 'MZ' header missing"
|
|
else
|
|
_pe_off_hex="$(dd if="$_f" bs=1 skip=60 count=4 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
# little-endian: reverse the byte order before interpreting as hex
|
|
_pe_off=$((16#${_pe_off_hex:6:2}${_pe_off_hex:4:2}${_pe_off_hex:2:2}${_pe_off_hex:0:2}))
|
|
_pe_sig="$(dd if="$_f" bs=1 skip="$_pe_off" count=4 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_pe_sig" = "50450000" ]] ; then
|
|
echo "VALID|PE ('MZ' + 'PE\\0\\0') signature ok"
|
|
else
|
|
echo "INVALID|'MZ' header ok but 'PE' signature missing at offset $_pe_off (got $_pe_sig)"
|
|
fi
|
|
fi
|
|
;;
|
|
cab)
|
|
if [[ "$(head -c4 "$_f" 2> /dev/null)" = "MSCF" ]] ; then
|
|
echo "VALID|Microsoft Cabinet (MSCF) signature ok"
|
|
else
|
|
echo "INVALID|Microsoft Cabinet (MSCF) signature missing"
|
|
fi
|
|
;;
|
|
js|mjs|json|xml|svg|txt|csv|tsv|ini|cfg|conf|log|md|yml|yaml|properties|sql|sh|bash|py|php|java|c|h|cpp|hpp)
|
|
# Plain-text formats: broken decryption output is essentially
|
|
# never clean, printable text over any non-trivial length, so
|
|
# "no binary/control bytes" is itself strong positive evidence -
|
|
# much stronger than for an unknown/binary extension, where the
|
|
# same check only feeds the generic fallback below.
|
|
if LC_ALL=C grep -qP '[\x00-\x08\x0E-\x1F\x7F]' "$_f" 2> /dev/null ; then
|
|
echo "INVALID|contains binary/control bytes, not plausible '.${_ext}' text"
|
|
else
|
|
echo "VALID|plain text, no binary/control bytes (no deeper '.${_ext}' syntax check performed)"
|
|
fi
|
|
;;
|
|
indd|indt|indl)
|
|
# Adobe InDesign document/template/library container. There is
|
|
# no open decoder to fully parse it, but every valid file (since
|
|
# CS2/CS4) starts with this fixed 16-byte GUID-like signature -
|
|
# a corrupted/garbage decryption result will essentially never
|
|
# reproduce it by chance.
|
|
local _head16
|
|
_head16="$(head -c16 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_head16" = "0606edf5d81d46e5bd31efe7fe74b71d" ]] ; then
|
|
echo "VALID|InDesign container signature ok (content/layout itself not parsed - open in InDesign to fully confirm)"
|
|
else
|
|
echo "INVALID|InDesign container signature missing (head=$_head16)"
|
|
fi
|
|
;;
|
|
*)
|
|
_validate_by_content_or_heuristic "$_f" "$_ext" "$_size" "$_origsize"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
## - PDF structural check shared by the 'pdf' case and the 'ai'
|
|
## - (PDF-compatible) case. Sets $_pdf_check_detail, returns 0/1.
|
|
## -
|
|
_pdf_check() {
|
|
local _f="$1"
|
|
if [[ "$(head -c5 "$_f" 2> /dev/null)" != "%PDF-" ]] ; then
|
|
_pdf_check_detail="missing %PDF- header"
|
|
return 1
|
|
fi
|
|
if command -v qpdf > /dev/null 2>&1 ; then
|
|
if qpdf --check "$_f" > /dev/null 2>&1 ; then
|
|
_pdf_check_detail="qpdf --check ok"
|
|
return 0
|
|
else
|
|
_pdf_check_detail="qpdf --check failed"
|
|
return 1
|
|
fi
|
|
fi
|
|
_pdf_check_detail="PDF header ok (qpdf not installed, no deep check)"
|
|
return 0
|
|
}
|
|
|
|
## - JPEG structural check. A raw "does the file end in FFD9" byte check
|
|
## - produces false positives: many real-world JPEGs (EXIF/thumbnail
|
|
## - trailers, app-specific padding, camera-written footers) legally carry
|
|
## - a few extra bytes AFTER the actual End-Of-Image marker, so the file's
|
|
## - very last 2 bytes are often NOT ffd9 even though the image is 100%
|
|
## - intact and every viewer opens it fine. We therefore prefer an actual
|
|
## - JPEG decoder (which only cares whether the compressed image data is
|
|
## - intact, not what trails after it) and only fall back to the old
|
|
## - marker heuristic if no decoder tool is available.
|
|
## - Sets $_jpeg_check_detail, returns 0/1.
|
|
_jpeg_check() {
|
|
local _f="$1"
|
|
if command -v identify > /dev/null 2>&1 ; then
|
|
if identify -regard-warnings "$_f" > /dev/null 2>&1 ; then
|
|
_jpeg_check_detail="ImageMagick 'identify' decoded the image ok"
|
|
return 0
|
|
else
|
|
_jpeg_check_detail="ImageMagick 'identify' failed to decode the image"
|
|
return 1
|
|
fi
|
|
fi
|
|
if command -v php > /dev/null 2>&1 ; then
|
|
local _phpout
|
|
_phpout="$(php -r '
|
|
error_reporting(0);
|
|
if (!function_exists("imagecreatefromjpeg")) { echo "NOGD"; exit(0); }
|
|
$im = @imagecreatefromjpeg($argv[1]);
|
|
if ($im === false) { echo "BAD"; exit(0); }
|
|
imagedestroy($im);
|
|
echo "OK";
|
|
' "$_f" 2> /dev/null)"
|
|
case "$_phpout" in
|
|
OK)
|
|
_jpeg_check_detail="PHP GD (imagecreatefromjpeg) decoded the image ok"
|
|
return 0
|
|
;;
|
|
BAD)
|
|
_jpeg_check_detail="PHP GD (imagecreatefromjpeg) failed to decode the image"
|
|
return 1
|
|
;;
|
|
esac
|
|
# NOGD or empty output: GD extension not available, fall through
|
|
fi
|
|
# last resort: the old, less reliable marker heuristic
|
|
local _head _tail
|
|
_head="$(head -c3 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
_tail="$(tail -c2 "$_f" 2> /dev/null | od -An -tx1 | tr -d ' \n')"
|
|
if [[ "$_head" = "ffd8ff" && "$_tail" = "ffd9" ]] ; then
|
|
_jpeg_check_detail="JPEG SOI/EOI markers ok (no decoder available for a deep check)"
|
|
return 0
|
|
elif [[ "$_head" = "ffd8ff" ]] ; then
|
|
_jpeg_check_detail="JPEG SOI marker ok but no decoder available for a deep check; raw EOI-at-EOF heuristic failed (head=$_head tail=$_tail) - this is NOT reliable, many valid JPEGs carry trailer bytes after EOI, verify manually or install ImageMagick/php-gd"
|
|
return 1
|
|
else
|
|
_jpeg_check_detail="JPEG SOI marker missing (head=$_head)"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
## - Fallback for extensions without a dedicated structural check (or
|
|
## - no extension at all): use 'file'/libmagic to see what the content
|
|
## - actually looks like. If it is confidently one of our known strong
|
|
## - types (this can happen for misnamed files, e.g. a '.pdf' saved
|
|
## - without the dot), re-run the matching dedicated check instead of
|
|
## - just guessing. Otherwise report the detected type plus a
|
|
## - text/binary plausibility check - never auto-classifies as INVALID
|
|
## - purely from an unrecognised type, since libmagic not knowing a
|
|
## - rare/proprietary format is not proof of corruption.
|
|
## -
|
|
_validate_by_content_or_heuristic() {
|
|
local _f="$1" _ext="$2" _size="$3" _origsize="$4"
|
|
local _magic=""
|
|
|
|
if command -v file > /dev/null 2>&1 ; then
|
|
_magic="$(file --mime-type -b "$_f" 2> /dev/null)"
|
|
fi
|
|
|
|
case "$_magic" in
|
|
application/pdf)
|
|
if _pdf_check "$_f" ; then
|
|
echo "VALID|content-detected PDF ('.${_ext:-<none>}' extension), $_pdf_check_detail"
|
|
else
|
|
echo "UNVERIFIED|content-detected PDF ('.${_ext:-<none>}' extension), but $_pdf_check_detail"
|
|
fi
|
|
return
|
|
;;
|
|
image/jpeg|image/png|image/gif|image/bmp|image/tiff|application/zip|video/mp4|video/quicktime)
|
|
echo "UNVERIFIED|content-detected as $_magic (extension was '.${_ext:-<none>}') - re-run with that extension to structurally validate, or check manually"
|
|
return
|
|
;;
|
|
esac
|
|
|
|
# - Kein starker Treffer ueber libmagic: zumindest grob zwischen
|
|
# - "sieht nach Text aus" und "enthaelt binaere/Steuerzeichen"
|
|
# - unterscheiden - reine Zufalls-/Entschluesselungs-Reste sind so
|
|
# - gut wie nie durchgehend druckbarer Text.
|
|
# -
|
|
local _looks_like_text="unknown"
|
|
if LC_ALL=C grep -qP '[\x00-\x08\x0E-\x1F\x7F]' "$_f" 2> /dev/null ; then
|
|
_looks_like_text="no (contains binary/control bytes)"
|
|
else
|
|
_looks_like_text="yes (no binary/control bytes found)"
|
|
fi
|
|
|
|
# Note: recovered (plaintext) is ALWAYS smaller than original
|
|
# (ciphertext on disk, incl. IV/signature/padding overhead per 8192-byte
|
|
# block) - roughly 74-86% of it for this instance. That's normal and
|
|
# expected, not a sign of corruption; we only flag it if the ratio is
|
|
# implausible (e.g. way too small, suggesting truncation).
|
|
local _size_note
|
|
if [[ -n "$_origsize" && "$_origsize" =~ ^[0-9]+$ && "$_origsize" -gt 0 && "$_size" -gt 0 ]] ; then
|
|
local _ratio_pct=$(( _size * 100 / _origsize ))
|
|
if [[ "$_ratio_pct" -ge 65 && "$_ratio_pct" -le 95 ]] ; then
|
|
_size_note="size ratio plausible (recovered ${_size} / original ${_origsize} = ${_ratio_pct}%, expected ~74-86% for this instance)"
|
|
else
|
|
_size_note="size ratio LOOKS OFF (recovered ${_size} / original ${_origsize} = ${_ratio_pct}%, expected ~74-86% - check manually)"
|
|
fi
|
|
else
|
|
_size_note="size comparison not possible (recovered ${_size} bytes, original ${_origsize:-?} bytes)"
|
|
fi
|
|
|
|
echo "UNVERIFIED|no dedicated check for '.${_ext:-<none>}', detected type: ${_magic:-file/libmagic not installed}, looks like text: ${_looks_like_text}, ${_size_note}"
|
|
}
|
|
|
|
blank_line() {
|
|
if $terminal ; then
|
|
echo ""
|
|
fi
|
|
}
|
|
|
|
|
|
|
|
# - Running in a terminal?
|
|
# -
|
|
if [[ -t 1 ]] ; then
|
|
terminal=true
|
|
else
|
|
terminal=false
|
|
fi
|
|
|
|
# - This script needs root privileges (chown/chmod of the recovery
|
|
# - directory, 'su' into the webserver user, 'occ config:system:set').
|
|
# - Fail fast with a clear message instead of a confusing permission
|
|
# - error somewhere in the middle of the run.
|
|
# -
|
|
if [[ "$(id -u)" -ne 0 ]] ; then
|
|
fatal "This script must be run as root (it needs to chown/chmod the recovery directory, 'su' into the webserver user and run 'occ config:system:set'). Please re-run as root, e.g. via sudo."
|
|
fi
|
|
|
|
# ----------
|
|
# - Jobhandling
|
|
# ----------
|
|
|
|
if pgrep -f "$(basename $0)" | grep -q -v $$ ; then
|
|
|
|
msg="A previos instance of script \"`basename $0`\" seems already be running."
|
|
|
|
echo ""
|
|
if $terminal ; then
|
|
echo -e "[ \033[31m\033[1mFatal\033[m ]: $msg"
|
|
echo ""
|
|
echo -e " \033[31m\033[1mScript was interupted\033[m!"
|
|
else
|
|
echo " [ Fatal ]: $msg"
|
|
echo ""
|
|
echo " Script was interupted!"
|
|
fi
|
|
echo
|
|
|
|
exit 1
|
|
else
|
|
if [[ -d "$LOCK_DIR" ]] ; then
|
|
rm -rf "$LOCK_DIR" 2> /dev/null
|
|
fi
|
|
fi
|
|
|
|
|
|
# - If job already runs, stop execution..
|
|
# -
|
|
if mkdir "$LOCK_DIR" 2> /dev/null ; then
|
|
|
|
# - Remove lockdir when the script finishes, or when it receives a signal
|
|
# -
|
|
trap clean_up SIGHUP SIGINT SIGTERM
|
|
|
|
else
|
|
|
|
msg="A previos instance of script \"`basename $0`\" seems already be running."
|
|
|
|
echo ""
|
|
if $terminal ; then
|
|
echo -e "[ \033[31m\033[1mFatal\033[m ]: $msg"
|
|
echo ""
|
|
echo -e " \033[31m\033[1mScript was interupted\033[m!"
|
|
else
|
|
echo " [ Fatal ]: $msg"
|
|
echo ""
|
|
echo " Script was interupted!"
|
|
fi
|
|
echo
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
|
|
# -------------
|
|
# - Read in Commandline arguments
|
|
# -------------
|
|
REVALIDATE_ONLY=false
|
|
_revalidate_only_explicit=false
|
|
|
|
while getopts hVs: opt ; do
|
|
case $opt in
|
|
h) usage ;;
|
|
V) REVALIDATE_ONLY=true; _revalidate_only_explicit=true ;;
|
|
s) WEBSITE=$OPTARG ;;
|
|
\?) usage
|
|
esac
|
|
done
|
|
|
|
|
|
# =============
|
|
# --- Ask which mode to run in, unless '-V' was already given on the
|
|
# --- command line (that still works unchanged for scripted/non-
|
|
# --- interactive invocations).
|
|
# =============
|
|
if ! $_revalidate_only_explicit && $terminal ; then
|
|
|
|
blank_line
|
|
echo -e "\033[37m\033[1mWhich mode should this run use?\033[m"
|
|
echo ""
|
|
echo -e " \033[1m[1] Recovery\033[m - decrypt bad-signature files (temporarily skips the signature check), write them under ${DEFAULT_RECOVERY_BASE_DIR}/<website> and validate them"
|
|
echo " [2] Revalidate-only - re-run just the validation checks against files a previous recovery run already wrote to disk (same as '-V'); nothing is decrypted again and no config value is touched"
|
|
info "Just press Return to use the default: [1] Recovery."
|
|
echo -n " Select mode by number [1]: "
|
|
read _mode_choice
|
|
|
|
case "$(trim "$_mode_choice")" in
|
|
2) REVALIDATE_ONLY=true ;;
|
|
""|1) REVALIDATE_ONLY=false ;;
|
|
*) fatal "Invalid selection '$_mode_choice'." ;;
|
|
esac
|
|
|
|
fi
|
|
|
|
if [[ -z "$WEBSITE" ]] ; then
|
|
|
|
while IFS='' read -r -d '' _conf_file ; do
|
|
source $_conf_file
|
|
if [[ -n "$WEBSITE" ]] ; then
|
|
unsorted_website_arr+=("${WEBSITE}:$_conf_file")
|
|
fi
|
|
WEBSITE=""
|
|
done < <(find "${conf_dir}" -maxdepth 1 -type f -name "*.conf" -print0)
|
|
|
|
# - Sort array
|
|
# -
|
|
IFS=$'\n' website_arr=($(sort <<<"${unsorted_website_arr[*]}"))
|
|
|
|
# Which cloud instance (website) would you like to update
|
|
#
|
|
source ${snippet_dir}/get-cloud-instance-to-update.sh
|
|
|
|
else
|
|
|
|
while IFS='' read -r -d '' _conf_file ; do
|
|
if $(grep -E -q "WEBSITE=\"?${WEBSITE}\"?" ${_conf_file} 2> /dev/null) ; then
|
|
conf_file="${_conf_file}"
|
|
break
|
|
fi
|
|
done < <(find "${conf_dir}" -maxdepth 1 -type f -name "*.conf" -print0)
|
|
|
|
fi
|
|
|
|
|
|
# - Reset IFS
|
|
# -
|
|
IFS=$CUR_IFS
|
|
|
|
DEFAULT_SRC_BASE_DIR="/usr/local/src/nextcloud"
|
|
DEFAULT_HTTP_USER="www-data"
|
|
DEFAULT_HTTP_GROUP="www-data"
|
|
DEFAULT_PHP_ENGINE='FPM'
|
|
|
|
blank_line
|
|
echononl " Include Configuration file '$(basename "${conf_file}")'.."
|
|
if [[ ! -f $conf_file ]]; then
|
|
echo_skipped
|
|
fatal "Missing configuration file '$conf_file'."
|
|
else
|
|
source $conf_file
|
|
echo_ok
|
|
fi
|
|
|
|
DEFAULT_WEB_BASE_DIR="/var/www/${WEBSITE}"
|
|
[[ -n "$WEB_BASE_DIR" ]] || WEB_BASE_DIR=$DEFAULT_WEB_BASE_DIR
|
|
|
|
if [[ ! -d ${WEB_BASE_DIR} ]] ; then
|
|
fatal "Web base directory '$WEB_BASE_DIR' not found!"
|
|
fi
|
|
|
|
DATA_DIR="$(realpath ${WEB_BASE_DIR}/data)"
|
|
|
|
[[ -n "$PHP_ENGINE" ]] || PHP_ENGINE=$DEFAULT_PHP_ENGINE
|
|
|
|
INSTALL_DIR="$(realpath ${WEB_BASE_DIR}/nextcloud)"
|
|
CURRENT_VERSION="$(basename $INSTALL_DIR | cut -d"-" -f2)"
|
|
|
|
# - Recovery-Zielverzeichnis: bewusst ausserhalb von script_dir/WEB_BASE_DIR
|
|
# - (siehe Kommentar bei DEFAULT_RECOVERY_BASE_DIR weiter oben) - eine
|
|
# - per-Website Unterordner, den 'www-data' auch tatsaechlich erreichen
|
|
# - kann.
|
|
# -
|
|
[[ -n "$RECOVERY_BASE_DIR" ]] || RECOVERY_BASE_DIR=$DEFAULT_RECOVERY_BASE_DIR
|
|
recovery_dir="${RECOVERY_BASE_DIR}/${WEBSITE}"
|
|
|
|
|
|
# =============
|
|
# --- Some
|
|
# =============
|
|
|
|
# - Support systemd ?
|
|
# -
|
|
SYSTEMD_EXISTS=false
|
|
systemd=$(which systemd)
|
|
systemctl=$(which systemctl)
|
|
|
|
if [[ -n "$systemd" ]] || [[ -n "$systemctl" ]] ; then
|
|
SYSTEMD_EXISTS=true
|
|
fi
|
|
|
|
#clear
|
|
|
|
if $terminal ; then
|
|
echo ""
|
|
echo -e "\033[32m-----\033[m"
|
|
echo -e "Attempt to recover \033[1mBad Signature\033[m files on system \033[1m${WEB_BASE_DIR}\033[m"
|
|
echo -e "\033[1m
|
|
Original files are never touched. Recovered content is written to a
|
|
separate directory and must be reviewed manually.\033[m"
|
|
echo -e "\033[32m-----\033[m"
|
|
fi
|
|
|
|
|
|
# =============
|
|
# --- Some checks
|
|
# =============
|
|
|
|
DEFAULT_HTTP_USER="www-data"
|
|
DEFAULT_HTTP_GROUP="www-data"
|
|
|
|
|
|
NGINX_IS_ENABLED=false
|
|
APACHE2_IS_ENABLED=false
|
|
|
|
# Get Webservice environment as IS_HTTPD_RUNNING, HTTP_USER, HTTP_GROUP..
|
|
#
|
|
source ${snippet_dir}/get-webservice-environment.sh
|
|
|
|
|
|
# Check PHP Version
|
|
#
|
|
source ${snippet_dir}/get-php-major-version.sh
|
|
|
|
|
|
# Get full qualified PHP command
|
|
#
|
|
source ${snippet_dir}/get-path-of-php-command.sh
|
|
|
|
|
|
if [[ ! -x "$PHP_BIN" ]]; then
|
|
fatal "No PHP binary found!"
|
|
fi
|
|
|
|
|
|
# =============
|
|
# --- Check Server-Side Encryption status
|
|
# =============
|
|
|
|
blank_line
|
|
echononl " Check Server-Side Encryption status.."
|
|
|
|
_encryption_status_out="$(su -c "$PHP_BIN $INSTALL_DIR/occ encryption:status" -s /bin/bash $HTTP_USER 2> "$log_file")"
|
|
|
|
ENCRYPTION_ENABLED="unknown"
|
|
|
|
if [[ -s "$log_file" ]] ; then
|
|
echo_failed
|
|
error "$(cat "$log_file")"
|
|
elif echo "$_encryption_status_out" | grep -qiE 'enabled:[[:space:]]*true' ; then
|
|
echo_ok
|
|
ENCRYPTION_ENABLED="yes"
|
|
else
|
|
echo_warning
|
|
ENCRYPTION_ENABLED="no"
|
|
fi
|
|
|
|
if [[ "$ENCRYPTION_ENABLED" != "yes" && "$REVALIDATE_ONLY" = false ]] ; then
|
|
fatal "Server-Side Encryption is not enabled on ${WEBSITE} - a signature-skip recovery attempt makes no sense here."
|
|
fi
|
|
|
|
|
|
# =============
|
|
# --- Determine available bad-signature reports
|
|
# =============
|
|
|
|
mapfile -t _available_reports < <(ls -t "${report_dir}"/bad_signature_*.tsv 2> /dev/null)
|
|
|
|
if [[ ${#_available_reports[@]} -eq 0 ]] ; then
|
|
fatal "No scan report files (bad_signature_*.tsv) found in '${report_dir}'. Run scan_bad_signature.sh first."
|
|
fi
|
|
|
|
blank_line
|
|
if $terminal ; then
|
|
echo -e "\033[37m\033[1mAvailable bad-signature reports (newest first)\033[m"
|
|
echo ""
|
|
_i=1
|
|
for _f in "${_available_reports[@]}" ; do
|
|
printf " [%2d] %s\n" "$_i" "$(basename "$_f")"
|
|
(( _i++ ))
|
|
done
|
|
echo ""
|
|
fi
|
|
|
|
echo -n " Select report by number: "
|
|
read _report_choice
|
|
|
|
if ! [[ "$_report_choice" =~ ^[0-9]+$ ]] || [[ "$_report_choice" -lt 1 ]] || [[ "$_report_choice" -gt ${#_available_reports[@]} ]] ; then
|
|
fatal "Invalid selection '$_report_choice'."
|
|
fi
|
|
|
|
chosen_report="${_available_reports[$((_report_choice-1))]}"
|
|
|
|
|
|
# =============
|
|
# --- Determine accounts contained in the chosen report
|
|
# =============
|
|
|
|
unsorted_account_arr=($(awk -F'\t' 'NF==5 && $3 ~ /^[0-9]+$/ {print $1}' "$chosen_report" | sort -u))
|
|
IFS=$'\n' account_arr=($(sort <<<"${unsorted_account_arr[*]}"))
|
|
IFS=$CUR_IFS
|
|
|
|
if [[ ${#account_arr[@]} -eq 0 ]] ; then
|
|
fatal "No bad-signature entries found in '$(basename "$chosen_report")'."
|
|
fi
|
|
|
|
blank_line
|
|
if $terminal ; then
|
|
echo -e "\033[37m\033[1mAccounts with 'Bad Signature' entries in this report\033[m"
|
|
echo ""
|
|
for _a in "${account_arr[@]}" ; do
|
|
echo " - $_a"
|
|
done
|
|
echo ""
|
|
fi
|
|
|
|
echo -n " Account(s) to attempt recovery for (blank separated, or 'all'): "
|
|
read _input
|
|
|
|
while true ; do
|
|
|
|
IFS=' ' read -r -a unsorted_selected_user_arr <<< "$(trim "$_input")"
|
|
|
|
if [[ "${#unsorted_selected_user_arr[@]}" -eq 1 && "${unsorted_selected_user_arr[0],,}" = "all" ]] ; then
|
|
selected_user_arr=("${account_arr[@]}")
|
|
break
|
|
fi
|
|
|
|
_all_valid=true
|
|
for _u in "${unsorted_selected_user_arr[@]}" ; do
|
|
if ! containsElement "$_u" "${account_arr[@]}" ; then
|
|
error "Unknown account '$_u' (not found in the selected report)."
|
|
_all_valid=false
|
|
fi
|
|
done
|
|
|
|
if $_all_valid && [[ "${#unsorted_selected_user_arr[@]}" -gt 0 ]] ; then
|
|
IFS=$'\n' selected_user_arr=($(sort <<<"${unsorted_selected_user_arr[*]}"))
|
|
IFS=$CUR_IFS
|
|
break
|
|
fi
|
|
|
|
echo -n " Account(s) to attempt recovery for (blank separated, or 'all'): "
|
|
read _input
|
|
|
|
done
|
|
|
|
|
|
# =============
|
|
# --- Confirmation
|
|
# =============
|
|
|
|
mkdir -p "$report_dir" 2> /dev/null
|
|
recovery_report_file="${report_dir}/recovery_${WEBSITE}_${run_date}.tsv"
|
|
|
|
if $terminal ; then
|
|
echo ""
|
|
if $REVALIDATE_ONLY ; then
|
|
echo -e "\033[1;32mStarting revalidate-only run for \033[1;37m${WEBSITE}\033[m"
|
|
else
|
|
echo -e "\033[1;32mStarting recovery attempt for \033[1;37m${WEBSITE}\033[m"
|
|
fi
|
|
echo ""
|
|
echo -e " Cloud instance to be scanned.........: $WEBSITE"
|
|
echo ""
|
|
echo -e " Report used...........................: $(basename "$chosen_report")"
|
|
echo -e " Account(s) to recover.................: \033[33m${selected_user_arr[*]}\033[m"
|
|
echo ""
|
|
if $REVALIDATE_ONLY ; then
|
|
echo -e " Existing recovered files under........: $recovery_dir"
|
|
echo -e " Revalidate-only report..................: reports/$(basename "${recovery_report_file}")"
|
|
else
|
|
echo -e " Recovered files will be written to....: $recovery_dir"
|
|
echo -e " Recovery report........................: reports/$(basename "${recovery_report_file}")"
|
|
fi
|
|
echo ""
|
|
|
|
if $REVALIDATE_ONLY ; then
|
|
info "Revalidate-only mode: nothing is decrypted again, no config value is changed. Only the current (possibly newer) validation checks are re-run against files already recovered by a previous, normal run."
|
|
else
|
|
warn "This will TEMPORARILY set 'encryption_skip_signature_check' to true instance-wide, so already-broken files can be decrypted despite failing the signature check. It is restored to its previous value automatically when this script ends (also on Ctrl-C or error). Files with genuinely corrupted ciphertext will still come out as garbage - every recovered file is validated afterwards, but please still spot-check important results yourself before relying on them."
|
|
fi
|
|
|
|
echo ""
|
|
echo -n " Type upper case 'YES' to continue executing with this parameters: "
|
|
read OK
|
|
if [[ "$OK" = "YES" ]] ; then
|
|
echo ""
|
|
echo ""
|
|
echo -e "\033[1;32mGoing to attempt recovery for each selected account on \033[1;37m$WEBSITE \033[m"
|
|
else
|
|
fatal "Abort by user request - Answer as not 'YES'"
|
|
fi
|
|
fi
|
|
|
|
|
|
{
|
|
echo "=================================================================="
|
|
echo " Bad-Signature-Recovery-Versuch ${WEBSITE} ${run_date}"
|
|
echo "=================================================================="
|
|
echo ""
|
|
echo " Basis-Report: $(basename "$chosen_report")"
|
|
echo " Wiederhergestellte Dateien liegen unter: ${recovery_dir}"
|
|
echo ""
|
|
echo -e "path\trecovered_bytes\toriginal_size\tstatus\tvalidation\tdetail"
|
|
} > "$recovery_report_file"
|
|
|
|
|
|
if ! $REVALIDATE_ONLY ; then
|
|
|
|
# =============
|
|
# --- Temporarily enable encryption_skip_signature_check
|
|
# =============
|
|
|
|
blank_line
|
|
echononl " Reading current encryption_skip_signature_check value.."
|
|
_orig_skip_check="$(su -c "$PHP_BIN $INSTALL_DIR/occ config:system:get encryption_skip_signature_check" -s /bin/bash $HTTP_USER 2> /dev/null)"
|
|
_orig_skip_check="$(trim "$_orig_skip_check")"
|
|
echo_done
|
|
|
|
echononl " Enabling encryption_skip_signature_check (temporary)..."
|
|
su -c "$PHP_BIN $INSTALL_DIR/occ config:system:set encryption_skip_signature_check --value=true --type=boolean" -s /bin/bash $HTTP_USER > /dev/null 2> "$log_file"
|
|
if [[ $? -eq 0 ]] ; then
|
|
echo_ok
|
|
_encryption_flag_changed=true
|
|
trap 'restore_encryption_flag; clean_up 1' SIGHUP SIGINT SIGTERM
|
|
else
|
|
echo_failed
|
|
fatal "Could not enable encryption_skip_signature_check: $(cat "$log_file")"
|
|
fi
|
|
|
|
fi
|
|
|
|
|
|
if ! $REVALIDATE_ONLY ; then
|
|
|
|
# =============
|
|
# --- Write the embedded PHP recovery script
|
|
# =============
|
|
|
|
recovery_php_file="${INSTALL_DIR}/.recover_bad_signature_$$.php"
|
|
|
|
cat > "$recovery_php_file" <<'PHP_RECOVER_EOF'
|
|
<?php
|
|
/**
|
|
* recover_bad_signature.php
|
|
*
|
|
* Attempts to decrypt a known list of 'Bad Signature' files while
|
|
* 'encryption_skip_signature_check' is enabled (set by the calling
|
|
* wrapper script), and writes the resulting bytes to a separate
|
|
* output directory. Never touches the original file.
|
|
*
|
|
* Usage: php recover_bad_signature.php <uid> <listFile> <outDir>
|
|
* listFile: TSV with "path\tsize\tmtime" per line (no header)
|
|
*/
|
|
|
|
error_reporting(E_ALL);
|
|
ini_set('display_errors', '1');
|
|
|
|
fwrite(STDERR, "DEBUG: Recovery-Skript gestartet, PID=" . getmypid() . "\n");
|
|
|
|
register_shutdown_function(function () {
|
|
$err = error_get_last();
|
|
if ($err !== null && in_array($err['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR], true)) {
|
|
fwrite(STDERR, "DEBUG: FATAL bei Shutdown: [{$err['type']}] {$err['message']} in {$err['file']}:{$err['line']}\n");
|
|
}
|
|
});
|
|
|
|
define('OC_CONSOLE', 1);
|
|
|
|
$oldWorkingDir = getcwd();
|
|
if ($oldWorkingDir === false) {
|
|
fwrite(STDERR, "Konnte aktuelles Arbeitsverzeichnis nicht ermitteln. Bitte mit absolutem Pfad aufrufen.\n");
|
|
exit(1);
|
|
}
|
|
chdir(__DIR__);
|
|
require_once __DIR__ . '/lib/base.php';
|
|
// Nextcloud's own bootstrap (lib/base.php) unconditionally calls
|
|
// set_time_limit(3600) as part of the require above - this OVERRIDES
|
|
// whatever -d max_execution_time was passed on the PHP command line,
|
|
// since it is a later, explicit runtime call. Undo that here, now that
|
|
// the require is done, so recovering a large account isn't killed
|
|
// after exactly one hour regardless of the CLI flag.
|
|
set_time_limit(0);
|
|
chdir($oldWorkingDir);
|
|
|
|
if (function_exists('posix_getuid') && posix_getuid() === 0) {
|
|
fwrite(STDERR, "Bitte NICHT als root ausfuehren, sondern als Webserver-User.\n");
|
|
exit(1);
|
|
}
|
|
|
|
try {
|
|
$uid = $argv[1] ?? null;
|
|
$listFile = $argv[2] ?? null;
|
|
$outDir = $argv[3] ?? null;
|
|
|
|
if ($uid === null || $listFile === null || $outDir === null) {
|
|
fwrite(STDERR, "Usage: php recover_bad_signature.php <uid> <listFile> <outDir>\n");
|
|
exit(1);
|
|
}
|
|
if (!is_file($listFile)) {
|
|
fwrite(STDERR, "Liste nicht gefunden: $listFile\n");
|
|
exit(1);
|
|
}
|
|
if (!is_dir($outDir)) {
|
|
@mkdir($outDir, 0750, true);
|
|
}
|
|
|
|
$rootFolder = \OC::$server->get(\OCP\Files\IRootFolder::class);
|
|
\OC_Util::setupFS($uid);
|
|
|
|
$lines = file($listFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
|
|
if ($lines === false) {
|
|
$lines = [];
|
|
}
|
|
|
|
$total = 0;
|
|
$ok = 0;
|
|
$failed = 0;
|
|
|
|
echo "path\trecovered_bytes\toriginal_size\tstatus\n";
|
|
|
|
foreach ($lines as $line) {
|
|
$cols = explode("\t", $line);
|
|
$path = $cols[0] ?? '';
|
|
$origSize = $cols[1] ?? '';
|
|
if ($path === '') {
|
|
continue;
|
|
}
|
|
$total++;
|
|
|
|
try {
|
|
$node = $rootFolder->get($path);
|
|
} catch (\Throwable $e) {
|
|
$failed++;
|
|
$msg = str_replace(["\t", "\n", "\r"], ' ', $e->getMessage());
|
|
echo "$path\t0\t$origSize\tNOT_FOUND: $msg\n";
|
|
flush();
|
|
continue;
|
|
}
|
|
|
|
if (!($node instanceof \OCP\Files\File)) {
|
|
$failed++;
|
|
echo "$path\t0\t$origSize\tNOT_A_FILE\n";
|
|
flush();
|
|
continue;
|
|
}
|
|
|
|
// Zielpfad unterhalb outDir, gleiche relative Struktur wie
|
|
// innerhalb der Nextcloud-Dateien des Users (ohne /<uid>/files/)
|
|
$relative = preg_replace('#^/' . preg_quote($uid, '#') . '/files/#', '', $path);
|
|
if ($relative === null || $relative === '') {
|
|
$relative = ltrim($path, '/');
|
|
}
|
|
$targetPath = rtrim($outDir, '/') . '/' . $relative;
|
|
$targetDir = dirname($targetPath);
|
|
if (!is_dir($targetDir)) {
|
|
@mkdir($targetDir, 0750, true);
|
|
}
|
|
|
|
try {
|
|
$in = $node->fopen('r');
|
|
if ($in === false) {
|
|
throw new \RuntimeException('fopen lieferte false');
|
|
}
|
|
$out = fopen($targetPath, 'w');
|
|
if ($out === false) {
|
|
throw new \RuntimeException("Zieldatei konnte nicht geoeffnet werden: $targetPath");
|
|
}
|
|
$bytes = stream_copy_to_stream($in, $out);
|
|
fclose($in);
|
|
fclose($out);
|
|
|
|
if ($bytes === false) {
|
|
throw new \RuntimeException('stream_copy_to_stream schlug fehl');
|
|
}
|
|
|
|
$ok++;
|
|
echo "$path\t$bytes\t$origSize\tOK\n";
|
|
flush();
|
|
} catch (\Throwable $e) {
|
|
$failed++;
|
|
$msg = str_replace(["\t", "\n", "\r"], ' ', $e->getMessage());
|
|
echo "$path\t0\t$origSize\tERROR: " . get_class($e) . ": $msg\n";
|
|
flush();
|
|
@unlink($targetPath);
|
|
}
|
|
}
|
|
|
|
fwrite(STDERR, "\nFertig. Dateien verarbeitet: $total, erfolgreich gelesen: $ok, Fehler: $failed\n");
|
|
} catch (\Throwable $e) {
|
|
fwrite(STDERR, "\n!!! UNBEHANDELTE AUSNAHME !!!\n");
|
|
fwrite(STDERR, get_class($e) . ": " . $e->getMessage() . "\n");
|
|
fwrite(STDERR, "in " . $e->getFile() . ":" . $e->getLine() . "\n");
|
|
fwrite(STDERR, $e->getTraceAsString() . "\n");
|
|
exit(2);
|
|
}
|
|
PHP_RECOVER_EOF
|
|
|
|
chmod 644 "$recovery_php_file"
|
|
|
|
fi
|
|
|
|
|
|
# -----
|
|
# - Main part of the script
|
|
# -----
|
|
|
|
if $terminal ; then
|
|
echo ""
|
|
echo ""
|
|
echo -e "\033[37m\033[1mMain part of the script\033[m"
|
|
echo ""
|
|
fi
|
|
|
|
if $REVALIDATE_ONLY ; then
|
|
if [[ ! -d "$recovery_dir" ]] ; then
|
|
fatal "Revalidate-only mode: recovery directory '$recovery_dir' does not exist - run this script without -V first."
|
|
fi
|
|
else
|
|
|
|
mkdir -p "$recovery_dir" 2> /dev/null
|
|
|
|
# - 'mkdir -p' creates missing parent directories (e.g. RECOVERY_BASE_DIR
|
|
# - itself) subject to the current umask - if that happens to be
|
|
# - restrictive, the PARENT of recovery_dir can end up blocking
|
|
# - traversal for $HTTP_USER even though recovery_dir itself is fine.
|
|
# - Explicitly (re-)open both levels for traversal (RECOVERY_BASE_DIR is
|
|
# - only ever traversed, never written into directly).
|
|
# -
|
|
chmod 755 "$RECOVERY_BASE_DIR" 2> /dev/null
|
|
chmod 755 "$recovery_dir" 2> /dev/null
|
|
|
|
# - recovery_dir itself still belongs to root at this point though -
|
|
# - mode 755 only grants $HTTP_USER (as 'other', not the owner) read +
|
|
# - traverse, NOT write. Files are later written per-account into
|
|
# - freshly created (and per-account chown'ed) subdirectories, but
|
|
# - recovery_dir itself also needs to be owned by $HTTP_USER so the
|
|
# - write test below (and 'mkdir' calls done by the PHP process
|
|
# - running as $HTTP_USER) can actually create things directly in it.
|
|
# -
|
|
chown "$HTTP_USER":"$HTTP_GROUP" "$recovery_dir" 2> /dev/null
|
|
|
|
# - Frueher, klarer Fehler statt 780x der gleiche stille Flop: pruefen,
|
|
# - ob der Webserver-User ($HTTP_USER) hier tatsaechlich schreiben kann,
|
|
# - BEVOR der eigentliche Recovery-Lauf beginnt. Faengt u.a. den Fall
|
|
# - ab, dass RECOVERY_BASE_DIR auf ein fuer $HTTP_USER unerreichbares
|
|
# - Verzeichnis (z.B. unterhalb von /root) gesetzt wurde.
|
|
# -
|
|
_write_test_file="${recovery_dir}/.write_test_$$"
|
|
su -c "touch '$_write_test_file'" -s /bin/bash $HTTP_USER 2> "$log_file"
|
|
if [[ ! -f "$_write_test_file" ]] ; then
|
|
fatal "Cannot write to recovery directory '$recovery_dir' as user '$HTTP_USER' - check the permissions of every path component (in particular that none of them, e.g. a parent directory, is only accessible to root). $(cat "$log_file")"
|
|
fi
|
|
rm -f "$_write_test_file" 2> /dev/null
|
|
|
|
fi
|
|
|
|
declare -i total_processed=0
|
|
declare -i total_valid=0
|
|
declare -i total_invalid=0
|
|
declare -i total_unverified=0
|
|
declare -i total_read_errors=0
|
|
declare -i total_failed_users=0
|
|
|
|
for _user in "${selected_user_arr[@]}" ; do
|
|
|
|
_sep_len=${#_user}
|
|
[[ $_sep_len -lt 9 ]] && _sep_len=9
|
|
_sep_line="$(printf '%*s' "$_sep_len" '' | tr ' ' '-')"
|
|
|
|
{
|
|
echo ""
|
|
echo ""
|
|
echo "$_sep_line"
|
|
echo "$_user"
|
|
echo "$_sep_line"
|
|
} >> "$recovery_report_file"
|
|
|
|
list_file="${LOCK_DIR}/list_${_user}.tsv"
|
|
awk -F'\t' -v u="$_user" 'NF==5 && $1==u && $3 ~ /^[0-9]+$/ {print $2"\t"$3"\t"$4}' "$chosen_report" > "$list_file"
|
|
|
|
_user_total=$(wc -l < "$list_file")
|
|
|
|
if [[ $_user_total -eq 0 ]] ; then
|
|
warn "No bad-signature entries for account '${_user}' found in the selected report - skipping."
|
|
echo " [ keine Eintraege im gewaehlten Report ]" >> "$recovery_report_file"
|
|
continue
|
|
fi
|
|
|
|
user_out_dir="${recovery_dir}/${_user}"
|
|
user_result_tsv="${LOCK_DIR}/result_${_user}.tsv"
|
|
|
|
if $REVALIDATE_ONLY ; then
|
|
|
|
echononl " Revalidating account \033[1;37m${_user}\033[m (${_user_total} files).."
|
|
{
|
|
echo -e "path\trecovered_bytes\toriginal_size\tstatus"
|
|
while IFS=$'\t' read -r _p _osize _omtime ; do
|
|
[[ -z "$_p" ]] && continue
|
|
_rel="${_p#/${_user}/files/}"
|
|
_local="${user_out_dir}/${_rel}"
|
|
if [[ -f "$_local" ]] ; then
|
|
_b=$(stat -c%s "$_local" 2> /dev/null)
|
|
printf '%s\t%s\t%s\t%s\n' "$_p" "${_b:-0}" "$_osize" "OK"
|
|
else
|
|
printf '%s\t%s\t%s\t%s\n' "$_p" "0" "$_osize" "NOT_RECOVERED: no file found under ${user_out_dir} (run without -V first)"
|
|
fi
|
|
done < "$list_file"
|
|
} > "$user_result_tsv"
|
|
_rc=0
|
|
|
|
else
|
|
|
|
mkdir -p "$user_out_dir" 2> /dev/null
|
|
chown -R "$HTTP_USER":"$HTTP_GROUP" "$recovery_dir" 2> /dev/null
|
|
|
|
echononl " Recovering account \033[1;37m${_user}\033[m (${_user_total} files).."
|
|
# -d max_execution_time=0: decrypting/validating every file of a
|
|
# large account can run well over an hour; without this the PHP
|
|
# CLI process is killed by PHP's own execution-time limit
|
|
# (typically inherited from the webserver's php.ini) mid-run.
|
|
su -c "$PHP_BIN -d max_execution_time=0 $recovery_php_file $_user $list_file $user_out_dir" -s /bin/bash $HTTP_USER > "$user_result_tsv" 2> "$log_file"
|
|
_rc=$?
|
|
|
|
fi
|
|
|
|
if [[ $_rc -ne 0 ]]; then
|
|
echo_failed
|
|
error "$(cat "$log_file")"
|
|
echo " [ FEHLER beim Recovery-Lauf - siehe Server-Log ]" >> "$recovery_report_file"
|
|
(( total_failed_users++ ))
|
|
continue
|
|
fi
|
|
|
|
echo_done
|
|
$terminal && echo ""
|
|
|
|
declare -i _user_valid=0
|
|
declare -i _user_invalid=0
|
|
declare -i _user_unverified=0
|
|
declare -i _user_read_errors=0
|
|
declare -a _user_invalid_lines=()
|
|
declare -a _user_unverified_lines=()
|
|
|
|
while IFS=$'\t' read -r _path _recbytes _origsize _status ; do
|
|
|
|
[[ "$_path" = "path" ]] && continue
|
|
[[ -z "$_path" ]] && continue
|
|
|
|
if [[ "$_status" == OK* ]] ; then
|
|
_rel="${_path#/${_user}/files/}"
|
|
_local="${user_out_dir}/${_rel}"
|
|
_val_result="$(validate_recovered_file "$_local" "$_path" "$_origsize")"
|
|
_val_class="${_val_result%%|*}"
|
|
_val_detail="${_val_result#*|}"
|
|
case "$_val_class" in
|
|
VALID) (( _user_valid++ )) ;;
|
|
INVALID) (( _user_invalid++ )); _user_invalid_lines+=("${_path}"$'\t'"${_val_detail}") ;;
|
|
*) (( _user_unverified++ )); _user_unverified_lines+=("${_path}"$'\t'"${_val_detail}") ;;
|
|
esac
|
|
else
|
|
_val_class="READ_ERROR"
|
|
_val_detail="$_status"
|
|
(( _user_read_errors++ ))
|
|
fi
|
|
|
|
# printf, not 'echo -e': $_val_detail (or $_status for a
|
|
# READ_ERROR row) can contain a raw PHP exception message (e.g.
|
|
# 'OCA\Encryption\Exceptions\...') - 'echo -e' would reinterpret
|
|
# those backslashes as escape sequences and silently mangle/eat
|
|
# parts of the text. printf's %s never reinterprets its argument,
|
|
# only the literal \t in the format string itself.
|
|
printf '%s\t%s\t%s\t%s\t%s\t%s\n' "$_path" "$_recbytes" "$_origsize" "$_status" "$_val_class" "$_val_detail" >> "$recovery_report_file"
|
|
|
|
done < "$user_result_tsv"
|
|
|
|
_user_pct_valid="$(calc_percent "$_user_valid" "$_user_total")"
|
|
|
|
if $terminal ; then
|
|
echo -e " \033[1;37mAccount ${_user}\033[m"
|
|
echo -e " Verarbeitete Dateien.....................: ${_user_total}"
|
|
if [[ $_user_valid -gt 0 ]] ; then
|
|
echo -e " Wiederhergestellt (valide)...............: \033[1;32m${_user_valid} (${_user_pct_valid} %)\033[m"
|
|
else
|
|
echo -e " Wiederhergestellt (valide)...............: ${_user_valid} (${_user_pct_valid} %)"
|
|
fi
|
|
if [[ $_user_invalid -gt 0 ]] ; then
|
|
echo -e " Datenmuell (ungueltig)...................: \033[1;31m${_user_invalid}\033[m"
|
|
fi
|
|
if [[ $_user_unverified -gt 0 ]] ; then
|
|
echo -e " Nicht pruefbar...........................: \033[33m${_user_unverified}\033[m"
|
|
fi
|
|
if [[ $_user_read_errors -gt 0 ]] ; then
|
|
echo -e " Weiterhin Lesefehler.....................: \033[1;31m${_user_read_errors}\033[m"
|
|
fi
|
|
echo ""
|
|
fi
|
|
|
|
# - 'Datenmuell' and 'Nicht pruefbar' files listed as their own,
|
|
# - visually set-off block(s), before the account statistics -
|
|
# - easier to scan/copy than digging them out of the full path list
|
|
# - above.
|
|
# -
|
|
{
|
|
if [[ $_user_invalid -gt 0 ]] ; then
|
|
echo ""
|
|
echo " ------------------------------------------------------------------"
|
|
echo " Datenmuell (ungueltig) - Account ${_user} (${_user_invalid})"
|
|
echo " ------------------------------------------------------------------"
|
|
for _line in "${_user_invalid_lines[@]}" ; do
|
|
printf ' %s\n' "$_line"
|
|
done
|
|
fi
|
|
if [[ $_user_unverified -gt 0 ]] ; then
|
|
echo ""
|
|
echo " ------------------------------------------------------------------"
|
|
echo " Nicht pruefbar - Account ${_user} (${_user_unverified})"
|
|
echo " ------------------------------------------------------------------"
|
|
for _line in "${_user_unverified_lines[@]}" ; do
|
|
printf ' %s\n' "$_line"
|
|
done
|
|
fi
|
|
} >> "$recovery_report_file"
|
|
|
|
{
|
|
echo ""
|
|
echo " Account ${_user}"
|
|
echo " Verarbeitete Dateien.....................: ${_user_total}"
|
|
echo " Wiederhergestellt (valide)...............: ${_user_valid} (${_user_pct_valid} %)"
|
|
[[ $_user_invalid -gt 0 ]] && echo " Datenmuell (ungueltig)...................: ${_user_invalid}"
|
|
[[ $_user_unverified -gt 0 ]] && echo " Nicht pruefbar...........................: ${_user_unverified}"
|
|
[[ $_user_read_errors -gt 0 ]] && echo " Weiterhin Lesefehler.....................: ${_user_read_errors}"
|
|
} >> "$recovery_report_file"
|
|
|
|
(( total_processed += _user_total ))
|
|
(( total_valid += _user_valid ))
|
|
(( total_invalid += _user_invalid ))
|
|
(( total_unverified += _user_unverified ))
|
|
(( total_read_errors += _user_read_errors ))
|
|
|
|
done
|
|
|
|
|
|
# =============
|
|
# --- Restore encryption_skip_signature_check as early as possible,
|
|
# --- before printing the overall summary.
|
|
# =============
|
|
|
|
restore_encryption_flag
|
|
|
|
|
|
total_pct_valid="$(calc_percent "$total_valid" "$total_processed")"
|
|
|
|
{
|
|
echo ""
|
|
echo ""
|
|
echo "=================================================================="
|
|
echo " Gesamtergebnis"
|
|
echo "=================================================================="
|
|
echo ""
|
|
echo "Gescannte Accounts..........................: ${#selected_user_arr[@]}"
|
|
[[ $total_failed_users -gt 0 ]] && echo "Accounts mit Recovery-Fehler................: ${total_failed_users}"
|
|
echo "Verarbeitete Dateien insgesamt..............: ${total_processed}"
|
|
echo "Wiederhergestellt insgesamt (valide)........: ${total_valid} (${total_pct_valid} %)"
|
|
[[ $total_invalid -gt 0 ]] && echo "Datenmuell insgesamt (ungueltig)............: ${total_invalid}"
|
|
[[ $total_unverified -gt 0 ]] && echo "Nicht pruefbar insgesamt....................: ${total_unverified}"
|
|
[[ $total_read_errors -gt 0 ]] && echo "Weiterhin Lesefehler insgesamt..............: ${total_read_errors}"
|
|
echo ""
|
|
echo "Wiederhergestellte Dateien liegen unter: ${recovery_dir}"
|
|
echo "Bitte Ergebnisse vor Weiterverwendung stichprobenartig pruefen,"
|
|
echo "und das Recovery-Verzeichnis danach sicher aufraeumen (enthaelt"
|
|
echo "unverschluesselte, ggf. sensible Nutzerdaten ausserhalb von Nextcloud)."
|
|
} >> "$recovery_report_file"
|
|
|
|
blank_line
|
|
|
|
if $terminal ; then
|
|
echo -e "\033[37m\033[1mErgebnis\033[m"
|
|
echo ""
|
|
echo -e " Gescannte Accounts..........................: ${#selected_user_arr[@]}"
|
|
[[ $total_failed_users -gt 0 ]] && echo -e " Accounts mit Recovery-Fehler................: \033[1;31m${total_failed_users}\033[m"
|
|
echo -e " Verarbeitete Dateien insgesamt..............: ${total_processed}"
|
|
if [[ $total_valid -gt 0 ]] ; then
|
|
echo -e " Wiederhergestellt insgesamt (valide)........: \033[1;32m${total_valid} (${total_pct_valid} %)\033[m"
|
|
else
|
|
echo -e " Wiederhergestellt insgesamt (valide)........: ${total_valid} (${total_pct_valid} %)"
|
|
fi
|
|
[[ $total_invalid -gt 0 ]] && echo -e " Datenmuell insgesamt (ungueltig)............: \033[1;31m${total_invalid}\033[m"
|
|
[[ $total_unverified -gt 0 ]] && echo -e " Nicht pruefbar insgesamt....................: \033[33m${total_unverified}\033[m"
|
|
[[ $total_read_errors -gt 0 ]] && echo -e " Weiterhin Lesefehler insgesamt..............: \033[1;31m${total_read_errors}\033[m"
|
|
echo ""
|
|
echo -e " Recovery-Verzeichnis.........................: $recovery_dir"
|
|
echo -e " Recovery-Report..............................: reports/$(basename "${recovery_report_file}")"
|
|
echo ""
|
|
warn "Wiederhergestellte Dateien vor Weiterverwendung stichprobenartig pruefen und das Recovery-Verzeichnis danach sicher aufraeumen - es enthaelt unverschluesselte, ggf. sensible Nutzerdaten ausserhalb von Nextcloud."
|
|
fi
|
|
|
|
clean_up 0
|