Suivi de Localisation des Appareils sur macOS

Suivez et surveillez la localisation géographique de vos appareils Roundfleet en utilisant les services de géolocalisation par adresse IP. Ce tutoriel couvre la découverte de localisation, la surveillance de sécurité, les politiques de géofencing, et les rapports de conformité pour la gestion d'appareils d'entreprise.

Comprendre le Suivi de Localisation Basé sur IP

La géolocalisation IP fournit des informations précieuses sur la localisation des appareils et l'environnement réseau, essentielles pour la sécurité et la conformité d'entreprise. Cette méthode suit les appareils basée sur leur connexion internet plutôt que le GPS, la rendant adaptée à la gestion de flotte et la surveillance de sécurité.

Informations Clés Récupérées

Adresse IP - Adresse IP publique de l'appareil
Localisation Géographique - Ville, région et pays
Coordonnées - Latitude et longitude pour la cartographie
Fournisseur Réseau - Détails du FAI ou de l'organisation
Fuseau Horaire - Informations de fuseau horaire local
Contexte de Sécurité - Évaluation de l'environnement réseau

Découverte de Localisation Basique

Géolocalisation IP Simple

#!/bin/bash

# Recherche de localisation basique utilisant l'adresse IP
curl -s https://ipinfo.io

echo "Informations de localisation récupérées avec succès"

Requête de Localisation Améliorée

#!/bin/bash

