Linux România

Locul de discuții al utilizatorilor de Linux din România
https://linuxromania.ro/

Script Bash pentru detectarea software-ului proprietăresc în Linux Mint

https://linuxromania.ro/viewtopic.php?t=34

Pagina 1 din 1

Script Bash pentru detectarea software-ului proprietăresc în Linux Mint

Scris: 19 Feb 2026, 18:12
de ThinkRoot

Scanează sistemul și identifică toate programele cu licențe proprietărești (non-libere): pachete .deb, Snap, Flatpak, drivere, firmware și codec-uri. Verifică licențele efective, nu doar sursa de instalare. Interfață colorată și ușor de citit în terminal.

Utilizare:

Cod: Selectaţi tot

chmod +x detect_proprietary.sh
./detect_proprietary.sh

Nu necesită root. Nu modifică nimic pe sistem - doar afișează informații.

Cod: Selectaţi tot

#!/bin/bash

# Script pentru detectarea programelor și pachetelor proprietărești în Linux Mint
# Versiune modernă cu formatare îmbunătățită
# Autor: Claude Sonnet 4.6
# Data: 2026-02-19

# ═══════════════════════════════════════════════════════════════
# OPȚIUNI
# ═══════════════════════════════════════════════════════════════
OUTPUT_FILE=""
while [[ "$#" -gt 0 ]]; do
    case $1 in
        --output|-o) OUTPUT_FILE="$2"; shift ;;
        --help|-h)
            echo "Utilizare: $0 [--output <fisier>]"
            echo "  --output, -o   Salvează raportul într-un fișier text"
            exit 0 ;;
        *) echo "Opțiune necunoscută: $1"; exit 1 ;;
    esac
    shift
done

# Culori și stiluri
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
MAGENTA='\033[0;35m'
CYAN='\033[0;36m'
WHITE='\033[1;37m'
GRAY='\033[0;90m'
BOLD='\033[1m'
DIM='\033[2m'
RESET='\033[0m'

# Simboluri Unicode moderne
CHECK="✓"
CROSS="✗"
ARROW="→"
WARNING="⚠"
INFO="ℹ"
LOCK="🔒"

# ═══════════════════════════════════════════════════════════════
# SISTEM DE OUTPUT (terminal + fișier opțional, fără coduri ANSI în fișier)
# ═══════════════════════════════════════════════════════════════
_print() {
    echo -e "$1"
    if [ -n "$OUTPUT_FILE" ]; then
        echo -e "$1" | sed 's/\x1b\[[0-9;]*m//g' >> "$OUTPUT_FILE"
    fi
}

# ═══════════════════════════════════════════════════════════════
# CONTOR GLOBAL — folosim fișier temp pentru a evita problema subshell
# ═══════════════════════════════════════════════════════════════
COUNTER_FILE=$(mktemp)
echo 0 > "$COUNTER_FILE"

increment_counter() {
    local val
    val=$(cat "$COUNTER_FILE")
    echo $((val + 1)) > "$COUNTER_FILE"
}

get_counter() {
    cat "$COUNTER_FILE"
}

# Curăță fișierul temp la ieșire
trap 'rm -f "$COUNTER_FILE"' EXIT

# ═══════════════════════════════════════════════════════════════
# FUNCȚII DE AFIȘARE
# ═══════════════════════════════════════════════════════════════
print_header() {
    _print "${CYAN}${BOLD}"
    _print "╔════════════════════════════════════════════════════════════════╗"
    _print "║                                                                ║"
    _print "║          ${LOCK} DETECTARE SOFTWARE PROPRIETĂRESC ${LOCK}                ║"
    _print "║                      Linux Mint System                         ║"
    _print "║                                                                ║"
    _print "╚════════════════════════════════════════════════════════════════╝"
    _print "${RESET}"
    _print "${DIM}${GRAY}Scanare inițiată: $(date '+%d %B %Y, %H:%M:%S')${RESET}\n"
}

print_section() {
    _print "\n${BOLD}${BLUE}$1${RESET}"
    _print "${GRAY}$(printf '─%.0s' {1..64})${RESET}"
}

print_found() {
    _print "  ${RED}${CROSS}${RESET} ${WHITE}$1${RESET}"
    increment_counter
}

