Install fails because apt-key is missing in the system [apt-key replacement script source added]

On the latest release of kali linux installation of insync is unable to finish because install script heavily relies on apt-key (which completely is removed from the latest versions of the OS). To easily overcome this I did recreated apt-key replacement script, but it would be nice for the authors to remove this dependency so it would not require this tinkering to work.

The /usr/bin/apt-key script:

#!/bin/bash

# apt-key replacement script
# Supports: add, adv (with --recv-keys or --fetch-keys), list (finger), del
# Keys are stored in /etc/apt/trusted.gpg.d as .gpg files (binary keyring format).
# Requires gnupg (gpg) to be installed.

set -u

usage() {
    echo "Usage: apt-key [--keyring <file>] {add <file> | del <keyid> | list | finger | adv <gpg-options>}" >&2
    exit 1
}

# Check for gnupg availability
if ! command -v gpg >/dev/null 2>&1; then
    echo "apt-key: gnupg is not installed, but required for this operation" >&2
    exit 1
fi

# Global keyring override if provided
KEYRING=""
if [ "${1:-}" = "--keyring" ]; then
    if [ -z "${2:-}" ]; then
        usage
    fi
    KEYRING="$2"
    shift 2
fi

if [ $# -lt 1 ]; then
    usage
fi

CMD="$1"
shift

case "$CMD" in
    add)
        FILE="${1:-}"
        if [ -z "$FILE" ]; then
            usage
        fi
        # Require root to add keys
        if [ "$(id -u)" -ne 0 ]; then
            echo "apt-key: add must be run as root" >&2
            exit 1
        fi
        # Prepare input file
        if [ "$FILE" = "-" ]; then
            TMP_IN=$(mktemp)
            cat - > "$TMP_IN"
            FILE="$TMP_IN"
        else
            if [ ! -r "$FILE" ]; then
                echo "apt-key: cannot open '$FILE': No such file or directory" >&2
                exit 1
            fi
        fi
        # Ensure target directory exists (for separate files or custom keyring)
        if [ -z "$KEYRING" ]; then
            mkdir -p /etc/apt/trusted.gpg.d 2>/dev/null || true
        else
            DIR="$(dirname "$KEYRING")"
            mkdir -p "$DIR" 2>/dev/null || true
        fi
        # Use a temporary GNUPG home to verify keys
        TMPDIR=$(mktemp -d /tmp/apt-key-gpghome.XXXXXX)
        trap "rm -rf \"$TMPDIR\"" EXIT
        if ! gpg --batch --homedir "$TMPDIR" --import "$FILE" 2>&1; then
            # gpg error should have been shown
            exit 1
        fi
        imported_fprs=$(gpg --batch --homedir "$TMPDIR" --fingerprint --with-colons 2>/dev/null | grep '^fpr:' | grep -o -E '[0-9A-F]{40}')
        if [ -z "$imported_fprs" ]; then
            echo "apt-key: no valid OpenPGP data found." >&2
            rm -rf "$TMPDIR"
            exit 1
        fi
        if [ -n "$KEYRING" ]; then
            # Import keys into the specified keyring
            if ! gpg --batch --no-default-keyring --keyring "$KEYRING" --import "$FILE" 2>/dev/null; then
                echo "apt-key: failed to add key to $KEYRING" >&2
                rm -rf "$TMPDIR"
                exit 1
            fi
            rm -rf "$TMPDIR"
            trap - EXIT
            [ -n "${TMP_IN:-}" ] && rm -f "$TMP_IN"
            exit 0
        fi
        # Store each imported key as a separate .gpg file
        for fpr in $imported_fprs; do
            OUTFILE="/etc/apt/trusted.gpg.d/$fpr.gpg"
            gpg --batch --yes --homedir "$TMPDIR" --export "$fpr" > "$OUTFILE"
            chmod 644 "$OUTFILE"
            chown root:root "$OUTFILE" 2>/dev/null || true
        done
        rm -rf "$TMPDIR"
        trap - EXIT
        [ -n "${TMP_IN:-}" ] && rm -f "$TMP_IN"
        exit 0
        ;;
    list|finger)
        # Listing trusted keys
        if [ -n "$KEYRING" ]; then
            files_list=("$KEYRING")
        else
            files_list=()
            if [ -f /etc/apt/trusted.gpg ]; then
                files_list+=("/etc/apt/trusted.gpg")
            fi
            shopt -s nullglob
            for f in /etc/apt/trusted.gpg.d/*.gpg; do
                files_list+=("$f")
            done
            shopt -u nullglob
        fi
        if [ "${#files_list[@]}" -eq 0 ]; then
            exit 0
        fi
        for kr in "${files_list[@]}"; do
            [ -e "$kr" ] || continue
            echo "$kr"
            printf '%*s\n' "${#kr}" '' | tr ' ' '-'
            gpg --no-default-keyring --keyring "$kr" --list-keys --fingerprint
            echo
        done
        exit 0
        ;;
    del)
        KEY="${1:-}"
        if [ -z "$KEY" ]; then
            usage
        fi
        if [ "$(id -u)" -ne 0 ]; then
            echo "apt-key: del must be run as root" >&2
            exit 1
        fi
        if [ -n "$KEYRING" ]; then
            if [ ! -f "$KEYRING" ]; then
                echo "apt-key: keyring file '$KEYRING' not found" >&2
                exit 1
            fi
            if gpg --batch --yes --no-default-keyring --keyring "$KEYRING" --delete-key "$KEY" 2>/dev/null; then
                remaining=$(gpg --no-default-keyring --keyring "$KEYRING" --list-keys 2>/dev/null)
                [ -z "$remaining" ] && rm -f "$KEYRING"
                exit 0
            else
                echo "gpg: key \"$KEY\" not found" >&2
                exit 1
            fi
        fi
        found=false
        if [ -f /etc/apt/trusted.gpg ]; then
            if gpg --no-default-keyring --keyring /etc/apt/trusted.gpg --list-keys "$KEY" >/dev/null 2>&1; then
                if gpg --batch --yes --no-default-keyring --keyring /etc/apt/trusted.gpg --delete-key "$KEY" 2>/dev/null; then
                    found=true
                fi
            fi
        fi
        shopt -s nullglob
        for f in /etc/apt/trusted.gpg.d/*.gpg; do
            if gpg --no-default-keyring --keyring "$f" --list-keys "$KEY" >/dev/null 2>&1; then
                if gpg --batch --yes --no-default-keyring --keyring "$f" --delete-key "$KEY" 2>/dev/null; then
                    found=true
                    remaining=$(gpg --no-default-keyring --keyring "$f" --list-keys 2>/dev/null)
                    [ -z "$remaining" ] && rm -f "$f"
                fi
            fi
        done
        shopt -u nullglob
        if [ "$found" = true ]; then
            exit 0
        else
            echo "gpg: key \"$KEY\" not found" >&2
            exit 1
        fi
        ;;
    adv)
        if [ $# -lt 1 ]; then
            usage
        fi
        if [ "$(id -u)" -ne 0 ]; then
            echo "apt-key: adv must be run as root" >&2
            exit 1
        fi
        KEYSERVER=""
        KEYS=""
        FETCH_URL=""
        OTHER_ARGS=()
        expect_keys=false
        for arg in "$@"; do
            if [ "$expect_keys" = true ]; then
                if [[ "$arg" == -* ]]; then
                    expect_keys=false
                else
                    KEYS="$KEYS $arg"
                    continue
                fi
            fi
            case "$arg" in
                --keyserver)
                    ;;
                --keyserver=*)
                    KEYSERVER="${arg#--keyserver=}"
                    continue
                    ;;
                --keyserver-options)
                    ;;
                --keyserver-options=*)
                    continue
                    ;;
                --recv-key|--recv-keys)
                    expect_keys=true
                    continue
                    ;;
                --fetch-keys)
                    ;;
                --fetch-keys=*)
                    FETCH_URL="${arg#--fetch-keys=}"
                    continue
                    ;;
                *)
                    OTHER_ARGS+=("$arg")
                    ;;
            esac
        done
        args_list=("$@")
        for (( i=0; i<${#args_list[@]}; i++ )); do
            case "${args_list[i]}" in
                --keyserver)
                    if [ -n "${args_list[i+1]:-}" ]; then
                        KEYSERVER="${args_list[i+1]}"
                        i=$((i+1))
                    fi
                    ;;
                --keyserver-options)
                    if [ -n "${args_list[i+1]:-}" ]; then
                        i=$((i+1))
                    fi
                    ;;
                --fetch-keys)
                    if [ -n "${args_list[i+1]:-}" ]; then
                        FETCH_URL="${args_list[i+1]}"
                        i=$((i+1))
                    fi
                    ;;
            esac
        done
        KEYSERVER="${KEYSERVER## }"
        KEYSERVER="${KEYSERVER%% }"
        KEYS="${KEYS## }"
        KEYS="${KEYS%% }"
        if [ -n "$FETCH_URL" ]; then
            TMPDIR=$(mktemp -d /tmp/apt-key-gpghome.XXXXXX)
            TMPFILE=$(mktemp)
            trap "rm -rf \"$TMPDIR\"; rm -f \"$TMPFILE\"" EXIT
            echo "Executing: $TMPDIR/gpg.1.sh --fetch-keys $FETCH_URL"
            if command -v curl >/dev/null 2>&1; then
                curl -fsSL "$FETCH_URL" -o "$TMPFILE" || { echo "apt-key: failed to fetch key from $FETCH_URL" >&2; exit 1; }
            elif command -v wget >/dev/null 2>&1; then
                wget -q -O "$TMPFILE" "$FETCH_URL" || { echo "apt-key: failed to fetch key from $FETCH_URL" >&2; exit 1; }
            else
                echo "apt-key: no tool available to fetch keys (curl or wget required)" >&2
                exit 1
            fi
            "$0" ${KEYRING:+--keyring "$KEYRING"} add "$TMPFILE"
            code=$?
            rm -rf "$TMPDIR"
            rm -f "$TMPFILE"
            trap - EXIT
            exit $code
        fi
        if [ -z "$KEYS" ] && [ ${#OTHER_ARGS[@]} -gt 0 ]; then
            KR_ARGS=()
            if [ -n "$KEYRING" ]; then
                KR_ARGS=(--no-default-keyring --keyring "$KEYRING")
            else
                KR_ARGS=(--no-default-keyring)
                [ -f /etc/apt/trusted.gpg ] && KR_ARGS+=("--keyring" "/etc/apt/trusted.gpg")
                shopt -s nullglob
                for f in /etc/apt/trusted.gpg.d/*.gpg; do
                    KR_ARGS+=("--keyring" "$f")
                done
                shopt -u nullglob
            fi
            echo "Executing: gpg ${KR_ARGS[*]} ${OTHER_ARGS[*]}"
            exec gpg "${KR_ARGS[@]}" "${OTHER_ARGS[@]}"
        fi
        if [ -z "$KEYS" ]; then
            usage
        fi
        [ -z "$KEYSERVER" ] && KEYSERVER="hkps://keyserver.ubuntu.com"
        TMPDIR=$(mktemp -d /tmp/apt-key-gpghome.XXXXXX)
        trap "rm -rf \"$TMPDIR\"" EXIT
        echo "Executing: $TMPDIR/gpg.1.sh --keyserver $KEYSERVER --recv-keys $KEYS"
        fail=false
        for key in $KEYS; do
            if ! gpg --batch --yes --homedir "$TMPDIR" --keyserver "$KEYSERVER" --recv-keys "$key" 2>&1; then
                fail=true
            fi
        done
        imported_keys=$(gpg --homedir "$TMPDIR" --list-keys --with-colons 2>/dev/null | grep '^pub:')
        if [ -z "$imported_keys" ]; then
            echo "apt-key: keyserver fetch failed (no keys imported)." >&2
            rm -rf "$TMPDIR"
            exit 1
        fi
        # Save keys to the system keyrings
        if [ -n "$KEYRING" ]; then
            for fpr in $(gpg --batch --homedir "$TMPDIR" --fingerprint --with-colons 2>/dev/null | grep '^fpr:' | grep -o -E '[0-9A-F]{40}'); do
                gpg --batch --homedir "$TMPDIR" --export "$fpr" | gpg --batch --yes --no-default-keyring --keyring "$KEYRING" --import 2>/dev/null
            done
        else
            mkdir -p /etc/apt/trusted.gpg.d 2>/dev/null || true
            for fpr in $(gpg --batch --homedir "$TMPDIR" --fingerprint --with-colons 2>/dev/null | grep '^fpr:' | grep -o -E '[0-9A-F]{40}'); do
                OUTFILE="/etc/apt/trusted.gpg.d/$fpr.gpg"
                gpg --batch --yes --homedir "$TMPDIR" --export "$fpr" > "$OUTFILE"
                chmod 644 "$OUTFILE"
                chown root:root "$OUTFILE" 2>/dev/null || true
            done
        fi
        rm -rf "$TMPDIR"
        trap - EXIT
        if [ "$fail" = true ]; then
            exit 1
        else
            exit 0
        fi
        ;;
    *)
        usage
        ;;
esac

Apologies for the trouble! I have responded to your feedback on this thread. Rest assured that we are working on improving the installation process for our Linux users. Thank you for your patience!