Analyse des Signatures de Code et Sécurité sur macOS
Analysez et gérez les signatures de code des applications sur vos appareils MacFleet 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.jsonSystème de Gestion des Signatures de Code d'Entreprise
#!/bin/bash
# Outil de Gestion des Signatures de Code MacFleet
# Analyse complète des signatures de code et application des politiques de sécurité
# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/macfleet_codesigning.log"
REPORT_DIR="/etc/macfleet/reports/codesigning"
CONFIG_DIR="/etc/macfleet/codesigning"
POLICY_DIR="/etc/macfleet/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 MacFleet 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é