print_detail() {
    _print "    ${GRAY}${ARROW}${RESET} ${DIM}$1${RESET}"
}

print_warning() {
    _print "  ${YELLOW}${WARNING}${RESET} ${YELLOW}$1${RESET}"
}

print_info() {
    _print "  ${CYAN}${INFO}${RESET} ${DIM}$1${RESET}"
}

print_success() {
    _print "  ${GREEN}${CHECK}${RESET} ${DIM}$1${RESET}"
}

print_subsection() {
    _print "\n  ${BOLD}$1${RESET}"
}

# Inițializare fișier output dacă e specificat
if [ -n "$OUTPUT_FILE" ]; then
    > "$OUTPUT_FILE"
    echo "Raport scanare software proprietăresc - $(date '+%d %B %Y, %H:%M:%S')" >> "$OUTPUT_FILE"
    echo "════════════════════════════════════════════════════════════════" >> "$OUTPUT_FILE"
fi

# Header principal
clear
print_header

# Verifică dacă rulează ca root
if [ "$EUID" -eq 0 ]; then
    print_warning "Script-ul rulează ca root (nu este necesar)"
    echo ""
fi

# ═══════════════════════════════════════════════════════════════
# 1. PACHETE .DEB
# ═══════════════════════════════════════════════════════════════
print_section "📦 Pachete .deb cu licențe proprietărești"

deb_found=0

# Folosește vrms dacă e disponibil
if command -v vrms &> /dev/null; then
    print_info "Folosind vrms pentru detectare rapidă..."
    vrms_output=$(vrms 2>/dev/null | grep -E "^[[:space:]]*[a-z0-9]" | head -20)
    if [ -n "$vrms_output" ]; then
        _print ""
        while IFS= read -r line; do
            print_found "$line"
            deb_found=1
        done <<< "$vrms_output"
    fi
else
    print_info "vrms nu este instalat (sudo apt install vrms pentru analiză detaliată)"
fi

# Verifică pachete din non-free/contrib
print_subsection "Repository-uri non-free/contrib:"
nonfree_packages=$(dpkg-query -W -f='${Package}\t${Section}\n' 2>/dev/null | grep -E 'non-free|contrib' | awk '{print $1}')

if [ -n "$nonfree_packages" ]; then
    count=$(echo "$nonfree_packages" | wc -l)
    while IFS= read -r pkg; do
        print_found "$pkg"
        deb_found=1
    done <<< "$(echo "$nonfree_packages" | head -15)"

if [ "$count" -gt 15 ]; then
    print_info "...și încă $((count - 15)) pachete"
fi
else
    print_success "Niciun pachet din repository-uri non-free/contrib"
fi

# Verificare licențe în fișiere copyright
print_subsection "Analiză fișiere copyright:"
proprietary_keywords="proprietary|commercial|closed.source"
free_keywords="GPL|LGPL|MIT|BSD|Apache|MPL|ISC"