# Découverte de localisation améliorée avec sortie formatée
get_device_location() {
    echo "📍 Récupération des informations de localisation de l'appareil..."
    
    # Interroger les données de localisation
    local location_data
    location_data=$(curl -s https://ipinfo.io)
    
    if [[ $? -eq 0 && -n "$location_data" ]]; then
        echo "✅ Données de localisation récupérées avec succès :"
        echo "$location_data" | jq '.' 2>/dev/null || echo "$location_data"
    else
        echo "❌ Échec de la récupération des informations de localisation"
        return 1
    fi
}

# Exécuter la découverte de localisation
get_device_location

Informations de Localisation Structurées

#!/bin/bash

# Analyser et afficher les informations de localisation structurées
parse_location_data() {
    echo "🌍 Analyse de Localisation de l'Appareil"
    echo "======================================="
    
    # Obtenir les données de localisation
    local location_json
    location_json=$(curl -s https://ipinfo.io)
    
    if [[ $? -ne 0 ]]; then
        echo "❌ Échec de la récupération des données de localisation"
        return 1
    fi
    
    # Analyser les champs individuels
    local ip city region country loc org timezone
    ip=$(echo "$location_json" | jq -r '.ip // "Inconnu"')
    city=$(echo "$location_json" | jq -r '.city // "Inconnu"')
    region=$(echo "$location_json" | jq -r '.region // "Inconnu"')
    country=$(echo "$location_json" | jq -r '.country // "Inconnu"')
    loc=$(echo "$location_json" | jq -r '.loc // "Inconnu"')
    org=$(echo "$location_json" | jq -r '.org // "Inconnu"')
    timezone=$(echo "$location_json" | jq -r '.timezone // "Inconnu"')
    
    # Afficher les informations formatées
    echo "🔗 Adresse IP : $ip"
    echo "🏙️  Ville : $city"
    echo "🗺️  Région : $region"
    echo "🌎 Pays : $country"
    echo "📍 Coordonnées : $loc"
    echo "🏢 Organisation : $org"
    echo "🕐 Fuseau horaire : $timezone"
    
    # Informations de sécurité supplémentaires
    echo ""
    echo "🔒 Évaluation de Sécurité :"
    if [[ "$org" == *"VPN"* ]] || [[ "$org" == *"Proxy"* ]]; then
        echo "  ⚠️  VPN/Proxy potentiel détecté"
    else
        echo "  ✅ Connexion internet directe"
    fi
}

# Exécuter l'analyse de localisation
parse_location_data

Suivi de Localisation Avancé

Vérification de Localisation Multi-Sources

#!/bin/bash

# Vérifier la localisation en utilisant plusieurs services de géolocalisation
verify_location_multi_source() {
    echo "🔍 Vérification de localisation multi-sources..."
    
    # Service 1 : ipinfo.io
    echo "Vérification ipinfo.io..."
    local ipinfo_data
    ipinfo_data=$(curl -s https://ipinfo.io)
    
    # Service 2 : ipapi.co (alternative)
    echo "Vérification ipapi.co..."
    local ipapi_data
    ipapi_data=$(curl -s https://ipapi.co/json/)
    
    # Service 3 : ip-api.com (sauvegarde)
    echo "Vérification ip-api.com..."
    local ipapi_alt_data
    ipapi_alt_data=$(curl -s http://ip-api.com/json/)
    
    # Comparer les résultats
    echo ""
    echo "📊 Résultats de Vérification de Localisation :"
    echo "=============================================="
    
    if [[ -n "$ipinfo_data" ]]; then
        echo "Résultats ipinfo.io :"
        echo "$ipinfo_data" | jq '.city, .region, .country' 2>/dev/null || echo "$ipinfo_data"
        echo ""
    fi
    
    if [[ -n "$ipapi_data" ]]; then
        echo "Résultats ipapi.co :"
        echo "$ipapi_data" | jq '.city, .region, .country_name' 2>/dev/null || echo "$ipapi_data"
        echo ""
    fi
    
    if [[ -n "$ipapi_alt_data" ]]; then
        echo "Résultats ip-api.com :"
        echo "$ipapi_alt_data" | jq '.city, .regionName, .country' 2>/dev/null || echo "$ipapi_alt_data"
    fi
}

# Exécuter la vérification multi-sources
verify_location_multi_source

Détection de Changement de Localisation

#!/bin/bash

# Surveiller et détecter les changements de localisation
monitor_location_changes() {
    local previous_location_file="/tmp/last_known_location.json"
    local current_location
    
    echo "📱 Surveillance des changements de localisation de l'appareil..."
    
    # Obtenir la localisation actuelle
    current_location=$(curl -s https://ipinfo.io)
    
    if [[ $? -ne 0 ]]; then
        echo "❌ Échec de la récupération de la localisation actuelle"
        return 1
    fi
    
    # Vérifier si la localisation précédente existe
    if [[ -f "$previous_location_file" ]]; then
        local previous_location
        previous_location=$(cat "$previous_location_file")
        
        # Comparer les localisations
        local current_city previous_city
        current_city=$(echo "$current_location" | jq -r '.city // "Inconnu"')
        previous_city=$(echo "$previous_location" | jq -r '.city // "Inconnu"')
        
        if [[ "$current_city" != "$previous_city" ]]; then
            echo "🚨 Changement de localisation détecté !"
            echo "Précédente : $previous_city"
            echo "Actuelle : $current_city"
            
            # Enregistrer le changement
            echo "$(date) : Localisation changée de $previous_city à $current_city" >> /var/log/location_changes.log
        else
            echo "✅ Aucun changement de localisation détecté"
        fi
    else
        echo "📝 Première vérification de localisation - sauvegarde de la référence"
    fi
    
    # Sauvegarder la localisation actuelle comme précédente
    echo "$current_location" > "$previous_location_file"
}

# Exécuter la surveillance de localisation
monitor_location_changes

Script de Gestion de Localisation d'Entreprise

#!/bin/bash

# Système de Gestion de Localisation d'Appareil Roundfleet
# Suivi complet de localisation et surveillance de sécurité pour appareils d'entreprise

# Configuration
LOG_FILE="/var/log/roundfleet_location.log"
CONFIG_FILE="/etc/roundfleet/location_policy.conf"
LOCATION_DB="/var/lib/roundfleet/location_history.db"
ALERT_THRESHOLD_MILES=100

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

# Configurer les répertoires et fichiers
setup_environment() {
    sudo mkdir -p "$(dirname "$LOG_FILE")" 2>/dev/null
    sudo mkdir -p "$(dirname "$CONFIG_FILE")" 2>/dev/null
    sudo mkdir -p "$(dirname "$LOCATION_DB")" 2>/dev/null
    
    # Créer la base de données de localisation si elle n'existe pas
    if [[ ! -f "$LOCATION_DB" ]]; then
        echo "timestamp,ip,city,region,country,lat,lon,org,timezone" > "$LOCATION_DB"
    fi
}

# Charger la configuration
load_config() {
    if [[ -f "$CONFIG_FILE" ]]; then
        source "$CONFIG_FILE"
        log_action "Configuration chargée depuis $CONFIG_FILE"
    else
        # Configuration par défaut
        LOCATION_TRACKING_ENABLED=true
        GEOFENCE_ENABLED=false
        ALLOWED_COUNTRIES=("US" "CA" "GB" "FR")
        BLOCKED_NETWORKS=("VPN" "TOR" "PROXY")
        MONITORING_INTERVAL=3600  # 1 heure
        REPORT_EMAIL="[email protected]"
        
        log_action "Utilisation de la configuration de localisation par défaut"
    fi
}

# Obtenir des informations de localisation complètes
get_location_info() {
    local provider="${1:-ipinfo.io}"
    
    case "$provider" in
        "ipinfo.io")
            curl -s https://ipinfo.io
            ;;
        "ipapi.co")
            curl -s https://ipapi.co/json/
            ;;
        "ip-api.com")
            curl -s http://ip-api.com/json/
            ;;
        *)
            curl -s https://ipinfo.io
            ;;
    esac
}

# Valider les données de localisation
validate_location() {
    local location_data="$1"
    
    # Vérifier si les données sont du JSON valide
    if ! echo "$location_data" | jq empty 2>/dev/null; then
        log_action "Format de données de localisation invalide"
        return 1
    fi
    
    # Vérifier les champs requis
    local ip city country
    ip=$(echo "$location_data" | jq -r '.ip // empty')
    city=$(echo "$location_data" | jq -r '.city // empty')
    country=$(echo "$location_data" | jq -r '.country // empty')
    
    if [[ -z "$ip" ]] || [[ -z "$city" ]] || [[ -z "$country" ]]; then
        log_action "Champs de localisation requis manquants"
        return 1
    fi
    
    return 0
}

# Stocker la localisation dans la base de données
store_location() {
    local location_data="$1"
    
    if ! validate_location "$location_data"; then
        return 1
    fi
    
    # Analyser les données de localisation
    local timestamp ip city region country lat lon org timezone
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    ip=$(echo "$location_data" | jq -r '.ip')
    city=$(echo "$location_data" | jq -r '.city')
    region=$(echo "$location_data" | jq -r '.region // ""')
    country=$(echo "$location_data" | jq -r '.country')
    lat=$(echo "$location_data" | jq -r '.loc | split(",")[0] // ""')
    lon=$(echo "$location_data" | jq -r '.loc | split(",")[1] // ""')
    org=$(echo "$location_data" | jq -r '.org // ""')
    timezone=$(echo "$location_data" | jq -r '.timezone // ""')
    
    # Ajouter à la base de données
    echo "$timestamp,$ip,$city,$region,$country,$lat,$lon,$org,$timezone" >> "$LOCATION_DB"
    
    log_action "Localisation stockée : $city, $region, $country"
}

# Vérifier la conformité géofencing
check_geofence() {
    local location_data="$1"
    local country
    country=$(echo "$location_data" | jq -r '.country')
    
    if [[ "$GEOFENCE_ENABLED" == "true" ]]; then
        # Vérifier si le pays est dans la liste autorisée
        local allowed=false
        for allowed_country in "${ALLOWED_COUNTRIES[@]}"; do
            if [[ "$country" == "$allowed_country" ]]; then
                allowed=true
                break
            fi
        done
        
        if [[ "$allowed" == "false" ]]; then
            log_action "ALERTE : Appareil en dehors du géofencing autorisé - Pays : $country"
            send_security_alert "Violation de géofencing" "Appareil détecté dans un pays non autorisé : $country"
            return 1
        fi
    fi
    
    return 0
}

# Vérifier les réseaux suspects
check_network_security() {
    local location_data="$1"
    local org
    org=$(echo "$location_data" | jq -r '.org')
    
    # Vérifier contre les réseaux bloqués
    for blocked_network in "${BLOCKED_NETWORKS[@]}"; do
        if [[ "$org" == *"$blocked_network"* ]]; then
            log_action "ALERTE SÉCURITÉ : Réseau suspect détecté - $org"
            send_security_alert "Réseau Suspect" "Appareil connecté via un réseau potentiellement risqué : $org"
            return 1
        fi
    done
    
    return 0
}

# Envoyer des alertes de sécurité
send_security_alert() {
    local alert_type="$1"
    local message="$2"
    local hostname
    hostname=$(hostname)
    
    # Enregistrer l'alerte
    log_action "ALERTE SÉCURITÉ [$alert_type] : $message"
    
    # Envoyer une alerte email (si configurée)
    if command -v mail >/dev/null 2>&1 && [[ -n "$REPORT_EMAIL" ]]; then
        echo "Alerte de Sécurité de l'Appareil Roundfleet : $hostname
        
Type d'Alerte : $alert_type
Message : $message
Horodatage : $(date)
Appareil : $hostname

Ceci est une alerte de sécurité automatisée de la Surveillance de Localisation Roundfleet." | \
        mail -s "Alerte de Sécurité Roundfleet : $alert_type" "$REPORT_EMAIL"
    fi
}

# Calculer la distance entre coordonnées
calculate_distance() {
    local lat1="$1" lon1="$2" lat2="$3" lon2="$4"
    
    # Utiliser python pour un calcul plus précis si disponible
    if command -v python3 >/dev/null 2>&1; then
        python3 -c "
import math
def haversine(lat1, lon1, lat2, lon2):
    R = 6371  # Rayon de la Terre en kilomètres
    dlat = math.radians(float(lat2) - float(lat1))
    dlon = math.radians(float(lon2) - float(lon1))
    a = math.sin(dlat/2)**2 + math.cos(math.radians(float(lat1))) * math.cos(math.radians(float(lat2))) * math.sin(dlon/2)**2
    c = 2 * math.asin(math.sqrt(a))
    return R * c
print(f'{haversine($lat1, $lon1, $lat2, $lon2):.2f}')
"
    else
        echo "0"
    fi
}

# Surveiller les changements de localisation
monitor_location() {
    log_action "Démarrage de la surveillance de localisation..."
    
    while true; do
        # Obtenir la localisation actuelle
        local current_location
        current_location=$(get_location_info)
        
        if validate_location "$current_location"; then
            # Stocker la localisation
            store_location "$current_location"
            
            # Vérifications de sécurité
            check_geofence "$current_location"
            check_network_security "$current_location"
            
            # Vérifier les mouvements significatifs
            check_location_change "$current_location"
        else
            log_action "Échec de la récupération de données de localisation valides"
        fi
        
        sleep "$MONITORING_INTERVAL"
    done
}

# Vérifier les changements de localisation significatifs
check_location_change() {
    local current_location="$1"
    local last_location_file="/tmp/last_location.json"
    
    if [[ -f "$last_location_file" ]]; then
        local previous_location
        previous_location=$(cat "$last_location_file")
        
        # Obtenir les coordonnées
        local curr_lat curr_lon prev_lat prev_lon
        curr_lat=$(echo "$current_location" | jq -r '.loc | split(",")[0] // ""')
        curr_lon=$(echo "$current_location" | jq -r '.loc | split(",")[1] // ""')
        prev_lat=$(echo "$previous_location" | jq -r '.loc | split(",")[0] // ""')
        prev_lon=$(echo "$previous_location" | jq -r '.loc | split(",")[1] // ""')
        
        if [[ -n "$curr_lat" && -n "$curr_lon" && -n "$prev_lat" && -n "$prev_lon" ]]; then
            local distance
            distance=$(calculate_distance "$prev_lat" "$prev_lon" "$curr_lat" "$curr_lon")
            
            local threshold_km
            threshold_km=$(echo "$ALERT_THRESHOLD_MILES * 1.60934" | bc -l)
            
            if (( $(echo "$distance > $threshold_km" | bc -l) )); then
                log_action "ALERTE : Changement de localisation significatif détecté - Distance : ${distance} km"
                send_security_alert "Changement de Localisation" "L'appareil s'est déplacé de ${distance} km de la localisation précédente"
            fi
        fi
    fi
    
    # Sauvegarder la localisation actuelle
    echo "$current_location" > "$last_location_file"
}

# Générer un rapport de localisation
generate_location_report() {
    local report_file="/tmp/roundfleet_location_report_$(date +%Y%m%d_%H%M%S).txt"
    local hostname
    hostname=$(hostname)
    
    {
        echo "Rapport de Localisation d'Appareil Roundfleet"
        echo "==========================================="
        echo "Généré : $(date)"
        echo "Appareil : $hostname"
        echo ""
        
        echo "Localisation Actuelle :"
        local current_location
        current_location=$(get_location_info)
        if validate_location "$current_location"; then
            echo "$current_location" | jq '.'
        else
            echo "Impossible de récupérer la localisation actuelle"
        fi
        echo ""
        
        echo "Historique de Localisation (10 dernières entrées) :"
        if [[ -f "$LOCATION_DB" ]]; then
            tail -10 "$LOCATION_DB" | column -t -s ','
        else
            echo "Aucun historique de localisation disponible"
        fi
        echo ""
        
        echo "Événements de Sécurité (10 derniers) :"
        if [[ -f "$LOG_FILE" ]]; then
            grep -i "alerte\|sécurité" "$LOG_FILE" | tail -10
        else
            echo "Aucun événement de sécurité enregistré"
        fi
        
    } > "$report_file"
    
    echo "📄 Rapport de localisation généré : $report_file"
    log_action "Rapport de localisation généré : $report_file"
}

# Fonction principale
main() {
    case "${1:-status}" in
        "track")
            setup_environment
            load_config
            log_action "=== Suivi de Localisation : Vérification Unique ==="
            current_location=$(get_location_info)
            if validate_location "$current_location"; then
                store_location "$current_location"
                check_geofence "$current_location"
                check_network_security "$current_location"
                echo "$current_location" | jq '.'
            fi
            ;;
        "monitor")
            setup_environment
            load_config
            log_action "=== Surveillance de Localisation : Continue ==="
            monitor_location
            ;;
        "report")
            setup_environment
            load_config
            generate_location_report
            ;;
        "history")
            if [[ -f "$LOCATION_DB" ]]; then
                echo "📍 Historique de Localisation :"
                column -t -s ',' "$LOCATION_DB"
            else
                echo "Aucun historique de localisation disponible"
            fi
            ;;
        "status"|*)
            setup_environment
            load_config
            echo "📊 Statut de Localisation Roundfleet :"
            echo "===================================="
            current_location=$(get_location_info)
            if validate_location "$current_location"; then
                echo "$current_location" | jq '.'
            else
                echo "Impossible de récupérer les informations de localisation"
            fi
            ;;
    esac
}

