Browse Source

Initial commit

main
Miraty 1 month ago
commit
5bd2bcaad1
  1. 6
      .gitignore
  2. 14
      config.ini
  3. 9
      src/ca.md
  4. 25
      src/crypto.md
  5. 58
      src/css.md
  6. 18
      src/dig.md
  7. 279
      src/dns.md
  8. 52
      src/gemini.md
  9. 40
      src/glue-record.md
  10. 16
      src/html.md
  11. 3
      src/http.md
  12. 7
      src/hypertext.md
  13. 38
      src/index.md
  14. 17
      src/ip.md
  15. 192
      src/markdown.md
  16. 63
      src/sftp.md
  17. 3
      src/tls.md
  18. 36
      src/tor.md
  19. 37
      src/units.md
  20. 3
      src/zone.md

6
.gitignore

@ -0,0 +1,6 @@
*.gmi
*.html
*.html.gz
*.md
!/src/*.md
/css/*

14
config.ini

@ -0,0 +1,14 @@
; Used in <title> and <header>
siteTitle = "Documentation de Niver"
; Whether to advertise the CSS file in the HTML document or not
css = false
; Whether to add a <header> tag to the HTML document or not
header = false
; Whether to center text on indexes or not
centerIndex = true
; Which language to add to <html lang="?"> if not found in file extension
defaultLang = "fr"

9
src/ca.md

@ -0,0 +1,9 @@
# Les autorités de certification
Dans TLS, une autorité de certification est un organisme qui a acquis la confiance d'autres systèmes numériques pour garantir l'identité d'un serveur.
À la demande d'un serveur, l'autorité s'assurera de son identité puis signera avec sa clé privée le certificat publique du serveur et lui enverra cette signature. Lorsqu'un client se connectera au serveur, celui-ci enverra en plus de son certificat publique la signature transmise par l'autorité de certification. Le client pourra déchiffrer cette signature avec la clé publique de l'autorité de certification et s'il a confiance en cette dernière, aura aussi confiance en l'authenticité du certificat publique du serveur.
souhaitant permettre au client de s'assurer de son authenticité.
La plupart des autorités de certification sont des entreprises qui font payer la certification, mais [Let's Encrypt](https://letsencrypt.org/) est à but non lucratif et sa certification est gratuite.

25
src/crypto.md

@ -0,0 +1,25 @@
# La cryptographie
La cryptographie est un procédé de modification et de formation de messages afin de garantir les propriétés suivantes :
confidentialité
: Le message n'est compréhensible que par les personnes à qui il est destiné.
authenticité
: Je peux vérifier que le message provient de et se destine aux bonnes personnes.
intégrité
: On peut vérifier que le message n'a pas été altéré.
## Hashage
Le hashage cryptographique consiste en la formation à partir d'une information d'une empreinte avec les propriétés suivantes :
* taille fixe
* des information différentes auront forcément une empreinte différente
## Chiffrement
## Cryptographie symétrique
## Cryptographie asymétrique

58
src/css.md

@ -0,0 +1,58 @@
# Les CSS
CSS, acronyme de Cascading Style Sheet, en français feuille de style en cascade, est la norme utilisée par un site Web pour indiquer aux navigateurs comment une page doit être affichée. Les CSS n'apportent pas de sens au document, seulement une apparence graphique.
La structure de base d'une règle en CSS est la suivante :
```css
élément-ciblé {
propriété: valeur;
}
```
## Cibler un élément
## Les propriétés
### `color`
Spécifie la couleur du texte. Prend une valeur de type couleur.
### `background-color`
Spécifie la couleur de fond. Prend une valeur de type couleur.
### `font-size`
Spécifie taille du texte. Prend une valeur de type taille.
## Les valeurs
### Couleurs
L'indication de couleur par mot-clé est la plus simple pour commencer. L'utilisation de code hexadécimal est plus compliquée, mais permet de choisir précisément la couleur recherchée.
#### Mot-clé
Il suffit d'indiquer le nom de la couleur en anglais.
-Insérer lien vers la liste de mot clé de MDN-
#### Hexadécimale
La notation de couleur hexadécimale représente les valeurs de rouge, de vert et bleu par 2 chiffres hexadécimaux chacun.
Un chiffre hexadécimal représente une valeur ordinale en base 16, c'est à dire qu'il utilise un ensemble de 16 symboles/chiffres (`0123456789abcdef`) pour représenter les nombres, au lieu des 10 dont on a l'habitude.
En CSS, une couleur hexadécimale est toujours précédée d'un dièse (`#`).
Quelques exemples simples :
* Du rouge : `#ff0000`
* Du vert : `#00ff00`
* Du jaune (du rouge, du vert, pas de bleu) : `#ffff00`
Pour copier le code hexadécimal d'une couleur présente sur une page Web dans les navigateurs basés sur Firefox, on peut aller dans `Menu` > `Développement Web` > `Pipette`.
La plupart des logiciels de dessins intègrent des sélecteur de couleur qui affichent la valeur en hexadécimal. Celui de [Gimp](https://gimp.org) par exemple.
### Taille

18
src/dig.md

@ -0,0 +1,18 @@
# Utilisation de Dig
Dig est un utilitaire commun sur GNU/Linux et la plupart des systèmes UNIX.
Sa syntaxe fondamentale est la suivante :
`dig <domaine> <type>`
On peut ajouter à cette commande :
* `@<serveur>` pour préciser le serveur auprès duquel effectuer la requête
* +dnssec pour obtenir aussi les enregistrements liés à DNSSEC (RRSIG...)
* +short pour n'obtenir que les résultats bruts, sans toutes les métadonnées
## Exemples
```
$ dig wikipedia.org AAAA +short
```

279
src/dns.md

@ -0,0 +1,279 @@
# Le DNS
Le DNS (Domain Name System) est un système de distribution d'informations correspondant à des noms de domaines. Il est notamment utilisé pour obtenir des adresses IP à partir d'un nom de domaine, mais peut servir à obtenir n'importe quelle information suffisamment courte à partir d'un nom de domaine.
1. Le client DNS demande l'adresse IPv6 de `fr.wikipedia.org.` à un résolveur DNS récursif
2. Le résolveur DNS récursif demande l'adresse de `fr.wikipedia.org.` à `.`, l'un serveur racine.
3. Le serveur racine ne connait pas cette information, mais il sait comment s'en rapprocher : il répond l'adresse du serveur qui gère `org.`.
4. Le résolveur DNS récursif demande l'adresse de `fr.wikipedia.org.` au serveur de `org.`
5. Le serveur qui gère `org.` n'a pas cette information, mais sait comment s'en rapprocher et répond l'adresse du serveur qui gère `wikipedia.org.`.
6. Le résolveur DNS récursif demande l'adresse de `fr.wikipedia.org.` au serveur qui gère `wikipedia.org.`.
7. Cette information se trouve directement dans la zone servie par ce serveur, il lui répond donc l'adresse IPv6 de `fr.wikipedia.org.`.
8. Le résolveur DNS récusif répond finalement l'adresse IPv6 reçue au client DNS qui avait initié la demande.
## Les enregistrements DNS
Un enregistrement DNS est composé de plusieurs parties :
```
<domaine> <classe> <type> <ttl> <contenu>
```
`<domaine>`
: Le domaine concerné par l'enregistrement
`<classe>`
: Toujours IN (pour Internet)
`<type>`
: Le type de donnée contenue, voir description des types possible après dans la page
`<ttl>`
: Temps pendant lequel l'enregistrement peut être gardé en cache
`<contenu>`
: Dépends du type d'enregistrement
## Le cache
En réalité, un résolveur DNS récursif correct ne fera pas toutes ces requêtes à chaque fois. Il garde les données reçu des serveurs ayant autorité pendant la période de validité indiquée par ceux-ci, cette période s'appelle le TTL (Time-To-Live, temps à vivre). Cela permet de ne pas surcharger les serveurs ayant autorité les plus haut placés, qui devraient sans le cache des résolveurs répondre à beaucoup plus de requêtes.
Ce mécanisme signifie toutefois que la modification d'un enregisrement n'est assurée d'être effective partout qu'une fois que la durée du TTL précédent a expiré.
## Les enregistrements multiples
Il peut exister plusieurs valeurs pour un même type d'enregistrement et même domaine.
Ainsi, il est probable que le résolveur reçoivent plusieurs adresses de serveurs ayant autorité pour un domaine ou que le client recoive plusieurs adresses IPv6 pour le domaine demandé ; le résolveur ou le client n'utilisera alors généralement qu'une seule de ces adresses, choisie aléatoirement. Si jamais l'adresse ne fonctionne pas, l'une des autres adresses reçues sera essayée, ce qui permet une meilleure résistance aux pannes de serveurs.
## DNSSEC
DNSSEC est un système permettant de signer les données du DNS afin de permettre la vérification de leur intégrité.
Toutes les enregistrements DNS sont signés par le serveur ayant autorité dans la zone, et sa clé publique est publiée dans la zone parente. Pour la clé publique du serveur racine, qui n'a pas de zone parente, elle est préchargée dans les client DNS qui valident DNSSEC.
## Types d'enregistrements
### NS
Un enregistrements NS indique le serveur de noms qui a autorité pour un domaine. Pour s'assurer de la disponibilité du DNS, on en utilise généralement plusieus hébergés à des endroits différents, afin de mitiger les pannes.
Doit pointer vers un domaine qui dispose d'un enregistrement A/AAAA.
```
domain.exemple. 10800 IN NS ns1.dnshost.exemple.
domain.exemple. 10800 IN NS ns2.dnshost.exemple.
domain.exemple. 10800 IN NS ns3.dnshost.exemple.
```
### A et AAAA
Permet l'enregistrement d'une adresse au format IPv4 pour A et IPv6 pour AAAA
Il est recommandé d'indiquer les 2 si possible :
- l'IPv4 pour être compatible avec les infrastructures internet vétustes qui sont encore nombreuses
- l'IPv6 pour être compatible avec l'internet moderne qui offre plus de possibilités
```
host.exemple. 10800 IN AAAA 2001:db8::3
host.exemple. 10800 IN A 203.0.113.42
```
### TXT
Contient du texte.
```
antopie.org. 172800 IN TXT "v=spf1 a mx -all"
```
### CAA
Limiter les autorités de certification autorisées à émettre des certificats
```
antopie.org. 172800 IN CAA 0 issue "letsencrypt.org"
antopie.org. 172800 IN CAA 0 iodef "mailto:miraty+caa@antopie.org"
```
### SRV
Indiquer l'adresse d'un service spécifique.
Note : pour des raisons historiques et malgré la meilleure flexibilité permise par les enregistrements `SRV`, le DNS utilise les enregistrements `NS`, SMTP utilise le plus souvent les enregistrements `MX`, et HTTP utilise le plus souvent directement les enregistrements `A`/`AAAA`.
#### Syntaxe
```
_<service>._<protocole>.exemple. 10800 IN SRV <malus> <poids> <port> <cible>
```
`<service>`
: Nom arbitraire du service (exemples : `submission`, `imap`, `imaps`, `http`, `mumble`, `xmpp-server`, `xmpp-client`, `matrix`, `ldap`, `stun`, `stuns`, `turn`, `turns`...)
`<protocole>`
: Protocole de transport sur IP, selon le service généralement `tcp` ou `udp`
`<malus>` [0-65535]
: Les enregistrements avec la plus petite valeur seront utilisés d'abord
Un enregistrement ne sera utilisé que si les enregistrements avec un malus moindre ne sont pas joignables.
`<poids>` [0-65535]
: Pour des enregistrements avec le même malus, la probabilité d'être d'utilisé est proportionnelle à cette valeur
`<port>`
: Port de l'hôte du service
`<cible>`
: Domaine absolu de l'hôte du service
#### Exemples
```
_matrix._tcp.im.exemple. 86400 IN SRV 10 0 8448 a.im.exemple.
_matrix._tcp.im.exemple. 86400 IN SRV 5 50 1312 b.im.exemple.
_matrix._tcp.im.exemple. 86400 IN SRV 5 25 8448 c.im.exemple.
```
Signifie : Pour le service Matrix de `im.exemple` :
1. Utiliser avec 1 chance sur 3 `c.im.exemple:8448` et avec 2 chances sur 3 `b.im.exemple:1312`
2. Si aucun de ces 2 serveur n'est joignable, utiliser `a.im.exemple:8448`
```
_xmpp-client._tcp.im.example. 86400 IN SRV 5 0 5222 xmpp.im.example.
_xmpp-server._tcp.im.example. 86400 IN SRV 5 0 5269 xmpp.im.example.
```
### MX
Indiquer l'adresse du serveur recevant les courriels
```
example. 172800 IN MX 10 smtp.exemple.
```
### SSHFP
Indiquer les empreintes des clés SSH
#### Algorithme
1
: RSA
2
: DSA
3
: ECDSA
4
: Ed25519
6
: Ed448
#### Type
1
: SHA-1
2
: SHA-256
#### Exemples
```
ssh.example. SSHFP 4 2 7df9c981c9228fc9e4bff50e1d1ef8774a0f3496179f48fc8041ba746315c87a
```
### TLSA
Mettre en place DANE, pour permettre l'authentification des entitées nommée par le DNS
#### Usage
0 (PKIX-TA)
: Le certificat de l'entité doit être signé par ce certificat, ainsi que par une autorité de certification confiancée par le client
1 (PKIX-EE)
: Le certificat de l'entité doit être le même, et doit être signé par une autorité de certification confiancée par le client
2 (DANE-TA)
: Le certificat de l'entité doit être signé par ce certificat, et n'a pas à être signé par une autorité de certification
3 (DANE-EE)
: Le certificat de l'entité doit être le même, et n'a pas à être signé par une autorité de certification
#### Selecteur
0
: Certificat entier
1
: Seulement la clé publique du certificat
#### Méthode de correspondance
0
: Directe
1
: SHA-256
2
: SHA-512
#### Exemple
```
_443._tcp.host.example. 172800 IN TLSA 2 1 1 0B9FA5A59EED715C26C1020C711B4F6EC42D58B0015E14337A39DAD301C5AFC3
```
### CNAME
Définir un domaine comme étant l'alias d'un autre
```
blog.example. 86400 IN CNAME host.example.
www.example. 86400 IN CNAME host.example.
play.example. 86400 IN CNAME host.example.
host.example. 10800 IN AAAA 2001:db8::3
host.example. 10800 IN A 203.0.113.42
```
### DNAME
Définir les sous-domaines d'un domaine comme étant les alias des sous-domaines d'un autre domaine
### LOC
Indiquer des coordonnées géographiques
```
d1 [m1 [s1]] "N"|"S" d2 [m2 [s2]] "E"|"W" alt["m"] [siz["m"] [hp["m"] [vp["m"]]]]
```
Avec :
`d1` [0 .. 90]
: Degrés en latitude
`d2` [0 .. 180]
: Degrés en longitude
`m1`, `m2` [0 .. 59]
: Minutes
`s1`, `s2` [0 .. 59.999]:
: Secondes
`alt` [-100000.00 .. 42849672.95]
: Altitude en mètres
`siz`, `hp`, `vp` [0 .. 90000000.00]
: (size/precision in meters)
```
exemple. 172800 IN LOC 49 0 0.000 N 2 0 0.000 W 0.00m 10m 0.00m 0.00m
```

52
src/gemini.md

@ -0,0 +1,52 @@
# Gemini
Gemini est un protocole et un format de fichier, destinés à être utilisés ensemble dans un système hypertexte.
Gemini est axé sur les objectifs de :
* Simplicité d'implémentation
* Simplicité d'utilisation
* Confidentialité
## Le protocole
Le protocole Gemini permet simplement à un client de demander une ressource et au serveur de lui envoyer, avec son type MIME.
C'est HTTP avec seulement la méthode GET, pas de cookies, pas d'en-têtes envoyées par le client.
La communication est chiffrée avec TLS, mais sans vérifier l'authenticité des certificats (TOFU).
## Le format de fichier
Le format de fichier Gemini permet de décrire un document, d'après une syntaxe ressemblant à du [Markdown](markdown.md) simplifié.
### Les titres
Les titres sont définit comme en Markdown, en mettant un `#` devant :
```
# Titre principal
## Sous-titre
### Sous-sous-titre
```
### Les liens
On créé un lien hypertexte en préfixant une adresse par une flèche : `=> `. Si il y a du texte qui suit une première espace dans l'adresse, ce sera le titre du lien.
```gemtext
=> about.gmi À propos
=> gemini://gemini.exemple/ Un exemple de capsule Gemini
=> https://www.exemple/blog/
```
```markdown
[about.gmi](À propos)
[gemini://exemple/](Un exemple de capsule Gemini)
<https://www.exemple/blog/>
```
```html
<a href="about.gmi">À propos</a>
<a href="gemini://exemple/">Un exemple de capsule Gemini</a>
<a href="https://www.exemple/blog/">https://www.exemple/blog/</a>
```

40
src/glue-record.md

@ -0,0 +1,40 @@
# Glue record
Lorsqu'un résolveur DNS doit résoudre un domaine dont l'adresse du serveur de noms se trouve sur ce domaine (ou plus souvent, sur un sous-domaine), il se trouve bloqué car seul le serveur de noms en question connaît sa propre adresse IP.
Pour remédier à ce problème, le serveur de noms parent va envoyer en plus de l'enregistrement NS les enregistrements A ou AAAA correspondant à cet enregistrement NS.
N.B. : Un glue record n'est possible et utile que si l'adresse d'un serveur de nom est située dans un sous-domaine de la zone dont il a autorité.
## Exemple
Le résolveur DNS veut résoudre `niver.atope.art.`. Lors de son processus récursif de résolution, le serveur ayant autorité sur `art.` va répondre que le serveur de noms de la zone `atope.art.` est `ns1.atope.art.` (par un enregistrement NS), mais il va aussi répondre que les adresse IP de ce nom de domaine sont `45.13.104.169` et `2a0b:cbc0:1103:2::106f` (respectivement par des enregistrements A et AAAA).
### Tester le glue record de cet exemple avec dig
D'abord, obtenir les noms de domaine des serveurs de noms étant censés envoyer le glue record :
```
$ dig +short art. NS
d.nic.art.
a.nic.art.
c.nic.art.
b.nic.art.
```
Ensuite, en utilisant l'un des serveurs répondus à la requête précédente :
`dig atope.art. NS @c.nic.art.`
La réponse contiendra une section additionnelle avec les glue records :
```
;; AUTHORITY SECTION:
atope.art. 3600 IN NS ns1.atope.art.
;; ADDITIONAL SECTION:
ns1.atope.art. 3600 IN A 203.0.113.42
ns1.atope.art. 3600 IN AAAA 2001:db8::3
```
-> Passer un domaine précédé d'une arobase en argument à `dig` lui indique le serveur de noms auprès duquel effectuer la requête.

16
src/html.md

@ -0,0 +1,16 @@
# Le format de fichier HTML
HTML, acronyme de HyperText Markup Language, en français langage de balisage pour l'hypertexte, est un langage de mise en page pour des documents hypertextes.
```html
<!DOCTYPE html>
<html>
<head>
<title><!-- Titre de la page compréhensible hors-contexte --></title>
<!-- Autres métadonnées du document -->
</head>
<body>
<!-- Contenu du document -->
</body>
</html>
```

3
src/http.md

@ -0,0 +1,3 @@
# Le protocole HTTP
HTTP, acronyme de HyperText Transfert Protocol, en français protocole de transfert pour l'hypertexte, est un protocole Internet pris en charge par les navigateurs et serveurs Web pour transférer des fichiers. À l'origine, il avait été créé pour transférer des document HTML, mais l'immense succès du Web a généralisé son utilisation à la plupart des échanges de données entre client et serveurs.

7
src/hypertext.md

@ -0,0 +1,7 @@
# L'hypertexte
L'hypertexte est le concept d'un texte informatique qui contient des liens vers d'autres textes en rapport avec ce texte, ainsi que le résultat de la mise en pratique de ce concept.
Ses utilisataires peuvent ainsi créer leur propre parcours sur l'hypertexte, en ne lisant que les informations qui les intéressent et dans l'ordre qu'oles souhaitent.
C'est le principe à l'origine du Web et de Gemini.

38
src/index.md

@ -0,0 +1,38 @@
# Documentation de Niver
## Les bases
[Les unités binaires](units.md)
[Le protocole Internet](ip.md)
[La cryptographie](crypto.md)
## DNS
[Le DNS](dns.md)
[Les zones DNS](zone.md)
[Les glue records](glue-record.md)
[Le logiciel Dig](dig.md)
## Hypertexte
### Chiffrement
[Le protocole TLS](tls.md)
[Les autorités de certification](ca.md)
[Le réseau Tor](tor.md)
### Transport
[Le protocole HTTP](http.md)
[Le protocole SFTP](sftp.md)
### Languages
[Le language Markdown](md.md)
[Le language HTML](html.md)
[Le language CSS](css.md)

17
src/ip.md

@ -0,0 +1,17 @@
# Le protocole Internet
Le protocole Internet (Internet Protocol, IP) est le plus essentiel protocole qui soit commun à tout internet.
Il existe 2 versions qui sont utilisées : IPv4 et IPv6.
## IPv4
Les adresse IPv4 sont composées de 4 nombres entre 0 et 255 séparés par des points (`.`), par exemple : `203.0.113.42`.
Ceci permet de stocker les adresses sur 32 bits, soit 4 294 967 296 possibilités.
## IPv6
Les adresses IPv6 sont composées de 8 blocs de 4 chiffres hexadécimaux séparés par des `:`, par exemple `2001:0db8:0000:0000:0000:8a2e:0370:7334`. Elles peuvent toutefois être raccourcies, par exemple `2001:db8::8a2e:370:7334`.
Ceci permet de stocker les adresses sur 128 bits, soit 340 282 366 920 938 463 463 374 607 431 768 211 456 possibilités.

192
src/markdown.md

@ -0,0 +1,192 @@
# Le format de fichier Markdown
Markdown est un langage créer pour simplifier la rédaction de texte, dans le but d'être transformer en HTML.
## Les titres
Une ligne qui commence par `#` est un titre. L'imporance du titre est définie par le nombre de `#`.
Markdown :
```
# Titre de niveau 1
###### Titre de niveau 6
```
Équivalent HTML :
```
<h1>Titre de niveau 1</h1>
<h6>Titre de niveau 6</h6>
```
## Les liens
Markdown :
```
[Texte du lien](https://example/chemin)
```
Équivalent HTML :
```
<a href="https://example/chemin">Texte du lien</a>
```
Résultat :
[Texte du lien](https://example/chemin)
## Les images
Markdown :
```
![Texte alternatif](https://example/image)
```
Équivalent HTML :
```
<img src="https://example/image" alt="Texte alternatif">
```
## Texte préformatté en ligne
Markdown :
```
Lister les dossier dans le fichier : `ls`
```
Équivalent HTML :
```
Lister les dossier dans le fichier : <code>ls</code>
```
Résultat :
Lister les dossier dans le fichier : `ls`
## Texte préformatté en bloc
Équivalent HTML :
```
<pre>
$ make
# make install
</pre>
```
Résultat :
```
$ make
# make install
```
## Citation
Markdown :
```
> J'ai faim.
```
Équivalent HTML :
```
<blockquote><p>J'ai faim.</p></blockquote>
```
Résultat
> J'ai faim.
## Emphase
Markdown :
```
J'ai réussi *in extremis*.
```
Équivalent HTML :
```
J'ai réussi <em>in extremis</em>.
```
Résultat :
J'ai réussi *in extremis*.
## Importance
Markdown :
```
Les kangourous vivent en **Australie**.
```
Équivalent HTML :
```
Les kangourous vivent en <strong>Australie</strong>.
```
Résultat :
Les kangourous vivent en **Australie**.
## Liste
Markdown :
```
* 12g de farine
* 8g de beurre
* 6g de sucre
```
Équivalent HTML :
```
<ul>
<li>12g de farine</li>
<li>8g de beurre</li>
<li>6g de sucre</li>
</ul>
```
Résultat :
* 12g de farine
* 8g de beurre
* 6g de sucre
## Liste ordonnée
Markdown :
```
1) Mettre la farine dans un saladier
2) Ajouter le beurre et mélanger
3) Verser le sucre petit à petit en continuant de mélanger
```
Équivalent HTML :
```
<ol>
<li>Mettre la farine dans un saladier</li>
<li>Ajouter le beurre et mélanger</li>
<li>Verser le sucre petit à petit en continuant de mélanger</li>
</ol>
```
Résultat :
1) Mettre la farine dans un saladier
2) Ajouter le beurre et mélanger
3) Verser le sucre petit à petit en continuant de mélanger
## Séparateur
Markdown :
```
***
```
Équivalent HTML :
```
<hr>
```
Résultat :
***

63
src/sftp.md

@ -0,0 +1,63 @@
# Le protocole SFTP
SFTP est un protocole basé sur la cryptographie utilisée dans SSH, qui permet de transferrer des fichiers sur le modèle client-serveur.
## Clients SFTP
Il existe plusieurs clients SFTP.
### En ligne de commande (CLI)
#### SSHFS
La commande `sshfs` permet de monter un dossier SFTP dans l'arborescence de fichiers de son système.
`sshfs -p <port> <utilisataire>@<serveur>:<chemin distant> <chemin local>`
Les logiciels du système local pourront ainsi accéder au contenu en passant par `<chemin local>`, sans se soucier qu'ils supportent SFTP ou non.
Pour se déconnecter : `umount <chemin local>`
* Nom du paquet Debian : `sshfs-fuse`
* Nom du paquet Arch Linux : `sshfs`
* Nom du paquet Fedora : `fuse-sshfs`
* Page Repology : <https://repology.org/project/fusefs:sshfs/versions>
#### OpenSSH
OpenSSH founit la commande `sftp` qui a pour syntaxe : `sftp -P <port> <utilisataire>@<serveur>`.
* Nom courant du paquet sur GNU/Linux : `openssh`
* Page Repology : <https://repology.org/project/openssh/versions>
### Graphiques
#### Dolphin
Dolphin est l'explorateur de fichiers de KDE. Pour se connecter à un serveur SFTP avec Dolphin, saisir l'URL SFTP dans la barre d'addresse.
Nom courant du paquet sur GNU/Linux : `dolphin`
Page Repology : <https://repology.org/project/dolphin-fm/versions>
#### GNOME Fichiers
GNOME Fichiers est l'explorateur de fichiers de GNOME.
* Nom courant du paquet sur GNU/Linux : `nautilus`
* Page Repology : <https://repology.org/project/nautilus/versions>
#### Thunar
Thunar est l'explorateur de fichiers de XFCE.
* Nom courant du paquet sur GNU/Linux : `thunar`
* Page Repology : <https://repology.org/project/thunar/versions>
#### FileZilla
FileZilla est un logiciel spécialisé dans le transfert de fichiers par Internet.
* Nom courant du paquet sur GNU/Linux : `filezilla`
* Page Repology : <https://repology.org/project/filezilla/versions>
* Aussi disponible pour Windows et macOS : <https://filezilla-project.org/>

3
src/tls.md

@ -0,0 +1,3 @@
# Le protocole TLS
TLS (Transport Layer Security) est un système cryptographique permettant de chiffrer le traffic entre un client et un serveur.

36
src/tor.md

@ -0,0 +1,36 @@
# Le réseau Tor
Tor (acronyme de The Onion Router, en français le routeur en ognon) est un réseau d'anonymisation de connexion construit par dessus Internet. Il permet à ses utilisataires de relayer leur connexion par des ordinateurs intermédiaires afin de ne pas communiquer leur propre adresse IP.
Le réseau Tor est composé de milliers d'ordinateurs bénévoles connectés à différentes connexions Internet et endroits du monde (surtout aux États-Unis, en France, en Allemagne et aux Pays-Bas).
Lorsqu'ane utilisataire souhaites établir une connexion Internet en utilisant Tor comme intermédiaire, son client Tor demande la liste de tous les relais à l'un des relais qu'il a préchargé, puis choisit 3 de ces relais pour les utiliser en chaîne.
Client Tor <=> Relai A (dit garde) <=> Relai B <=> Relai C (dit de sortie) <=> Autre ordinateur connecté à Internet
Dans cette chaîne, chaque élément ne connaît que les identités (les addresses IP) de ses voisins directs (à par le client qui les connaît toutes).
Les informations sont réparties entre les maillons de la chaîne de sorte que personne ne sache qui a fait quoi :
* A : Le relai garde sait qui utilise le réseau Tor, mais pas pour faire quoi.
* B : Le relai central ne sais rien du tout.
* C : Le relai de sortie peut lire et modifier toutes les données à la sortie du réseau Tor, mais il ne sais pas qui a initié cette connexion.
Que ce soit dans une utilisation normale d'Internet pour se protéger de son FAI, ou dans une utilisation de Tor pour se protéger du relai de sortie, l'utilisation de la cryptographie pour le chiffrement de bout en bout est toujours nécessaire pour garantir la confidentialité et l'intégrité des données échangées entre les ordinateurs aux extrémités du réseau.
## Services Onion
Tor permet également d'être utilisé pour rendre accessible un service réseau.
### Avantage par rapport à un site IP+DNS+TLS
* Pas besoin de pouvoir recevoir de connexion, il suffit de pouvoir en émettre
* Pas besoin de nom de domaine
* Pas besoin d'autorité de certification
* Chiffré de bout en bout
* Plus anonyme
### Désavantage par rapport à un site IP+DNS+TLS
* Ne marche que depuis le réseau Tor, qui est plus lent qu'une connexion directe
* C'est plus compliqué d'écrire l'adresse de mémoire ou de vérifier l'identité du site

37
src/units.md

@ -0,0 +1,37 @@
# Les unités binaires
L'informatique utilise une représentation de l'information basée sur le binaire.
bit (b)
: Un chiffre binaire, représenté par un `0` ou un `1`.
octet (o) (en anglais byte (baïte) (B))
: Un groupement de 8 bits, par exemple `01101011`.
## Multiples en préfixes binaires
kibioctet (Kio)
: 1024 octets ; 2<sup>10</sup>octets
mébioctet (Mio)
: 1024 kibioctets ; 2<sup>20</sup>octets
gibioctet (Gio)
: 1024 mébioctets ; 2<sup>30</sup>octets
tébioctet (Tio)
: 1024 tébioctets ; 2<sup>40</sup>octets
## Multiples en préfixes décimaux
kilooctet (Ko)
: 1000 octets ; 10<sup>3</sup>octets
mégaoctet (Mo)
: 1000 kilooctets ; 10<sup>6</sup>octets
gigaoctet (Go)
: 1000 mégaoctets ; 10<sup>9</sup>octets
téraoctet (Mo)
: 1000 gigaoctets ; 10<sup>12</sup>octets

3
src/zone.md

@ -0,0 +1,3 @@
# Les zones DNS
Une zone DNS est un ensemble d'enregistrements pour un domaine et ses sous-domaines qui ne sont pas délégués.
Loading…
Cancel
Save