copyright_found=0
for copyright_file in /usr/share/doc/*/copyright; do
    [ ! -f "$copyright_file" ] && continue
    package=$(basename "$(dirname "$copyright_file")")

echo "$nonfree_packages" | grep -q "^${package}$" && continue

if head -30 "$copyright_file" 2>/dev/null | grep -qiE "$proprietary_keywords"; then
    if ! head -30 "$copyright_file" 2>/dev/null | grep -qiE "$free_keywords"; then
        print_found "$package"
        copyright_found=1
        deb_found=1
    fi
fi
done

[ $copyright_found -eq 0 ] && print_success "Fără indicatori proprietărești în fișierele copyright"
[ $deb_found -eq 0 ] && _print "" && print_success "Niciun pachet .deb proprietăresc detectat"

# ═══════════════════════════════════════════════════════════════
# 2. SOFTWARE POPULAR PROPRIETĂRESC
# ═══════════════════════════════════════════════════════════════
print_section "🔍 Software popular proprietăresc"

popular_proprietary=(
    "google-chrome-stable:Google Chrome"
    "google-chrome-beta:Google Chrome Beta"
    "microsoft-edge-stable:Microsoft Edge"
    "microsoft-edge-beta:Microsoft Edge Beta"
    "opera-stable:Opera"
    "slack-desktop:Slack"
    "discord:Discord"
    "skype:Skype"
    "teams:Microsoft Teams (deb)"
    "teams-for-linux:Teams for Linux"
    "spotify-client:Spotify"
    "teamviewer:TeamViewer"
    "zoom:Zoom"
    "dropbox:Dropbox"
    "anydesk:AnyDesk"
    "sublime-text:Sublime Text"
    "code:Visual Studio Code"
    "steam:Steam"
    "nvidia-driver:NVIDIA Driver"
    "virtualbox-ext-pack:VirtualBox Extension Pack"
    "unrar:UnRAR"
    "rar:RAR"
    "onedrive:OneDrive"
    "4kvideodownloader:4K Video Downloader"
    "winehq-stable:Wine (Stable)"
    "winehq-devel:Wine (Devel)"
)

popular_found=0
for item in "${popular_proprietary[@]}"; do
    pkg="${item%%:*}"
    name="${item##*:}"

if dpkg -l "$pkg" 2>/dev/null | grep -q "^ii"; then
    version=$(dpkg -l "$pkg" 2>/dev/null | grep "^ii" | awk '{print $3}' | head -1)
    print_found "$name"
    print_detail "Pachet: $pkg (v$version)"
    popular_found=1
fi
done

[ $popular_found -eq 0 ] && print_success "Niciun software popular proprietăresc detectat"

# ═══════════════════════════════════════════════════════════════
# 3. DRIVERE PROPRIETĂREȘTI
# ═══════════════════════════════════════════════════════════════
print_section "🖥️  Drivere proprietărești"

driver_found=0

# NVIDIA
if lspci 2>/dev/null | grep -qi nvidia; then
    print_info "GPU NVIDIA detectat"
    if dpkg -l 2>/dev/null | grep -q "^ii.*nvidia-driver"; then
        nvidia_ver=$(dpkg -l | grep "^ii.*nvidia-driver" | awk '{print $3}' | head -1)
        print_found "Driver NVIDIA"
        print_detail "Versiune: $nvidia_ver"
        driver_found=1
    else
        print_success "Driver open-source (nouveau)"
    fi
fi

# AMD
if lspci 2>/dev/null | grep -qiE "amd|ati|radeon"; then
    print_info "GPU AMD/ATI detectat"
    if dpkg -l 2>/dev/null | grep -qE "^ii.*(fglrx|amdgpu-pro)"; then
        print_found "Driver AMD proprietăresc"
        driver_found=1
    else
        print_success "Driver open-source (amdgpu/radeon)"
    fi
fi

# Broadcom WiFi
if lspci 2>/dev/null | grep -qi broadcom; then
    print_info "Hardware Broadcom detectat"
    if dpkg -l 2>/dev/null | grep -q "^ii.*broadcom-sta"; then
        print_found "Driver Broadcom proprietăresc"
        driver_found=1
    else
        print_success "Driver open-source"
    fi
fi

[ $driver_found -eq 0 ] && print_success "Niciun driver proprietăresc detectat"

# ═══════════════════════════════════════════════════════════════
# 4. MODULE KERNEL PROPRIETĂREȘTI (DKMS)
# ═══════════════════════════════════════════════════════════════
print_section "⚙️  Module kernel proprietărești (DKMS)"

dkms_found=0

if command -v dkms &> /dev/null; then
    proprietary_dkms=("nvidia" "fglrx" "bcmwl" "vmware" "vboxdrv" "amdgpu-pro" "rtl" "tp_smapi")

dkms_status=$(dkms status 2>/dev/null)
if [ -n "$dkms_status" ]; then
    while IFS= read -r line; do
        [ -z "$line" ] && continue
        module_name=$(echo "$line" | awk -F'[,/]' '{print $1}' | xargs)
        module_ver=$(echo "$line" | awk -F'[,/]' '{print $2}' | xargs)
        module_status=$(echo "$line" | grep -oE 'installed|built|added' | head -1)

        is_proprietary=0
        for prop in "${proprietary_dkms[@]}"; do
            if echo "$module_name" | grep -qi "$prop"; then
                is_proprietary=1
                break
            fi
        done

        if [ $is_proprietary -eq 1 ]; then
            print_found "Modul DKMS: $module_name"
            [ -n "$module_ver" ] && print_detail "Versiune: $module_ver"
            [ -n "$module_status" ] && print_detail "Status: $module_status"
            dkms_found=1
        else
            print_info "Modul DKMS (open-source posibil): $module_name $module_ver"
        fi
    done <<< "$dkms_status"
else
    print_success "Niciun modul DKMS instalat"
fi
else
    print_info "DKMS nu este instalat"
fi

[ $dkms_found -eq 0 ] && print_success "Niciun modul kernel proprietăresc detectat"

# ═══════════════════════════════════════════════════════════════
# 5. FIRMWARE PROPRIETĂRESC
# ═══════════════════════════════════════════════════════════════
print_section "💾 Firmware proprietăresc"

firmware_packages=$(dpkg -l 2>/dev/null | grep -i "^ii.*firmware" \
    | grep -viE "(firmware-free|linux-firmware|free-firmware)" \
    | awk '{print $2}')

if [ -n "$firmware_packages" ]; then
    while IFS= read -r fw; do
        print_found "$fw"
    done <<< "$firmware_packages"
else
    print_success "Niciun firmware proprietăresc detectat"
fi

# ═══════════════════════════════════════════════════════════════
# 6. SNAP PACKAGES
# ═══════════════════════════════════════════════════════════════
print_section "📱 Aplicații Snap cu licențe proprietărești"

if command -v snap &> /dev/null; then
    snap_found=0
    free_licenses="GPL|LGPL|MIT|BSD|Apache|MPL|ISC|CC-BY"

while IFS= read -r line; do
    [ -z "$line" ] && continue
    snap_name=$(echo "$line" | awk '{print $1}')

    snap_info=$(snap info "$snap_name" 2>/dev/null)
    license=$(echo "$snap_info" | grep -i "^license:" | cut -d: -f2- | xargs)
    publisher=$(echo "$snap_info" | grep -i "^publisher:" | cut -d: -f2- | xargs)

    if [ -n "$license" ]; then
        if ! echo "$license" | grep -qiE "$free_licenses"; then
            print_found "$snap_name"
            print_detail "Licență: $license"
            [ -n "$publisher" ] && print_detail "Publisher: $publisher"
            snap_found=1
        fi
    else
        print_warning "$snap_name (licență necunoscută)"
        [ -n "$publisher" ] && print_detail "Publisher: $publisher"
        snap_found=1
    fi
done < <(snap list 2>/dev/null | tail -n +2)

[ $snap_found -eq 0 ] && print_success "Toate snap-urile au licențe libere"
else
    print_info "Snap nu este instalat"
fi

# ═══════════════════════════════════════════════════════════════
# 7. FLATPAK PACKAGES
# ═══════════════════════════════════════════════════════════════
print_section "📦 Aplicații Flatpak cu licențe proprietărești"

if command -v flatpak &> /dev/null; then
    flatpak_found=0
    free_licenses="GPL|LGPL|MIT|BSD|Apache|MPL|ISC|CC-BY"

while IFS= read -r app_id; do
    [ -z "$app_id" ] && continue

    app_info=$(flatpak info "$app_id" 2>/dev/null)
    license=$(echo "$app_info" | grep -i "^License:" | cut -d: -f2- | xargs)
    name=$(echo "$app_info" | grep "^Name:" | cut -d: -f2- | xargs)

    if [ -n "$license" ]; then
        if ! echo "$license" | grep -qiE "$free_licenses"; then
            print_found "${name:-$app_id}"
            print_detail "ID: $app_id"
            print_detail "Licență: $license"
            flatpak_found=1
        fi
    else
        print_warning "${name:-$app_id} (licență necunoscută)"
        print_detail "ID: $app_id"
        flatpak_found=1
    fi
done < <(flatpak list --app --columns=application 2>/dev/null)

[ $flatpak_found -eq 0 ] && print_success "Toate flatpak-urile au licențe libere"
else
    print_info "Flatpak nu este instalat"
fi

# ═══════════════════════════════════════════════════════════════
# 8. APPIMAGE FILES
# ═══════════════════════════════════════════════════════════════
print_section "📂 Fișiere AppImage"

appimage_search_dirs=("$HOME" "$HOME/Applications" "$HOME/apps" "$HOME/bin" "/opt" "/usr/local/bin")
appimage_found=0

for search_dir in "${appimage_search_dirs[@]}"; do
    [ ! -d "$search_dir" ] && continue
    while IFS= read -r app; do
        filename=$(basename "$app")
        print_warning "$filename"
        print_detail "Locație: $app"
        print_detail "Verificare manuală necesară pentru licență"
        appimage_found=1
    done < <(find "$search_dir" -maxdepth 4 -name "*.AppImage" 2>/dev/null)
done

[ $appimage_found -eq 0 ] && print_success "Niciun AppImage găsit în locațiile verificate"

# ═══════════════════════════════════════════════════════════════
# 9. CODEC-URI MULTIMEDIA
# ═══════════════════════════════════════════════════════════════
print_section "🎵 Codec-uri multimedia (potențial proprietărești)"

codec_packages=(
    "ubuntu-restricted-extras"
    "mint-meta-codecs"
    "libdvdcss2"
    "gstreamer1.0-plugins-ugly"
)

codec_found=0
for codec in "${codec_packages[@]}"; do
    if dpkg -l 2>/dev/null | grep -q "^ii.*$codec"; then
        print_found "$codec"
        codec_found=1
    fi
done

[ $codec_found -eq 0 ] && print_success "Niciun codec proprietăresc detectat"

# ═══════════════════════════════════════════════════════════════
# REZUMAT FINAL
# ═══════════════════════════════════════════════════════════════
TOTAL_PROPRIETARY=$(get_counter)

_print ""
_print "${CYAN}${BOLD}"
_print "╔════════════════════════════════════════════════════════════════╗"
_print "║                         REZUMAT FINAL                          ║"
_print "╚════════════════════════════════════════════════════════════════╝"
_print "${RESET}"

if [ "$TOTAL_PROPRIETARY" -eq 0 ]; then
    _print "${GREEN}${BOLD}  ${CHECK} Felicitări! Nu s-au detectat pachete proprietărești evidente.${RESET}\n"
else
    _print "${YELLOW}${BOLD}  ${WARNING} Detectate: $TOTAL_PROPRIETARY pachete/componente proprietărești${RESET}\n"
fi

_print "${BOLD}Categorii verificate:${RESET}"
print_info "Pachete .deb (repository-uri + analiza copyright)"
print_info "Software popular proprietăresc (lista predefinită)"
print_info "Drivere hardware (NVIDIA, AMD, Broadcom)"
print_info "Module kernel proprietărești (DKMS)"
print_info "Firmware proprietăresc"
print_info "Snap packages (verificare licențe)"
print_info "Flatpak applications (verificare licențe)"
print_info "AppImage files (locații extinse)"
print_info "Codec-uri multimedia"

_print ""
_print "${BOLD}Notă importantă:${RESET}"
_print "${DIM}  • Items marcate cu ${YELLOW}${WARNING}${RESET}${DIM} necesită verificare manuală"
_print "  • Unele programe pot avea componente cu licențe mixte"
_print "  • Firmware-ul proprietăresc poate fi necesar pentru hardware${RESET}"

_print ""
_print "${BOLD}Resurse utile:${RESET}"
_print "${DIM}  • Pentru .deb detaliat: ${CYAN}sudo apt install vrms && vrms${RESET}"
_print "${DIM}  • Pentru Snap: ${CYAN}snap info <nume-pachet>${RESET}"
_print "${DIM}  • Pentru Flatpak: ${CYAN}flatpak info <app-id>${RESET}"
_print "${DIM}  • Copyright files: ${CYAN}/usr/share/doc/<pachet>/copyright${RESET}"
_print "${DIM}  • Module DKMS: ${CYAN}dkms status${RESET}"

if [ -n "$OUTPUT_FILE" ]; then
    _print ""
    _print "${GREEN}Raport salvat în: ${OUTPUT_FILE}${RESET}"
fi

_print ""
_print "${GRAY}${DIM}Scanare completă: $(date '+%d %B %Y, %H:%M:%S')${RESET}"
_print ""

Atenție scriptul este făcut de AI

Ora este UTC+03:00
Pagina 1 din 1

Furnizat de phpBB® Forum Software © phpBB Limited

Translation/Traducere: phpBB România