Analyse des Signatures de Code et Sécurité sur macOS

Analysez et gérez les signatures de code des applications sur vos appareils Roundfleet pour améliorer la sécurité, vérifier l'authenticité des applications et implémenter les politiques de signature d'entreprise. Ce tutoriel couvre l'extraction des exigences de code, la vérification des signatures et l'analyse de sécurité complète.

Comprendre les Signatures de Code macOS

Les signatures de code sur macOS fournissent une vérification cryptographique que les applications n'ont pas été altérées et proviennent de sources fiables. Les composants clés incluent :

Exigences de Code - Contraintes que le code doit satisfaire pour être considéré comme valide
Identifiants de Bundle - Identifiants uniques pour les applications
Certificats de Développeur - Certificats numériques utilisés pour signer les applications
Droits - Permissions et capacités accordées aux applications

Importance de la Sécurité d'Entreprise

L'analyse des signatures de code est cruciale pour la sécurité d'entreprise :

Authenticité des Applications - Vérifier que les applications proviennent de développeurs de confiance
Détection d'Altération - Identifier les applications modifiées ou compromises
Application de Politique de Confidentialité - Contrôler l'accès aux données utilisateur protégées
Exigences de Conformité - Respecter les normes de sécurité pour les industries réglementées
Prévention des Malwares - Bloquer les applications non autorisées ou suspectes

Analyse de Base des Signatures de Code

Extraire les Exigences de Code

#!/bin/bash

# Extraction basique des exigences de code
APP_PATH="/System/Applications/Time Machine.app"

echo "Extraction des exigences de code pour : $APP_PATH"
codesign -dr - "$APP_PATH"

Extraction des Exigences de Code avec Gestion d'Erreurs

#!/bin/bash

# Extraction améliorée des exigences de code avec validation
extract_code_requirement() {
    local app_path="$1"
    
    # Valider l'entrée
    if [[ -z "$app_path" ]]; then
        echo "Erreur : Aucun chemin d'application fourni"
        echo "Usage : extract_code_requirement <chemin_app>"
        return 1
    fi
    
    # Vérifier si l'application existe
    if [[ ! -e "$app_path" ]]; then
        echo "Erreur : Application non trouvée au chemin : $app_path"
        return 1
    fi
    
    echo "=== Analyse des Exigences de Code ==="
    echo "Application : $app_path"
    echo ""
    
    # Extraire les exigences de code
    local code_req
    code_req=$(codesign -dr - "$app_path" 2>&1)
    
    if [[ $? -eq 0 ]]; then
        echo "Exigences de Code :"
        echo "$code_req"
        
        # Extraire seulement l'exigence désignée
        local designated_req
        designated_req=$(echo "$code_req" | grep "designated =>" | sed 's/designated => //')
        
        if [[ -n "$designated_req" ]]; then
            echo ""
            echo "Exigence Désignée :"
            echo "$designated_req"
        fi
    else
        echo "Erreur lors de l'extraction des exigences de code :"
        echo "$code_req"
        return 1
    fi
}

# Exemples d'utilisation
extract_code_requirement "/System/Applications/Safari.app"
extract_code_requirement "/Applications/Microsoft Word.app"

Analyse Complète de l'Application

#!/bin/bash

# Analyse complète de la signature d'application
analyze_application_signature() {
    local app_path="$1"
    local detailed="${2:-false}"
    
    if [[ ! -e "$app_path" ]]; then
        echo "Erreur : Application non trouvée : $app_path"
        return 1
    fi
    
    echo "=== Analyse Complète de la Signature d'Application ==="
    echo "Application : $app_path"
    echo "Date d'Analyse : $(date)"
    echo ""
    
    # Informations de base
    echo "--- Informations de Base ---"
    if [[ -d "$app_path" ]]; then
        local bundle_id
        bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
        echo "ID Bundle : $bundle_id"
        
        local app_version
        app_version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        echo "Version : $app_version"
    fi
    
    # Vérification de la signature de code
    echo ""
    echo "--- Vérification de la Signature de Code ---"
    if codesign -v "$app_path" 2>/dev/null; then
        echo "✓ La signature de code est valide"
    else
        echo "⚠️ La vérification de la signature de code a échoué"
    fi
    
    # Informations détaillées de signature
    echo ""
    echo "--- Détails de la Signature ---"
    codesign -dv "$app_path" 2>&1
    
    # Exigences de code
    echo ""
    echo "--- Exigences de Code ---"
    codesign -dr - "$app_path" 2>&1
    
    # Droits (si analyse détaillée demandée)
    if [[ "$detailed" == "true" ]]; then
        echo ""
        echo "--- Droits ---"
        codesign -d --entitlements - "$app_path" 2>/dev/null || echo "Aucun droit trouvé"
    fi
    
    echo ""
    echo "=== Analyse Terminée ==="
}

