Permisos y Propiedades de Archivos

#!/bin/bash

# Modo simbólico
chmod u+x archivo.sh        # Dar permiso de ejecución al propietario
chmod g-w archivo.txt       # Quitar permiso de escritura al grupo
chmod o+r archivo.txt       # Dar permiso de lectura a otros
chmod a+x script.sh         # Dar permiso de ejecución a todos (all)

# Modo octal
chmod 755 script.sh         # rwxr-xr-x
chmod 644 archivo.txt       # rw-r--r--
chmod 600 archivo_privado   # rw-------
chmod 777 archivo_publico   # rwxrwxrwx

# Aplicar recursivamente
chmod -R 755 directorio/    # Aplicar permisos a directorio y contenido

# Ejemplos combinados
chmod u+x,g+x,o-rwx script.sh    # Solo propietario y grupo pueden ejecutar
chmod u=rwx,g=rx,o=r archivo     # Establecer permisos específicos

#!/bin/bash

# Cambiar propietario
sudo chown usuario archivo.txt

# Cambiar propietario y grupo
sudo chown usuario:grupo archivo.txt

# Solo cambiar grupo
sudo chown :grupo archivo.txt

# Aplicar recursivamente
sudo chown -R usuario:grupo directorio/

# Verificar cambios
ls -la archivo.txt

#!/bin/bash
# permission_manager.sh - Gestor avanzado de permisos

show_permissions() {
    local file="$1"
    
    if [[ ! -e "$file" ]]; then
        echo "Error: Archivo no existe - $file"
        return 1
    fi
    
    echo "=== Información de Permisos: $file ==="
    
    # Información básica
    ls -la "$file"
    
    # Desglose detallado
    local perms=$(stat -f%Sp "$file" 2>/dev/null || stat -c%A "$file" 2>/dev/null)
    local owner=$(stat -f%Su "$file" 2>/dev/null || stat -c%U "$file" 2>/dev/null)
    local group=$(stat -f%Sg "$file" 2>/dev/null || stat -c%G "$file" 2>/dev/null)
    local octal=$(stat -f%Lp "$file" 2>/dev/null || stat -c%a "$file" 2>/dev/null)
    
    echo "Propietario: $owner"
    echo "Grupo: $group"
    echo "Permisos simbólicos: $perms"
    echo "Permisos octales: $octal"
    
    # Análisis de permisos
    echo ""
    echo "=== Análisis de Permisos ==="
    
    if [[ -r "$file" ]]; then
        echo "✓ Puedes leer este archivo"
    else
        echo "✗ NO puedes leer este archivo"
    fi
    
    if [[ -w "$file" ]]; then
        echo "✓ Puedes escribir en este archivo"
    else
        echo "✗ NO puedes escribir en este archivo"
    fi
    
    if [[ -x "$file" ]]; then
        echo "✓ Puedes ejecutar este archivo"
    else
        echo "✗ NO puedes ejecutar este archivo"
    fi
}

set_secure_permissions() {
    local file="$1"
    local type="$2"
    
    if [[ ! -e "$file" ]]; then
        echo "Error: Archivo no existe - $file"
        return 1
    fi
    
    case "$type" in
        "script")
            echo "Configurando permisos seguros para script..."
            chmod 750 "$file"  # rwxr-x---
            echo "Permisos establecidos: 750 (rwxr-x---)"
            ;;
        "config")
            echo "Configurando permisos seguros para archivo de configuración..."
            chmod 640 "$file"  # rw-r-----
            echo "Permisos establecidos: 640 (rw-r-----)"
            ;;
        "private")
            echo "Configurando permisos privados..."
            chmod 600 "$file"  # rw-------
            echo "Permisos establecidos: 600 (rw-------)"
            ;;
        "public")
            echo "Configurando permisos públicos de solo lectura..."
            chmod 644 "$file"  # rw-r--r--
            echo "Permisos establecidos: 644 (rw-r--r--)"
            ;;
        "executable")
            echo "Configurando permisos para ejecutable..."
            chmod 755 "$file"  # rwxr-xr-x
            echo "Permisos establecidos: 755 (rwxr-xr-x)"
            ;;
        *)
            echo "Tipos disponibles: script, config, private, public, executable"
            return 1
            ;;
    esac
    
    show_permissions "$file"
}

find_insecure_files() {
    local search_path="${1:-.}"
    
    echo "=== Buscando archivos con permisos inseguros en: $search_path ==="
    
    echo "Archivos escribibles por todos (world-writable):"
    find "$search_path" -type f -perm -002 2>/dev/null | head -10
    
    echo ""
    echo "Directorios escribibles por todos:"
    find "$search_path" -type d -perm -002 2>/dev/null | head -10
    
    echo ""
    echo "Archivos con SUID bit:"
    find "$search_path" -type f -perm -4000 2>/dev/null | head -10
    
    echo ""
    echo "Archivos con SGID bit:"
    find "$search_path" -type f -perm -2000 2>/dev/null | head -10
    
    echo ""
    echo "Archivos sin propietario:"
    find "$search_path" -nouser 2>/dev/null | head -10
    
    echo ""
    echo "Archivos sin grupo:"
    find "$search_path" -nogroup 2>/dev/null | head -10
}