# Exécuter la fonction principale avec les paramètres
main "$@"

Commandes de Suivi de Localisation

Référence Rapide

Tâche	Commande
Obtenir localisation actuelle	`curl -s https://ipinfo.io`
Infos de localisation formatées	`curl -s https://ipinfo.io \| jq '.'`
Sauvegarder localisation dans fichier	`curl -s https://ipinfo.io > location.json`
Obtenir champ spécifique	`curl -s https://ipinfo.io \| jq -r '.city'`

Champs de Données de Localisation

# Extraire des informations spécifiques
IP=$(curl -s https://ipinfo.io | jq -r '.ip')
CITY=$(curl -s https://ipinfo.io | jq -r '.city')
REGION=$(curl -s https://ipinfo.io | jq -r '.region')
COUNTRY=$(curl -s https://ipinfo.io | jq -r '.country')
COORDINATES=$(curl -s https://ipinfo.io | jq -r '.loc')
ORGANIZATION=$(curl -s https://ipinfo.io | jq -r '.org')
TIMEZONE=$(curl -s https://ipinfo.io | jq -r '.timezone')

Sécurité et Conformité

Considérations de Confidentialité

Collecte de Données - Ne collecter que les données de localisation nécessaires
Sécurité de Stockage - Chiffrer les bases de données de localisation
Contrôle d'Accès - Limiter l'accès aux informations de localisation
Politique de Rétention - Définir les périodes de rétention des données
Consentement Utilisateur - Assurer une autorisation appropriée

Implémentation de Géofencing

#!/bin/bash

# Vérification simple de géofencing
check_location_compliance() {
    local location_data
    location_data=$(curl -s https://ipinfo.io)
    
    local country
    country=$(echo "$location_data" | jq -r '.country')
    
    case "$country" in
        "US"|"CA"|"GB"|"FR")
            echo "✅ Localisation approuvée : $country"
            ;;
        *)
            echo "⚠️  Localisation en dehors des régions approuvées : $country"
            # Enregistrer l'événement de sécurité
            logger "Roundfleet : Appareil dans une localisation non autorisée : $country"
            ;;
    esac
}

Dépannage

Problèmes Courants

Problèmes de connectivité réseau
- Vérifier la connexion internet
- Vérifier les paramètres du pare-feu
- Tester des services de géolocalisation alternatifs
Données de localisation inexactes
- Les connexions VPN/proxy affectent la précision
- La localisation du FAI peut ne pas correspondre à la localisation physique
- Utiliser plusieurs services pour la vérification
Limites de taux d'API
- Implémenter des délais appropriés entre les requêtes
- Utiliser des clés API authentifiées quand disponibles
- Mettre en cache les données de localisation de manière appropriée

Commandes de Vérification

# Tester la connectivité réseau
ping -c 3 ipinfo.io

# Vérifier si jq est installé
which jq || echo "jq non installé"

# Vérifier la disponibilité du service de localisation
curl -I https://ipinfo.io

Notes Importantes

Limitations de précision : La géolocalisation IP fournit une localisation approximative, pas des coordonnées précises
Dépendances réseau : Nécessite une connectivité internet pour fonctionner
Conformité à la confidentialité : Assurer la conformité aux lois locales de confidentialité et réglementations
Détection VPN : Les résultats peuvent être affectés par les services VPN ou proxy
Limitation de taux : Implémenter des délais appropriés pour éviter les limites de taux de service
Stockage de données : Stocker et gérer de manière sécurisée les données de localisation collectées

Déploiement d'Entreprise

Pour le déploiement d'entreprise, considérer :

Définition de politique - Établir des politiques claires de suivi de localisation
Conformité légale - Assurer la conformité aux réglementations de confidentialité
Surveillance de sécurité - Implémenter des alertes de localisation en temps réel
Gouvernance des données - Définir les politiques de rétention et d'accès aux données
Communication utilisateur - Informer les utilisateurs des pratiques de suivi de localisation

Guide

Avis important