# Usage
analyze_application_signature "/Applications/Safari.app" "true"

Gestion des Signatures de Code d'Entreprise

Analyse d'Applications par Lots

#!/bin/bash

# Analyser plusieurs applications pour la revue de sécurité d'entreprise
batch_analyze_applications() {
    local scan_path="${1:-/Applications}"
    local output_format="${2:-table}"
    local include_system="${3:-false}"
    
    echo "=== Analyse par Lots des Signatures d'Applications ==="
    echo "Chemin de Scan : $scan_path"
    echo "Inclure Apps Système : $include_system"
    echo "Format de Sortie : $output_format"
    echo ""
    
    local app_count=0
    local valid_count=0
    local invalid_count=0
    local results=()
    
    # Trouver toutes les applications
    local find_paths=("$scan_path")
    if [[ "$include_system" == "true" ]]; then
        find_paths+=("/System/Applications" "/System/Library/CoreServices")
    fi
    
    for search_path in "${find_paths[@]}"; do
        if [[ -d "$search_path" ]]; then
            while IFS= read -r -d '' app_path; do
                ((app_count++))
                
                local app_name=$(basename "$app_path" .app)
                local bundle_id="Inconnu"
                local signature_status="Invalide"
                local developer="Inconnu"
                local code_req="Inconnu"
                
                # Extraire l'ID bundle
                if [[ -f "$app_path/Contents/Info.plist" ]]; then
                    bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
                fi
                
                # Vérifier la validité de la signature
                if codesign -v "$app_path" 2>/dev/null; then
                    signature_status="Valide"
                    ((valid_count++))
                    
                    # Extraire les informations du développeur
                    local sig_info
                    sig_info=$(codesign -dv "$app_path" 2>&1)
                    developer=$(echo "$sig_info" | grep "Authority=" | head -1 | sed 's/Authority=//' | tr -d '\n')
                    
                    # Extraire l'exigence de code
                    code_req=$(codesign -dr - "$app_path" 2>/dev/null | grep "designated =>" | sed 's/designated => //')
                else
                    ((invalid_count++))
                fi
                
                # Stocker les résultats
                results+=("$app_name|$bundle_id|$signature_status|$developer|$code_req")
                
                # Indicateur de progression
                if (( app_count % 10 == 0 )); then
                    echo "Analysé $app_count applications..."
                fi
                
            done < <(find "$search_path" -name "*.app" -type d -print0 2>/dev/null)
        fi
    done
    
    echo ""
    echo "=== Résumé de l'Analyse ==="
    echo "Total des Applications : $app_count"
    echo "Signatures Valides : $valid_count"
    echo "Signatures Invalides : $invalid_count"
    echo ""
    
    # Sortir les résultats dans le format demandé
    case "$output_format" in
        "table")
            printf "%-30s %-40s %-10s %-50s\n" "Application" "ID Bundle" "Signature" "Développeur"
            printf "%-30s %-40s %-10s %-50s\n" "----------" "---------" "---------" "-----------"
            
            for result in "${results[@]}"; do
                IFS='|' read -r app_name bundle_id sig_status developer code_req <<< "$result"
                printf "%-30s %-40s %-10s %-50s\n" \
                    "${app_name:0:29}" \
                    "${bundle_id:0:39}" \
                    "$sig_status" \
                    "${developer:0:49}"
            done
            ;;
        "csv")
            echo "Application,ID Bundle,Statut Signature,Développeur,Exigence Code"
            for result in "${results[@]}"; do
                echo "$result" | tr '|' ','
            done
            ;;
        "json")
            echo "{"
            echo "  \"analysis_summary\": {"
            echo "    \"total_applications\": $app_count,"
            echo "    \"valid_signatures\": $valid_count,"
            echo "    \"invalid_signatures\": $invalid_count,"
            echo "    \"scan_date\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\""
            echo "  },"
            echo "  \"applications\": ["
            
            local first=true
            for result in "${results[@]}"; do
                IFS='|' read -r app_name bundle_id sig_status developer code_req <<< "$result"
                
                if [[ "$first" == "true" ]]; then
                    first=false
                else
                    echo ","
                fi
                
                echo -n "    {"
                echo -n "\"name\": \"$app_name\", "
                echo -n "\"bundle_id\": \"$bundle_id\", "
                echo -n "\"signature_valid\": $([ "$sig_status" == "Valide" ] && echo "true" || echo "false"), "
                echo -n "\"developer\": \"$developer\", "
                echo -n "\"code_requirement\": \"$code_req\""
                echo -n "}"
            done
            
            echo ""
            echo "  ]"
            echo "}"
            ;;
    esac
}

