-
Writeup Hack-A-Sat : IQ
Description du challenge : Convert the provided series of transmit bits into in-phase quadrature samples.
Le challenge est disponible à cette adresse.
Connectons-nous à l’instance du challenge :
On nous demande de convertir une série de bits en un échantillon I/Q en modulation QPSK (Quadrature Phase Shift Keying).
Modulation QPSK
La modulation QPSK est une modulation de phase numérique où l’on va modifier la phase de la porteuse pour transmettre des données. Tu peux retrouver un cours sur ce qu’est la modulation juste là et sur la phase juste ici.
Concrètement, pour cette modulation, les bits sont regroupés par paires donc on a 4 combinaisons possibles : 00, 01,10,11 et ainsi 4 phases possibles. En général, chacune d’entre elles est espacée de 90°. Par exemple, on pourrait avoir 00 à 0°, 01 à 90°, 11 à 180° et 10 à 270°.
On peut aussi le voir sur ce schéma avec d’autres valeurs mais qui restent espacées de 90° :
Échantillon IQ
I (In-phase) et Q (Quadrature) sont les deux composantes orthogonales du signal modulé. Elles représentent respectivement les parties cosinus et sinus de l’onde porteuse modulée.
Si on décompose le signal avec ces deux valeurs, on peut représenter le signal modulé comme un point dans un plan à deux dimensions appelé diagramme de constellation.
Un échantillon I/Q permet ainsi de représenter les valeurs numériques des deux composantes du signal modulé. Cela nous permet de représenter la modulation en phase du signal comme pour le QPSK.
Résolution
Pour la résolution du challenge, on va faire un script en Python. Sachant qu’en QPSK, les bits sont codés par paire, on va commencer par cette étape :
bits = "01000011 01110010 01101111 01101101 01110101 01101100 01100101 01101110 01110100 00001010"
bits_pair = []
i = 0
while i < len(bits):
if bits[i] == " ": # Pour ignorer les espaces de notre variable bits (Oui, on aurait pu les enlever direct manuellement mais c'est pour que ça reste propre)
i += 1
pair = bits[i:i+2]
bits_pair.append(pair)
i += 2
print(bits_pair) # ['01', '00', '00', '11', '01', '11', '00', '10', '01', '10', '11', '11', '01', '10', '11', '01', '01', '11', '01', '01', '01', '10', '11', '00', '01', '10', '01', '01', '01', '10', '11', '10', '01', '11', '01', '00', '00', '00', '10', '10']
Chaque combinaison de bits est mappée à un point spécifique dans le plan I/Q où I (In-phase) est l’axe horizontal et Q (Quadrature) l’axe vertical.
Par rapport au diagramme qui nous est donné, on peut déduire la façon de coder nos bits :
Ainsi, on peut faire une table de mappage en utilisant un dictionnaire et sortir une liste iq_samples qui contient nos bits mappés :
bits_map = {
"00": "-1.0 -1.0",
"01": "-1.0 1.0",
"10": "1.0 -1.0",
"11": "1.0 1.0"
}
iq_samples = []
for pair in bits_pair:
iq_value = bits_map.get(pair)
iq_samples.append(iq_value)
print(iq_samples) # ['-1.0 1.0', '-1.0 -1.0', '-1.0 -1.0', '1.0 1.0', '-1.0 1.0', '1.0 1.0', '-1.0 -1.0', '1.0 -1.0', '-1.0 1.0', '1.0 -1.0', '1.0 1.0', '1.0 1.0', '-1.0 1.0', '1.0 -1.0', '1.0 1.0', '-1.0 1.0', '-1.0 1.0', '1.0 1.0', '-1.0 1.0', '-1.0 1.0', '-1.0 1.0', '1.0 -1.0', '1.0 1.0', '-1.0 -1.0', '-1.0 1.0', '1.0 -1.0', '-1.0 1.0', '-1.0 1.0', '-1.0 1.0', '1.0 -1.0', '1.0 1.0', '1.0 -1.0', '-1.0 1.0', '1.0 1.0', '-1.0 1.0', '-1.0 -1.0', '-1.0 -1.0', '-1.0 -1.0', '1.0 -1.0', '1.0 -1.0']
Et enfin, on peut construire notre échantillon QPSK :
qpsk = ' '.join(iq_samples)
print(qpsk)
Plus qu’à lancer notre script en entier et on obtient ça :
python .\iq.py
-1.0 1.0 -1.0 -1.0 -1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 1.0 -1.0 -1.0 1.0 -1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 -1.0 1.0 1.0 1.0 -1.0 1.0 -1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 -1.0 -1.0 -1.0 1.0 1.0 -1.0 -1.0 1.0 -1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 1.0 -1.0 -1.0 1.0 1.0 1.0 -1.0 1.0 -1.0 -1.0 -1.0 -1.0 -1.0 -1.0 1.0 -1.0 1.0 -1.0
On le copie colle et on obtient le flag :)
> docker run --rm -i -e FLAG=pouet iq:challenge
[...]
Input samples: -1.0 1.0 -1.0 -1.0 -1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 1.0 -1.0 -1.0 1.0 -1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 -1.0 1.0 1.0 1.0 -1.0 1.0 -1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 -1.0 -1.0 -1.0 1.0 1.0 -1.0 -1.0 1.0 -1.0 1.0 -1.0 1.0 1.0 -1.0 1.0 1.0 1.0 -1.0 -1.0 1.0 1.0 1.0 -1.0 1.0 -1.0 -1.0 -1.0 -1.0 -1.0 -1.0 1.0 -1.0 1.0 -1.0
You got it! Here's your flag:
pouet
-
Écoute des satellites russes METEOR-M
Les satellites américains NOAA que l’on a vu durant mon premier projet sont comme le Hello World en programmation. Mais, il existe d’autres satellites très similaires, qui produisent de meilleures images avec plus ou moins le même matériel que pour les NOAA, ce sont les satellites russes METEOR 🇷🇺.
Qui sont les METEOR ?
Les METEOR sont des satellites météorologiques soviétiques, puis russes. Depuis 1964, 70 modèles ont été lancés. Pour cet article, on va s’intéresser uniquement au dernier, ceux de la série METEOR-M dont voici l’historique :
Comme leurs homologues NOAA, la série de satellites METEOR-M se situe à une altitude d’environ 800km et possèdent une orbite polaire et plus précisément héliosynchrone. Ainsi, ils font constamment face au Soleil 🌞. Plus d’infos sur les types d’orbites juste ici.
L’orbite héliosynchrone va leur permettre de passer par les mêmes endroits à la même heure solaire 2 fois par jour.
La principale différence avec les NOAA est leur mode de transmission qui se nomme LRPT. Pour les NOAA, c’était le mode APT.
Pour cet article, 2 METEOR-M vont nous intéresser :
À noter que le METEOR M2-4 est toujours en phase de test. Du coup, sa fréquence varie des fois entre 137.1 et 137.9MHz et pareil pour le débit de symbole qui varie entre 72 et 80Kbit/s.
Pour vérifier, on peut utiliser ce site qui permet de savoir l’état actuel du satellite. Voici l’état actuel le 02/09/2024 :
Place à l’écoute
Concernant l’antenne, je vais utiliser exactement la même que durant ce projet.
Pour la réception, va utiliser SatDump pour récupérer les signaux satellites. Je ne vais pas rentrer dans tous les détails de configuration, j’ai déjà fait un cours sur SatDump ici :)
Dans un premier temps, il faut connaître le prochain passage du satellite. Pour ceux qui vivent en France, les passages sont tous répertoriés sur ma station. Mais on peut aussi directement les voir avec la section Tracking de SatDump ou utiliser des sites web.
Bref, quand un satellite est là, dans la section Device, on a juste à sélectionner notre récepteur SDR et choisir un gain, dans mon cas, 40, puis Start.
Dans la section Processing, on sélectionne METEOR M2-x LRPT 72k. On peut aussi cocher la case DC Blocking et à nouveau, on lance en cliquant sur Start.
Super, on voit le signal envoyé par METEOR M2-4 🛰️ !
On peut depuis la section Tracking sélectionner le satellite de notre choix et voir “où il en est”. Là, sur la capture, il a une élevation de 76° et le passage prendra fin dans 7 minutes 42 secondes.
D’ailleurs, on peut mieux faire ressortir le signal en modifiant quelques valeurs dans la section FFT.
⚠️ Une fois le satellite passé, on clique depuis la section Processing sur le bouton Stop et uniquement après, on peut arrêter l’écoute avec le bouton Stop de la section Device. Attention de ne pas inverser cet ordre car ça risque de perdre l’enregistrement que vous venez de faire.
L’écoute étant terminée, on peut après quelques instants décaler sur l’onglet Viewer pour voir nos images et appliquer du post-traitement. Après colorisation, voici l’image que j’ai reçue :
Les bandes noires sont les moments où le signal n’était pas assez fort pour être capté, probablement dû à mon antenne qui n’est pas parfaite. Mais on peut voir que la qualité de l’image est vraiment pas mal par rapport au NOAA.
À vous de jouer à présent !
-
Les différents types d'orbites
Lorsque l’on envoie un satellite dans l’espace, on a le choix avec une infinité d’orbites disponibles.
Pour la grande majorité des satellites, ce qui compte, c’est la Terre, puisque c’est avec elle qu’ils vont interagir. Ainsi, pour être efficace, ils doivent être placés sur des orbites qui tiennent compte à la fois de leur propre mouvement autour de la Terre mais aussi de la rotation de cette dernière sur son axe.
Il n’y a donc que quelques orbites spécifiques qui optimisent tout ça, et on va comprendre pourquoi dans ce cours.
Orbite géostationnaire (GEO)
Il s’agit d’une orbite qui match parfaitement avec la rotation de la Terre. Du coup, les satellites placés sur cette orbite apparaissent comme “stationnaires” ou immobiles au-dessus d’une position donnée. Comme ils tournent en même temps que la Terre, ils mettent 24h à faire le tour de cette dernière (23h 56min 4s exactement).
On va utiliser satvis pour mieux comprendre et prendre comme exemple, le satellite météorologique GOES-17
Sur cette image, on peut voir que ce satellite a un champ de vision énorme sur les 2 continents américains, donc presque tout un hémisphère 🌎.
Si on met la vue en 2D, la couverture du satellite donnerait ça :
Et ainsi, on peut récupérer ce type d’image bien pratique pour la météo par exemple :
Cette orbite n’est pas pratique uniquement pour faire des photos mais aussi pour des services comme la télévision par satellite.
Bon, l’orbite paraît idéal pour tout type d’activité mais en réalité, elle a un désavantage, sa distance de la Terre qui est de 35786km (au niveau de l’équateur) ! Donc non seulement, c’est très couteux et gourmand d’envoyer un satellite aussi loin mais surtout, il faut prendre en compte un délai de 22 secondes pour qu’une information aille du satellite jusqu’à la Terre ou l’inverse ce qui peut rendre plus difficile certaines opérations ⏳.
Orbite terrestre moyenne (MEO)
Rapprochons nous avec l’orbite terrestre moyenne situé entre l’orbite basse et l’orbite géostationnaire.
C’est une orbite idéale pour les satellites de navigations qui fonctionnent par constellation. Ainsi, sur cette orbite, chacun d’entre eux peux quand même voir 38% de la surface de la Terre tout en allant assez vite pour couvrir l’entiereté du globe. Leur période orbitale varient entre 2 et 12h.
On peut voir sur satvis par exemple la constellation Galileo constituée de 30 satellites avec la couverture d’un seul satellite permettant ainsi de savoir où l’on est à tout instant.
N’hésites pas à consulter juste ici mon cours sur le GPS/GNSS pour comprendre comment ça fonctionne :)
Orbite terrestre basse (LEO)
Allons au plus proche de notre surface terrestre avec l’orbite la plus peuplée, l’orbite basse (85% des satellites actuellement en orbite). Ce sont tous les satellites qui sont à moins de 2000km de nous à peu près.
Si c’est la plus remplie, c’est principalement car il faut “peu” de ressources pour les mettre en orbite, rendant l’espace accessible à de plus “petits” acteurs du spatial. En plus, il n’y a quasiment aucun délai pour la communications contrairement au 22 secondes des géostationnaires.
Comme ils sont proche, ils font aussi le tour de la Terre très rapidement, 90 minutes seulement. C’est ce qui explique que les astronautes à bord de l’ISS (qui va à 28000km/h) voient 16 couchers de soleil par jour 🌅.
Bien que cette orbite puisse balayer plusieurs endroits de la Terre rapidemet, sa couverture reste très petite ce qui nécessite de multiplier les stations de sol afin d’avoir un contact avec le satellite.
C’est d’ailleurs sur cette orbite qu’est placée la mega constellation de satellites Starlink de SpaceX. Il y en a plus de 6000 aujourd’hui (donc plus de la moitié du nombre total de satellites) et ça ne fait qu’augmenter.
Orbite polaire
L’orbite polaire qui est en soit une orbite basse tourne autour des pôles terrestres. En fait, son orbite est incliné de 90°. Comme la Terre tourne sur elle même, les satellites sur cette orbite ont une couverture sur toute le globe rapidement.
Bon sur mon schema, niveau échelle par rapport au Soleil, on fait comme ci ne rien n’était. Mais on comprend que l’avantage de cette orbite est que les satellites font toujours face au Soleil et donc peuvent recevoir en permanence de l’énergie ☀️.
Orbite héliosynchrone (SSO)
L’orbite héliosynchrone est une orbite quasi polaire qui fait aussi partie de l’orbite basse où l’on chosit un angle et une inclinaison de sorte que le satellite observe chaque bout de la Terre toujours aux mêmes heures. Pratique pour les études sur le climat.
C’est cette orbite qu’utilisent les NOAA dont on récupéraient les images sur ce projet.
Orbite elliptique élevée (HEO)
Une orbite particulière qui a une trajectoire elliptique de sorte que le satellite passe de très proche de la Terre à très très loin.
C’est par exemple utilisée par les satellites russes. Sur cette orbite, ils se déplacent lentement durant leur apogée pour avoir une couverture prolongée au niveau des latitudes nords. Et, ils se déplacent rapidement lors de leur périgée au niveau des latitudes sud. Dans cet exemple, on parle plus précisément d’orbite de Molniya.
Il existe aussi l’orbite Toundra mais bref, c’est des cas particuliers d’orbites en général les HEO qui sont surtout pratiques pour les télécommunications dans les régions polaires.
Et voilà pour les principaux types d’orbites, aujourd’hui, c’est plus de 10000 satellites qui sont actuellement en orbite autour de la Terre. Il n’est pas évident de connaître le nombre exacte de satellites mais on peut avoir un bon aperçu avec le site Orbiting now 🔍.
-
Writeup Hack-A-Sat : Fiddlin' John Carson
Description du challenge : Your spacecraft has provided its Cartesian ICRF position (km) and velocity (km/s). What is its orbit (expressed as Keplerian elements)?
Le challenge est disponible à cette adresse
Connectons-nous à l’instance du challenge :
> docker run --rm -i -e FLAG=pouet kepler:challenge
KEPLER
CHALLANGE
a e i Ω ω υ
. .
,' ,=, .
, / \ .
. | | .
. \ / .
+ '=' .
. .'
. . '
'
Your spacecraft reports that its Cartesian ICRF position (km) and velocity (km/s) are:
Pos (km): [8449.401305, 9125.794363, -17.461357]
Vel (km/s): [-1.419072, 6.780149, 0.002865]
Time: 2021-06-26-19:20:00.000-UTC
What is its orbit (expressed as Keplerian elements a, e, i, Ω, ω, and υ)?
Semimajor axis, a (km):
On va devoir à partir d’une position cartésienne et d’une vitesse retrouver les paramètres d’orbite de notre vaisseau spatial.
Il est important de comprendre de quoi on parle quand on évoque les paramètres d’orbite. Heureusement pour toi, j’ai fait un petit cours que tu peux consuler juste ici :)
Voici un petit schema de ce que représente les différentes données qu’on a (le placement du vaisseau est arbitraire, il ne correspond pas à ses coordonnées réelles, flemme de faire un truc en 3D) :
Bon, en vrai, les calculs pour trouver les paramètres d’orbite sont plutôt compliqués, donc on va juste apprendre à utiliser la bibliothèque Python poliastro pour arriver à nos fins.
Dans un premier temps, on va convertir nos listes qui contiennent les coordonnées de position et de vitesse en objets avec des unités physiques appropriées pour faire des calculs avec.
from poliastro.twobody.orbit import u
pos = [8449.401305, 9125.794363, -17.461357]
vel = [-1.419072, 6.780149, 0.002865]
pos_km = [*pos] * u.km
vel_kms = [*vel] * u.km / u.s
Le u.km, c’est une unité de mesure qui provient de la bibliothèque astropy. En multipliant notre liste avec, on convertit chaque coordonnée en objet Quantity. Ainsi, les coordonnées x, y et z sont désormais traitées comme ayant pour unité le km ce qui va nous permettre de faire des calculs physiques avec.
Pareil pour le u.s qui représente des secondes et donc u.km / u.s “transforme” notre liste de vitesse avec comme unité le km/s.
Ensuite, et c’est là que la magie se fait, on a juste à appeler la méthode Orbit.from_vectors qui va s’occuper de faire tous les calculs pour nous afin qu’on puisse récupérer tout ce dont on a besoin.
from poliastro.bodies import Earth
from poliastro.twobody import Orbit
time = "2021-06-26 19:20:00.000"
orb = Orbit.from_vectors(Earth, pos_km, vel_kms, time)
Earth, c’est juste un objet qui contient les paramètres gravitationnels et géométriques de la Terre. Ces derniers sont indispensables pour le calcul mais pas la peine de rentrer dans les détails.
On oublie pas aussi de lui spécifier notre temps (time) exacte qui représente le moment dans le temps où la position et la vitesse ont été mesurés. Et oui, les paramètres orbitaux peuvent être amenés à changer avec le temps en raison de divers perturbations gravitationnelles donc faut le spécifier ce temps.
Une fois, l’appel à Orbit.from_vectors fait, on a plus qu’à récupérer nos 6 paramètres d’orbite :
a = orb.a # Demi-grand axe en km
e = orb.ecc # Excentricité
i = orb.inc.to_value(u.deg) # Inclinaison
Omega = orb.raan.to_value(u.deg) # Longitude du nœud ascendant
omega = orb.argp.to_value(u.deg) # Argument du Périastre
nu = orb.nu.to_value(u.deg) # Anomalie vraie
Avec la méthode to_value d’astropy, on peut convertir directement une valeur avec l’unité de son choix. En l’occurrence, comme les angles sortent en radians, on s’en sert pour les convertir en degrés.
On print tout ça, et y a plus qu’à remplir avec les bonnes valeurs :
> docker run --rm -i -e FLAG=pouet kepler:challenge
KEPLER
CHALLANGE
a e i Ω ω υ
. .
,' ,=, .
, / \ .
. | | .
. \ / .
+ '=' .
. .'
. . '
'
Your spacecraft reports that its Cartesian ICRF position (km) and velocity (km/s) are:
Pos (km): [8449.401305, 9125.794363, -17.461357]
Vel (km/s): [-1.419072, 6.780149, 0.002865]
Time: 2021-06-26-19:20:00.000-UTC
What is its orbit (expressed as Keplerian elements a, e, i, Ω, ω, and υ)?
Semimajor axis, a (km): 24732.885760723184
Eccentricity, e: 0.7068070220620631
Inclination, i (deg): 0.11790360842507447
Right ascension of the ascending node, Ω (deg): 90.22650379956278
Argument of perigee, ω (deg): 226.58745900876278
True anomaly, υ (deg): 90.389955034578
You got it! Here's your flag:
pouet
Et on a notre flag :)
-
Satdump GUI pour récupérer des images satellites
Durant mon premier projet pour récupérer les images des satellites NOAA, j’avais évoqué le logiciel Satdump permettant de considérablement nous simplifier la vie.
Aujourd’hui, je vais vous présenter sa version graphique avec une démo :)
Offline processing
Voilà comment se présente SatDump au lancement.
On tombe sur l’onglet Offline Processing qui est utile dans le cas où l’on a déjà un enregistrement qui provient d’un satellite. On a juste à choisir le satellite de provenance, notre fichier et cliquer sur Start, facile.
Mais on va pas trop s’y attarder, ça reste intuitif, passons plutôt à l’onglet Settings pour régler quelques trucs.
Settings
Ici, on va venir régler la position de notre récepteur (ça servira pour les prédictions de passage des satellites).
Donc, on y met notre latitude, longitude, altitude, éventuellement les couleurs (si on les veut) qui seront affichées sur les images qu’on récupère.
On voit aussi en bas la dernière fois que les TLE ont été mis à jour.
Ceci étant fait, allons dans l’onglet principal Recorder.
Recorder
Device
Ici, on choisit notre récepteur SDR, dans mon cas, un HackRF. On peut choisir notre fréquence d’écoute et notre samplerate.
Aussi, on peut modifier différents paramètres en fonction du récepteur SDR. On retrouve les différentes options possibles ici.
J’ai activé le Bias-Tee, ça permet d’alimenter un filtre LNA directement avec son récepteur SDR. Mais si vous n’utilisez pas de filtre, n’activez pas cette option !
Sautons quelques sections pour voir celle permettant de voir et prédire le passage des satellites, l’onglet Tracking.
Tracking
On peut y voir l’azimuth et l’élevation de n’importe quel satellite (donc là NOAA 15) par rapport aux positions géographiques qu’on a entré dans les Settings.
Pour rappel, l’azimuth, c’est en quelque sorte la direction qu’indiquerait une boussole vers le satellite.
L’élevation, ça serait l’angle avec lequel il faut “lever les yeux” pour voir le satellite.
En dessous, le polar plot, très pratique, qui permet d’avoir une représentation graphique de nos deux valeurs.
Le haut du graphique, ça représente l’azimuth à 0°, le bas 180°.
Le centre du graphique, c’est pour une élevation à 90°, le premier anneau à partir du centre, 60°, le second 30° et le dernier, 0° donc l’horizon.
De plus, le polar plot permet de représenter le prochain passage d’un satellite avec la ligne orange qui représente la trajectoire du satellite et un point rouge pour sa position actuelle.
On a aussi le AOS (Acquisition Of Signal) qui indique dans combien de temps on pourrait enregistrer le signal pour commencer l’écoute.
À présent, cliquons en bas sur le bouton Schedule and Config
C’est ici qu’on va pouvoir prédire les prochains passages des satellites et éventuellement, lancer automatiquement l’acquisition du signal.
Alors, en haut, on choisit les satellites qui nous intéressent.
On peut choisir l’élevation minimale pour laquelle on accepte que le prochain passage doit être prédit. Donc, dans mon cas, tout ce qui est en dessous de 40° ne sera pas prédit.
Une fois qu’on sélectionne les satellites qu’on veut écouter, on voit qu’on peut les “configurer”.
Les informations comme la fréquence ou le mode de transmission doivent être remplies manuellement.
On peut alors cliquer sur le bouton Update Passes pour voir apparaître les prochains passages de nos satellites. Attention, l’heure indiquée est en UTC, je ne sais pas comment la modifier en heure française.
Dans mon cas, le prochain passage est donc prévu à 20h21 jusqu’à 20h37 avec une élevation maximale de 61° :
Toute cette partie sert dans le cas où vous souhaitez laisser votre ordinateur relié à l’antenne et que les enregistrements se fassent tout seul. Mais on peut aussi s’en servir pour rapidement jeter un coup d’oeil pour le prochain passage et faire les choses après plus ou moins manuellement.
Recording
Vite fait, l’onglet Recording.
Comme son nom l’indique, il permet de sauvegarder un signal dans un fichier. On pourra ainsi le conserver pour le traiter par la suite, soit sur l’onglet Offline Processing, soit avec un autre logiciel de traitement de signal. Plusieurs formats de fichiers sont pris en charge.
Processing
Avec l’onglet Processing, on va pouvoir préciser de quelle manière on veut traiter le signal reçue et le décoder en temps réel !
En glissant son curseur sur les différents paramètres, on a plus d’informations sur ce qui font donc je vais pas m’y attarder. Ce qui est intéressant, c’est que lorsqu’on sélectionne le mode, donc sur mon exemple NOAA APT, on nous propose lequel des 3 NOAA on souhaite écouter, et lorsque l’on en choisit un, automatiquement, la fréquence d’écoute se met à jour sur la bonne.
Le bouton Start restera grisé tant qu’on aura pas lancé l’écoute depuis l’onglet Device.
Globalement, on a vu les onglets principaux pour commencer à utiliser SatDump, il en reste un, le super onglet Viewer que l’on verra après la démo car il nous faut un enregistrement pour avoir des choses à montrer.
Exemples d’utilisation
Allez, c’est parti, on va écouter NOAA 15. J’appuie sur Start depuis l’onglet Device puis sur Start dans l’onget Processing en ayant configuré le traitement pour le mode APT.
Voici une capture d’écran lorsque le satellite passe :
On peut voir en bas en temps réel le scan progressif du satellite apparaître. Aussi, on constate la position du satellite avec le point rouge sur le polar plot.
Une fois l’acquisition terminée, on appuie sur le Stop de l’onglet Processing (Pas celui de l’onglet Device si non, SatDump ne va pas comprendre que le traitement est terminé).
Et l’on peut à présent décaler sur l’onglet Viewer pour voir nos résultats.
Viewer
Et voilà mon image :
Cet onglet est vraiment génial, on va pouvoir traiter en temps réel notre image, là par exemple, j’ai appliqué le mode d’image MCIR qui permet d’avoir de fausses couleurs sur notre image.
On peut jouer avec les différents paramètres en fonction de ce que l’on souhaite mettre en valeur.
Par exemple, afficher des couleurs pour les probabilités de pluie, les frontières des pays et bien d’autres trucs sympas.
Et voilà pour ce super SatDump qui permet en un seul logiciel de faire plusieurs choses à la fin, de la prédiction, de l’acquisition de signal et même le traitement de ce dernier. Peut-être un jour, j’aurais la possibilité de tester un rotor d’antenne car SatDump les prend en charge, ça peut être cool.
Évidemment, je n’ai pas tout présenté, je vous laisser explorer le reste par vous même :)
-
Comprendre les systèmes de positionnement par satellites
Le système de positionnement par satellites que l’on désigne par GNSS (Géolocalisation et Navigation par un Système de Satellites) nous permet de déterminer des positions géographiques précises n’importe où sur Terre 🌍.
On va aujourd’hui comprendre comment fonctionne tout ça, dans les grandes lignes parce que ça peut vite devenir compliqué :)
Introduction
Ce qu’on appelle GPS (Global Positioning System) n’est qu’un type de GNSS opéré par les États-Unis depuis les années 70. Mais il en existe d’autres, comme le Galileo en Europe (opérationnel en 2024 et plus précis que le GPS), le GLONASS en Russie ou encore le BeiDou en Chine.
Donc, dans le vie courante, lorsque l’on parle de “GPS”, on entend par là le terme générique GNSS quel qu’il soit.
Dans le cas de la constellation GPS, c’est 24 satellites qui orbitent autour de la Terre à une altitude d’environ 20000km sur l’orbite terrestre moyenne de sorte à ce qu’il est toujours au moins 4 satellites visibles en même temps.
Ces derniers émettent en permanence des ondes radios et comme on connaît leur position, on peut grâce à de la triangulation déterminer la distance entre le satellite et le récepteur sur Terre.
Même si 3 satellites pourraient suffire pour récupérer une latitude et une longitude, en pratique, il en faut plutôt au minimum 4. Ce dernier permettant de corriger le décalage d’horloge. Mais on va voir tout ça après.
Référentiel géocentrique
Un référentiel, c’est simplement un point de vue. Le lieu d’où on observe les choses. Et quand il s’agit de faire des calculs liés au GNSS, on se base sur le référentiel géocentrique 🌐 (ou ECEF en anglais).
Ce référentiel utilise le centre de la Terre comme point de référence.
Ce dernier se base sur un système dit cartésien, ça veut dire qu’il utilise 3 axes perpendiculaires entre eux, nommés X, Y et Z pour définir la position des points.
Ces coordonnées (x,y,z) permettant ainsi de localiser précisément des points dans l’espace en fonction de leur distance par rapport au centre de la Terre.
Mais comme des positions x,y,z c’est pas trop parlant pour nous, on convertit ses données en latitude et longitude bien plus simple à lire.
Pseudo-distance
On parle de pseudo-distance pour parler de la distance apparente entre un récepteur et un satellite.
Elle se mesure avec la formule qu’on apprenait au lycée D=V.Δt avec D la distance, V la vitesse moyenne de propagation du signal et Δt le temps mis pour recevoir le signal.
Si l’on utilise le mot “pseudo”, c’est qu’en réalité, cette distance inclut non seulement la vraie distance mais aussi des erreurs dues à divers facteurs comme les décalages d’horloges entre le récepteur et l’émetteur ou encore les effets atmosphériques.
Le satellite et le récepteur génèrent tous les deux un même code afin de bien identifier le satellite. En comparant les deux, le récepteur peut mesurer le retard entre l’émission et la réception du signal. Retard du au temps que met à parcourir le signal.
Pour calculer la pseudo-distance, on multiplie ce retard par la vitesse de l’onde (vitesse de la lumière).
Triangulation
Les horloges des satellites sont synchronisées sur la même source qu’on appelle le temps GPS. Si l’on reçoit 4 signaux de 4 satellites différents, on aura alors 4 pseudo-distances.
En résolvant une équation à 4 inconnues, on peut alors récupérer les coordonnées (x,y,z) du récepteur sur Terre ainsi que le décalage de son horloge par rapport à celles des satellites.
Alors, c’est quoi ces belles équations. En fait, elles représentent la distance réelle entre les satellites et le récepteur en appliquant le théorème de Pythagore en 3 dimensions avec X, Y et Z les coordonnées du satellite et U les coordonnées du récepteur que l’on recherche donc.
Puis on additionne l’erreur dû au décalage de l’horloge notée c qui est donc la différence de temps entre les 2 horloges.
On va pas rentrer dans les détails de comment résoudre ces équations, c’est trop complexe mais il y a 2 méthodes principales pour le faire (La méthode des moindres carrés et le filtre de Kalman). Si vous êtes curieux, vous pouvez y jeter un oeil ;)
Bref, une fois qu’on a résolut tout ça, on obtient les coordonnées (x,y,z) de U.
Latitude et Longitude
Bon, nous, on veut savoir exactement où on est sur Terre pour trouver notre route, et les x,y,z, ça nous arrange pas. Heureusement pour nous, on peut les convertir en latitude et longitude.
Déjà, faut comprendre que les coordonnées à base de latitude et longitude se base sur une approximation ellipsoïdale de la Terre. En soit c’est logique, on veut convertir des trucs 3D en des trucs en 2D, sur une carte quoi. Et le meilleur moyen de représenter notre planète bleue qui est plus ou moins une boule, c’est en utilisant une ellipsoïde de référence qui est définie par le modèle mathématique WGS 84.
Pareil, on va pas rentrer dans les détails, j’ai mis la page Wikipédia pour les curieux mais c’est avec un peu de trigonométrie que la conversion se passe.
Et voilà, on est capable de se positionner sur une carte 🗺️ ! On pourrait même aller plus loin pour connaître notre altitude mais ça se complexifie encore plus donc on laisse ça de côté pour le moment.
Merci d’avoir suivi ce cours :)
On pourra prochainement découvrir une attaque très populaire, le GPS Spoofing.
Lien vers un article qui m’a aidé pour ce cours
-
Writeup Hack-A-Sat : Linky
Description du challenge : Years have passed since our satellite was designed, and the Systems Engineers didn’t do a great job with the documentation. Partial information was left behind in the user documentation and we don’t know what power level we should configure the Telemetry transmitter to ensure we have 10 dB of Eb/No margin over the minimum required for BER (4.4 dB)
Le challenge est disponible à cette adresse
Le but de ce challenge est de trouver certains points d’un bilan de liaison (budget link) pour compléter une documentation afin d’aider les ingénieurs satellites.
Donc, lorsque l’on accède à l’instance on nous donne ça :
> docker run --rm -i linky:challenge
...
Here's the information we have captured
************** Global Parameters *****************
Frequency (Hz): 12100000000.0
Wavelength (m): 0.025
Data Rate (bps): 10000000.0
************* Transmit Parameters ****************
Transmit Line Losses (dB): -1
Transmit Half-power Beamwidth (deg): 26.30
Transmit Antenna Gain (dBi): 16.23
Transmit Pointing Error (deg): 10.00
Transmit Pointing Loss (dB): -1.74
*************** Path Parameters ******************
Path Length (km): 2831
Polarization Loss (dB): -0.5
Atmospheric Loss (dB): -2.1
Ionospheric Loss (dB): -0.1
************** Receive Parameters ****************
Receive Antenna Diameter (m): 5.3
Receive Antenna Efficiency: 0.55
Receive Pointing Error (deg): 0.2
Receive System Noise Temperature (K): 522
Receive Line Loss (antenna to LNA) (dB): -2
Receive Demodulator Implementation Loss (dB): -2
Required Eb/No for BER (dB): 4.4
Calculate and provide the receive antenna gain in dBi:
Ok, ça fait pas mal d’informations.
Calcul du gain
On va utiliser ce site. Ce dernier nous demande 3 paramètres :
L’efficacité de réception de l’antenne. Elle nous est donné, elle vaut 0.55.
La longueur d’onde. On l’a aussi, elle vaut 0.025m.
La surface d’aperture physique de l’antenne. Alors, ça on l’a pas mais on peut le calculer facilement. C’est juste la surface géométrique réelle qui capte ou émet les ondes. On nous donne le diamètre de notre antenne donc au final, sa surface physique, c’est juste son aire qui se calcule avec la formule π*r^2 avec r le rayon. Dans notre cas, il vaut r=5.3/2=2.65m
Donc, calculons cette surface : π*r^2=π*2.65^2=22. On peut à présent rentrer toutes nos valeurs dans le calculateur de gain :
Super, on a notre gain qui vaut à peu près 54dB. On peut répondre à la question et ça nous renvoit ceci :
Good job. You get to continue
Receive Antenna Gain (dBi): 54.00
Receive Half-power Beamwidth (deg): 0.33
Receive Pointing Error (deg): 0.2
Receive Pointing Loss (dB): -4.48
Okay, now we know the receive antenna gain.
Calculate and provide the ground terminal G/T (dB/K):
Calcul du G/T (Gain-To-Noise Temperature)
On a un calculateur pour ça qui utilise la formule suivante :
Pour l’antenna gain, on l’a calculé avant, il vaut 54 mais attention, on veut le G/T de la station de sol (ground terminal), pas juste de l’antenne donc il faut aussi prendre en compte les pertes de transmission qui nous sont donnés Receive Line Loss (antenna to LNA) (dB): -2. On parle de gain effectif dans le cas où on prend en compte les pertes. Le calcul reste le même pour autant. Donc, notre gain effectif vaut 54-2=52.
Le system noise temperature nous est donné à 522K.
Calculons tout ça :
Ok, très bien, on trouve 24.8dB/K
Calculate and provide the ground terminal G/T (dB/K): 24.8
Nicely done. Let's keep going.
Determine the transmit power (in W) to achieve 10dB of Eb/No margin (above minimum for BER):
SUPER ! On peut passer à la suite.
Calcul du Transit Power
À présent, on doit calculer la puissance de transmission pour atteindre une marge de 10dB de Eb/No au-dessus du minimum requis pour le taux d’erreur binaire (BER).
Le BER (Bit Error Rate) c’est la proportion de bits reçus avec des erreurs par rapport au nombre total de bits transmis.
Pour toute la suite, ce document va nous être bien utile si ce n’est indispensable :)
Ça nous dit que pour calculer le transmit power, il y a 3 étapes :
1 : Déterminer le Eb/No pour le BER voulu.
2 : Convertir le Eb/No en C/N (Carrier-to-Noise ratio).
3 : Ajouter les pertes de chemin et les marges d’affaiblissement.
1 : Déterminer le Eb/No
Le Eb/No pour le BER, on nous le donne, c’est 4.4dB.
2 : Convertir le Eb/No en C/N
On va utiliser ce calculateur qui se sert de cette formule.
On a besoin du bit rate, tant mieux, on nous le donne aussi, c’est 10000000.0bps donc 10Mbps.
On aussi besoin de la bande passante du récepteur. D’après l’exemple sur le pdf, ça vaut la moitié du bit rate donc 10/2=5MHz.
On remplit tout ça et on obtient C/N ≈ 7.4dB
3 : Ajouter les pertes et les marges
Carrier Power
Le carrier power (puissance de la porteuse) se calcule avec la formule suivante :
C = C/N * N ou en dB C = C/N + N avec C/N en db, N le noise power en W.
Noise Power
Donc, on doit d’abord calculer le Noise Power (Puissance du bruit) avec cette formule :
N = k * T * B avec k la constante de Boltzmann qui vaut 1.380650x10-23 J/K, T la température effective en Kelvin et B la bande passante du récepteur en Hz.
Quand on parle de puissance de bruit, on parle en réalité du bruit thermique généré par l’agitation thermique des électrons dans un conducteur, c’est pour ça qu’on utilise le Kelvin. Plus la température est élevée, plus les électrons s’agitent et plus le bruit est fort. Bref, calculons tout ça :
>>> boltzman = 1.38065e-23 # J/K
>>> data_rate = 10000000.0 # nous est donné
>>> bandwidth = data_rate / 2 # Hz
>>> effective_temperature = 290 # on prend la même que le PDF
>>> noise_power = boltzman * effective_temperature * bandwidth
>>> print(noise_power)
2.0019425e-14 # watts
Super, on a N = 2.0019425e-14W
Sauf qu’il ne faut pas oublier d’ajouter le bruit naturel auquel fait fasse notre récepteur. Ainsi, il faut aussi lui ajouter le noise figure qui mesure la dégradation du SNR en prenant comme référence une température de 290K (C’est une température de réference à laquelle les mesures de bruit sont normalisées). Le noise figure est un ratio alors que le noise power est une mesure absolue.
Noise Figure
On peut utiliser ce site pour récupérer ce dernier.
Le noise temp, il nous est donné à 522K et pour la reference temp, j’utilise la même que le guide donc 290K.
Et pour le noise power, on l’avait déjà calculé (2.0019425e-14) mais le résultat était en watt. Mettons le donc en dBm :
>>> import math
>>> noise_power_w = 2.0019425e-14 # W
>>> noise_power_mw = noise_power_w * 1000 # mW
>>> noise_power_dBm = 10*math.log10(noise_power_w) # dbm
>>> print(noise_power_dBm)
-106.98548400528693
On ajoute notre noise figure et noise temp : 4.4716 - 106.98548400528693 ≈ -102.5dBm
Et enfin, on a notre carrier power : C = 7.4 - 102.5 = -95.1dB.
Il s’agit de la puissance que reçoit le récepteur en entrée.
Path Loss
La path loss (pertes de propagation) en dB pour un site en plein air suivent cette formule : PL = 22dB + 20log(d/λ) avec d la distance entre l’émetteur et le récepteur. Et λ la longueur d’onde de la porteuse. Ces 2 valeurs nous sont déjà données.
>>> distance = 2831000 # m
>>> wavelength = 0.025 # m
>>> path_loss_dB = 22 + 20*math.log10(distance/wavelength) # dB
>>> print(path_loss_dB)
183.0799972138613
Okkk, on a notre PL=183.0799972138613
Transmit Power
On arrive au bout là, plus qu’à additionner tout ça ainsi que les autres pertes qui nous sont données et on aura enfin ce que l’on recherche, le transmit power
>>> transmit_line_losses = 1
>>> transmit_pointing_loss = 1.74
>>> polarization_loss = 0.5
>>> atmospheric_loss = 2.1
>>> ionospheric_loss = 0.1
>>> receive_pointing_loss = 4.48
>>> carrier_power_dBm = -95.1
>>> path_loss_dB = 183.0799972138613
>>> margin_dB = 10
>>> tx_antenna_gain_dBi = 16.23
>>> rx_antenna_gain_dBi = 54.00
>>> tx_power_dBm = transmit_line_losses + transmit_pointing_loss + polarization_loss + atmospheric_loss + ionospheric_loss + receive_pointing_loss + carrier_power_dBm + path_loss_dB + margin_dB - tx_antenna_gain_dBi - rx_antenna_gain_dBi # dBm
>>> tx_power_w = 10 ** (tx_power_dbm / 10) * 10**-3 # watt
>>> print(tx_power_W)
5.847897089829658
SUPER, donc notre puissance de transmission serait 5.8W.
Determine the transmit power (in W) to achieve 10dB of Eb/No margin (above minimum for BER): 5.8
Sorry, you lost
Wrong! Maybe next time.
AIE 🥲. Pourtant, le résultat est vraiment super cohérent.
Du coup, on va brute force, tant pis. Voici le script :
from pwn import *
context.log_level = "critical"
output = b"Wrong answer! You lose."
tx_power = 5.0
while b"Wrong" in output:
command = "docker run --rm -i linky:challenge"
p = process(command, shell=True)
p.recvuntil(b"Calculate and provide the receive antenna gain in dBi: ")
p.send(b"54\n")
p.recvuntil(b"Calculate and provide the ground terminal G/T (dB/K): ")
p.send(b"24.8\n")
p.recvuntil(b"Determine the transmit power (in W) to achieve 10dB of Eb/No margin (above minimum for BER): ")
print(f"Trying with Power Transmission = {tx_power:.1f}")
tx_power_formatted = f"{tx_power:.1f}\n"
p.send(tx_power_formatted.encode())
output = p.recv()
p.close()
tx_power += 0.1
print(output.decode())
On lance notre super script est … :
> p pouet.py
Trying with Power Transmission = 5.0
Trying with Power Transmission = 5.1
...
Trying with Power Transmission = 9.4
Trying with Power Transmission = 9.5
Winner Winner Chicken Dinner
OK, ça a l’air d’être 9.5W, un peu loin de ce que l’on a trouvé mais tant pis, on essaie cette valeur et let’s gooo, on a le flag !
Et voilà pour ce challenge avec pleins de calculs.
-
Comprendre les TLE et les orbites des satellites
Pour prédire le passage d’un satellite, il faut comprendre comment on décrit une orbite. Et pour ça, on a besoin de 6 paramètres. Ils nous permettront d’avoir une représentation standardisée que l’on nomme TLE (Two Line Elements).
Dans ce cours, on va explorer chacun de ces paramètres qui ont des noms barbares mais je vais tenter de les expliquer à ma manière avec une approche simpliste en utilisant le super site Orbital Mechanics alors tenez bon et ne fuyez pas :)
Le demi-grand axe
Noté a, il représente la moitié du grand axe d’une ellipse.
Voilà ce que ça donne quand on modifie cette valeur :
L’excentricité
Noté e, ça représente l’aplatissement d’une ellipse. Elle se calcule à partir des longueurs du demi-grand axe a et du demi-petit axe b avec cette formule.
Pour e=0, on a un cercle parfait (orbite & chemin fermé).
Pour 0<e<1, on a une ellipse (orbite & chemin fermé). C’est ce type d’excentricité qu’on aura affaire pour les satellites.
Pour e=1, on a une parabole (trajectoire ouverte).
Pour e>1, on a une hyperbole (trajectoire ouverte).
Changement de e :
L’inclinaison
Noté i, c’est l’angle d’inclinaison du plan de l’orbite par rapport au plan équatorial.
On comprend mieux comme ça :
En bleu, c’est le plan de l’orbite terrestre.
En orange, c’est le plan de l’orbite du satellite.
On distingue 3 types d’inclinaison :
0°≤i≤90° : Prograde, le sens de l’orbite est le même que le sens de rotation de la Terre (ouest vers l’est).
90°<i≤180° : Rétrograde, le sens de l’orbite est à l’inverse du sens de rotation de la Terre (est vers l’ouest).
i=90° : Orbite polaire, cas particulier qui couvre toutes les latitudes.
Longitude du nœud ascendant
Oui, toujours plus compliqué. Noté Ω, c’est l’angle entre le nœud ascendant et le point vernal.
D’abord, la notion de nœud ascendant et tant qu’on y est de nœud descendant avec ce schéma explicite :
Donc, le nœud ascendant, c’est le croisement entre le plan de l’orbite terrestre et celle du satellite lorsque ce dernier “remonte”.
Le nœud descendant, c’est pareil mais inversement.
Ok, et maintenant le point vernal. En gros, c’est le nœud ascendant de l’orbite du Soleil avec celle de la Terre.
L’écliptique, c’est l’orbite que décrit le Soleil autour de la Terre.
L’équateur céleste, c’est le plan défini par l’équateur terrestre.
Et donc, pour en revenir à nos aliens moutons, je répète que la longitude du nœud ascendant, c’est l’angle entre le nœud ascendant et le point vernal.
Bon, j’avoue, c’est le plus dur de tous à assimiler mais voyons ce que si passe quand on change cet angle :
L’argument du Périastre
Noté ω, c’est l’angle entre le nœud ascendant et le périastre.
Donc le périastre, c’est le point sur l’orbite où le satellite est au plus proche de l’astre autour duquel il tourne.
Si l’astre c’est la Terre, on parle de périgée et d’apogée (périhélie et aphélie pour le Soleil).
Voyons ce qui se passe quand on change cet valeur :
L’anomalie vraie
Noté 𝜈, c’est l’angle entre le périastre d’une orbite et la position actuelle du satellite. En fait, c’est ce paramètre qui nous permet de situer le satellite sur notre orbite. Sur le schéma ci-dessous, en fonction de l’angle, le satellite sera à différents endroits sur l’orbite.
Donc voilà, on a :
La taille et la forme de notre orbite grâce au demi-grand axe et l’excentricité.
L’orientation de l’orbite grâce à l’inclinaison, la longitude du nœud ascendant et l’argument du périastre.
La position du satellite grâce à l’anomalie vraie.
TLE (paramètres orbitaux à deux lignes)
Il existe un standard pour représenter les paramètres d’une orbite, c’est les TLE (Two Lines Elements).
On y retrouve sur la deuxième ligne les paramètres qu’on a appris.
Sur la première ligne, on a des informations concernant le satellite comme son NORAD ID.
Et c’est bon, on a réussi à arriver jusqu’au bout, BRAVO 😎.
Retenez surtout qu’on va souvent utiliser les TLE car c’est grâce à eux qu’on pourra prédire le passage d’un satellite à un endroit bien précis.
Pour ceux qui auraient besoin d’une autre représentation visuelle, y a cette super vidéo.
Touch background to close
