Browse Source

initial

master
commit
76b30a0078
172 changed files with 80965 additions and 0 deletions
  1. +88
    -0
      Makefile
  2. +13
    -0
      README.md
  3. BIN
      __pycache__/pelicanconf.cpython-34.pyc
  4. BIN
      cache/ArticlesGenerator-Readers
  5. BIN
      cache/PagesGenerator-Readers
  6. BIN
      content/.markdown.md.swp
  7. +152
    -0
      content/2013-07-10.12:44:28.md
  8. +262
    -0
      content/archlinux-made-simple.md
  9. +147
    -0
      content/comment-saurik-a-roote-les-google-glass.md
  10. +36
    -0
      content/debuts-presentation-etc.md
  11. +244
    -0
      content/dns.md
  12. +84
    -0
      content/gnulinux-pour-les-non-technophiles-ou-los-libre-pour-votre-grand-mere.md
  13. +158
    -0
      content/introduction-a-bash-en-tant-que-language-de-programmation.md
  14. +177
    -0
      content/la-cryptographie-avec-pgp-et-principalement-gnupg.md
  15. +75
    -0
      content/la-programmation-expliquee-simplement.md
  16. +108
    -0
      content/la-separation-des-eglises-et-de-letat-une-idee-quelle-est-bonne.md
  17. +44
    -0
      content/le-quenya-episode-o.md
  18. +94
    -0
      content/les-differentes-couches-dun-systeme-dexploitation.md
  19. +123
    -0
      content/les-systemes-de-fichiers.md
  20. +81
    -0
      content/linformatique-a-lecole.md
  21. +71
    -0
      content/mfsbsd-online.md
  22. +183
    -0
      content/monter-son-propre-serveur-partie-1-le-serveur-et-lapache.md
  23. +263
    -0
      content/mutt-ou-le-client-email-le-meilleur-moins-mauvais.md
  24. +8
    -0
      content/nat.md
  25. +385
    -0
      content/opensmtpd.md
  26. +27
    -0
      content/pages/about.md
  27. +74
    -0
      content/plan9.md
  28. +170
    -0
      content/pourquoi-je-vais-quitter-linux-pour-passer-a-freebsd.md
  29. +84
    -0
      content/redesign-du-blog.md
  30. +112
    -0
      content/sed.md
  31. +150
    -0
      content/ssl.md
  32. +34
    -0
      content/update-a-propos-du-blog.md
  33. +75
    -0
      content/update-et-pensees-a-propos-du-raspberry-pi.md
  34. +9
    -0
      content/update.md
  35. +244
    -0
      output/archives.html
  36. +1727
    -0
      output/author/wxcafe.html
  37. +1764
    -0
      output/author/wxcafe2.html
  38. +821
    -0
      output/author/wxcafe3.html
  39. +0
    -0
      output/authors.html
  40. +195
    -0
      output/categories.html
  41. +348
    -0
      output/category/hacking/index.html
  42. +238
    -0
      output/category/language/index.html
  43. +561
    -0
      output/category/notes/index.html
  44. +579
    -0
      output/category/oses/index.html
  45. +406
    -0
      output/category/programmation/index.html
  46. +669
    -0
      output/category/ranting/index.html
  47. +585
    -0
      output/category/teaching/index.html
  48. +576
    -0
      output/category/tutorial/index.html
  49. +1445
    -0
      output/category/tutoriel/index.html
  50. +3123
    -0
      output/feeds/all-fr.atom.xml
  51. +3123
    -0
      output/feeds/feed.atom.all.xml
  52. +3123
    -0
      output/feeds/feed.atom.xml
  53. +140
    -0
      output/feeds/feed.hacking.xml
  54. +30
    -0
      output/feeds/feed.language.xml
  55. +265
    -0
      output/feeds/feed.notes.xml
  56. +349
    -0
      output/feeds/feed.oses.xml
  57. +198
    -0
      output/feeds/feed.programmation.xml
  58. +373
    -0
      output/feeds/feed.ranting.xml
  59. +3123
    -0
      output/feeds/feed.rss.all.xml
  60. +140
    -0
      output/feeds/feed.rss.hacking.xml
  61. +30
    -0
      output/feeds/feed.rss.language.xml
  62. +265
    -0
      output/feeds/feed.rss.notes.xml
  63. +349
    -0
      output/feeds/feed.rss.oses.xml
  64. +198
    -0
      output/feeds/feed.rss.programmation.xml
  65. +373
    -0
      output/feeds/feed.rss.ranting.xml
  66. +311
    -0
      output/feeds/feed.rss.teaching.xml
  67. +368
    -0
      output/feeds/feed.rss.tutorial.xml
  68. +1105
    -0
      output/feeds/feed.rss.tutoriel.xml
  69. +3123
    -0
      output/feeds/feed.rss.xml
  70. +311
    -0
      output/feeds/feed.teaching.xml
  71. +368
    -0
      output/feeds/feed.tutorial.xml
  72. +1105
    -0
      output/feeds/feed.tutoriel.xml
  73. +3123
    -0
      output/feeds/wxcafe.atom.xml
  74. +3123
    -0
      output/feeds/wxcafe.rss.xml
  75. +1727
    -0
      output/index.html
  76. +1764
    -0
      output/index2.html
  77. +821
    -0
      output/index3.html
  78. +203
    -0
      output/pages/about/index.html
  79. +355
    -0
      output/posts/%D/SSL-ou-la-securite-sur-internet/index.html
  80. +502
    -0
      output/posts/%D/archlinux-made-simple/index.html
  81. +354
    -0
      output/posts/%D/comment-saurik-a-roote-les-google-glass/index.html
  82. +240
    -0
      output/posts/%D/debuts-presentation-etc/index.html
  83. +273
    -0
      output/posts/%D/freebsd-online-mfsbsd/index.html
  84. +279
    -0
      output/posts/%D/gnulinux-pour-les-non-technophiles-ou-los-libre-pour-votre-grand-mere/index.html
  85. +412
    -0
      output/posts/%D/introduction-a-bash-en-tant-que-language-de-programmation/index.html
  86. +377
    -0
      output/posts/%D/la-cryptographie-avec-pgp-et-principalement-gnupg/index.html
  87. +278
    -0
      output/posts/%D/la-programmation-expliquee-simplement/index.html
  88. +307
    -0
      output/posts/%D/la-separation-des-eglises-et-de-letat-une-idee-quelle-est-bonne/index.html
  89. +365
    -0
      output/posts/%D/le-chiffrement-de-partition-avec-dm-crypt-et-device-mapper/index.html
  90. +244
    -0
      output/posts/%D/le-quenya-episode-o/index.html
  91. +286
    -0
      output/posts/%D/les-differentes-couches-dun-systeme-dexploitation/index.html
  92. +330
    -0
      output/posts/%D/les-systemes-de-fichiers/index.html
  93. +280
    -0
      output/posts/%D/linformatique-a-lecole/index.html
  94. +437
    -0
      output/posts/%D/mise-en-place-dun-serveur-dns/index.html
  95. +376
    -0
      output/posts/%D/monter-son-propre-serveur-partie-1/index.html
  96. +469
    -0
      output/posts/%D/mutt-ou-le-client-email-le-meilleur-moins-mauvais/index.html
  97. +218
    -0
      output/posts/%D/nat/index.html
  98. +582
    -0
      output/posts/%D/opensmtpd-debian/index.html
  99. +277
    -0
      output/posts/%D/plan-9-from-whichever-space/index.html
  100. +368
    -0
      output/posts/%D/pourquoi-je-vais-quitter-linux-pour-passer-a-freebsd/index.html
  101. +289
    -0
      output/posts/%D/redesign-du-blog/index.html
  102. +318
    -0
      output/posts/%D/sed-basics/index.html
  103. +241
    -0
      output/posts/%D/update-a-propos-du-blog/index.html
  104. +278
    -0
      output/posts/%D/update-et-pensees-a-propos-du-raspberry-pi/index.html
  105. +218
    -0
      output/posts/%D/update/index.html
  106. +187
    -0
      output/tags.html
  107. +1109
    -0
      output/theme/css/bootstrap-responsive.css
  108. +6167
    -0
      output/theme/css/bootstrap.css
  109. +1268
    -0
      output/theme/css/font-awesome.css
  110. +70
    -0
      output/theme/css/pygments.css
  111. BIN
      output/theme/font/FontAwesome.otf
  112. +1197
    -0
      output/theme/font/font-awesome-ie7.css
  113. +382
    -0
      output/theme/font/font-awesome-ie7.min.css
  114. +1471
    -0
      output/theme/font/font-awesome.css
  115. +402
    -0
      output/theme/font/font-awesome.min.css
  116. BIN
      output/theme/font/fontawesome-webfont.eot
  117. +399
    -0
      output/theme/font/fontawesome-webfont.svg
  118. BIN
      output/theme/font/fontawesome-webfont.svgz
  119. BIN
      output/theme/font/fontawesome-webfont.ttf
  120. BIN
      output/theme/font/fontawesome-webfont.woff
  121. BIN
      output/theme/img/favicon.ico
  122. BIN
      output/theme/img/glyphicons-halflings-white.png
  123. BIN
      output/theme/img/glyphicons-halflings.png
  124. +30
    -0
      output/theme/js/autosidebar.js
  125. +6
    -0
      output/theme/js/bootstrap.min.js
  126. +4
    -0
      output/theme/js/jquery-1.7.2.min.js
  127. +49
    -0
      pelicanconf.py
  128. BIN
      pelicanconf.pyc
  129. +1109
    -0
      themes/bootstrap2/static/css/bootstrap-responsive.css
  130. +6167
    -0
      themes/bootstrap2/static/css/bootstrap.css
  131. +1268
    -0
      themes/bootstrap2/static/css/font-awesome.css
  132. +70
    -0
      themes/bootstrap2/static/css/pygments.css
  133. BIN
      themes/bootstrap2/static/font/FontAwesome.otf
  134. +1197
    -0
      themes/bootstrap2/static/font/font-awesome-ie7.css
  135. +382
    -0
      themes/bootstrap2/static/font/font-awesome-ie7.min.css
  136. +1471
    -0
      themes/bootstrap2/static/font/font-awesome.css
  137. +402
    -0
      themes/bootstrap2/static/font/font-awesome.min.css
  138. BIN
      themes/bootstrap2/static/font/fontawesome-webfont.eot
  139. +399
    -0
      themes/bootstrap2/static/font/fontawesome-webfont.svg
  140. BIN
      themes/bootstrap2/static/font/fontawesome-webfont.svgz
  141. BIN
      themes/bootstrap2/static/font/fontawesome-webfont.ttf
  142. BIN
      themes/bootstrap2/static/font/fontawesome-webfont.woff
  143. BIN
      themes/bootstrap2/static/img/favicon.ico
  144. BIN
      themes/bootstrap2/static/img/glyphicons-halflings-white.png
  145. BIN
      themes/bootstrap2/static/img/glyphicons-halflings.png
  146. +30
    -0
      themes/bootstrap2/static/js/autosidebar.js
  147. +6
    -0
      themes/bootstrap2/static/js/bootstrap.min.js
  148. +4
    -0
      themes/bootstrap2/static/js/jquery-1.7.2.min.js
  149. +11
    -0
      themes/bootstrap2/templates/analytics.html
  150. +13
    -0
      themes/bootstrap2/templates/archives.html
  151. +22
    -0
      themes/bootstrap2/templates/article.html
  152. +26
    -0
      themes/bootstrap2/templates/article_infos.html
  153. +2
    -0
      themes/bootstrap2/templates/author.html
  154. +0
    -0
      themes/bootstrap2/templates/authors.html
  155. +116
    -0
      themes/bootstrap2/templates/base.html
  156. +8
    -0
      themes/bootstrap2/templates/categories.html
  157. +2
    -0
      themes/bootstrap2/templates/category.html
  158. +7
    -0
      themes/bootstrap2/templates/comments.html
  159. +11
    -0
      themes/bootstrap2/templates/disqus_script.html
  160. +9
    -0
      themes/bootstrap2/templates/github.html
  161. +45
    -0
      themes/bootstrap2/templates/index.html
  162. +13
    -0
      themes/bootstrap2/templates/page.html
  163. +15
    -0
      themes/bootstrap2/templates/pagination.html
  164. +16
    -0
      themes/bootstrap2/templates/piwik.html
  165. +15
    -0
      themes/bootstrap2/templates/search_sidebar.html
  166. +58
    -0
      themes/bootstrap2/templates/sidebar.html
  167. +2
    -0
      themes/bootstrap2/templates/tag.html
  168. +6
    -0
      themes/bootstrap2/templates/taglist.html
  169. +13
    -0
      themes/bootstrap2/templates/tags.html
  170. +6
    -0
      themes/bootstrap2/templates/translations.html
  171. +6
    -0
      themes/bootstrap2/templates/twitter.html
  172. +1
    -0
      themes/bootstrap2/templates/twitter_profile.html

+ 88
- 0
Makefile View File