# Exemples d'utilisation
batch_analyze_applications "/Applications" "table" "false"
batch_analyze_applications "/Applications" "json" "true" > /tmp/app_analysis.json

Système de Gestion des Signatures de Code d'Entreprise

#!/bin/bash

# Outil de Gestion des Signatures de Code Roundfleet
# Analyse complète des signatures de code et application des politiques de sécurité

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_codesigning.log"
REPORT_DIR="/etc/roundfleet/reports/codesigning"
CONFIG_DIR="/etc/roundfleet/codesigning"
POLICY_DIR="/etc/roundfleet/policies/codesigning"
QUARANTINE_DIR="/var/quarantine/applications"

# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$POLICY_DIR" "$QUARANTINE_DIR"

# Modèles de politiques de signature de code
declare -A SIGNING_POLICIES=(
    ["enterprise_standard"]="signed_required,developer_id_preferred,apple_signed_trusted,third_party_review"
    ["enterprise_strict"]="apple_signed_only,developer_id_required,no_unsigned,enterprise_review"
    ["development"]="signed_preferred,developer_id_optional,self_signed_allowed,minimal_restrictions"
    ["kiosk_lockdown"]="apple_signed_only,no_third_party,system_apps_only,maximum_security"
    ["healthcare"]="apple_signed_required,enterprise_approved_only,no_unsigned,hipaa_compliant"
    ["financial"]="apple_signed_required,enterprise_certified_only,strict_validation,sox_compliant"
    ["education"]="signed_required,educational_approved,apple_preferred,moderate_security"
    ["government"]="apple_signed_only,government_approved,no_unsigned,maximum_security"
    ["retail"]="signed_required,pos_approved,apple_preferred,moderate_security"
    ["manufacturing"]="signed_required,industrial_approved,apple_preferred,operational_security"
)

# Registre des développeurs de confiance
declare -A TRUSTED_DEVELOPERS=(
    ["apple"]="Apple Inc.,Software Signing,Apple Mac OS Application Signing"
    ["microsoft"]="Microsoft Corporation,Microsoft Corporation"
    ["adobe"]="Adobe Inc.,Adobe Systems Incorporated"
    ["google"]="Google LLC,Google Inc."
    ["zoom"]="Zoom Video Communications, Inc."
    ["slack"]="Slack Technologies, Inc."
    ["dropbox"]="Dropbox, Inc."
    ["1password"]="AgileBits Inc."
    ["firefox"]="Mozilla Corporation"
    ["chrome"]="Google LLC"
)

# Niveaux de classification de sécurité
declare -A SECURITY_LEVELS=(
    ["maximum"]="apple_signed_only,no_exceptions,immediate_quarantine"
    ["high"]="signed_required,trusted_developers_only,review_required"
    ["medium"]="signed_preferred,warnings_enabled,monitoring_active"
    ["low"]="unsigned_allowed,notification_only,basic_monitoring"
)

# Fonction de journalisation
log_action() {
    local message="$1"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] $message" | tee -a "$LOG_FILE"
}