fix_permissions_recursively() {
    local directory="$1"
    local file_perms="${2:-644}"
    local dir_perms="${3:-755}"
    
    if [[ ! -d "$directory" ]]; then
        echo "Error: Directorio no existe - $directory"
        return 1
    fi
    
    echo "Corrigiendo permisos recursivamente en: $directory"
    echo "Permisos para archivos: $file_perms"
    echo "Permisos para directorios: $dir_perms"
    
    read -p "¿Continuar? (y/N): " confirm
    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
        echo "Operación cancelada"
        return 1
    fi
    
    # Cambiar permisos de directorios
    find "$directory" -type d -exec chmod "$dir_perms" {} \;
    
    # Cambiar permisos de archivos
    find "$directory" -type f -exec chmod "$file_perms" {} \;
    
    echo "Permisos corregidos exitosamente"
}

backup_permissions() {
    local directory="$1"
    local backup_file="${2:-permissions_backup_$(date +%Y%m%d_%H%M%S).txt}"
    
    if [[ ! -e "$directory" ]]; then
        echo "Error: Ruta no existe - $directory"
        return 1
    fi
    
    echo "Creando backup de permisos en: $backup_file"
    
    # Crear backup de permisos
    find "$directory" -exec stat -f "%N %Mp%Lp %Su %Sg" {} \; 2>/dev/null > "$backup_file" || \
    find "$directory" -exec stat -c "%n %a %U %G" {} \; 2>/dev/null > "$backup_file"
    
    echo "Backup creado: $backup_file"
    echo "Archivos incluidos: $(wc -l < "$backup_file")"
}

restore_permissions() {
    local backup_file="$1"
    
    if [[ ! -f "$backup_file" ]]; then
        echo "Error: Archivo de backup no existe - $backup_file"
        return 1
    fi
    
    echo "Restaurando permisos desde: $backup_file"
    
    read -p "¿Continuar con la restauración? (y/N): " confirm
    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
        echo "Restauración cancelada"
        return 1
    fi
    
    while read -r line; do
        local file=$(echo "$line" | awk '{print $1}')
        local perms=$(echo "$line" | awk '{print $2}')
        local owner=$(echo "$line" | awk '{print $3}')
        local group=$(echo "$line" | awk '{print $4}')
        
        if [[ -e "$file" ]]; then
            chmod "$perms" "$file" 2>/dev/null
            # Solo intentar cambiar propietario si tenemos privilegios
            if [[ $EUID -eq 0 ]]; then
                chown "$owner:$group" "$file" 2>/dev/null
            fi
        fi
    done < "$backup_file"
    
    echo "Restauración completada"
}

# Función principal con menú
main() {
    if [[ $# -eq 0 ]]; then
        echo "=== Gestor de Permisos de Archivos ==="
        echo "1. Mostrar información de permisos"
        echo "2. Establecer permisos seguros"
        echo "3. Buscar archivos inseguros"
        echo "4. Corregir permisos recursivamente"
        echo "5. Crear backup de permisos"
        echo "6. Restaurar permisos desde backup"
        
        read -p "Seleccione opción [1-6]: " option
        
        case "$option" in
            1)
                read -p "Archivo/directorio: " file
                show_permissions "$file"
                ;;
            2)
                read -p "Archivo: " file
                echo "Tipos: script, config, private, public, executable"
                read -p "Tipo: " type
                set_secure_permissions "$file" "$type"
                ;;
            3)
                read -p "Ruta de búsqueda [.]: " path
                find_insecure_files "${path:-.}"
                ;;
            4)
                read -p "Directorio: " dir
                read -p "Permisos archivos [644]: " fperms
                read -p "Permisos directorios [755]: " dperms
                fix_permissions_recursively "$dir" "${fperms:-644}" "${dperms:-755}"
                ;;
            5)
                read -p "Directorio: " dir
                read -p "Archivo backup [auto]: " backup
                backup_permissions "$dir" "$backup"
                ;;
            6)
                read -p "Archivo de backup: " backup
                restore_permissions "$backup"
                ;;
        esac
    else
        case "$1" in
            "show") show_permissions "$2" ;;
            "secure") set_secure_permissions "$2" "$3" ;;
            "scan") find_insecure_files "$2" ;;
            "fix") fix_permissions_recursively "$2" "$3" "$4" ;;
            "backup") backup_permissions "$2" "$3" ;;
            "restore") restore_permissions "$2" ;;
            *) echo "Comandos: show, secure, scan, fix, backup, restore" ;;
        esac
    fi
}

# Ejecutar función principal
main "$@"