@@ -0,0 +1,88 @@
PY=python
PELICAN=pelican
PELICANOPTS=

BASEDIR=$(CURDIR)
INPUTDIR=$(BASEDIR)/content
OUTPUTDIR=$(BASEDIR)/output
CONFFILE=$(BASEDIR)/pelicanconf.py
PUBLISHCONF=$(BASEDIR)/publishconf.py

FTP_HOST=localhost
FTP_USER=anonymous
FTP_TARGET_DIR=/

SSH_HOST=localhost
SSH_PORT=22
SSH_USER=root
SSH_TARGET_DIR=/var/www

S3_BUCKET=my_s3_bucket

DROPBOX_DIR=~/Dropbox/Public/

help:
@echo 'Makefile for a pelican Web site '
@echo ' '
@echo 'Usage: '
@echo ' make html (re)generate the web site '
@echo ' make clean remove the generated files '
@echo ' make regenerate regenerate files upon modification '
@echo ' make publish generate using production settings '
@echo ' make serve serve site at http://localhost:8000'
@echo ' make devserver start/restart develop_server.sh '
@echo ' make stopserver stop local server '
@echo ' ssh_upload upload the web site via SSH '
@echo ' rsync_upload upload the web site via rsync+ssh '
@echo ' dropbox_upload upload the web site via Dropbox '
@echo ' ftp_upload upload the web site via FTP '
@echo ' s3_upload upload the web site via S3 '
@echo ' github upload the web site via gh-pages '
@echo ' '


html: clean $(OUTPUTDIR)/index.html

$(OUTPUTDIR)/%.html:
$(PELICAN) $(INPUTDIR) -o $(OUTPUTDIR) -s $(CONFFILE) $(PELICANOPTS)

clean:
[ ! -d $(OUTPUTDIR) ] || find $(OUTPUTDIR) -mindepth 1 -delete

regenerate: clean
$(PELICAN) -r $(INPUTDIR) -o $(OUTPUTDIR) -s $(CONFFILE) $(PELICANOPTS)

serve:
cd $(OUTPUTDIR) && $(PY) -m pelican.server

devserver:
$(BASEDIR)/develop_server.sh restart

stopserver:
kill -9 `cat pelican.pid`
kill -9 `cat srv.pid`
@echo 'Stopped Pelican and SimpleHTTPServer processes running in background.'

publish:
$(PELICAN) $(INPUTDIR) -o $(OUTPUTDIR) -s $(PUBLISHCONF) $(PELICANOPTS)