# Analyse avancée des signatures de code
analyze_code_signature() {
    local app_path="$1"
    local output_format="${2:-detailed}"
    local security_check="${3:-true}"
    
    log_action "Analyse de la signature de code pour : $app_path"
    
    if [[ ! -e "$app_path" ]]; then
        log_action "ERREUR : Application non trouvée : $app_path"
        return 1
    fi
    
    local analysis_data=()
    local app_name=$(basename "$app_path" .app)
    
    echo "=== Analyse Avancée des Signatures de Code ==="
    echo "Application : $app_name"
    echo "Chemin : $app_path"
    echo "Date d'Analyse : $(date)"
    echo ""
    
    # Informations de base de l'application
    extract_app_metadata "$app_path" analysis_data
    
    # Vérification de la signature de code
    verify_code_signature "$app_path" analysis_data
    
    # Extraire les exigences de code
    extract_code_requirements "$app_path" analysis_data
    
    # Analyse de sécurité
    if [[ "$security_check" == "true" ]]; then
        perform_security_analysis "$app_path" analysis_data
    fi
    
    # Générer la sortie dans le format demandé
    case "$output_format" in
        "detailed")
            display_detailed_analysis analysis_data
            ;;
        "summary")
            display_summary_analysis analysis_data
            ;;
        "json")
            generate_json_analysis "$app_path" analysis_data
            ;;
        "csv")
            generate_csv_analysis "$app_path" analysis_data
            ;;
    esac
    
    log_action "Analyse de signature de code terminée pour : $app_path"
}

# Extraire les métadonnées de l'application
extract_app_metadata() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo "--- Métadonnées de l'Application ---"
    
    if [[ -f "$app_path/Contents/Info.plist" ]]; then
        local bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
        local version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
        local build=$(defaults read "$app_path/Contents/Info.plist" CFBundleVersion 2>/dev/null || echo "Inconnue")
        local min_os=$(defaults read "$app_path/Contents/Info.plist" LSMinimumSystemVersion 2>/dev/null || echo "Inconnu")
        
        echo "ID Bundle : $bundle_id"
        echo "Version : $version"
        echo "Build : $build"
        echo "OS Minimum : $min_os"
        
        data_ref+=("bundle_id:$bundle_id")
        data_ref+=("version:$version")
        data_ref+=("build:$build")
        data_ref+=("min_os:$min_os")
    else
        echo "Aucun Info.plist trouvé"
        data_ref+=("bundle_id:Inconnu")
    fi
    
    # Taille du fichier et date de modification
    local file_size=$(du -sh "$app_path" | cut -f1)
    local mod_date=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$app_path")
    
    echo "Taille de l'Application : $file_size"
    echo "Dernière Modification : $mod_date"
    
    data_ref+=("size:$file_size")
    data_ref+=("modified:$mod_date")
}

# Vérifier la signature de code
verify_code_signature() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo ""
    echo "--- Vérification de la Signature de Code ---"
    
    # Vérification de base
    if codesign -v "$app_path" 2>/dev/null; then
        echo "✓ La signature de code est valide"
        data_ref+=("signature_valid:true")
        
        # Informations détaillées de signature
        local sig_info=$(codesign -dv "$app_path" 2>&1)
        
        # Extraire les informations clés
        local identifier=$(echo "$sig_info" | grep "Identifier=" | sed 's/Identifier=//')
        local format=$(echo "$sig_info" | grep "Format=" | sed 's/Format=//')
        local cdhash=$(echo "$sig_info" | grep "CDHash=" | sed 's/CDHash=//')
        local team_id=$(echo "$sig_info" | grep "TeamIdentifier=" | sed 's/TeamIdentifier=//')
        
        echo "Identifiant : $identifier"
        echo "Format : $format"
        echo "CDHash : $cdhash"
        echo "ID Équipe : $team_id"
        
        data_ref+=("identifier:$identifier")
        data_ref+=("format:$format")
        data_ref+=("cdhash:$cdhash")
        data_ref+=("team_id:$team_id")
        
        # Extraire la chaîne de certificats
        local authorities=$(echo "$sig_info" | grep "Authority=" | sed 's/Authority=//')
        echo "Chaîne de Certificats :"
        while IFS= read -r authority; do
            echo "  - $authority"
        done <<< "$authorities"
        
        data_ref+=("authorities:$authorities")
        
    else
        echo "⚠️ La vérification de la signature de code a ÉCHOUÉ"
        data_ref+=("signature_valid:false")
        
        local error=$(codesign -v "$app_path" 2>&1)
        echo "Erreur : $error"
        data_ref+=("signature_error:$error")
    fi
}

