Gestion Sécurisée d'Archives sur macOS
Gérez des archives de fichiers sécurisées sur vos appareils MacFleet avec des outils de compression et chiffrement de niveau entreprise. Ce tutoriel couvre la création de ZIP protégés par mot de passe, les opérations d'archivage par lots, la conformité sécuritaire et la gestion complète d'archives à l'échelle de la flotte.
Comprendre la Gestion Sécurisée d'Archives
La gestion sécurisée d'archives sur macOS implique la création de fichiers compressés protégés pour le transfert, stockage et conformité des données :
Composants Principaux
- Compression ZIP - Format d'archive standard avec compatibilité étendue
- Protection Mot de Passe - Chiffrement AES pour sécurité d'archive
- Opérations Lot - Création et gestion d'archives en masse
- Vérification Intégrité - Validation d'archive et détection corruption
- Suivi Conformité - Pistes d'audit et rapports sécuritaires
Avantages Entreprise
- Sécurité Données - Transfert et stockage fichiers protégés
- Optimisation Stockage - Archives compressées économisent espace disque
- Exigences Conformité - Archivage sécurisé données pour réglementations
- Gestion Flotte - Opérations d'archive standardisées sur appareils
- Capacités Audit - Suivi complet opérations d'archive
Création Basique ZIP Protégé par Mot de Passe
Création ZIP Simple avec Mot de Passe
#!/bin/bash
# Création basique ZIP protégé par mot de passe
create_basic_password_zip() {
local file_path="${1:-/Users/Shared/exemple.txt}"
local zip_name="${2:-archive_securisee.zip}"
local password="${3:-ChangezMoiMaintenant123!}"
local content="${4:-Bonjour MacFleet - Archive Sécurisée Créée}"
echo "📦 Création Archive ZIP Protégée par Mot de Passe"
echo "================================================"
echo "Fichier : $file_path"
echo "Archive : $zip_name"
echo "Contenu : $content"
echo ""
# Créer le fichier avec contenu
echo "Création fichier avec contenu..."
touch "$file_path"
printf '%s\n' "$content" > "$file_path"
if [[ -f "$file_path" ]]; then
echo "✅ Fichier créé avec succès : $file_path"
else
echo "❌ Échec création fichier : $file_path"
return 1
fi
# Naviguer vers répertoire fichier
local file_dir=$(dirname "$file_path")
local file_name=$(basename "$file_path")
echo "Navigation vers répertoire : $file_dir"
cd "$file_dir" || return 1
# Créer ZIP protégé par mot de passe
echo "Création archive ZIP protégée par mot de passe..."
if zip -r "$zip_name" "$file_name" --password "$password" >/dev/null 2>&1; then
echo "✅ Archive ZIP créée avec succès : $file_dir/$zip_name"
# Vérifier archive
if [[ -f "$zip_name" ]]; then
local zip_size=$(du -h "$zip_name" | cut -f1)
echo "Taille archive : $zip_size"
echo "Emplacement archive : $file_dir/$zip_name"
fi
else
echo "❌ Échec création archive ZIP"
return 1
fi
# Nettoyer fichier original (optionnel)
echo ""
read -p "Supprimer fichier original ? (o/n) : " remove_original
if [[ "$remove_original" =~ ^[Oo]$ ]]; then
rm "$file_path"
echo "✅ Fichier original supprimé"
fi
return 0
}
# Exécuter création ZIP basique
create_basic_password_zip "/Users/Shared/test_macfleet.txt" "macfleet_securise.zip" "MotDePasseSecurise123!" "Archive Entreprise MacFleet"Convertir Fichier Existant en ZIP Protégé par Mot de Passe
#!/bin/bash
# Convertir fichier existant en ZIP protégé par mot de passe
convert_file_to_secure_zip() {
local source_file="$1"
local zip_name="${2:-}"
local password="${3:-}"
local compression_level="${4:-6}"
echo "🔄 Conversion Fichier en ZIP Sécurisé"
echo "===================================="
echo ""
# Valider fichier d'entrée
if [[ ! -f "$source_file" ]]; then
echo "❌ Fichier source non trouvé : $source_file"
echo "Veuillez fournir un chemin fichier valide"
return 1
fi
# Obtenir informations fichier
local file_dir=$(dirname "$source_file")
local file_name=$(basename "$source_file")
local file_ext="${file_name##*.}"
local file_base="${file_name%.*}"
# Générer nom ZIP si non fourni
if [[ -z "$zip_name" ]]; then
zip_name="${file_base}_securise.zip"
fi
# Générer mot de passe sécurisé si non fourni
if [[ -z "$password" ]]; then
password=$(openssl rand -base64 12 | tr -d "=+/" | cut -c1-12)
echo "🔐 Mot de passe sécurisé généré : $password"
echo "⚠️ Sauvegardez ce mot de passe - il ne peut être récupéré !"
fi
echo "Fichier source : $source_file"
echo "Nom archive : $zip_name"
echo "Niveau compression : $compression_level (1-9)"
echo ""
# Obtenir taille fichier avant compression
local original_size=$(du -h "$source_file" | cut -f1)
echo "Taille fichier original : $original_size"
# Naviguer vers répertoire fichier
cd "$file_dir" || return 1
# Créer ZIP sécurisé avec compression spécifiée
echo "Création archive ZIP sécurisée..."
if zip -"$compression_level" -r "$zip_name" "$file_name" --password "$password" >/dev/null 2>&1; then
echo "✅ ZIP sécurisé créé avec succès"
# Obtenir taille compressée et calculer ratio compression
local compressed_size=$(du -h "$zip_name" | cut -f1)
local original_bytes=$(du -b "$source_file" | cut -f1)
local compressed_bytes=$(du -b "$zip_name" | cut -f1)
local compression_ratio=$(echo "scale=1; (($original_bytes - $compressed_bytes) * 100) / $original_bytes" | bc 2>/dev/null || echo "N/A")
echo ""
echo "=== Résumé Archive ==="
echo "Taille originale : $original_size"
echo "Taille compressée : $compressed_size"
echo "Ratio compression : ${compression_ratio}%"
echo "Emplacement archive : $file_dir/$zip_name"
echo "Mot de passe : $password"
# Tester intégrité archive
echo ""
echo "Test intégrité archive..."
if unzip -t "$zip_name" >/dev/null 2>&1; then
echo "✅ Intégrité archive vérifiée"
else
echo "⚠️ Vérification intégrité archive échouée"
fi
else
echo "❌ Échec création archive ZIP sécurisée"
return 1
fi
return 0
}
# Exemple d'utilisation
echo "Exemple : Convertir fichier existant en ZIP sécurisé"
# convert_file_to_secure_zip "/Users/Shared/document.pdf" "document_securise.zip" "MonMotDePasseSecurise123!"Gestion d'Archives d'Entreprise
Système de Création d'Archives Complet
#!/bin/bash
# Système de gestion d'archives d'entreprise
enterprise_archive_manager() {
local operation="${1:-create}"
local source_path="$2"
local archive_config="${3:-default}"
local output_dir="${4:-/tmp/macfleet_archives}"
echo "🏢 Gestionnaire d'Archives Entreprise MacFleet"
echo "=============================================="
echo "Opération : $operation"
echo "Source : $source_path"
echo "Config : $archive_config"
echo "Sortie : $output_dir"
echo ""
# Assurer que répertoire sortie existe
mkdir -p "$output_dir"
# Préréglages configuration
declare -A archive_configs
archive_configs[default]="zip:6:AES256"
archive_configs[haute_securite]="zip:9:AES256"
archive_configs[rapide]="zip:1:AES128"
archive_configs[maximum]="zip:9:AES256"
# Analyser configuration
local config_string="${archive_configs[$archive_config]:-${archive_configs[default]}}"
IFS=':' read -r format compression encryption <<< "$config_string"
# Générer métadonnées sécurisées
local timestamp=$(date +"%Y%m%d_%H%M%S")
local hostname=$(hostname)
local user=$(whoami)
local archive_id=$(openssl rand -hex 8)
case "$operation" in
"create")
create_enterprise_archive "$source_path" "$output_dir" "$format" "$compression" "$encryption" "$timestamp" "$archive_id"
;;
"batch")
batch_archive_creation "$source_path" "$output_dir" "$format" "$compression" "$encryption"
;;
"verify")
verify_archive_integrity "$source_path"
;;
"extract")
secure_archive_extraction "$source_path" "$output_dir"
;;
*)
echo "❌ Opération inconnue : $operation"
echo "Opérations disponibles : create, batch, verify, extract"
return 1
;;
esac
}
# Créer archive de niveau entreprise
create_enterprise_archive() {
local source="$1"
local output_dir="$2"
local format="$3"
local compression="$4"
local encryption="$5"
local timestamp="$6"
local archive_id="$7"
echo "📦 Création Archive Entreprise"
echo "=============================="
# Valider source
if [[ ! -e "$source" ]]; then
echo "❌ Source non trouvée : $source"
return 1
fi
# Générer mot de passe sécurisé
local password=$(openssl rand -base64 16 | tr -d "=+/" | cut -c1-16)
# Déterminer nom archive
local source_name=$(basename "$source")
local archive_name="macfleet_${archive_id}_${timestamp}.${format}"
local archive_path="$output_dir/$archive_name"
local metadata_file="$output_dir/${archive_name}.metadata.json"
local password_file="$output_dir/${archive_name}.password"
echo "ID Archive : $archive_id"
echo "Source : $source"
echo "Archive : $archive_path"
echo "Compression : Niveau $compression"
echo "Chiffrement : $encryption"
echo ""
# Obtenir informations source
local source_size=""
local source_type=""
local file_count=0
if [[ -f "$source" ]]; then
source_type="fichier"
source_size=$(du -h "$source" | cut -f1)
file_count=1
elif [[ -d "$source" ]]; then
source_type="répertoire"
source_size=$(du -sh "$source" | cut -f1)
file_count=$(find "$source" -type f | wc -l | xargs)
fi
echo "Type source : $source_type"
echo "Taille source : $source_size"
echo "Nombre fichiers : $file_count"
echo ""
# Créer archive
echo "Création archive..."
local start_time=$(date +%s)
if zip -r -"$compression" "$archive_path" "$source" --password "$password" >/dev/null 2>&1; then
local end_time=$(date +%s)
local duration=$((end_time - start_time))
echo "✅ Archive créée avec succès"
echo "Temps création : ${duration}s"
# Obtenir statistiques archive
local archive_size=$(du -h "$archive_path" | cut -f1)
local checksum=$(shasum -a 256 "$archive_path" | cut -d' ' -f1)
# Sauvegarder mot de passe de manière sécurisée
echo "$password" > "$password_file"
chmod 600 "$password_file"
# Générer métadonnées
cat > "$metadata_file" << EOF
{
"info_archive": {
"id": "$archive_id",
"nom": "$archive_name",
"cree": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
"nom_hote": "$(hostname)",
"utilisateur": "$(whoami)",
"version_macfleet": "2025.07"
},
"info_source": {
"chemin": "$source",
"type": "$source_type",
"taille": "$source_size",
"nombre_fichiers": $file_count
},
"details_archive": {
"format": "$format",
"niveau_compression": $compression,
"chiffrement": "$encryption",
"taille": "$archive_size",
"checksum_sha256": "$checksum",
"duree_creation": ${duration}
},
"securite": {
"protege_mot_de_passe": true,
"fichier_mot_de_passe": "${archive_name}.password",
"algorithme_chiffrement": "AES-256"
}
}
EOF
echo ""
echo "=== Résumé Archive ==="
echo "Archive : $archive_path"
echo "Taille : $archive_size"
echo "Checksum : $checksum"
echo "Fichier mot de passe : $password_file"
echo "Métadonnées : $metadata_file"
else
echo "❌ Échec création archive"
return 1
fi
}
# Création archives par lots
batch_archive_creation() {
local source_dir="$1"
local output_dir="$2"
local format="$3"
local compression="$4"
local encryption="$5"
echo "📦 Création Archives par Lots"
echo "============================="
echo "Répertoire source : $source_dir"
echo ""
if [[ ! -d "$source_dir" ]]; then
echo "❌ Répertoire source non trouvé : $source_dir"
return 1
fi
local processed=0
local failed=0
# Traiter chaque élément dans répertoire source
for item in "$source_dir"/*; do
if [[ -e "$item" ]]; then
local item_name=$(basename "$item")
echo "Traitement : $item_name"
local timestamp=$(date +"%Y%m%d_%H%M%S")
local archive_id=$(openssl rand -hex 4)
if create_enterprise_archive "$item" "$output_dir" "$format" "$compression" "$encryption" "$timestamp" "$archive_id"; then
echo "✅ Archivage réussi : $item_name"
((processed++))
else
echo "❌ Échec archivage : $item_name"
((failed++))
fi
echo ""
fi
done
echo "=== Résumé Lot ==="
echo "Traités : $processed"
echo "Échoués : $failed"
echo "Total : $((processed + failed))"
}
# Vérification intégrité archive
verify_archive_integrity() {
local archive_path="$1"
echo "🔍 Vérification Intégrité Archive"
echo "================================="
echo "Archive : $archive_path"
echo ""
if [[ ! -f "$archive_path" ]]; then
echo "❌ Archive non trouvée : $archive_path"
return 1
fi
# Vérifier si c'est un fichier ZIP
if ! file "$archive_path" | grep -q "Zip archive"; then
echo "❌ Pas une archive ZIP valide"
return 1
fi
# Tester intégrité archive
echo "Test intégrité archive..."
if unzip -t "$archive_path" >/dev/null 2>&1; then
echo "✅ Intégrité archive vérifiée"
# Obtenir informations archive
local archive_size=$(du -h "$archive_path" | cut -f1)
local file_count=$(unzip -l "$archive_path" 2>/dev/null | tail -1 | awk '{print $2}' || echo "Inconnu")
echo ""
echo "=== Informations Archive ==="
echo "Taille : $archive_size"
echo "Fichiers : $file_count"
echo "Format : ZIP"
# Vérifier métadonnées
local metadata_file="${archive_path}.metadata.json"
if [[ -f "$metadata_file" ]]; then
echo "Métadonnées : Disponibles"
local creation_date=$(jq -r '.info_archive.cree' "$metadata_file" 2>/dev/null || echo "Inconnue")
local archive_id=$(jq -r '.info_archive.id' "$metadata_file" 2>/dev/null || echo "Inconnu")
echo "Créée : $creation_date"
echo "ID Archive : $archive_id"
else
echo "Métadonnées : Non disponibles"
fi
else
echo "❌ Vérification intégrité archive échouée"
echo "Archive peut être corrompue ou protégée par mot de passe"
return 1
fi
}
# Exemples d'utilisation
echo "Exemples Gestionnaire d'Archives Entreprise :"
echo "============================================="
echo ""
echo "1. Créer archive entreprise :"
enterprise_archive_manager "create" "/Users/Shared/documents" "haute_securite" "/tmp/archives"
echo ""
echo "2. Création archives par lots :"
enterprise_archive_manager "batch" "/Users/Shared/source_lot" "default" "/tmp/archives_lot"
echo ""
echo "3. Vérifier intégrité archive :"
enterprise_archive_manager "verify" "/tmp/archives/exemple.zip"Fonctionnalités Sécurité et Conformité
Système d'Archives Sécurité Avancée
#!/bin/bash
# Système d'archives sécurité et conformité avancées
secure_compliance_archiver() {
local operation="${1:-audit}"
local archive_path="$2"
local compliance_level="${3:-standard}"
echo "🔒 Archiveur Conformité Sécurisé"
echo "================================"
echo "Opération : $operation"
echo "Niveau conformité : $compliance_level"
echo ""
case "$operation" in
"audit")
perform_security_audit "$archive_path" "$compliance_level"
;;
"encrypt")
apply_advanced_encryption "$archive_path" "$compliance_level"
;;
"validate")
validate_compliance_requirements "$archive_path" "$compliance_level"
;;
"report")
generate_compliance_report "$compliance_level"
;;
*)
echo "❌ Opération inconnue : $operation"
echo "Opérations disponibles : audit, encrypt, validate, report"
return 1
;;
esac
}
# Audit sécurité pour archives
perform_security_audit() {
local archive_path="$1"
local compliance_level="$2"
echo "🔍 Audit Sécurité"
echo "=================="
echo ""
local audit_passed=0
local audit_warnings=0
local audit_failures=0
# Vérifier permissions fichier
if [[ -f "$archive_path" ]]; then
local permissions=$(stat -f "%A" "$archive_path" 2>/dev/null || echo "inconnues")
echo "Permissions fichier : $permissions"
if [[ "$permissions" =~ ^[67][0-4][0-4]$ ]]; then
echo "✅ Permissions sont sécurisées"
((audit_passed++))
else
echo "⚠️ Permissions peuvent être trop permissives"
((audit_warnings++))
fi
fi
# Vérifier statut chiffrement
if file "$archive_path" | grep -q "password-protected\|encrypted"; then
echo "✅ Archive est protégée par mot de passe"
((audit_passed++))
else
echo "❌ Archive n'est pas protégée par mot de passe"
((audit_failures++))
fi
# Vérifier intégrité métadonnées
local metadata_file="${archive_path}.metadata.json"
if [[ -f "$metadata_file" ]]; then
echo "✅ Fichier métadonnées présent"
((audit_passed++))
# Valider JSON
if jq empty "$metadata_file" 2>/dev/null; then
echo "✅ Format métadonnées valide"
((audit_passed++))
else
echo "❌ Format métadonnées invalide"
((audit_failures++))
fi
else
echo "⚠️ Fichier métadonnées manquant"
((audit_warnings++))
fi
# Vérifications spécifiques à la conformité
case "$compliance_level" in
"haute"|"entreprise")
# Vérifier fichier mot de passe sécurisé
local password_file="${archive_path}.password"
if [[ -f "$password_file" ]]; then
local pass_permissions=$(stat -f "%A" "$password_file" 2>/dev/null || echo "inconnues")
if [[ "$pass_permissions" == "600" ]]; then
echo "✅ Permissions fichier mot de passe sécurisées"
((audit_passed++))
else
echo "❌ Permissions fichier mot de passe non sécurisées"
((audit_failures++))
fi
fi
;;
esac
# Générer résumé audit
echo ""
echo "=== Résumé Audit Sécurité ==="
echo "Réussis : $audit_passed"
echo "Avertissements : $audit_warnings"
echo "Échecs : $audit_failures"
local total_checks=$((audit_passed + audit_warnings + audit_failures))
if [[ "$audit_failures" -eq 0 ]]; then
echo "🎉 Audit sécurité RÉUSSI"
return 0
else
echo "❌ Audit sécurité ÉCHOUÉ"
return 1
fi
}
# Générer rapport conformité
generate_compliance_report() {
local compliance_level="$1"
local report_file="/tmp/macfleet_archive_compliance_$(date +%Y%m%d_%H%M%S).json"
echo "📊 Génération Rapport Conformité"
echo "================================="
echo ""
# Scanner toutes archives MacFleet
local archive_dirs=("/tmp/macfleet_archives" "/tmp/archives" "/tmp/archives_lot")
local total_archives=0
local compliant_archives=0
local non_compliant_archives=0
{
echo "{"
echo " \"rapport_conformite\": {"
echo " \"genere\": \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\","
echo " \"nom_hote\": \"$(hostname)\","
echo " \"niveau_conformite\": \"$compliance_level\","
echo " \"archives\": ["
local first_archive=true
for dir in "${archive_dirs[@]}"; do
if [[ -d "$dir" ]]; then
for archive in "$dir"/*.zip; do
if [[ -f "$archive" ]]; then
if [[ "$first_archive" == "false" ]]; then
echo ","
fi
local archive_name=$(basename "$archive")
local archive_size=$(du -h "$archive" | cut -f1)
local is_compliant="false"
# Vérifier conformité
if perform_security_audit "$archive" "$compliance_level" >/dev/null 2>&1; then
is_compliant="true"
((compliant_archives++))
else
((non_compliant_archives++))
fi
echo " {"
echo " \"nom\": \"$archive_name\","
echo " \"chemin\": \"$archive\","
echo " \"taille\": \"$archive_size\","
echo " \"conforme\": $is_compliant"
echo -n " }"
first_archive=false
((total_archives++))
fi
done
fi
done
echo ""
echo " ],"
echo " \"resume\": {"
echo " \"total_archives\": $total_archives,"
echo " \"conformes\": $compliant_archives,"
echo " \"non_conformes\": $non_compliant_archives,"
echo " \"taux_conformite\": \"$(echo "scale=1; ($compliant_archives * 100) / $total_archives" | bc 2>/dev/null || echo "0")%\""
echo " }"
echo " }"
echo "}"
} > "$report_file"
echo "✅ Rapport conformité généré : $report_file"
echo ""
echo "=== Résumé ==="
echo "Total archives : $total_archives"
echo "Conformes : $compliant_archives"
echo "Non conformes : $non_compliant_archives"
if [[ "$total_archives" -gt 0 ]]; then
local compliance_rate=$(echo "scale=1; ($compliant_archives * 100) / $total_archives" | bc 2>/dev/null || echo "0")
echo "Taux conformité : ${compliance_rate}%"
fi
}
# Exécuter opérations conformité
echo "Exemples Sécurité et Conformité :"
echo "================================="
echo ""
echo "1. Générer rapport conformité :"
secure_compliance_archiver "report" "" "entreprise"Notes Importantes
Fonctionnalités Entreprise
- Sécurité Avancée - Chiffrement AES-256 avec génération mot de passe sécurisé
- Gestion Métadonnées - Suivi et documentation archives complets
- Opérations Lot - Création et gestion archives en masse
- Vérification Intégrité - Validation archive et détection corruption
- Rapports Conformité - Audit sécurité et suivi conformité
- Déploiement Flotte - Opérations archives standardisées sur appareils
Meilleures Pratiques Sécurité
- Mots de Passe Forts - Génération mots de passe cryptographiquement sécurisés
- Stockage Sécurisé - Fichiers mots de passe protégés avec permissions restreintes
- Standards Chiffrement - Chiffrement AES-256 pour sécurité maximale
- Pistes Audit - Journalisation et suivi opérations complets
- Contrôles Accès - Permissions fichiers et mesures sécurité appropriées
Opérations Supportées
- Créer - Création archive fichier unique ou répertoire
- Lot - Création archives multiples depuis contenu répertoire
- Vérifier - Test et validation intégrité archive
- Extraire - Extraction archive sécurisée avec vérification
- Audit - Vérification conformité sécurité et rapports
Exemples d'Utilisation
# ZIP basique protégé par mot de passe
touch /Users/Shared/fichier.txt
printf 'Bonjour monde\n' > /Users/Shared/fichier.txt
cd /Users/Shared
zip -r fichier.zip fichier.txt --password 1234
# Archive entreprise MacFleet améliorée
create_basic_password_zip "/Users/Shared/document.pdf" "doc_securise.zip" "MotDePasseSecurise123!"
# Archive entreprise avec métadonnées
enterprise_archive_manager "create" "/Users/Shared/projets" "haute_securite" "/tmp/archives"
# Création archives par lots
enterprise_archive_manager "batch" "/Users/Shared/documents" "default" "/tmp/archives_lot"
# Audit sécurité
secure_compliance_archiver "audit" "/tmp/archives/exemple.zip" "entreprise"