ssh_upload: publish
scp -P $(SSH_PORT) -r $(OUTPUTDIR)/* $(SSH_USER)@$(SSH_HOST):$(SSH_TARGET_DIR)

rsync_upload: publish
rsync -e "ssh -p $(SSH_PORT)" -P -rvz --delete $(OUTPUTDIR)/ $(SSH_USER)@$(SSH_HOST):$(SSH_TARGET_DIR) --cvs-exclude

dropbox_upload: publish
cp -r $(OUTPUTDIR)/* $(DROPBOX_DIR)

ftp_upload: publish
lftp ftp://$(FTP_USER)@$(FTP_HOST) -e "mirror -R $(OUTPUTDIR) $(FTP_TARGET_DIR) ; quit"

s3_upload: publish
s3cmd sync $(OUTPUTDIR)/ s3://$(S3_BUCKET) --acl-public --delete-removed

github: publish
ghp-import $(OUTPUTDIR)
git push origin gh-pages

.PHONY: html help clean regenerate serve devserver publish ssh_upload rsync_upload dropbox_upload ftp_upload s3_upload github

+ 13
- 0
README.md View File

@@ -0,0 +1,13 @@
Source code for my [blog][]
===========================

So this is the source code for my blog.
More exactly, this is the configuration files and the theme I've used and
modified to put this blog online.

This repository will also contain the markdown "source" for the articles, and of
course the output folder.

So here goes. Not sure why anyone would be interested, but still.

[blog]: http://wxcafe.net

BIN
__pycache__/pelicanconf.cpython-34.pyc View File


BIN
cache/ArticlesGenerator-Readers View File


BIN
cache/PagesGenerator-Readers View File


BIN
content/.markdown.md.swp View File


+ 152
- 0
content/2013-07-10.12:44:28.md View File

@@ -0,0 +1,152 @@
Title: Le chiffrement de partitions avec dm-crypt et device-mapper
Date: 2013-07-10 03:18
Author: Wxcafe
Category: Tutoriel
Slug: le-chiffrement-de-partition-avec-dm-crypt-et-device-mapper


Le chiffrement en tant que concept informatique est traditionnellement associé
au chiffrement de fichiers, c'est a dire au fait de passer d'un fichier *en
clair* a un fichier chiffré dit *cyphertext*. Cependant, il ne se limite pas a
ça, et peut aussi servir a garantir l'intégrité d'un système d'exploitation, ou
bien la confidentialité d'un support de stockage, par exemple. Nous allons ici
voir comment mettre en place un système de ce type sous GNU/Linux. Cet article
n'a pas pour but de vous apprendre a mettre en place un système basé sur une
procédure de boot sécurisée, mais plutôt d'expliquer les concepts qui entrent en
jeu dans l'utilisation du sous-système du noyau Linux [__dm_crypt__](http://en.wikipedia.org/wiki/dm-crypt) et de
présenter un rapide tutoriel concernant la création d'un support chiffré sur
lequel garder vos informations confidentielles (par exemple, votre [clé GPG](http://wxcafe.net/posts/11/19/12/la-cryptographie-avec-pgp-et-principalement-gnupg))

dm-crypt est un sous-système de device-mapper, qui est lui-même un sous-système
du noyau Linux, et s'appuie sur [LUKS](http://en.wikipedia.org/wiki/Linux_Unified_Key_Setup), un standard de chiffrement
de disques. Comme son nom l'indique, device-mapper est un système qui a pour but
de __mapper__ des __block devices__. Pour être plus clair, le kernel considère
comme "block device" tout fichier spécial (en gros, les fichiers disques dans
`/dev/`, les systèmes de fichiers type LVM, les RAID logiciels, et, dans le
cas qui nous intéresse, les systèmes de fichier chiffrés). Son mode de
fonctionnement est simple : a partir d'un "fichier de périphérique" (trad.
Wikipédia), il en "crée" un nouveau, virtuel, ayant des propriétés différentes.
Par exemple, un disque partitionné via LVM apparaîtra comme un seul disque dans
/dev, et device-mapper est requis pour pouvoir en voir les partitions (qui
apparaîtront donc dans /dev/mapper)

Ainsi, dans le cas qui nous intéresse ici, device-mapper prend un système de
fichier chiffré, crée un périphérique virtuel non chiffré dans /dev/mapper, et
déchiffre a la volée tous les accès disques a ce périphérique non chiffré en les
traduisant sur le système de fichier chiffré, le tout de manière tout a fait
transparente pour les applications utilisant le disque en question. Cela induit
bien entendu une baisse de performance relativement significative dans le cas
d'un chiffrement du système de fichier root, mais quasiment insignifiante dans
le cas de chiffrement de partitions de données.

D'ailleurs, certain-e-s se demandent peut-être comment le système peut démarrer
si le système de fichier root est chiffré. Dans ce cas précis, la procédure de
boot __*doit*__ s'appuyer sur une image initrd (l'initrd est un système de
fichier minimal qui sert uniquement a initialiser le système. Les kernels de
base de la plupart des distributions GNU/Linux en utilisent un dans tous les
cas, pour des raisons de compatibilité) et sur une partition de boot qui elle
n'est pas chiffrée. Ainsi, le bootloader de niveau 2 (grub, syslinux,...) charge
en mémoire le kernel depuis la partition de boot, puis ce dernier décompresse et
charge l'initrd en RAM, celui-ci a son tour lance un script permettant de
charger les modules nécessaires a la suite du boot (que ce soit pour un boot
sans disque root local, ou bien comme ici avec un système chiffré), puis le
système de fichier "cible" est remonté sur la racine, et l'initrd est démonté
est la RAM qu'il occupait est libérée, puis la procédure de boot normale reprend
depuis le système de fichier maintenant monté sur la racine.

La méthode la plus évidente pour contourner le chiffrement du disque est alors
de remplacer le fichier compressé initrd dans /boot, qui n'est pas chiffrée, par
un autre modifié, copiant par exemple la phrase de passe permettant de
déchiffrer la partition cible. Plusieurs méthodes permettent de se prémunir
contre ce genre d'attaques : l'une des plus simple est de faire un checksum du
fichier initrd utilisé et reconnu comme sûr, et de vérifier lors du *vrai* boot
que l'initrd présente toujours le même checksum. Cela dit, cette méthode a
l'inconvénient d'intervenir après les faits, et de nécessiter au moins un accès
a un fichier initrd reconnu comme sûr.
Une autre approche consisterait a placer le système de fichier /boot sur un
périphérique dédié, protégé en écriture de façon matérielle (par exemple, une
carte SD) ou, de façon encore plus efficace, sur un périphérique chiffré et
protégé en écriture de façon matérielle. Ainsi, il n'est pas possible pour un
attaquant de modifier ce système de fichier, et l'initrd est alors toujours de
confiance. Cependant, cela a pour conséquence de rendre la mise a jour de
l'initrd et du noyau *beaucoup* plus difficile qu'elle ne le serait sans.

Pour en revenir aux systèmes de fichiers chiffrés, leur gestion est faite par un
programme dédié, `cryptsetup`. Ce dernier était en charge de cryptoloop,
l'ancien sous-système de chiffrement du kernel Linux (déprécié depuis), et est
maintenant responsable de l'utilisation *userspace* de dm-crypt, qui pour sa
part est entièrement *kernel-space*. Cryptsetup permet ainsi le chiffrement, la
manipulation (montage/démontage/...) et la gestion de clé des systèmes de fichier
LUKS. Cryptsetup est cependant conçu pour être utilisé en tant que root, et les
utilisateurs qui veulent monter de systèmes de fichiers chiffrés devront ainsi
obligatoirement être capables de le faire en tant que root.

Voyons comment il faudrait procéder pour créer une image disque chiffrée de 1Go :
Tout d'abord, il nous faut créer le fichier qui contiendra l'image. Pour cela,
dans une situation réelle ou l'on cherche a chiffrer un disque, il convient
d'utiliser /dev/urandom comme source, pour éviter la détection du système de
fichier chiffré sur le disque.
Ici, par exemple, nous allons faire :

dd bs=1000 count=1000000 if=/dev/urandom of=image.img

Maintenant que notre image est créée, nous pouvons la chiffrer :

sudo cryptsetup luksFormat image.img

`cryptsetup` va alors nous demander si nous sommes absolument surs de vouloir
formater ce disque (nous allons donc valider en tapant YES), puis une
passphrase. Il convient ici de choisir une passphrase particulièrement sûre,
puisque toute personne ayant accès a la passphrase aura aussi accès au disque et
donc a vos secrets.
Une fois cela fait, nous allons mapper cette image :

sudo cryptsetup luksOpen image.img crypto

`cryptsetup` nous redemande la passphrase, charge pendant quelques secondes,
puis nous redonne le prompt. Que s'est-il passé? En cherchant un peu, nous
voyons qu'il n'y a pas de nouveau disque dans /dev. C'est tout a fait normal. En
effet, cryptsetup (et par lui, device-mapper et dm-crypt) ne monte pas les
systèmes de fichiers chiffrés, il les mappe, et ça n'a rien a voir. On remarque
qu'est apparu dans /dev/mapper le fichier crypto. Ce fichier est le disque
virtuel qui correspond a notre image. Il se comporte comme toute partition, et
peut donc être monté, formaté, etc (il ne peut cependant pas être partitionné.
Il se comporte en effet comme une partition, et non comme un véritable disque.)
Bon, ceci fait, notre disque virtuel n'est pas formaté. Il nous reviens donc de
le faire, pour pouvoir l'utiliser.

sudo mkfs.ext4 /dev/mapper/crypto

Maintenant que notre disque est formaté, il peut être monté :

sudo mount /dev/mapper/crypto /mnt

Et voila, nous avons un système de fichier fonctionnel et chiffré! Si vous
voulez vérifier, un `mount | grep crypto` devrait vous donner le résultat
suivant :

/dev/mapper/crypto on /mnt type ext4 (rw,relatime,data=ordered)

Vous pouvez maintenant commencer a stocker tous vos secrets sur ce fichier, ils
sont (en fonction de votre passphrase) en sécurité.

Pour résumer :

- Pour monter vos partitions :

sudo cryptsetup luksOpen <fichier chiffré> <nom de disque virtuel>
sudo mount /dev/mapper/<nom de disque virtuel> <emplacement>

- Pour démonter vos partitions :

sudo umount <emplacement>
sudo cryptsetup luksClose <nom de disque virtuel>

Pour simplifier la vie de tous, j'ai créé deux petits scripts vous permettant de
créer et de monter/démonter vos images/disques chiffré-e-s en une seule
commande. Ils se trouvent sur [github](https://github.com/wxcafe/cryptoscripts).

Par ailleurs, si vous comptez transferer votre image disque sur un véritable
disque (ou clé usb, ou autre), il est préférable de créer une partition de
taille appropriée et de faire un `dd if=votre_image of=/dev/votre_partition`
pour ce faire.

+ 262
- 0
content/archlinux-made-simple.md View File

@@ -0,0 +1,262 @@
Title: Archlinux made simple
Date: 2012-10-05 14:48
Author: Wxcafe
Category: OSes
Slug: archlinux-made-simple

Archlinux est réputée être une distribution Linux très complexe a
installer et a maintenir.

Je vais tenter ici de vous convaincre que ce n'est pas le cas, et
qu'elle peut se monter très intéressante et très instructive a installer
tout autant qu'a utiliser.

Il convient tout d'abord de rappeler a quels principes obéit Arch:

1. Le KISS : Keep It Simple and Stupid, Archlinux tente de faire des
programmes simples et utilisables par tous. Avec comme base de
simplicité les utilisateurs de LFS... Mais il n'empêche qu'avec un peu
de bonne volonté, la configuration n'est pas si compliquée!

2. La philosophie UNIX : chaque programme est prévu pour ne remplir
qu'une seule tâche. Bien entendu, cela ne concerne que les programmes
conçus pour s’insérer dans la philosophie UNIX, et les installations de
dépendances avec le gestionnaire de paquet d'Arch fonctionnent
superbement bien.

De plus, posons les bases d'Arch : le gestionnaire de paquets s'appelle
pacman, et les commandes de base sont :

- recherche d'un paquet :

pacman -Ss paquet

- installation d'un paquet :

sudo pacman -S paquet

- désinstallation d'un paquet :

sudo pacman -R paquet

- mise a jour de tous les paquets installés :

sudo pacman -Syu paquet

Archlinux est une distribution dite "rolling release", ce qui signifie
qu'il n'y a pas de version a proprement dites, et que les paquets se
mettent a jour en permanence, sans jamais changer la "version" d'Arch.
Il n'y a d'ailleurs qu'une seule version de l'installeur sur le site,
puisqu'une version plus ancienne n'aurait aucun sens.

Arch n'offre pas d'interface graphique par défaut : après avoir installé
le système, vous n'aurez qu'une invite de commande. Heureusement, je
vais ici vous guider a travers l'installation d'une interface graphique
(mate, le fork de gnome 2)

L'installation d'Arch se fait par le réseau, veillez a avoir une
connection WiFi ou filaire a proximité avant de suivre ce guide.

Ce guide utilise SystemV, alors qu'Arch va prochainement passer sous
systemd. N'ayant pas encore eu le temps d’expérimenter assez avec ce
dernier, je ferais un tutoriel pour passer votre Arch a systemd bientôt.

Bon, passons a l'explication de l'installation proprement dite :

Tout d'abord, téléchargeons l'iso d'arch la plus récente :

wget http://mir.archlinux.fr/iso/2012.09.07/archlinux-2012.09.07-dual.iso

Ensuite, gravons cette image sur un disque USB :

dd if=archlinux-2012.09.07-dual.iso of=/dev/sdX

Après reboot de la machine sur l'iso en question et choix de
l'architecture, nous sommes accueillis par un shell root.

La première chose a faire est de paramétrer le clavier :

loadkeys fr

Puis nous pouvons passer a l'installation proprement dite.
Partitionnement :

cfdisk # cfdisk est suffisamment clair pour ne pas nécessiter d'explications

formatage des partitions :

mkfs.ext4 /dev/sda1 # partition root

pacman -Syu btrfs-progs && mkfs.btrfs /dev/sda2 # partition home

mkswap /dev/sda3 && swapon /dev/sda3 # partition de swap

Montons les partitions nouvellement créées, puis installons le système :

mount /dev/sda1 /mnt

mkdir /mnt/home && mount /dev/sda2 /mnt/home

dhclient eth0 # si vous utilisez une connection filaire, sinon voire http://wiki.archlinux.fr/Wifi#Configuration

pacstrap /mnt base base-devel

genfstab -p /mnt > /mnt/etc/fstab

Allons prendre un café le temps que ça charge, puis installons les
quelques paquets nécessaires a notre installation et au premier
démarrage:

pacstrap /mnt syslinux btrfs-progs wireless_tools dhclient

Maintenant, passons sur notre install toute fraîche d'Arch :

arch-chroot /mnt bash

configurons les bases :

echo HOSTNAME > /etc/hostname

ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime

date MMJJhhmmAAAA

hwclock --systohc

vim /etc/locale.gen # Décommentez les lignes correspondant au français : fr_FR.UTF-8 et fr_FR.ISO-8859-1

echo 'LANG="fr_FR.UTF-8"' > /etc/locale.conf

locale-gen

mkinitcpio -p linux

Enfin, vérifions que syslinux est correctement configuré :

vim /boot/syslinux/syslinux.cfg # il devrait y avoir "append root=/dev/sda1"

Si tout est correct, installons syslinux, et paramétrons un mot de passe
root :

syslinux-install_update /dev/sda -mia

passwd root

Et voila, l'installation est terminée! Plus qu'a quitter la session et a
redémarrer l'ordinateur!

exit
umount /mnt/home
umount /mnt
reboot

Fini!

Prenons une petite pause. La partie suivante de ce tutoriel consister en
un paramétrage des principaux services nécessaires a l'utilisation d'un
OS, disons, moyen :

- Installation de MATE, le gestionnaire de bureau (voir
[http://mate-desktop.org/][])

- Installation de sudo et de networkmanager pour faire fonctionner les
composants essentiels du système sans avoir a tout activer a la main a
chaque démarrage

- Installation de SLiM comme gestionnaire de login graphique, pour
présenter une interface plus accueillante que la console, et
configuration de celui-ci

- Installation des principaux logiciels utiles non inclus dans mate ni
base (yaourt, chromium, thunderbird, etc...).

Ce guide est bien sur optionnel, si vous souhaitez utiliser Arch avec un
gestionnaire de bureau autre que mate, ou sans, vous pouvez vous arrêter
ici.

Bon, reprenons.

Nous sommes donc sur une demande de mot de passe. Entrez donc le mot de
passe paramétré plus haut pour le root, puis retapez la commande
utilisée plus tôt pour vous connecter a internet.

Il convient d'ajouter le dépôt de MATE pour installer ce dernier, puis
d'effectuer l'action en question :

vim /etc/pacman.conf

Ici, ajoutez les lignes suivantes :

[mate]
Server = http://repo.mate-desktop.org/archlinux/$arch

Installons maintenant les paquets :

pacman -Syu mate mate-extras dbus dbus-core alsa networkmanager sudo

Ajoutons un compte utilisateur pour utiliser les composants du système
sans tout crasher a chaque fois :

useradd -g users -G wheel,audio,optical,lp,scanner,log,power,floppy,storage,games,video -m -s /bin/bash *votrenom*
passwd *votrenom*
su *votrenom*

Il faut maintenant éditer le fichier \~/.xinitrc pour préciser a X.org
ce que l'on veut utiliser :

echo "exec ck-launch-session mate-session" > ~/.xinitrc

Profitons en pour ajouter les démons système au lancement :

vim /etc/rc.conf

Ajoutez donc `dbus, alsa. hwclock` et `networkmanager` dans la section
DAEMONS (entre les parenthèses, après crond normalement)

DAEMONS=(syslog-ng network crond dbus alsa hwclock networkmanager)

Pour éviter un reboot, il est ici possible de faire un

su

Puis un

/etc/rc.d/dbus start && /etc/rc.d/alsa start && /etc/rc.d/networkmanager start

Sinon, il est possible de juste redémarrer.
Une fois cela fait, profitez de ce moment pour vous autoriser vous même
a utiliser sudo. Loggez vous en root, et :

vim /etc/sudoers

Décommentez la ligne qui commence par \# %wheel ALL=(ALL)
Sauvegardez le fichier, puis, après un `su *votrenom*`, tentez de faire
un sudo ls /
Normalement, vous devriez avoir un listing du dossier /
Bon, maintenant, pourquoi ne pas tenter de lancer MATE?
C'est simple comme bonjour :

startx

Et PAF! Voila un MATE desktop flambant neuf a configurer!
Avant de faire ça, retournez sur un TTY (CTRL+ALT+Fx), loggez vous,
puis installez SLiM (`sudo pacman -Syu slim`).
Configurons le:

echo "exec dbus-launch mate-session" > ~/.xinitrc && vim /etc/slim.conf

Éditez la ligne
"`sessions xfce4,icewm-session,wmaker,blackbox`" de facon a
ce qu'elle ressemble a "`sessions mate-session`"
Puis ajoutez slim dans /etc/rc.conf, dans la section DAEMONS.
Normalement, tout devrait fonctionner!
Ah oui, et pour installer thunderbird, firefox, chromium, etc...

sudo pacman -Syu chromium thunderbird xchat firefox rhythmbox pidgin transmission-gtk vlc

Voila! Et comme dirait [@Spartition][], c'est sale, mais qu'est-ce que c'est
bon!
A plus~

[@Spartition]: https://twitter.com/spartition
[http://mate-desktop.org/]: http://mate-desktop.org/

+ 147
- 0
content/comment-saurik-a-roote-les-google-glass.md View File

@@ -0,0 +1,147 @@
Title: Comment Saurik a rooté les Google Glass
Date: 2013-05-06 06:24
Author: Wxcafe
Category: Hacking
Slug: comment-saurik-a-roote-les-google-glass

Comme vous avez pu le lire dans les médias, Saurik (Jay Freeman, connu
pour avoir développé Cydia, un "app store" alternatif pour les iTrucs),
après avoir reçu une paire de Google glass de la part de Google (de
façon assez évidente...), a trouvé intéressant d'obtenir un accès root
sur celles-ci, ce qu'il a accompli très rapidement. Des démentis de la
part de Google et de certains autres sites sont vite arrivés, disant que
les lunettes possédaient un bootloader débloqué et que de fait, le root
était facile a obtenir : il suffisait de débloquer le bootloader,
d'extraire l'OS, de le rooter hors-fonctionnement, puis de le
réinstaller, rooté, sur les lunettes.

Le fait est que de débloquer le bootloader laisse une trace permanente
sur les lunettes, et que Saurik n'a pas utilisé cette technique pour
rooter sa paire. Voyons comment il a fait :

_Je tiens tout d'abord a préciser que toutes les informations qui vont
suivre sont extraites de [cet article][], et plus précisément de la
partie "How does this exploit work".  Je tente d'apporter ma maigre
contribution a cette explication._

Donc, d'après les témoignages des quelques utilisateurs de Glass dans le
monde, il semblerait que ces dernières fonctionnent avec un système
d'exploitation Android, avec une nouvelle interface, mais avec les mêmes
outils internes: un kernel Linux, des outils userland GNU et une machine
virtuelle Java Dalvik pour les applications.

Saurik a donc cherché un exploit connu pour cette version d'android, et
l'a appliqué a son problème. L'exploit en question est relativement
simple. Depuis la version 4.0 d'android, le système permet la sauvegarde
des données des différentes applications, une a une, via ADB (Android
Debug Bridge, un protocole USB permettant l'accès a de nombreuses
fonctions avancées des machines fonctionnant sous android, dont, entre
autre, un shell, un accès au logs de debugging, etc... Cette
fonctionnalité est bien entendu désactivable.) Ce backup est très simple :
il crée un fichier .tgz contenant le dossier de configuration de
l'application. Lors de la restauration, le système supprime la
configuration existante, puis la remplace par celle dans l'archive gzip.

Le problème de sécurité vient du fait que les applications android
voient leurs données stockées dans /data/data/identifiant/, et que
/data/ a pour permissions drwxrwx--x  27  system  system, ce qui
signifie que seul system et les membres du groupe system peuvent lire
dessus. Or, le fichier /data/local.prop définit de nombreux paramètres
au démarrage, et notamment un qui permet au système de déterminer s'il
fonctionne dans une VM ou sur un véritable appareil. S'il fonctionne sur
une machine virtuelle, il donne les droits root a tout utilisateur se
connectant via ADB, ce qui est ce que l'on cherche pour l'instant. Le
fait que /data/ appartienne a system veut dire que le programme de
restauration doit être setuid pour accéder aux données a l’intérieur qui
appartiennent a root (soit toutes les applications système d'android,
dont l'application paramètres, et, dans ce cas précis, l'application de
log système présente sur les google glass de test. Ainsi, nous avons un
processus tournant en tant que root, qui va écrire sur une partition qui
nous intéresse des données que nous possédons.

Cependant, un problème reste : le système de restauration d'Android
vérifie les données avant de restaurer, et ne restaure pas les symlinks,
ce qui nous empêche d'avoir accès directement a /data/local.prop, le
fichier qu'on cherche a modifier. Cela dit, il nous reste une
possiblité. Plaçons un dossier world-writable dans le fichier de backup,
et nous pourrons écrire dedans pendant quelques secondes, le temps que
la restauration se termine et que le système remette les permissions en
place. Ainsi, nous pouvons créer le fichier
/data/local/com.google.glass.logging/whatev/x, lien vers
/data/local.prop, et nous avons un toujours un processus tournant en
tant que root qui est en train d'écrire dans ce dossier.

Donc, nous allons lancer deux processus en même temps :

- Le premier tentera en boucle de créer le symlink. Il sera consitué de
la commande suivante, depuis un shell sur les lunettes :

while ! ln -s /data/local.prop /data/data/com.google.glass.logging/whatev/x 2>/dev/null
do :
done

- Le deuxième sera le processus de restauration de notre exploit. Celui
ci, pour une plus grande chance de réussite, devra être suffisamment
lourd : au moins \~50Mo. Il devra contenir whatev/bigfile et whatev/x,
pour qu'il crée whatev, prenne du temps a copier bigfile, puis écrive
dans x après que le symlink soit effectif. La commande sera, depuis
l'ordinateur host :

adb restore exploit.ab

Ces commandes vont fonctionner de concert pour nous donner un accès root :
- Le processus de restauration va créer le dossier whatev, qui sera
world-readable. Il va commencer a copier le fichier bigfile.
- Le processus de symlink va créer le lien
/data/data/com.google.glass.logging/whatev/x, pointant vers
/data/local.prop, puis rendre l'âme proprement.
- Le processus de restauration, ayant enfin fini de copier
whatev/bigfile, copiera les contenus que nous voulons dans whatev/x, qui
est lié a /data/local.prop. Comme le processus est setuid root, il ne se
rendra compte de rien, et écrira tout dans /data/local.prop.

And voilà! On a écrit ce que l'on veut dans /data/local.prop, ce qui
nous permet de faire croire a android qu'il tourne dans une machine
virtuelle (ce que l'on veut, c'est en fait "ro.kernel.qemu=1", qui
indique au noyau qu'il tourne dans qemu, un système de VM).

Il nous reste a rebooter, depuis l'ordinateur host :

adb reboot

Puis nous remontons la partitions système en lecture/écriture (r/w),
depuis le host :

adb shell "mount -o remount,rw /system"

Nous copions le binaire [su][] vers l'appareil :

adb push su /system/xbin

Nous donnons les bonnes permissions a ce binaire, afin de pouvoir
l’exécuter plus tard :

adb shell "chmod 6755 /system/xbin/su"

Ensuite, nous supprimons le fichier /data/local.prop, pour pouvoir
redémarrer normalement :

adb shell "rm /data/local.prop"

Enfin, nous redemarrons a nouveau :

adb reboot

Et voila, une paire de google glass rootée!

Il est bon de préciser que cette manipulation n'est possible que parce
que les lunettes tournent sous une ancienne version d'android, et que ce
bug a été fixé depuis.

Il serait aussi interessant de couvrir les problèmes de vie privée
qu'engendrent les Google Glass, et ce sera fait dans un autre billet.

A bientôt!

[cet article]: http://www.saurik.com/id/16
[su]: https://data.wxcafe.net/uploads/android/glass/su

+ 36
- 0
content/debuts-presentation-etc.md View File

@@ -0,0 +1,36 @@
Title: Débuts, présentation, etc...
Date: 2012-08-18 20:27
Author: Wxcafe
Category: Notes
Slug: debuts-presentation-etc

Bonjour!

Je m'appelle Wxcafé, et ça fait pas mal de temps que je sévis sur
Twitter, mais aussi sur IRC (Je traîne pas mal sur
irc.freenode.net/\#\#nolife et \#debian-fr)

J'ai 17 ans, je suis donc étudiant (bac général), je vis a Paris, et je
fais partie de ce genre de personne qui sont capables d'investir tout
leur temps et leur énergie a s’intéresser a un sujet en particulier, et
qui ne peuvent pas vivre sans leurs passions, avec une petite différence
cependant, qui est que je m’intéresse a plusieurs choses :
l'informatique, qui est un champ tellement large qu'on peut passer une
vie a apprendre des choses dessus, et plus particulièrement à
l'informatique avancée (Noyaux dérivés d'UNIX et de Linux, outils libres
{bien que n'étant pas un barbu intégriste [ceci est un troll assumé. Les
trolls seront a partir de maintenant indiqués avec le tag [tr]] du
libre, je préfère utiliser de l'open-source si c'est possible},
programmation en C, python et java, etc...) , mais aussi a
l’électronique.

Dans un tout autre registre, je m’intéresse aussi
beaucoup aux différents aspects du féminisme et des égalités sexuelles
(anti-homophobie/transphobie/biphobie/etc , anti-sexisme, et cætera) ,
et a la culture dite "geek" en général.

Je tenterai de poster ici le plus souvent possible, mais j'ai de gros
problèmes en terme de régularité de post, donc ne vous inquiétez pas si
vous ne voyez rien pendant deux semaines.

Merci beaucoup de votre attention, et a bientôt!

+ 244
- 0
content/dns.md View File

@@ -0,0 +1,244 @@
Title: Mise en place d'un serveur DNS
Date: 2014-02-24 02:49
Author: Wxcafe
Category: Tutoriel
Slug: mise-en-place-dun-serveur-dns

Le DNS (Domain Name System) est le service permettant la résolution des noms de
domaines en différentes informations : adresses IPv4, adresses IPv6, certificats
DNSSEC ou IPsec, localisation géographique, ou encore texte. En général, le DNS
est utilisé pour résoudre des noms de domaines en adresses IP, et ainsi pour
simplifier la vie de tous les utilisateurs (je doute que tout le monde retienne
de se connecter a [http://173.194.45.66](http://173.194.45.66), ou a
[http://199.16.156.70](http://199.16.156.70). Voire même a
[http://5.39.76.46](http://5.39.76.46)).

Cependant, le DNS est un système qui date de 1984, et les exigences de l'époque
en termes d'expérience utilisateur n'étaient pas forcément aussi importantes que
de nos jours. La configuration des serveurs DNS peut ainsi être assez
contre intuitive.
Cela étant dit, comprendre le fonctionnement de DNS et contrôler ses
enregistrements est important.

Tout d'abord, une petite explication théorique. Le DNS fonctionne de la même
façon que le système de fichiers : en arborescence. Cependant, là ou la racine
du FS est `/`, celle de DNS est `.`, et là ou il convient d'écrire, par exemple,
`/usr/` et ou la progression se fait de gauche a droite pour le FS, pour DNS le
`.` n'est pas obligatoire et la progression se fait de droite a gauche. Par
exemple, le tld(top level domain, domaine de haut niveau) `com`, et le domaine
`google.com` appartient a `com`, on écrit donc `google.com` sans écrire le point
a la fin de façon courante.

Le reverse DNS est une variante du DNS "classique" permettant de résoudre les
adresses IP en nom de domaine. Ainsi, 5.39.46.76 a pour domaine wxcafe.net.
Cependant, le reverse DNS n'a, par définition, pas de TLD sur lequel se diriger
quand on lui adresse une query. Les "adresses" que l'on query en reverse DNS
sont donc constituées de l'adresse IP, **_dans le sens contraire a l'ordre
habituel_**, et du faux domaine .in-addr.arpa
Par exemple, pour connaitre le reverse de 5.39.46.76, il faudra faire `dig PTR
76.46.39.5.in-addr.arpa`. La réponse sera, évidemment, `wxcafe.net`

Voyons maintenant comment mettre en place son propre serveur DNS. Tout d'abord,
quelques informations. DNS fonctionne sur le port 53 en UDP, et la commande
utilisée pour faire des tests DNS est `dig`. Le DNS fonctionne avec des
"enregistrements", records en anglais. Par exemple, un record A indique une
adresse IP, un record NS indique un Serveur de nom, etc. `dig` se base sur ces
records : par défaut, il ira chercher le(s) record(s) A correspondant(s) au nom
de domaine que vous donnez en argument, mais en précisant un autre type de
record, vous pouvez obtenir n'importe quelle information : par exemple, `dig NS
wxcafe.net` devrait vous renvoyer

; <<>> DiG 9.8.4-rpz2+rl005.12-P1 <<>> NS wxcafe.net
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 13846
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;wxcafe.net. IN NS
;; ANSWER SECTION:
wxcafe.net. 3600 IN NS ns.wxcafe.net.
wxcafe.net. 3600 IN NS ns.home.wxcafe.net.
;; Query time: 60 msec
;; SERVER: 10.0.42.1#53(10.0.42.1)
;; WHEN: Tue Dec 10 13:31:18 2013
;; MSG SIZE rcvd: 67

Comme vous pouvez le voir, les serveurs DNS principaux pour
[wxcafe.net](http://wxcafe.net) sont `ns.wxcafe.net` et `ns.home.wxcafe.net`,
qui sont respectivement des alias pour `wxcafe.net` et `home.wxcafe.net`. Ainsi,
chacun fait autorité pour lui même, et le problème évident est que le résolveur
ne peut résoudre la query si il est renvoyé encore et encore vers le même
serveur. Il convient donc de définir dans le même fichier de configuration
l'adresse de ces deux serveurs. Ainsi, le résolveur, au bout de son deuxième
loop, se rendra compte qu'il est en train de faire une boucle infinie et
demandera l'adresse au serveur auquel il est connecté. La première indication de
direction se fait grâce au serveur du TLD.

La configuration de bind est assez simple dans le principe, le plus complexe
étant en fait d'écrire les fichiers de zone.
La configuration de bind sous debian se fait dans le dossier /etc/bind/. Il
existe 4 fichiers de configuration principaux : `named.conf`,
`named.conf.default-zones`, `named.conf.local` et `named.conf.options`.
`named.conf` contient les options par défaut de bind, `named.conf.default-zones`
les déclarations des zones par défaut (auxquelles il vaut mieux ne pas toucher),
`named.conf.local` contient les déclarations de vos zones, et
named.conf.options contient les options que vous rajoutez pour changer le
comportement de bind.

Pour commencer, il convient de préciser que nous allons parler ici du cas dans
lequel se trouve wxcafe.net: deux domaines dont nous voulons faire l'autorité,
deux serveurs DNS, et un service de résolution récursive limitée a quelques IPs
(notamment mon accès chez moi).

Examinons tout d'abord les fichiers de configuration de named.
`named.conf.local` contient les définitions des zones forward et reverse.
Sur wxcafe.net, les zones `wxcafe.net` et `76.46.39.5.in-addr.arpa` sont gérées
en master, et les zones `home.wxcafe.net` et `103.177.67.80.in-addr.arpa` sont
gérées en slave. Nous n'examinerons ici que les déclarations de zones sur ce
serveur, et pas sur home., car elles sont sensiblement les mêmes. La différence
principale étant que l'un héberge en slave les masters de l'autre.
Le fichier `named.conf.local` sur wxcafe.net contient donc

zone "wxcafe.net" {
type master;
file "/etc/bind/master/wxcafe.net";
allow-transfer {
80.67.177.103;
};
};

zone "home.wxcafe.net" {
type slave;
file "/etc/bind/slave/home.wxcafe.net";
masters {
80.67.177.103;
};
};

zone "46.76.39.5.in-addr.arpa" {
type master;
file "/etc/bind/master/46.76.39.5.in-addr.arpa";
allow-transfer {
80.67.177.103;
};
};

zone "103.177.67.80.in-addr.arpa" {
type slave;
file "/etc/bind/slave/103.177.67.80.in-addr.arpa";
masters {
80.67.177.103;
};
};

Cela devrait être relativement clair. Globalement, les zones master ont un
fichier dans `/etc/bind/master/`, et les slaves un fichier dans
`/etc/bind/slave/`, les masters autorisent le transfert vers home.wxcafe.net
tandis que les slaves déclarent home.wxcafe.net comme master, et le reste est
assez parlant.

Voyons maintenant le fichier de zone concernant wxcafe.net, soit
`/etc/bind/master/wxcafe.net` :
$TTL 3600 ; 1 hour
@ IN SOA ns.wxcafe.net. wxcafe.wxcafe.net. (
2014011001 ; serial
3h ; refresh
1h ; retry
168h ; expire
300 ; negative response ttl
)
; Name servers
IN NS ns.wxcafe.net.
IN NS ns.home.wxcafe.net.
; Mail exchangers
IN MX 10 wxcafe.net.
IN SPF "v=spf1 ip4:5.39.76.46 a -all"
; Main A/AAAA records
IN A 5.39.76.46
ns IN A 5.39.76.46
; Aliases
data IN CNAME wxcafe.net.
; [...]
www IN CNAME wxcafe.net.
; home.wxcafe.net. definition
$ORIGIN home.wxcafe.net.
@ IN NS ns.home.wxcafe.net.
IN NS ns.wxcafe.net.
ns IN A 80.67.177.103
IN A 80.67.177.103



Alors. Expliquons ligne par ligne.
Tout d'abord, le TTL (time to live) est un paramètre définissant le temps
pendant lequel les serveurs récursif (qui font un cache des données) doivent
cacher ce fichier de zone.
Le @ est un raccourci pour exprimer le nom de domaine courant. Ici, donc,
wxcafe.net.
Maintenant, nous arrivons a un record important : SOA (Start of Authority).
Ce record prend de nombreux arguments, dans l'ordre :
- Le nameserver autoritaire pour le nom de domaine en question,
- L'adresse email du responsable de cette zone, avec le premier point
remplacé par un @,

puis entre parenthèses :
- Le numéro de série ("version" du fichier de zone, ici au format
YYYYMMDDNN)
- La période de refresh, période entre chaque mise a jour du nameserver
authoritaire secondaire,
- La période de retry, le temps entre chaque essai de mise a jour si le
nameserveur authoritaire primaire est indisponible,
- La période d'expire, le temps qu'attendra le serveur autoritaire
secondaire avant de supprimer les informations de son cache si le primaire
reste indisponible, et enfin
- La période de TTL négatif, le temps qu'attendra le serveur secondaire
avant de ne plus offrir les informations de cette zone si le serveur
primaire est injoignable.

Bon, tout ceci est peut-être un peu confus, mais ce n'est pas le record le plus
important a lire (pour les humains en tout cas). Continuons :

NS (nameserver) permet de désigner les différents nameservers faisant autorité
pour ce domaine.

MX permet d'indiquer ou il convient d'envoyer les emails pour ce domaine.
SPF est un record d'authentification pour les emails.
Les records A désignent l'association entre un nom de domaine et une adresse
IPv4. Les records AAAA font de même pour les IPv6, mais malheureusement ce site
n'est pas encore en IPv6.

Les CNAME (canonical name) sont en quelque sorte des alias, ils permettent de
mettre en place des domaines exactement semblables a d'autre (ce qui permet par
exemple de filtrer ensuite avec les Virtual Hosts d'Apache, pour le web)

Enfin, la partie qui suit commence avec une déclaration $ORIGIN, ce qui permet
de changer la valeur du @ et des noms de domaine non complets (qui ne se
terminent pas avec un .). Ainsi, la partie suivant définit les nameservers et
l'adresse IP principale de home.wxcafe.net et de ns.home.wxcafe.net. Comme on
l'a vu, étant donné que ce nom de domaine est géré par un autre serveur DNS,
cela permet de rediriger les requêtes nous parvenant et demandant un domaine se
trouvant sous home.wxcafe.net.

Les autres fichiers de zone sont sensiblement similaires, avec les quelques
différences n'étant en fin de compte que des différences de valeurs (dues au
fait que, eh bah, c'est pas les mêmes domaines...).

Voila donc une courte explication de ce qu'est le DNS. Bien entendu, tout n'est
pas expliqué ici, je ne suis passé que sur ce qui est en place au niveau de
wxcafe.net, et encore, rapidement. Si vous voulez en savoir plus, vous pouvez
aller vous renseigner directement a la source : le [RFC
1034](https://www.ietf.org/rfc/rfc1034.txt) et le
[RFC 1035](https://www.ietf.org/rfc/rfc1035.txt). Dans un autre style (bien plus
avancé) le blog de [Stéphane Bortzmeyer](http://bortzmeyer.org) est interessant
aussi.


+ 84
- 0
content/gnulinux-pour-les-non-technophiles-ou-los-libre-pour-votre-grand-mere.md View File

@@ -0,0 +1,84 @@
Title: GNU/Linux pour les non technophiles, ou l'OS libre pour votre grand-mère
Date: 2012-08-22 20:33
Author: Wxcafe
Category: Teaching
Slug: gnulinux-pour-les-non-technophiles-ou-los-libre-pour-votre-grand-mere

GNU/Linux est un vaste et extraordinaire territoire technologique, mais
je ne vais pas m'attarder ici sur les aspects profondément techniques de
ce territoire pour faire plutôt une sorte d'introduction a ce qu'est
vraiment GNU/Linux, pour les gens n'ayant aucune ou très peu de
connaissances en informatique.

GNU/Linux, que j’abrégerai ici en Linux pour plus de simplicité, est un
Système d'Exploitation. Un système d'exploitation est, pour simplifier,
un ensemble d'outils informatiques qui vous permettent d'utiliser votre
ordinateur, ainsi, Windows est un système d'exploitation. L'abréviation
de système d'exploitation (Operating System en anglais) est OS. Les 4
principaux OS existants aujourd'hui sont Windows, Mac OS, GNU/Linux, et
Solaris. Les trois derniers sont issus d'un autre système, plus ancien,
nommé UNIX.

De ce fait, on pourrait penser que Linux remplace complètement Windows
une fois installé, et comprend une interface graphique, et toutes sortes
d'utilitaires permettant a l'utilisateur d'utiliser le système (sous
Windows, pensez a l'explorateur de fichiers, ou a Internet Explorer.
Pour l'interface graphique, pensez a... Pensez que votre système affiche
autre chose que des lignes de commande.) Or non, une fois installé,
Linux en lui même ne vous afficherait aucune interface graphique, et
s'il est effectivement livré avec des utilitaires, ils ne sont que des
programmes en ligne de commande. Autant les utilisateurs avancés sauront
s'en servir, et pourront argumenter que c'est plus efficace ou plus
rapide, autant les utilisateurs basiques préfèrent une interface
graphique. Alors comment en obtenir une?

Ici, il convient de faire une précision importante. Si il n'existe
qu'une seule version de Windows, ou de Mac OS, il existe en fait
plusieurs centaines de "versions" différentes de Linux. Appelées
distributions, ces dernière sont développées par des groupes
complètement séparés, et se basent sur le fait que Linux soit
entièrement placé sous licence libre (ce qui leur permet de l'utiliser a
leur guise, a condition que leur travail soit lui aussi placé sous
licence libre). De ce fait, de nombreuses distributions existent et se
développent en parallèle. On peut ainsi citer [Debian][], qui est l'une
des distributions les plus importantes, ou encore [Ubuntu][], qui est
l'une des plus connues et des plus simples a utiliser.

Ainsi, ces distributions intègrent une interface graphique. Cependant,
grâce a la liberté dont bénéficient les développeurs sous Linux, il
existe de nombreuses interfaces graphiques différentes : [Unity][], la
nouvelle interface d'Ubuntu; [GNOME][] , une interface qui vise a la
simplicité; ou encore [KDE][], une interface utilisateur ressemblant a
Windows 7.

Ainsi, le choix astronomique de distributions Linux a bien un sens :
chacune d'entre elle intègre des outils différents. Par exemple, Debian
intègre GNOME 2, qui est l'ancienne version de GNOME, ce qui la rend
particulièrement stable. Ubuntu intègre Unity, ce qui en fait une
distribution particulièrement intuitive. Linux Mint intègre Cinnamon,
qui est une version dérivée de GNOME 3, ce qui permet encore une autre
expérience. Et Arch Linux n'intègre pas d'interface graphique du tout,
ce qui permet a l'utilisateur de choisir entre les multiples interfaces
existantes.

Ce qu'il est important de retenir de cela, c'est que Linux est un OS
complètement libre, ce qui signifie que n'importe qui peut modifier et
utiliser tout le code de Linux gratuitement et comme il l'entend. Ainsi,
Linux est un OS qui est véritablement créé par des passionnés, pour tous
et toutes. Surtout, il convient de retenir que Linux n'est pas compliqué
a utiliser, ni a installer. Windows et Mac OS ne le sont pas non plus.
Cependant, Linux donne la possibilité a l'utilisateur de le rendre
affreusement complexe, mais aussi de le rendre adapté a ses besoins,
quels que soient ceux ci. Et c'est la que réside l'incroyable puissance
de ce Système d'Exploitation. Il est extraordinairement adaptable.

N'hésitez donc pas a le présenter a vos proches, même s'ils ne sont pas
technophiles. Ils pourraient adorer, et peut être même le devenir :)

A bientôt!

[Debian]: http://debian.org
[Ubuntu]: http://ubuntu.com
[Unity]: unity.ubuntu.com
[GNOME]: gnome.org
[KDE]: http://kde.org/

+ 158
- 0
content/introduction-a-bash-en-tant-que-language-de-programmation.md View File

@@ -0,0 +1,158 @@
Title: Introduction a bash en tant que language de programmation.
Date: 2012-09-08 18:15
Author: Wxcafe
Category: Programmation
Slug: introduction-a-bash-en-tant-que-language-de-programmation

L’interpréteur de commandes bash (Bourne Again SHell)
est possiblement le shell le plus connu, notamment grâce a son
intégration en tant que shell par défaut dans les distributions Linux
les plus répandues (Debian - Ubuntu, Fedora, OpenSUSE, Mandriva -
Mageia, etc...).

Cependant, il n'est souvent connu qu'en tant qu’interpréteur de
commande. Alors qu'en réalité, le bash est un langage de programmation
(presque) complet! Ainsi, il intègre les structures de contrôle
habituelles ( pour mémoire, les structures de contrôle comprennent les
conditions (les ifs), les boucles (les while), et les choix (les case),
entre autres.), et est donc ce que l'on pourrait appeler un langage de
script, interprété, de la même façon que python, a la difference près
qu'il contient un prompt (un système d'entrée de commande interactif)
bien plus complet et développé que python.

Cependant, les programmes en bash ne sont executables que dans un
environnement de type UNIX, et donc pas sous Windows (cygwin
(cygwin.com) propose ceci dit un système permettant d'utiliser bash sous
windows. Il faut malgré tout convenir que cet environnement est bien
plus compliqué a manipuler, et globalement ne permet pas d'acceder a des
portages de qualité satisfaisante.)

Ainsi, il est possible de créer des fichiers .sh, contenant des
instructions bash mises a la suite (de la même façon qu'un script BATCH
Windows .bat), et faisant appel autant aux commandes internes de bash,
aussi bien que les commandes externes mises en place par les programmes
installés sur le système, exactement comme dans une invite de commande.
Ainsi, pour appeller firefox, la commande 'firefox' lancera le petit
panda roux directement dans la boite magique, tandis qu'un if
[condition] suivi d'un then (quelque chose) lancera le fameux quelque
chose suscité si la condition est vérifiée. Un peu comme en C, quoi.

De cette façon, et avec quelques informations et connaissances, il est
facile de comprendre le fonctionnement de la programmation en bash.
Quelques exemples commentés:

#!/bin/bash
# La ligne du dessus est très importante, c'est elle qui dit a bash quel doit être
# l'interpreteur des commandes écrites dans ce script. Ici, on dit a bash d'interpréter
# lui même les commandes comprises dans ce script. On aurait tout de fois pu lui faire
# executer du python, par exemple, en mettant #!/usr/bin/python a la place.
echo "this is a test of bash as a simple script manager" # echo est une commande d'affichage de message.
echo "what's your name, user?"
read your_name # la commande read permet de demander a l'utilisateur de donner une
# information, stockée dans la variable en paramètre.
echo $your_name "is your name" # echo permet aussi d'afficher la valeur de variables.
# Ici, on renvoie la variable remplie précédemment, suivie d'un message.
exit # cet appel a exit n'est pas obligatoire, mais donne un aspect plus
# propre au code. Il ne quittera pas la session de terminal, cependant.

Voila. Ce script bash ne sert pas a grand chose, mais il a le mérite
d'être clair quand aux capacités et a la simplicité du bash en tant que
language de programmation. Alors en effet, nous n'avons ici absolument
pas utilisé les capacités de bash en lui même, et n'avons fait que le
renvoyer a des programmes externes (sauf read, il est vrai). Voyons
maintenant la syntaxe de bash quand il s'agit d'utiliser les structures
de contrôle:

#!/bin/bash
echo "welcome to this second bash program. would you please kindly enter the name of the machine you're running this on?"
read host_name
if [ $host_name == $HOSTNAME ] ## voici la syntaxe du if. Attention a bien penser a mettre les espaces avant la première variable, et après la seconde. La variable $HOSTNAME ici utilisée est une variable présente par défaut sur le système.
then echo "you told the truth!"
fi ## le fi est la commande fermant le if, tout comme le EndIf en basic. C'est un peu vieillot, mais important en bash.
if [ $host_name != $HOSTNAME ] ## l'opérateur != est l'inverse de ==, il vérifie donc si les deux variables ne sont pas les mêmes.
then echo "you lied!"
fi
exit

Voila un petit programme permettant d'apprendre la syntaxe du if en
bash. comme vous pouvez le voir, le language est plutôt lite, et la
structure if n'est pas très difficile a prendre en main.

Passons maintenant au while:

#!/bin/bash
echo "what is your name?"
read name
while [ 1 < 10 ] ## le while se présente sous la forme while (truc); do (machin); done. Les [] sont en fait des programmes differents, inclus dans bash.
do echo "i love" $name
done
exit

Ce petit programme permet d'observer les bases de while (qui est la
boucle de base en bash).

Le troisième opérateur de bash est case. Voyons:

#!/bin/bash
echo "please enter a number between one and five"
read number
case $number in
1)
echo "the choosen number was one"
;;
2)
echo "the choosen number was two"
;;
3)
echo "the choosen number was three"
;;
4)
echo "the choosen number was four"
;;
5)
echo "the choosen number was five"
;;
*)
echo "this number is not correct"
;;
esac
exit

case est un opérateur plus complexe a utiliser a bon escient, et sert a
faire des ifs multiples sans avoir a taper des dizaines de lignes de
code.
(pour ceux qui auraient du mal avec cet opérateur, il faut comprendre
que le code vérifie chacune des conditions : le 1) est validé si la
valeur de \$number est 1, le 2) est validé si cette valeur est 2, etc..
le \*) désigne toutes les valeurs, et est donc validé si aucune autre
valeur n'a précédemment acceptée.

Quelques notions manquent ici:
- les nombres aléatoires sont générés par un appel a la variable
\$RANDOM, qui renvoie un nombre aléatoire entre 0 et 32767 (un entier a
16 bits donc). il est possible de faire des invocations a des nombres
aléatoires plus grands, mais les méthodes permettant de faire cela sont
plus complexes, et je ne les aborderai donc pas ici.
- comme vous avez pu le constater, les variables sont désignées en tant
que telles par l'utilisation d'un symbole \$ au début de leur nom.
Ainsi, echo number renverra "number", tandis que echo \$number renverra
le résultat de la variable \$number.
être utilisées dans un programme bash.
- comme vous avez pu le constater, les commandes doivent tenir en
théorie en une ligne. Cependant, le caractère \\ permet de retourner a
la ligne en faisant considérer a bash qu'il s'agit de la même ligne.

Globalement, il faut admettre que bash n'a pas vocation a être un
langage de programmation extrêmement développé. Sans framework
graphique, avec peu de manières d'utiliser de grandes variables, ou
encore une gestion de la mémoire risible, bash n'a rien d'un langage de
développement professionnel.
Cependant, le simple fait qu'il soit considéré comme un langage de
programmation a part entière font de lui un langage de script d'une
puissance incontestable, et sa simplicité et sa grande popularité font
de lui un langage de choix pour apprendre la programmation simplement et
sans trop se prendre la tête.

J'espère que cet article aura été utile a certain-e-s, et je vous
souhaite bonne chance dans votre découverte de la programmation (n'allez
pas voir ceux qui font de l'orienté objet, c'est des méchants :3)

+ 177
- 0
content/la-cryptographie-avec-pgp-et-principalement-gnupg.md View File

@@ -0,0 +1,177 @@
Title: La cryptographie avec PGP et principalement GnuPG
Date: 2012-11-19 00:36
Author: Wxcafe
Category: Tutoriel
Slug: la-cryptographie-avec-pgp-et-principalement-gnupg

PGP (pour [pretty good privacy][]) est un système de
chiffrement asymétrique (pour plus d'information sur le chiffrement
asymétrique, voir [ici][]) utilisant en général les algorithmes RSA
et/ou DSA, et pouvant servir a chiffrer tout fichier, mais aussi a
signer des emails. Le système de signature consiste a s'identifier en
tant que la personne que l'on est, en certifiant de son identité, et
repose sur un système dit de *Web of Trust*.

Ce concept de Web of Trust est simple: si je valide le code vous
identifiant (votre clé), en certifiant que vous êtes qui vous êtes et
que je vous connais, et que d'autres personnes m'ont déjà
personnellement validé, les autres utilisateurs seront enclins a croire
que vous êtes en effet la personne que vous prétendez être. Bien
entendu, les utilisateurs validant trop de clés rapportées comme fausses
voient la valeur de leurs signatures baissée, et toutes les clés signées
par ces utilisateurs voient leur crédibilité baisser.
Inversement, les "bons utilisateurs" voient la valeur de leurs
signatures augmentée, ce qui augmente la crédibilité des clés qu'ils ont
signées.

Ceci dit, un email peut être a la fois signé et chiffré, de façon a être
sûr, non seulement que l’expéditeur de l'email est bien celui qu'il dit
être, mais aussi que l'email n'a pas été modifié entre l'envoi et
la réception (en effet, avec un chiffrement de type RSA/DSA, une
modification du corps de l'email rend ce dernier illisible, la clé
publique ne  correspondant plus a la phrase de passe du message), ce qui
offre bien évidemment des avantages non négligeables dans un
environnement ou la protection des échanges est importante (soit a peu
près partout sur internet, si vous tenez a votre vie privée. Pensez a
[quitter Gmail][] aussi, par exemple).

Il est cependant a noter que les clés publiques sont généralement
situées sur un serveur de clés publiques, tel pgp.mit.edu ou encore
subkeys.pgp.net (certaines personnes préfèrent garder leur clés hors des
serveurs de clés publiques, craignant une compromission de ces serveurs.
Dans le cas d'utilisateurs normaux (c'est a dire n'échangeant pas de
secrets classés secret-défense par email), la protection offerte par les
serveurs de clé publiques est suffisante)

L'une des implémentations les plus connues et utilisées de PGP est sans
conteste GPG ([GNU Privacy Guard][]) , qui comme son nom l'indique fait
partie du projet GNU, et qui (`<troll>` de façon surprenante pour un
programme GNU`</troll>`) est extrêmement efficace et claire.

Après ces explications techniques, voici venue le
moment intéressant/utile, a savoir l'application. Le chiffrement et la
signature de mails doivent cependant attendre un petit peu, étant donné
qu'il vous faut d'abord créer votre clé et la placer sur un serveur de
clés publiques, de façon à ce que votre destinataire puisse vous
identifier lorsqu'il recevra le mail, mais aussi a configurer votre
client mail pour utiliser gpg (je baserai les explications de cet
article sur Thunderbird, mais des explications efficaces sont trouvables
facilement sur les interwebs).

Tout d'abord, générons une clé GPG :

gpg --gen-key

GPG va vous demander les méthodes de chiffrement que vous voulez
utiliser, le plus sur est de laisser la valeur par défaut. La question
suivante est de savoir quelle taille votre clé doit faire, il est
préférable de choisir la taille la plus importante possible (4096). GPG
veut ensuite savoir quand votre clé doit expirer. La méthode simple est
bien évidemment de ne jamais la faire expirer, il est cependant plus
intéressant dans une logique de sécurité de régler cette durée a six
mois/un an.

Des informations personnelles vous sont ensuite demandées,
concernant votre nom (mettez le vrai, tel qu'il apparaît sur votre carte
d'identité, si vous souhaitez utiliser votre véritable identité), votre
adresse mail (mettez la plus utilisée, vous pourrez en rajouter plus
tard), et un mot de passe pour la clé (utilisez un mot de passe
sécurisé!! Il est conseillé d'utiliser au moins 8 caractères, dont majuscules,
minuscules, caractères spéciaux et nombres (vous pouvez utiliser la
commande `makepasswd`, qui génère automatiquement un mot de
passe)

GPG va maintenant prendre un peu de temps pour générer le couple clé
publique/clé privée, vous devriez profiter de ce temps pour effectuer
des opérations autres sur votre ordinateur : taper des textes, lancer
des films, écouter de la musique... De façon à augmenter les chances
d'obtenir un nombre bien aléatoire (le générateur d'aléatoire se base
sur la RAM pour obtenir des bits au hasard)

Une fois cela fini, vous obtenez un couple clé publique/clé privée, que
vous ne pouvez pas visualiser entièrement pour l'instant. Il est
cependant possible (et recommandé) de les exporter pour les sauvegarder
via une commande:

gpg --armor --export --output=pubkey.gpg

pour la clé publique, et

gpg --armor --export-secret-keys --output=seckey.gpg

pour la clé privée. Il est possible et même souhaitable de copier ces
clés sur une clé USB, une carte SD, ou un autre support de stockage
résistant, de façon a avoir une solution de sauvegarde, au cas ou vous
perdiez ces clés sur ce PC.

Cela fait, listons les informations sur votre clé publique :

$ gpg --list-keys --fingerprint
pub 4096R/27D81AC8 2012-11-17
Key fingerprint = 6345 A91A FF89 97E0 13D0 96A9 9E2A 1917 27D8 1AC8
uid Clément Hertling (Wxcafe)
uid [jpeg image of size 14692]
sub 4096R/9ED7F77F 2012-11-17

La partie `pub` indique que c'est une clé publique, `4096R` indique que c'est
une clé RSA sur 4096 bits. La partie `27D81AC8` est
l'identifiant de la clé publique, `Key fingerprint = 6345 A91A FF89 97E0 13D0
96A9 9E2A 1917 27D8 1AC8` est appelé fingerprint de la clé. Les champs
`uid` sont des manières d'identifier la clé et la personne associée a
celle-ci, et enfin le champ `sub` est indicateur d'une subkey, système
uniquement pris en charge par GPG et non inclus dans les premières
versions de PGP, donc non-implémentées dans nombre de clients pgp.
Passons maintenant a la mise en place de cette clé publique sur un
serveur de clés : nous utiliserons ici le serveur pgp.mit.edu.

gpg --keyserver pgp.mit.edu --send-keys *ID de la clé a uploader*

Maintenant que votre clé publique a été uploadée, vous pouvez l'utiliser
pour signer et chiffrer vos emails!
Installons donc l'extension Enigmail pour Thunderbird, permettant de
chiffrer/signer vos emails de façon transparente. Il conviendra de
paramétrer cette extension, via le menu OpenPGP dans Thunderbird, puis
Setup Wizard (l'option entre Help et About OpenPGP). Normalement,
Enigmail détecte votre installation de gpg automatiquement, si cependant
ce n'était pas le cas, vous pouvez utiliser la clé exportée tout a
l'heure (pubkey.gpg) en l'important (import key from file).

Selon les options que vous avez utilisées, vos emails seront
automatiquement signés et/ou chiffrés a l'envoi. Gardez cependant a
l'esprit que si tout le monde peut lire les mails signés, il n'en est
pas de même pour les mails chiffrés, pour lesquels il est nécessaire de
posséder la clé publique du correspondant en question, et de posséder
soi même une clé privée, donc d'utiliser OpenPGP aussi.
Concernant les signatures de clés, elles fonctionnent de manière très
simple :
Vous devez télécharger la clé de votre correspondant, via un

gpg --keyserver pgp.mit.edu --search-keys *ID de la clé de votre correspondant*

(a noter que cette commande fonctionne aussi en cherchant une adresse
email ou un nom. Cependant, en cherchant via l'identifiant de la clé,
vous êtes sur de trouver votre correspondant. Globalement, l'email est
lui aussi assez sûr en terme de recherche de clés, tandis que le nom
donne rarement un résultat). L'étape suivante est de vérifier que votre
correspondant est bien la personne qui est spécifiée sur sa clé. Pour
cela, il convient d'avoir déjà vu physiquement cette personne et si
possible d'avoir vu une pièce d'identité lui appartenant, et d'avoir une
confirmation de cette personne que la clé que vous voyez lui appartient
bien.
Ceci fait, vous pouvez signer la clé via un

gpg --sign *ID de la clé a signer*

puis la renvoyer au serveur via

gpg --keyserver pgp.mit.edu --send-key *ID de la clé a signer*

Voila, la clé de votre correspondant est signée!

Ce tutoriel sur PGP/GPG est terminé, et votre sécurité est améliorée
grâce a cette superbe invention qu'est la cryptographie!

[pretty good privacy]: http://fr.wikipedia.org/wiki/Pretty_Good_Privacy
[ici]: http://fr.wikipedia.org/wiki/Cryptographie_asym%C3%A9trique
[quitter Gmail]: http://www.hauteresolution.net/pourquoi-je-vais-quitter-gmail/
[GNU Privacy Guard]: http://fr.wikipedia.org/wiki/GNU_Privacy_Guard

+ 75
- 0
content/la-programmation-expliquee-simplement.md View File

@@ -0,0 +1,75 @@
Title: La programmation expliquée simplement
Date: 2012-08-27 00:22
Author: Wxcafe
Category: Teaching
Slug: la-programmation-expliquee-simplement

Salut!
Tout d'abord, je tiens a m'excuser de ne pas avoir eu le temps d'écrire
récement, mais j'ai eu la chance d'avoir un PC a monter, donc j'ai passé
pas mal de temps assez occupé.

Enfin, après un certain temps a farfouiller au millieu des connecteurs
SATA et a apprendre que, oui, l'alimentation sert aussi pour les disques
durs, je suis de retour pour un court article.
Du coup, je m'étais dit que j'allais reprendre sur le thème de
l'informatique expliquée au grand public, en tentant d'aller un peu plus
loin que la dernière fois sur le thème de la programmation
Ce qu'il faut comprendre, c'est la facon dont fonctionne un ordinateur.
Si a peu près tout le monde sait que "les ordinateurs, ils ne
comprennent que les 1 et les 0!", peu de gens savent comment cela
fonctionne en détail.

Si vous êtes sur ce blog, il y a pas mal de chance que vous ayez déjà
des notions de base en informatique. Ainsi, vous savez surement que les
ordinateurs fonctionnent avec des programmes, qui sont composés de
code.
Ainsi, il faut comprendre que le code (source) est "compilé" en un
fichier "binaire". Un fichier binaire est un fichier comprenant les
instructions telles qu’exécutées par le processeur, et donc absolument
illisible pour un humain.

La compilation est le processus qui transforme le code source en
binaire executable. Les binaires ont, sous Windows, l'extension .exe,
tandis que sous les systèmes UNIX-like, ils n'ont pas d'extension
particulière.
Ceci étant dit, il faut comprendre que certains langages sont plus
proches que d'autres du langage processeur, les langages les plus
proches sont dits de "bas niveau". Les langages les plus éloignés sont
donc dits de haut niveau.

Par exemple, l'assembleur est l'un des languages de plus bas niveau,
tandis que python par exemple est un langage de plus haut niveau. Les
langages de haut niveau sont souvent bien plus simples a comprendre et a
apprendre que les langages de bas niveau

Ainsi, en C, un langage de niveau relativement bas, pour afficher
"hello world" sur l'écran, le code nécessaire est :

#include
void main() {
printf("hello world");
return 0;
}

le même programme en python s'écrit :

print "hello world"

et n'a pas besoin d'être compilé , puisqu'il peut être intepreté
directement.

Python utilise en effet un système similaire a Java en ayant un
interpréteur dit "runtime" ou "temps réel", qui interprète le programme
sans le compiler. Java utilise un système légèrement différent, puisque
le code a besoin d'être compilé, mais est interpreté par un interpréteur
et non par le processeur.

Cette méthode permet le fameux "code once, run everywhere", ce qui
signifie que le même code est exécutable sur quasiment tous les systèmes
d'exploitation (en fait, tous ceux sur lesquels l’interpréteur est
disponible.)

Voila, je vous laisse sur le fonctionnement de Java et de Python, et je
vais me coucher.
A bientôt!

+ 108
- 0
content/la-separation-des-eglises-et-de-letat-une-idee-quelle-est-bonne.md View File

@@ -0,0 +1,108 @@
Title: La séparation des églises et de l'état, une idée qu'elle est bonne?
Date: 2012-12-13 03:08
Author: Wxcafe
Category: Ranting
Slug: la-separation-des-eglises-et-de-letat-une-idee-quelle-est-bonne

Aujourd'hui, et depuis 1901 (j'ai révisé mon histoire récemment), il
existe une loi dite de séparation des églises et de l'état, qui consiste
a faire en sorte que l'état n'ait rien a voir avec les differentes
églises, pour de sombres histoires d'indépendance et de laïcité.
(principes qui sont aujourd'hui en voie de disparition, mais ce n'est
pas le propos qui nous occupe ici). Cela dit, cette bonne idée
politique, si elle a évité a ses auteurs de nombreux tracas, et leur a
surement permis de conserver une tête en état de fonctionnement bien
reliée a leur colonne vertébrale, ne vous interesse que moyennement, et
vous voudriez retourner répondre a vos mails sur Gmail et micro-blogguer
(quel mot horrible...) sur twitter?

Ça tombe bien, vous abordez justement le sujet véritable de cet article
(non, mon blog n'est pas devenu un histoblog, désolé aux déçus...), a savoir
la centralisation qui se met progressivement en place sur internet depuis
quelques années : Twitter, Google, Facebook, Micro$oft, Apple, tous ces
acteurs du web (et pas que, pour certains...) ont commencé a prendre
pour manie de centraliser vos données : pour prendre un exemple simple,
si vous utilisez Gmail (qui depuis quelque temps, lit aussi vos mails
pour accorder la publicité, dites adieu a votre vie privée), vous avez
un compte Google Talk, probablement aussi un Google+.

L'outil le plus pratique aujourd'hui pour aggreger des flux RSS est
Google Reader, et vous l'utilisez aussi probablement. Votre téléphone
est un android? Ah, un Nexus? Vous avez donc toutes les applications
google installées, et Chrome mobile comme navigateur par défaut, qui est
synchronisé avec la version qui tourne sur votre PC (via les serveurs de
Google, bien sur).
Depuis peu, les recherches sur le moteur de recherche
sont elles aussi ajoutées a votre profil, enregistrées a jamais par
Google (qui n'est pas touchée, en tant que société américaine, par la
"loi des 10 ans" francaise.). Vous commencez a voir le truc? Non, ne
jetez pas ce telephone, enfin! (je refuse de rembourser tout smartphone
ayant été perdu a cause de cet article) J'ai pris ici comme exemple
Google, parce que c'est celui qui propose le plus de services, mais
Apple avec iCloud, iTunes et son iPhone fait pareil, tout comme M$ avec
WP8 et Skydrive.

Twitter et Facebook n'ont de rôle dans ce sujet qu'en ce que vous leur
fournissez des informations dont ils s'empressent de devenir seuls
propriétaires (cf les Conditions d'Utilisation de ces deux services),
puis de les revendre a des annonceurs faisant de la publicité
ciblée. Le problème est simple a apprehender, vous ne voulez pas que
l'un de ces services connaisse trop de choses sur vous (et ils recoupent
très bien les informations venant de sources differentes), car il est
évident qu'ils les vendent a des entreprises peu scrupuleuses quand
a leurs engagements de confidentialité, quand a leurs securité
aussi; mais surtout parce que depuis le 11 Septembre 2001 et le
Patriot Act, toute entreprise américaine **doit**fournir toutes ses
informations au gouvernement américain **sans aucune intervention d'un
juge, ou de quelque institution de controle que ce soit.**

Ce qui est, comme vous pouvez le comprendre, relativement
problématique. (pour ceux qui a ce point se disent "je n'ai rien a
cacher, donc je m'en fous si le gouvernement américain sait tout de
moi", je vous conseille d'aller lire [cet article][] de Jean Marc
Manach, plein de bon sens...) Pour éviter cela, vous avez plusieurs
possibilités: utiliser des services concurrents pour tout (Facebook
Mail, Skydrive, Twitter et Google Reader par exemple), tout en vous
souvenant que comme ces entreprises sont toutes américaines, le
gouvenrnement américain détient tout de même vos informations, et que ca
lui prendra juste un peu plus de temps.

Vous pouvez aussi n'utiliser que des entreprises francaises,
mais cela ne regle que le problème du Patriot Act, et pas celui de
la revente de vos données. Et puis essayez de trouver un service équivalent
a Google Reader et fourni par une entreprise française, on en reparlera.
Non, la véritable alternative, c'est d'héberger vos services vous
même, d'avoir votre propre serveur sur lequel vous possedez le plus
de services possibles, et d'utiliser des concurents ou des services
libres au maximum pour les autres, ceux qui ne sont pas distribuables
(par exemple, les cartes sont difficiles a mettre en commun,
or plusieurs alternatives existent: Google Maps, `<troll>`Apple
Maps`</troll>`, Bing Maps, OpenStreetMaps, etc...).
Beaucoup de ces services sont cependant très facilement
décentralisables, surement parce qu'ils ont a la base étés conçus comme
des services décentralisés. Ainsi les emails, le web, le chat (via XMPP)
par exemple sont basés sur un système décentralisé.

De plus, votre serveur peut vous servir a beaucoup d'autres des
choses que vous feriez habituellement sur votre ordinateur
personnel: conserver une présence sur IRC, compiler du code, faire
du rendu vidéo, etc... En bref, un serveur peut vous servir
a effectuer toutes les opérations que vous effectuez sur votre
ordinateur sans les inconvénients de la consommation éléctrique
ni du bruit, mais vous permet aussi de ne dépendre aucunement
d'une entreprise américaine, et cependant de disposer de tous les
services utiles offerts par ces dernières.

Un serveur peut de plus vous permettre de controller parfaitement
tous ces services, sans aucune limitation d'aucune sorte,
voire de vous créer une page web. Bien entendu, il est bien plus
utile d'avoir un serveur si vous avez aussi un nom de domaine.
Heureusement, ils sont peu chers et souvent fournis avec le serveur.

Dans de prochains articles, je vous expliquerai comment louer puis
configurer votre serveur pour qu'il serve de serveur mail (IMAP/SMTP),
web, base de données, et proxy. Cela dit, comme c'est un serveur sous
linux, vous pouvez l'utiliser pour a peu près n'importe quoi.
Voila, a bientôt!

[cet article]: http://www.internetactu.net/2009/03/12/la-vie-privee-un-probleme-de-vieux-cons/

+ 44
- 0
content/le-quenya-episode-o.md View File

@@ -0,0 +1,44 @@
Title: Le Quenya - Épisode ø
Date: 2012-09-18 19:07
Author: Wxcafe
Category: Language
Slug: le-quenya-episode-o

Le Quenya est, pour ceux qui ne connaissent pas (comme moi jusqu’à il y
a peu...), le nom que donnait Tolkien au dialecte principal parlé par
les Elfes dans les différentes œuvres de l'auteur, dont Le Seigneur des
Anneaux, le Hobbit, ou encore le Silmarillion. Il faut se rendre compte
avant de commencer cet article que l'une des œuvres les plus
impressionnantes de Tolkien, si ce n'est la plus grande, est
l'impressionnant travail linguistique passé sur les différentes langues
présentes dans son œuvre littéraire : L'elfique, qui est donc le quenya,
la langue des nains, qui est appelé le khazalide, etc.

En effet, a contrario des "langues" développées dans d'autres œuvres littéraires
telles Eragon ou Harry Potter, où l'auteur-e se contente de lier un mot
de français (ou d'anglais) a un mot de sa "langue", les langues de
l'oeuvre de Tolkien sont des langues complètes. Elles possèdent des
racines logiques, des systèmes de grammaire et de conjugaison propres,
une logique inhérente dans la prononciation ou l'orthographe, et ainsi
de suite.

Un véritable rêve de linguiste donc, puisque ces langues sont
pratiquement entièrement documentées par Tolkien lui même (voir
l'appendice E du SdA, particulièrement instructif a ce sujet.)

J'ai donc décidé d'apprendre le Quenya récemment, et je vais donc poster
ici des résumés des cours que je suis ( disponibles [ici][] , une
traduction en français est disponible [la][] en pdf ), et des infos ici
toutes les deux semaines.

Si ce sujet vous intéresse, le compte twitter @Quenya101 poste
régulièrement des informations sur le sujet, et pour plus d'infos sur le
sujet, vous pouvez en trouver [par ici][].

Et en tant que première leçon, vous pouvez apprendre que ce mot que vous
avez prononcé comme le Kenya tout le long de cet article se prononce en
fait [Kwenïa], ou bien Qwenya!

[ici]: http://folk.uib.no/hnohf/qcourse.htm
[la]: http://www.ambar-eldaron.com/telechargements/integraleshelge.pdf
[par ici]: olk.uib.no/hnohf/quenya.htm

+ 94
- 0
content/les-differentes-couches-dun-systeme-dexploitation.md View File

@@ -0,0 +1,94 @@
Title: Les différentes couches d'un système d'exploitation
Date: 2012-09-06 23:29
Author: Wxcafe
Category: Teaching
Slug: les-differentes-couches-dun-systeme-dexploitation

Étant utilisateur plus ou moins fidèle de GNU/Linux depuis quelques
années (plus ou moins, parce que j'ai toujours un Windows en dual boot,
principalement pour les jeux (possiblement plus pour longtemps, avec
l'arrivée de Steam pour Linux... ) ), je commence a connaître plus ou
moins bien mon système. Or il y a plusieurs choses a savoir sur les
systèmes d'exploitation, et celle dont je vais parler aujourd'hui, c'est
le système de couches.

Un système d'exploitation (de type UNIX, \<troll\>enfin un vrai système quoi.
\</troll\>) incorpore plusieurs systèmes de couches.

Ainsi, Linux (le noyau) a commencé en étant un kernel monolithique,
c'est a dire que tous les composants sont intégrés au kernel. Ce qui
signifie que rien ne peut être ajouté au noyau sans recompiler celui ci.
Or, quand on sait que le noyau comprend entre autres les drivers du
matériel et des systèmes de fichier, cela peut poser des problèmes quand
a la taille du kernel et a la licence libre de ce dernier.

Depuis un certain temps, le kernel linux est devenu un kernel modulaire, ce qui
signifie que des modules peuvent être chargé a tout moment en cours
d’exécution, ce qui permet l'utilisation de nouveaux systèmes de
fichiers a chaud, ou l'insertion de matériel et l'installation de
drivers sans interrompre l’exécution du système (Windows utilise un
système de fausse installation de drivers pour le matériel externe, et
un système de pré-installation des drivers pour les périphériques dits
"plug and play")

Après le noyau intervient le système. Or, au tous premiers instants du
boot, les systèmes GNU/Linux utilisent un système permettant de limiter
l'utilisation de ressources systèmes si elles ne sont pas nécessaires,
et incorpore ainsi un système dit de "runlevels"

Ainsi, au runlevel 0, le système s'éteint après avoir booté. Ainsi, ce
runlevel permet de tester le bon démarrage du système sans avoir a
effectuer de manipulation pour le ré-éteindre

Le runlevel 1 est appelé mode single user, et c'est un nom plutôt adapté
étant donné que ce runlevel donne accès a un système en étant
automatiquement loggé en tant que root, avec tous les autres
utilisateurs désactivés, de même que tous les systèmes de réseaux

Le runlevel 2 est appelé mode multi user, et vous mets en face d'un
système classique. en ligne de commande, mais avec tous les systèmes de
réseau désactivés.

Le runlevel 3 est le même que le 2, mais avec les systèmes de réseaux
activés.

Le runlevel 4 n'est pas officiellement défini, et est censé être
activable en fonction des besoins de l'utilisateur. Sur la plupart des
distributions grand public, ce runlevel est lié au...

Runlevel 5! Multi-user, networking, with working GUI! c'est le système
tel que vous le connaissez, avec l'interface graphique et le système de
login graphique.

Le runlevel 6, enfin, est le bien nommé "reboot", qui reboot la machine
quand il devient le runlevel courant.

(Il est a noter que Debian, et donc toutes les distribs qui en sont
dérivées, ne font pas de distinction entre les differents runlevels du 2
au 5. Ainsi, Ubuntu fonctionne par défaut au runlevel 2, avec un login
et une interface graphique, et un mode réseau fonctionnel, bref avec des
fonctionnalités qui ne sont normalement disponibles que sous le runlevel 5.)

Il est possible de changer de runlevel grâce a la commande runlevel
(oui, c'est évident...)

Les systèmes Linux utilisent aussi un système dit de SandBox , qui en
informatique est un système permettant d'isoler les processus les uns
des autres. Ainsi, la pile réseau, qui est le système auquel les
différents processus envoient les différents paquets qui doivent sortir
de la machine , et qui redistribue ces paquets, est isolée du reste du
système, en cela qu'aucun des autres processus ne peuvent modifier cette
pile hors du runlevel 1 ou 2.

De la même façon, le navigateur chrom/ium fait fonctionner tous les
onglets, ainsi que toutes les extensions, dans des processus différents.
Certaines distributions linux implémentent un système de cette sorte
pour toutes les applications, ou seulement pour certaines. ainsi Chakra
Linux a un système d'installation d'applications dans des disques
virtuels, ce qui permet une sécurité totale du processus.

Voila, j'espère vous en avoir appris un peu sur le fonctionnement des
différentes couches de linux, et j'espère que cet article vous poussera
a tester un peu votre système et a vous amuser avec les différents
runlevels


+ 123
- 0
content/les-systemes-de-fichiers.md View File

@@ -0,0 +1,123 @@
Title: Les systèmes de fichiers
Date: 2012-09-25 10:28
Author: Wxcafe
Category: Teaching
Slug: les-systemes-de-fichiers

Un système de fichiers. Vous en avez surement déjà entendu parlé si vous
avec déjà installé Linux, ou formaté une clé USB. Dans ces cas, vous
connaissez surement NTFS, EXT4, ou encore FAT32.

Ces différents noms désignent en effet des systèmes de fichiers. Mais
qu'est-ce qu'un système de fichiers?

Pour comprendre cela, il faut déjà savoir ce qu'est exactement un
fichier. Un fichier est un ensemble de blocs (les blocs sont l'unité la
plus petite traitable par le matériel, ils font généralement 1 ou 4 Kio
([kibioctet][]), en fonction du système de fichier utilisé.), qui est
donc composé de bits, interprétés différemment en fonction du type de
fichier. Cependant, seul, le fichier n'est pas accessible, puisqu'il
n'est pas indexé, c'est a dire que l'OS ne sait pas qu'il est présent,
ou il commence ni où il s'arrête (je schématise un peu, mais c'est
l'idée).

Ainsi, le système de fichier donne un cadre et un standard à
l'arborescence des fichiers. Par exemple, le système de fichier ext4
utilise des blocs de 1 Kio, et de ce fait, toutes les partitions de
disque dur formatées en ext4 peuvent prendre comme unité de base 1 Kio
et mesurer la taille des fichiers en blocs de cette façon. Les systèmes
de fichiers nécessitent l'inclusion de drivers dans le noyau pour
pouvoir être pris en compte.

Le noyau linux inclut par défaut les drivers pour ext2/3/4, btrfs,
reiserfs, ntfs, fat16/32 et hfsx, ce qui permet de monter a peu
près tout type de partition récente.

Il convient de bien faire la différence entre le système de fichier et
l'arborescence des fichiers. Si l'arborescence des fichiers est en fait
une entité virtuelle englobant la racine / et tous les fichiers et
dossiers contenus dedans, le système de fichier permet a votre système
GNU/Linux de distinguer les différents fichiers composants cette
arborescence.

Détaillons maintenant les types de fichiers les plus répandus:

- FAT16/32 : Les systèmes de fichier FAT (pour File Allocation Table,
soit la définition d'un système de fichier), remplissent leur rôle le
plus simplement possible. Ne permettant (historiquement) que des noms de
8 caractères (plus extension de trois caractères), ni chiffrement, ni
système de distinction d'utilisateurs (DOS étant un système
mono-utilisateur), Il fut décliné par microsoft en FAT16 et en FAT32,
utlisants respectivement des blocs de 16 et 32 Kio.

- NTFS :. Le NTFS (pour New Technology File System, rapport a Windows
NT) est un système de fichier qui est apparu avec Windows XP, et qui
était une mise a jour nécessaire du FAT32 vieillissant. NTFS ajoute a
FAT différentes capacités dont le chiffrement, les liens symboliques, la
compression et les quotas pour les volumes, permettant de limiter la
taille maximum occupée dans une partition.

- ReFS : ReFS est le système de fichiers introduit dans Windows Server 2012.
Ne différant pas énormément de NTFS, je le mentionne principalement
parce qu'il est prévu qu'il soit le défaut pour Windows 8.
Il apporte principalement la redondance, c'est a dire que chaque
fichier possède une somme de contrôle en 64 bits stockée dans un fichier
séparé pour éviter les corruption de disque.

- Ext2/3/4 : les systèmes ext (extended) sont les systèmes de fichiers
les plus utilisés sous linux pour le grand public. (Je traiterai ici
d'ext4, puisque c'est le plus récent.) Il dispose de toutes les
fonctions que l'on peut attendre d'un système de fichiers moderne, ni
plus ni moins. Ainsi, ext4 est un système de fichiers journalisé,
acceptant les capacités jusqu’à 1 Exioctet, et utilise l'allocation dite
"par extent", ce qui signifie que la création d'un fichier réserve
automatiquement les zones contiguës de façon a réduire la fragmentation.

- ReiserFS : ce système de fichiers, créé par le (légèrement mégalo)
programmeur Hans Reiser, est a retenir pour avoir été le premier système
de fichiers journalisé, et accepte un nombre de fichiers de l'ordre des
4 milliards. Le but de ce système est de créer un système polyvalent, a
la fois système de fichiers et base de donnée (de part sa grande
capacité en terme de nombre de fichiers et de l'utilisation d'un
journal.)

- Btrfs : ce système est l'évolution logique d'ext4, et inclut lui aussi
l'allocation par extent, mais possède de plus un système de
sous-volumes, qui permet d’accéder a plusieurs arborescences de fichiers
montées en même temps (système pratique et utile pour faire des
snapshots de systèmes.). Il permet aussi de redimensionner a chaud la
taille des partitions, en les agrandissant ou en les rétrécissant, est
compatible avec [LVM][], a un système de checking intégré (btrfsck), et
utilise un algorithme de compression appelé LZ4, qui accélère les accès
aux fichiers compressés d'environ 30% par rapport a LZO, le système
utilisé dans ext4.

- HFS+ : le système de fichier présent sur tous les macs a des capacités
relativement standards, et ressemble énormément a l'ext3. Il supporte
cependant les liens directs vers les dossiers, fonction rare sur les
systèmes de fichiers actuels. Il est possible qu'il évolue a nouveau
dans les années a venir

- ZFS : Ce système de fichier, venu de Solaris mais utilisable par Linux
et \*BSD, est, tel Btrfs, a la fois un système de fichier et un
remplaçant/compatible avec LVM, C'est un système de fichiers conçu
principalement pour les serveurs, et il intègre ainsi un système de
redondance des données pour éviter les corruptions, un mode RAID-Z
(apparenté au RAID5), des checks d’intégrité en continu, des snapshots,
etc...

Comme on a pu le voir, les systèmes de fichiers disponibles sont
légions. Cependant, le plus adapté a Linux et a une utilisation grand
public aujourd'hui est probablement Btrfs. Malheureusement, ce dernier
n'est pas aujourd'hui proposé par défaut sur les distributions les plus
utilisées, au profit de l'ext4, qui commence a accuser son âge...

Les systèmes de fichiers, s'ils peuvent ne pas sembler primordiaux au
fonctionnement du système, sont en fait de première importance, et ce
choix ne devrait pas être laissé au hasard, et être mis a jour
régulièrement (pour éviter les failles de sécurité...)

Bon courage, et bon choix pour votre prochain système.

[kibioctet]: http://fr.wikipedia.org/wiki/Kibioctet#Multiples_normalis.C3.A9s
[LVM]: http://fr.wikipedia.org/wiki/LVM

+ 81
- 0
content/linformatique-a-lecole.md View File

@@ -0,0 +1,81 @@
Title: L'informatique a l'école
Date: 2012-10-15 20:34
Author: Wxcafe
Category: Ranting
Slug: linformatique-a-lecole

Après avoir lu [cet article][] paru sur écrans.fr, et au vu des
nombreuses réflexions que j'ai eu sur ce sujet au cours des années, je
commence a me demander si la réponse logique ne serait pas d'enseigner
les bases de l'informatique (bases d’électronique, de programmation et
de logique formelle) dès le collège.

En effet, l'exemple qui me revient toujours est celui des technoprêtres
de warhammer 40 000, dans un univers ou la technologie est ritualisée et
incomprise même des plus savants, qui se contentent de reproduire ce qui
existe, et parfois par chance de retrouver un schéma explicatif lisible
par une machine, et qu'ils ne comprennent pas eux mêmes, ou toute
technologie est ointe d'onguents sacrés, entourée d'encens avant d'être
péniblement actionnée par des assistants ne comprenant rien a cette
technologie (ayant lu [Hackers - Heroes of the Computer Revolution][] de
Steven Levy, c'est l'ambiance que l'on retrouve quand l'auteur décrit
l'ambiance près des machines IBM au MIT, au début de l'ouvrage), et il
me semble que de plus en plus la société se rapproche de cela.

Cette culture de l’ingénierie, qui existait beaucoup lors des débuts de
l'informatique (telle que décrite par exemple par Steve Wozniak dans son
livre [iWoz][]) disparait pour laisser place a une culture de la
consommation et de l'utilisation de contenus existants, et même a une
certaine peur de la compréhension de la technologie. Ceux qui s'y
intéressent sont considérés comme marginaux (combien de hackers créent
des outils sur lesquels seront construits tous les systèmes du siècle a
venir, tels des Dennis Ritchie en puissance? Combien d'entre eux ne sont
pas intégrés a la société dite "normale"?), et on peut souvent observer
les réactions de peur que lancent les actions des hackers, ne serait-ce
que dans les journaux (combien de journaux 'mainstream' ont-ils parlés
des hackers en bien, c'est a dire tels qu'ils sont réellement, depuis
les années 80?) ou a la télévision.

Ainsi, la culture et la connaissance de ces appareils que
sont les ordinateurs, qui aujourd'hui se trouvent du fond de nos
poches a dans l'espace en passant par l’intérieur des pacemakers
jusqu’à être une composante indispensable de la société, se perdent et
rendent ainsi la compréhension de ces appareils impossible (j'ai eu
la désagréable surprise récemment de voir un camarade de classe
me poser ingénument la question "Ah, mais en fait, quand tu installes
Linux, ça change le fond d'écran et les icônes?". Au-delà du niveau,
la misère de cette question est que cette personne n'avait probablement
aucune idée de la façon dont fonctionnait son ordinateur, a part
pour le fond d'écran en question et pour les fameuses icônes.) pour
le grand public, et cet évolution crée de fait une sorte d'oligarchie de
techno-comprenants, seuls capables de manier et de créer la technologie.

C'est pour cela qu'il me semble intéressant, important, peut être même
requis, d'inclure au programme du collège puis du lycée des cours
d’électronique et d'informatique tels que décrits plus haut, de façon a
ce que les élèves comprennent le monde qui les entoure. Car c'est la le
but du cycle scolaire secondaire, me semble-t-il, et non pas de former
des futurs travailleurs. Sinon, pourquoi y aurait-il des cours de
musique, d'arts plastiques, ou encore de philosophie? Si le but du cycle
secondaire est bien d'ouvrir l'esprit des élèves sur le monde et sur ce
qui les entoure, alors les cours sur l'informatique s'imposent comme une
évidence, puisque ceux-ci nous entourent aujourd'hui bien plus que quoi
que soit d'autre...

Ces cours seraient su