# Extraire les exigences de code
extract_code_requirements() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo ""
    echo "--- Exigences de Code ---"
    
    local req_output=$(codesign -dr - "$app_path" 2>&1)
    
    if [[ $? -eq 0 ]]; then
        echo "$req_output"
        
        # Extraire l'exigence désignée
        local designated_req=$(echo "$req_output" | grep "designated =>" | sed 's/designated => //')
        if [[ -n "$designated_req" ]]; then
            echo ""
            echo "Exigence Désignée :"
            echo "$designated_req"
            data_ref+=("designated_requirement:$designated_req")
        fi
        
        data_ref+=("requirements_extracted:true")
    else
        echo "Échec de l'extraction des exigences de code"
        echo "$req_output"
        data_ref+=("requirements_extracted:false")
    fi
}

# Effectuer une analyse de sécurité
perform_security_analysis() {
    local app_path="$1"
    local -n data_ref=$2
    
    echo ""
    echo "--- Analyse de Sécurité ---"
    
    local security_score=100
    local security_issues=()
    
    # Vérifier si l'application est signée
    if ! codesign -v "$app_path" 2>/dev/null; then
        security_score=$((security_score - 50))
        security_issues+=("L'application n'est pas signée")
    fi
    
    # Vérifier le runtime durci
    local flags=$(codesign -dv "$app_path" 2>&1 | grep "CodeDirectory" | grep "runtime")
    if [[ -n "$flags" ]]; then
        echo "✓ Runtime durci activé"
        data_ref+=("hardened_runtime:true")
    else
        echo "⚠️ Runtime durci non activé"
        security_score=$((security_score - 20))
        security_issues+=("Runtime durci non activé")
        data_ref+=("hardened_runtime:false")
    fi
    
    # Vérifier la notarisation
    if spctl -a -v "$app_path" 2>&1 | grep -q "notarized"; then
        echo "✓ L'application est notarisée"
        data_ref+=("notarized:true")
    else
        echo "⚠️ L'application n'est pas notarisée"
        security_score=$((security_score - 15))
        security_issues+=("Application non notarisée")
        data_ref+=("notarized:false")
    fi
    
    # Vérifier les vulnérabilités connues (vérification de base)
    check_known_vulnerabilities "$app_path" security_score security_issues
    
    echo ""
    echo "Score de Sécurité : $security_score/100"
    data_ref+=("security_score:$security_score")
    
    if [[ ${#security_issues[@]} -gt 0 ]]; then
        echo "Problèmes de Sécurité Trouvés :"
        for issue in "${security_issues[@]}"; do
            echo "  ⚠️ $issue"
        done
        data_ref+=("security_issues:${security_issues[*]}")
    else
        echo "✓ Aucun problème de sécurité trouvé"
        data_ref+=("security_issues:none")
    fi
}

# Vérifier les vulnérabilités connues
check_known_vulnerabilities() {
    local app_path="$1"
    local -n score_ref=$2
    local -n issues_ref=$3
    
    local bundle_id
    bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
    
    # Vérifier contre les applications vulnérables connues (exemple simplifié)
    case "$bundle_id" in
        "com.adobe.flashplayer"*)
            score_ref=$((score_ref - 30))
            issues_ref+=("Flash Player a des vulnérabilités de sécurité connues")
            ;;
        "com.java."*)
            # Vérifier la version Java pour les vulnérabilités connues
            local java_version
            java_version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null)
            if [[ -n "$java_version" ]]; then
                echo "Version Java détectée : $java_version"
                # Ajouter des vérifications de version spécifiques ici
            fi
            ;;
    esac
    
    # Vérifier les applications avec des certificats expirés
    local cert_info=$(codesign -dv "$app_path" 2>&1 | grep "Timestamp=")
    if [[ -n "$cert_info" ]]; then
        # Extraire l'horodatage et vérifier si le certificat est ancien
        local timestamp=$(echo "$cert_info" | sed 's/Timestamp=//')
        echo "Horodatage du certificat : $timestamp"
    fi
}

# Générer une analyse complète de la flotte
analyze_fleet_applications() {
    local scan_paths=("$@")
    local report_file="$REPORT_DIR/fleet_analysis_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Analyse des Applications à l'Échelle de la Flotte ==="
    echo "Chemins de scan : ${scan_paths[*]}"
    echo ""
    
    local total_apps=0
    local signed_apps=0
    local unsigned_apps=0
    local notarized_apps=0
    local security_issues=0
    local applications=()
    
    for scan_path in "${scan_paths[@]}"; do
        if [[ -d "$scan_path" ]]; then
            echo "Scan : $scan_path"
            
            while IFS= read -r -d '' app_path; do
                ((total_apps++))
                
                local app_name=$(basename "$app_path" .app)
                local analysis_data=()
                
                # Analyse rapide pour aperçu de la flotte
                analyze_code_signature "$app_path" "summary" "true" > /dev/null
                
                # Extraire les métriques clés
                if codesign -v "$app_path" 2>/dev/null; then
                    ((signed_apps++))
                else
                    ((unsigned_apps++))
                fi
                
                if spctl -a -v "$app_path" 2>&1 | grep -q "notarized"; then
                    ((notarized_apps++))
                fi
                
                # Ajouter au tableau des applications
                applications+=("$app_path")
                
                # Indicateur de progression
                if (( total_apps % 25 == 0 )); then
                    echo "Analysé $total_apps applications..."
                fi
                
            done < <(find "$scan_path" -name "*.app" -type d -maxdepth 2 -print0 2>/dev/null)
        fi
    done
    
    # Générer le rapport d'analyse de flotte
    cat > "$report_file" << EOF
{
    "fleet_analysis": {
        "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
        "hostname": "$(hostname)",
        "scan_paths": [$(printf '"%s",' "${scan_paths[@]}" | sed 's/,$//')],
        "summary": {
            "total_applications": $total_apps,
            "signed_applications": $signed_apps,
            "unsigned_applications": $unsigned_apps,
            "notarized_applications": $notarized_apps,
            "signing_compliance": $(( signed_apps * 100 / total_apps )),
            "notarization_compliance": $(( notarized_apps * 100 / total_apps ))
        },
        "analysis_date": "$(date)",
        "script_version": "$SCRIPT_VERSION"
    }
}
EOF
    
    echo ""
    echo "=== Résumé de l'Analyse de Flotte ==="
    echo "Total des Applications : $total_apps"
    echo "Applications Signées : $signed_apps ($(( signed_apps * 100 / total_apps ))%)"
    echo "Applications Non Signées : $unsigned_apps ($(( unsigned_apps * 100 / total_apps ))%)"
    echo "Applications Notarisées : $notarized_apps ($(( notarized_apps * 100 / total_apps ))%)"
    echo ""
    echo "Rapport d'analyse de flotte : $report_file"
    
    log_action "Analyse de flotte terminée : $total_apps applications analysées"
}

# Fonction d'exécution principale
main() {
    local action="${1:-help}"
    local param1="${2:-}"
    local param2="${3:-}"
    local param3="${4:-}"
    local param4="${5:-}"
    
    log_action "=== Gestion des Signatures de Code Roundfleet Démarrée ==="
    log_action "Action : $action"
    
    case "$action" in
        "analyze")
            if [[ -z "$param1" ]]; then
                echo "Usage : $0 analyze <chemin_app> [format_sortie] [vérification_sécurité]"
                echo "Formats de sortie : detailed, summary, json, csv"
                exit 1
            fi
            analyze_code_signature "$param1" "${param2:-detailed}" "${param3:-true}"
            ;;
        "extract")
            if [[ -z "$param1" ]]; then
                echo "Usage : $0 extract <chemin_app>"
                exit 1
            fi
            extract_code_requirement "$param1"
            ;;
        "batch")
            if [[ -z "$param1" ]]; then
                param1="/Applications"
            fi
            batch_analyze_applications "$param1" "${param2:-table}" "${param3:-false}"
            ;;
        "fleet")
            local paths=("${@:2}")
            if [[ ${#paths[@]} -eq 0 ]]; then
                paths=("/Applications" "/System/Applications")
            fi
            analyze_fleet_applications "${paths[@]}"
            ;;
        "verify")
            if [[ -z "$param1" ]]; then
                echo "Usage : $0 verify <chemin_app>"
                exit 1
            fi
            if codesign -v "$param1" 2>/dev/null; then
                echo "✓ La signature de code est valide pour : $param1"
            else
                echo "⚠️ La vérification de la signature de code a échoué pour : $param1"
                codesign -v "$param1"
            fi
            ;;
        "help")
            echo "Usage : $0 [action] [options...]"
            echo "Actions :"
            echo "  analyze <chemin_app> [format] [sécurité] - Analyser la signature de l'application"
            echo "  extract <chemin_app> - Extraire seulement l'exigence de code"
            echo "  batch <chemin_scan> [format] [inclure_système] - Analyser les applications par lots"
            echo "  fleet [chemins...] - Analyser les applications à l'échelle de la flotte"
            echo "  verify <chemin_app> - Vérification rapide de signature"
            echo "  help - Afficher cette aide"
            echo ""
            echo "Formats de Sortie : detailed, summary, json, csv, table"
            echo "Politiques : ${!SIGNING_POLICIES[*]}"
            echo "Niveaux de Sécurité : ${!SECURITY_LEVELS[*]}"
            ;;
        *)
            log_action "ERREUR : Action inconnue : $action"
            echo "Utilisez '$0 help' pour les informations d'utilisation"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion des signatures de code terminée ==="
}

# Exécuter la fonction principale
main "$@"

Meilleures Pratiques de Sécurité

Gestion des Certificats d'Entreprise

#!/bin/bash

# Validation des certificats d'entreprise
validate_enterprise_certificates() {
    local cert_policy="${1:-strict}"
    
    echo "=== Validation des Certificats d'Entreprise ==="
    echo "Politique : $cert_policy"
    echo ""
    
    local expired_certs=()
    local revoked_certs=()
    local untrusted_certs=()
    
    # Vérifier le trousseau système pour les certificats d'entreprise
    security find-certificate -a -p /Library/Keychains/System.keychain | \
    while IFS= read -r cert_line; do
        if [[ "$cert_line" == "-----BEGIN CERTIFICATE-----" ]]; then
            # Traiter le certificat
            echo "Vérification du certificat d'entreprise..."
        fi
    done
    
    echo "✓ Validation des certificats d'entreprise terminée"
}

validate_enterprise_certificates "strict"

Rapport de Conformité

#!/bin/bash

# Générer un rapport de conformité pour les exigences réglementaires
generate_compliance_report() {
    local compliance_type="${1:-general}"
    local output_file="$REPORT_DIR/compliance_${compliance_type}_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Génération du Rapport de Conformité : $compliance_type ==="
    
    local total_apps=0
    local compliant_apps=0
    local non_compliant_apps=0
    
    # Scanner les applications pour la conformité
    while IFS= read -r -d '' app_path; do
        ((total_apps++))
        
        case "$compliance_type" in
            "hipaa")
                check_hipaa_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
            "sox")
                check_sox_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
            "pci_dss")
                check_pci_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
            *)
                check_general_compliance "$app_path" compliant_apps non_compliant_apps
                ;;
        esac
    done < <(find /Applications -name "*.app" -type d -print0 2>/dev/null)
    
    # Générer le rapport
    local compliance_percentage=$(( compliant_apps * 100 / total_apps ))
    
    cat > "$output_file" << EOF
{
    "compliance_report": {
        "type": "$compliance_type",
        "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
        "hostname": "$(hostname)",
        "summary": {
            "total_applications": $total_apps,
            "compliant_applications": $compliant_apps,
            "non_compliant_applications": $non_compliant_apps,
            "compliance_percentage": $compliance_percentage
        }
    }
}
EOF
    
    echo "Rapport de conformité généré : $output_file"
    echo "Taux de conformité : $compliance_percentage%"
}

generate_compliance_report "general"

Notes Importantes

Les signatures de code vérifient l'authenticité et l'intégrité des applications
Les exigences de code spécifient les contraintes pour la validation des applications
Les politiques d'entreprise doivent équilibrer sécurité et besoins opérationnels
La surveillance régulière aide à détecter les applications non autorisées
Les exigences de conformité varient selon l'industrie et le cadre réglementaire
La notarisation fournit une validation de sécurité supplémentaire d'Apple
La gestion des certificats est cruciale pour la sécurité d'entreprise
L'analyse à l'échelle de la flotte permet une gestion proactive de la sécurité

Guide

Avis important