Vérifiez que la valeur de la variable "UserspaceHID" soit sur "true" dans le fichier "/etc/bluetooth/input.conf".
Pour commencer, oui, l’arithmétique des pointeurs dans la programmation actuelle, et globalement l’utilisation du langage C, est quelque chose de plus en plus rare, car la majorité des langages sont dits de haut niveau, ils font abstraction du code machine, et leur typage est dynamique.
Toutefois, le langage C a certains atouts (pas de démonstration, ce n’est pas le but de ce billet), et il est ainsi important de produire du code robuste et modulable.
Prenons le cas où vous devez manipuler à travers les paramètres d’une fonction :
(Exemple et démonstration plus bas)
Pour une allocation de mémoire sur une variable faites à partir de pointeurs d’objets, le comportement est :
mytype *my_variable;
my_variable = malloc(sizeof(mytype));
Mais ensuite, si ce n’est plus un seul niveau de pointeurs, mais plusieurs, il faut donc calculer le nombre de pointeurs à mettre : combien d’astérisques à écrire ? est-ce vraiment utile, i.e "void *" ne suffit-il pas ? ce nombre a-t-il un impact ?
Et si on change de type ? par exemple, à l’intérieur d’une structure, vous ne déclarez pas la variable, du coup, il faut aller chercher le type de la variable en question, ce qui n’est pas forcément facile, et si ça change, vous devez manipuler le code.
Voici une solution : utilisez l’idiomatique suivante :
my_var = malloc(sizeof(*my_var));
Il suffit de remarquer qu’il suffit simplement de rajouter un astéristique par rapport à la variable dans le paramètre de gauche, dans le contenu de l’appel sizeof, et c’est tout.
Exemple, vous avez une matrice de "choses", chose pouvant être un entier, un nombre à virgule, un pointeur, une structure, etc, mais que c’est une donnée ici d’un des paramètres de la fonction, voici le résultat :
void myFunction(mytype my_var) {
…
my_var = malloc(sizeof(my_var));
…
}
void main(void) {
mytype **myMatrix;
myFunction(&myMatrix);
…
}
Exemple et Situation :
Prenons le cas où vous avez déjà une liste d’objets, comme une liste de sommets (“vertex/vertices” en anglais) dans un graphe (“graph”) contenant un nombre important de paramètres et d’informations. Recopier le contenu alors que vous souhaitez manipuler l’objet pour lire et créer d’autres ensembles n’est pas le plus efficace, la mémoire s’en alourdi : il suffit d’appeler le pointeur sur l’objet en question.
Déterminons les enfants d’un sommets dans un graphe, avec les arêtes qui les relient (“edge” en anglais) ; on va donc à partir d’un graphe "g" et d’un sommet "v" recevoir une liste de sommets "listChildren", et le nombre d’éléments de cette liste. Comme indiqué en introduction, on ne cherche pas à recopier les données, mais on cherche à recevoir leurs pointeurs. Pareil pour les éléments passés en paramètres en tant que source d’informations.
Remarque : j’évite au maximum d’avoir des variables globales, et je mets en premier dans les paramètres d’une fonction les données qui seront modifiées.
Remarque : pour simplifier la lecture, on pourrait aussi utiliser un “typedef” pour parler de pointeurs sur les différents objets, comme "pgraph" = "graph ", "pvertex" = "vertex ", etc, mais ça devient lourd à utiliser, et ce n’est pas entièrement pratique si on ne l’utilise pas entièrement.
Nous avons en entrée :
La liste des paramètres de la fonction "childrenVertices" ainsi se compose :
int childrenVertices(vertex **list_children, graph g, vertex *v);
À l’intérieur, l’allocation mémoire pour "list_children" sera :
list_children = malloc(nb_vertices sizeof(**list_children));
et son appel sera :
nb_children = childrenVertices(&my_child, &my_graph, ¤t_vertex);
En conclusion, la fonction "childrenVertices" ne manipule que des pointeurs, ce qui économise beaucoup plus de place par rapport à des données dans des structures (sauf pour les petits types, comme les entiers, qui sont moins volumineux dans une architecture 64 bits (4 octets, soient 32 bits pour un entier relatif "int") que pour un pointeur, 8 octets soient 64 bits en archi 64 bits.
Sauvegarde ici, car oh punaise, je le sens venir, les problèmes que je vais devoir corriger avec cet OS … Si ça ne tenait qu’à moi, je n’y toucherai tout simplement pas.
-------- BEGIN --------
Activer le God Mode : GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}
Lister et Supprimer des applications (Powershell) :
Get-AppxPackage -User UTILISATEUR
Remove-AppxPackage NOMCOMPLETDUPACKAGEADESINSTALLER
Désactiver les fonctions indiscrètes :
Logiciel : Disable Windows 10 Tracking - https://github.com/10se1ucgo/DisableWinTracking/releases
Logiciel : Destroy Windows 10 Spying - https://github.com/Nummer/Destroy-Windows-10-Spying
Logiciel : O&O ShutUp10 - http://www.oo-software.com/en/shutup10 (http://www.libellules.ch/dotclear/index.php?post/2015/11/07/OO-ShutUp10)
Le dossier windows 10 de libellules.ch : http://www.libellules.ch/dotclear/index.php?category/Windows-10
De nombreux articles sur Windows 10 par niko{pik} : http://www.nikopik.com/?submit=&s=windows+10
src : http://korben.info/windows-10-activez-le-mode-god.html
src : http://korben.info/windows-10-comment-desinstaller-candy-crush-ou-dautres-applications-qui-pre-installees.html
src : http://korben.info/windows-10-un-freeware-pour-desactiver-toutes-les-fonctionnalites-un-peu-trop-curieuses.html
src : http://www.libellules.ch/dotclear/index.php?post/2015/08/09/DoNotSpy-10
src : http://korben.info/windows-10-comment-reprendre-le-dessus.html
src : http://www.nikopik.com/2015/08/des-sites-de-telechargement-bannissent-les-utilisateurs-de-windows-10.html
src : http://www.nikopik.com/2015/08/loutil-de-telemetrie-de-windows-10-debarque-aussi-sur-windows-7-et-8-1-via-une-mise-a-jour.html
-------- END --------
Le post en lui-même n'est pas important, mais c'est plutôt les explications et bidouilles sur le système de fichiers derrière /proc.
À savoir, /proc/<pid>/exe est un lien symbolique vers le chemin de l’exécutable, sauf ça reste être un "fd" (file descriptor) tant que le processus n'est pas terminé, ce qui permet de continuer d'exécuter le processus même si son programme n'est plus (virtuellement) sur le disque dur (un fichier n'est pas supprimé tant que des références vers ce fichier sont ouvertes).
Un document en français contenant une liste d'astuces pour modifier les paramètres de télémétrie et de vie privée dans Windows 10.
Sauvegarde au format PNG (avec les commentaires, malheureusement) https://thican.net/~thican/windows_10_debloating_guide-fr.png (2,7 Mo, 1909 x 19068)
Par défaut, Microsoft Windows ne gère pas l'heure en UTC dans le BIOS, rendant la cohabitation difficile entre ce système d'exploitation et un autre.
Pour ma part, j'avais donc l'heure en UTC dans le BIOS, mais j'avais mis UTC dans Windows, ce qui du coup ne m'affichait pas l'heure correctement.
Et pourtant, il existe un « hack », une très simple modification à faire dans le registre pour résoudre ce problème :
Profitez donc du redémarrage pour mettre l'heure en UTC dans le BIOS, indiquez ensuite le bon fuseau horaire, et c'est tout.
Source : un peu partout sur le web.
Si vous avez besoin de bibliothèques en « 32 bits » (dites x86_32) alors que votre système est en x86_64 multilib (amd64), voici un petit tutoriel, très simple à utiliser et qui fonctionne :
1) commencez par exécuter : echo '-abi_x86_32' >> /etc/portage/profile/use.mask
2) lancez la compilation avec ABI_X86="32" en début de ligne :
ABI_X86="32" emerge -vaN1 libX libY libZ
S'il vous arrive souvent d'utiliser votre ordinateur alors qu'il fait nuit, et que vous resentez de la fatigue visuelle (ou même en tant que prévention), découvrez le logiciel RedShift.
Le but de ce petit billet n'est pas concrètement de vous faire découvrir ce logiciel, mais de vous aider à le configurer, pour être fonctionnel rapidement. Les infos sont bien sûr écrites dans le man, mais en attendant de le lire, vu que l'interface graphique est très loin d'être “user-friendly”, voici comment faire :
Avant d'écrire la configuration, il faut déterminer vos coordonnées ; c'est à partir de ces infos que le logiciel changera la « température » des couleurs pour s'adapter à votre environnement. Utiliser donc votre GPS, ou des cartes en ligne comme OpenStreetMap voir Google Maps pour trouver vos coordonnées, c'est à dire la longitude et la latitude.
Avec vos coordonnées, nous allons écrire le fichier de configuration. En se basant sur l'exemple du man, nous allons écrire notre configuration dans ~/.config/redshift.conf :
[redshift]
temp-day=6500
temp-night=3600
location-provider=manual
[manual]
lat=votre_latitude
lon=votre_longitude
Remplacez donc les valeurs votre_latitude et votre_longitude par vos coordonnées. Les valeurs de temp-day et temp-night sont comme elles l'indiquent les « températures » des couleurs de votre écran à utiliser respectivement pendant la journée et pendant la nuit. La valeur 6500K est la température par défaut, sans programme ; pour la soirée, par défaut la valeur est 3600K. Personnellement, je baisse cette valeur à 5700K en journée et à 2700K pendant la nuit.
Comme vous pouvez le remarquer, la valeur 2700K fait sortir visiblement la couleur orange sur les fonds clairs, et quand c'est chaud, c'est bleu. On pourrait penser que c'est contraire à la vie de tous les jours, or en haute température, le bleu est bien plus chaud que le rouge. c'est ce qu'on remarque avec les flammes des gaz.
Maintenant, vous pouvez exécuter le programme, et le mettre en démarrage automatique. Vos yeux vous remercieront.
Quelque chose que j'oublie souvent, alors autant l'avoir ici sous le coude.
Avec une liste d'adresses IPv4, donc sous la forme W.X.Y.Z, chacun pouvant aller de 0 à 255 inclus, sort peut en utilisant ses options mettre dans l'ordre une telle liste :
sort --numeric-sort --field-separator=. --key=1,1 --key=2,2 --key=3,3 --key=4,4
(source : un peu partout sur le net)
Un DIY (Do It Yourself) pour rendre une maison isolée du point de vue de l'énergie électrique, ça fait rêver :-)
11 000 € pour l'ensemble des appareils pour créer l'électricité, ça me paraît raisonnable, mais je me demande si être complètement isolé n'est pas un risque trop élevé, et si ça vaut le coup niveau budget.
Quelques astuces en CSS, en fin de compte très simple, pour centrer correctement des blocks en CSS.
Wouah, mais c'est trop génial ce hack :-)
Cette personne nous montre pas à pas comment elle a modifié et contourné un disque dur pour faire fonctionner une distribution GNU/Linux sur sa partie électronique.
Le saviez-vous ?
PHP – comme d'autres langage – lors de l'évaluation de conditions booléennes, fonctionne en mode "évaluation minimale" (ou appelé "short-circuit evaluation" en anglais http://en.wikipedia.org/wiki/Short-circuit_evaluation).
Grâce à l'ordre des opérateurs booléens, cela permet de ne pas tester l'ensemble des expressions dans une condition.
Exemple :
A && B && C
avec l'opérateur "&&" (AND), B n'est testé que si A est "juste", et C n'est testé que si B est "juste" (sans oublier A).
Par contre, avec "||" (OR), dans l'exemple "A && B || C", c'est "B || C" qui est testé avant A (attention, ce n'est pas valable pour tous les langages), et il faut que B soit "faux" pour que C puisse testé.
Intéressant, une extension pour Firefox qui permet à sa guise d'activer le "http referer".
Pour info, le "http referer" est une donnée contenant l'url de la page actuelle, envoyée par défaut dans les en-têtes HTTP (les requêtes web), et qui a donc pour principale but d'indiquer la page de provenance, pour tracer ou pour éviter certains accès.
(via Mistukarenai http://root.suumitsu.eu/links/?6HSeuA)
Vous utilisez souvent GnuPG pour chiffrer du texte, mais vous voulez vous simplifier la tâche lorsque vous devez utiliser vim avec, et aussi rajouter un peu de sécurité ?
Voici donc le plugin gnupg.vim.
Lorsque je parle de "sécurité", le plugin d'après son auteur désactive des fonctionnalités de vim comme swapfile, viminfo, et undofile, ce qui permet d'éviter de lire les données écrites du fichier en lisant son fichier temporaire, par exemple.
EDIT: le script est disponible sur GitHub, ce qui permet de vérifier son intégrité https://github.com/jamessan/vim-gnupg
EDIT2 (2013-07-31): il est disponible en tant qu'ebuild sous Gentoo \o/ → app-vim/gnupg
Suite à mon petit article (https://links.thican.net/?OIlYuQ) sur le même principe (des requêtes HTTP), mais en utilisant telnet, voici donc une autre version bien plus propre, avec curl.
Pour rappel :
Utilisons donc quelques variables pour simplifier les envois (c'est du bash, au fait)
Attention : la variable "host" est obligatoire (le port est par défaut à "80" si la variable est vide).
Requête GET : curl --include http://${host}:{port:-80}/${url}?{getVars}
Requête POST : curl --include --data ${postVars} http://${host}:{port:-80}/${url}?{getVars}
That's it!
Concrètement, la différence entre telnet et curl, elle se réside uniquement dans votre démarche d'apprentissage et de compréhension.
Si vous voulez apprendre, modifier des données pour faire des tests, avoir un contrôle un peu plus poussé sur vos données, utilisez donc telnet.
Par contre, si vous voulez quelque chose qui fasse son boulot, simplement, avec le moins d'erreurs possible car maintenu à jour, sans prise de tête, tournez donc vers curl.
EDIT: une méthode, plus simple et plus "propre" à utiliser, avec curl : http://links.thican.net/?wGhHkw
Si vous avez besoin de tester un serveur web sans utiliser un navigateur web (pour ainsi mieux voir ce qui est concrètement reçu et envoyé), voici un début d'aide :
On va donc utiliser telnet, un logiciel qui permet simplement de se connecter à une machine distant, sur le port souhaité, et d'envoyer simplement des paquets TCP.
Utilisons donc quelques variables pour simplifier les envois (c'est du bash, au fait)
Attention : la variable "host" est obligatoire (le port est par défaut à "80" si la variable est vide).
Pour les requêtes GET, voici donc :
{ echo -n -e "GET /${url}?${getVars} HTTP/1.1\nHOST: ${host}:${port:-80}\n\n"; sleep 0.5 } | telnet ${host} ${port:-80}
Pour les requêtes POST, il faut rajouter l'info de la variable "Content-Type: application/x-www-form-urlencoded" (attention, d'après cette page http://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data s'il s'agit d'autres formes de données, mieux vaut modifier le contenu de cette variable), voici donc :
{ length=$(echo -n ${postVars} | wc -c --); echo -n -e "POST /${url}?${getVars} HTTP/1.1\nHOST: ${host}:${port:-80}\nContent-Type: application/x-www-form-urlencoded\nContent-Length: ${length}\n\n${postVars}"; sleep 0.5 } | telnet ${host} ${port:-80}
Voilà, c'est tout, simple non ? ;-)
Remarques :
Résumé :
Petite page d'introduction pour chiffrer et signer des courriels dans Mutt à l'aide de GnuPG.
Une suite d'outils qui permet d'utiliser une GUI (Graphical User Interface), donc une interface graphique, pour gérer d'autres services sous GNU/Linux.
Il faudrait voir ensuite comme et sauvegarder le fichier de config, le mieux serait simplement d'avoir l'outil qui donne à copier/coller le résultat, et détaillent ce qui a été modifié, rajouté, supprimé.
À voir donc.
(via Korben http://korben.info/une-interface-pour-vos-logiciels-gnulinux.html)
Si vous avez besoin de sauvegarder des fichiers, en les mettant sur un serveur ftp distant, tout ça en tâche automatique, voici un script de mon cru (parmi tant d'autres, je n'ai pas cherché) qui peut rendre bien service :
(EDIT: Vu que les indentations ont sauté, voici une copie directe en téléchargement http://thican.net/~thican/backup-ftp.sh)
################################
hostFTP="" # "ftp.example.com"
userFTP="" # "foo"
passwordFTP="" # "bar"
remoteDir="./"; # remote directory, where to save files (like "backup")
tempIFS=${IFS};
IFS=$'\x0a\x00'; # useful to avoid problem with namefiles contening some
errorStatue=false;
if [ "x${hostFTP}" = "x" ] || [ "x${userFTP}" = "x" ] ||
[ "x${passwordFTP}" = "x" ]; then
echo "ERROR: at least one parameter for FTP connexion is not set. Exiting." >&2
exit 1;
fi
if [ "x${1}" = "x" ]; then
echo "Missing arguments. Exiting." >&2
exit 2;
fi
for args in ${@}; do
if [[ -f ${args} && ! -L ${args} ]]; then # symbolic files are ignored.
ftp -n ${hostFTP}<<END
user ${userFTP} ${passwordFTP}
put ${args} ${remoteDir:-"./"}/$(basename ${args})
bye
END
else
errorStatue=true;
echo "${args} is NOT a regular file. Skipping." >&2;
fi
done
#IFS=$'\x20\x09\x0a\x00'; # Reset of the default IFS (I don't care about the old one)
IFS=${tempIFS};
if ${errorStatue}; then
exit 3;
fi
exit 0
################################
Ainsi, sauvegardez donc ce script dans /usr/local/bin/, par exemple, éditez donc les paramètres de connexion au serveur FTP dans le début du script, et utilisez-le avec cron, juste après vos tâches de sauvegardes automatisées.
Voilà, ce n'était pas plus compliqué que ça. :-)
(Note to myself)
Internal field separator sous GNU/Linux.
Par défaut :
% echo -n -E $IFS | hexdump -C --
00000000 20 09 0a 00 | ...|
00000004
\x20 == espace, \x09 == tabulation "\t", \x0a == nouvelle ligne "\n" et \x00 == NULL
https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange#Table_des_128_caract.C3.A8res_ASCII
(Je mets toujours du temps à retrouver ça, même si cette fois, c'est arrivé du premier coup, alors je sais qu'ici, je le retrouverai plus rapidement.)
Tiens tiens, intéressant, moi qui avait essayé Nagios assez récemment, mais m'étais cassé les dents dessus.
@TODO:
DR
(via SebSauvage http://sebsauvage.net/links/?TmZsfw)
Ohoh, joli hack, pour utiliser un écran comme le Retina d'Apple avec un port eDisplayPort, le tout pour $70.
Peut-être bientôt une mise à jour de ce hack pour rendre ce hack plus facile à utiliser.
ENFIN !
Enfin utf-8 reconnu à sa juste valeurs, et expliqué d'une façon parfaite à tout le monde.
Attention tout de même, il faut écrire "exactement" :
-- coding: utf-8 --
oui, s'il vous plaît, n'oubliez pas de mettre un simple trait d'union '-' (le "tiret du 6") entre "utf" et "8", et le tout en minuscule.
Encore merci à Sam (et Max ;)) pour ces articles super bien écrits.
Juste une copie du texte ici :
You need to have a SSH (Secure SHell) account for this to work. If you have not yet done so, Download PuTTY for free.
Open PuTTY.
Where it says 'Host Name (or IP address)' and has a box underneath it, enter the name of your SSH host into the box.
Under 'Saved Sessions' enter a name for this connection that will help you remember it later. For example, you could call it 'SSH Proxy' so you know this will be the proxy connection.
In the 'Category:' menu on the left, expand the 'Connection' menu list if it is not expanded already. Expand the 'SSH' menu list if that one is not expanded already. Click 'Tunnels' (underneath 'SSH'). This opens the options where you will enter the settings for PuTTY to create the tunnel.
Under 'Add new forwarded port:' enter 9853
Where it says 'Destination' leave that field blank but be sure to select the 'Dynamic' option underneath it.
Click the 'Add' button to add this port.
In the 'Category:' menu on the left, click the click 'Connection'.
Where it says 'Seconds between keepalives (0 to turn off)' enter 5 in the box. This will keep your connection alive and prevent it from timing out even when you walk away from the computer for a while.
In the 'Category:' menu on the left, click 'Session' at the very top to go back to the first screen.
Click the 'Save' button to save all of the settings you just entered. Later you will not have to enter these settings again in the future, you will only need to load up your saved profile (by double-clicking it after you open PuTTY) every time you wish to connect to the proxy.
Click the 'Open' button to open the connection to the proxy.
When connected you will be asked for your username and password. Enter the username and password for your account. Once connected the tunnel is open. After you are finished using the tunnel, type logout and press Enter.
Finished. Now you can connect using any SOCKS compatible software by configuring it to use localhost as the proxy server and use port 9853. The reason why you connect to localhost and not the address of the server is because PuTTY has forwarded that port from the server to your computer. Once you connect to localhost, it sends the data right back up through the encrypted tunnel to the server. Keep in mind data that leaves the server and goes out to the Internet is not encrypted unless you are connecting to a secure web site that uses SSL encryption (https://).
Alternative method: If you use PuTTY from the command line, here is a faster way to establish the secure tunnel without having to use any of the steps above:
putty.exe -D 9853 username@sshhost and press Enter
Just replace username with your actual username and ssh.host with the address of the SSH server. When it logs in you will automatically be asked for your password. Once that is accepted the encrypted tunnel is automatically created on port 9853 on your computer.
Another neat trick for command line users: Rename PuTTY.exe to ssh.exe. Move the newly renamed file to c:\windows. From then on, all you have to do to establish the tunnel from Windows is click 'Start --> Run...' to open the 'Run' dialogue box and then type ssh -D 9853 username@sshhost and press Enter. Replace username with your real username and ssh.host with the address of the SSH host.
Parce que je ne retrouve jamais ces commandes, voilà, je sais qu'ici, je m'en souviendrai :
free -m
sync && echo 3 > /proc/sys/vm/drop_caches
Il se peut que vous avez une machine hébergeant un service (prenons le cas simple du service Web), mais derrière un NAPT.
Du coup, vous ne pouvez pas accéder directement à votre service sur cette machine, sans devoir configurer ce NAPT.
Or, vous avez accès à un serveur distant, avec un service sshd.
"Super, ça va être facile", vous dites-vous -- en tout cas, c'est ce que je me suis dit -- car vous connaissez l'option -R, pour remote.
Et c'est là qu'on se rend compte qu'il suffit simplement de (re)lire le man (man 1 ssh) pour voir que déjà, il y a la réponse à nos question :
sous l'option -R [bind_address:]port:host:hostport
(Note : remarquez le contre sens qu'il y a entre la première phrase, et la troisième...) « By default, the listening socket on the server will be bound to the loopback interface only. This may be overridden by specifying a bind_address. An empty bind_address, or the address ‘*’, indicates that the remote socket should listen on all interfaces. Specifying a remote bind_address will only succeed if the server's GatewayPorts option is enabled (see sshd_config(5)). »
Ainsi, je détaille un peu :
Dans le fichier de configuration du service sshd sur le serveur distant (souvent /etc/ssh/sshd_config), il faut activer l'option GatewayPorts avec la valeur "clientspecified" :
GatewayPorts clientspecified
Et sur la machine qui héberge le service derrière le NAPT, faites donc :
ssh user@server_distant -N -R *:<port_serveur>:localhost:<port_service_web>
serveur_distant représente le nom de domaine ou l'adresse IP du serveur qui n'est pas derrière le NAPT.
'*', c'est pour indiquer sur quel interface et/ou adresse écouter du serveur distant ; on peut donc spécifier 0.0.0.0 pour écouter sur toutes les adresses IPv4, [::] pour uniquement les adresses IPv6, "localhost" pour écouter uniquement sur l'interface "loopback" (contrairement à ce qui est indiqué, ce n'est pas par défaut avec GatewayPorts sur "clientspecified"), ou une adresse IP spécifique. (voire si possible, à une interface spécifique, mais je n'arrive plus à remettre la main sur la RFC en question)
<port_serveur>, c'est donc le port, toujours du serveur distant qui exécute le service sshd, sur lequel vous écouterez les connexions. Ainsi, ce n'est pas forcément le port du service web configuré dans le configuration du service.
<port_service_web>, le port du service derrière le NAPT. (donc, 80 pour un service web par défaut).
Ainsi, depuis votre navigateur web, vous n'aurez plus qu'à entrer l'URL suivante :
http://serveur_distant:port_serveur/
Conclusion :
Même si vous connaissez déjà une option dans un outil (comme -R dans ssh), (re)vérifier le man, il y a sûrement la solution.
PS : Vérifiez aussi dans /etc/ssh/sshd_config que l'option AllowTcpForwarding est sur "yes" (ce qui est par défaut)
Dans la série "les problèmes que j'ai rencontrés, et qu'avoir la solution est bien pratique", je présente le problème du "parse new line" :
Concrètement, imaginez que vous devez, pour X ou Y raisons, "analyser" (venant de l'anglais "to parse" http://translate.google.fr/translate_t?q=to+parse) les "retours à la ligne" ("new line") pour les modifier en d'autres caractères (comme '\n', textuellement), un simple "sed 's/\n/mon_texte/g'" ne fonctionnera.
Ainsi, merci à StackOverFlow pour la réponse suivante :
sed ':a;N;$!ba;s/\n/mon_texte/g' mon_fichier.txt
Je copie simplement ici l'explication (principalement au cas où le lien meurt) :
This will read the whole file in a loop, then replaces the newline(s) with a space.
Il existe aussi tr :
tr '\n' ' ' < mon_fichier.txt
Mais tr ne remplace que par un SEUL caractère ... dommage.
Pour ceux qui veulent en savoir plus, un commentaire un peu plus bas explique bien mieux http://stackoverflow.com/a/7697604
Si comme moi -- j'étais jeune et insouciant … -- vous ne comprenez pas pourquoi certaines de vos règles iptables ne fonctionnent pas (celles qui n'arrivent pas à bloquer certains maudits botnets qui continuent toujours et encore de vous spammer le port SSH), voici le rappel de la règle d'or d'iptables -- et d'autres outils utilisant les ACL mêmes -- et une commande en bash pour pouvoir ban simplement et facilement une adresse IP :
La règle d'or, c'est celle-ci :
les règles sont lues de haut en bas, et dès qu'une règle correspond à aux informations du paquets, iptables redirige vers la cible. POINT.
Alors, ce n'est pas forcément clair tout de suite, mais on va détailler avec un exemple :
Disons qu'à l'heure actuelle, vous aviez cette configuration :
Chain INPUT (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
5771 442K ACCEPT all -- lo 0.0.0.0/0 0.0.0.0/0
771K 99M ACCEPT all -- 0.0.0.0/0 0.0.0.0/0 ctstate RELATED,ESTABLISHED
0 0 DROP all -- 1.2.3.4 0.0.0.0/0
0 0 DROP all -- 8.8.8.8 0.0.0.0/0
69993 5147K fail2ban-SSH tcp -- 0.0.0.0/0 0.0.0.0/0 tcp dpt:22
5765 483K ACCEPT icmp -- 0.0.0.0/0 0.0.0.0/0
2107 118K ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:22
432 458K ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:25
51 2604 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:80
0 0 REJECT all -- * 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
0 0 REJECT all -- 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
Chain OUTPUT (policy ACCEPT 5 packets, 820 bytes)
pkts bytes target prot opt in out source destination
Chain fail2ban-SSH (1 references)
pkts bytes target prot opt in out source destination
69914 5142K RETURN all -- 0.0.0.0/0 0.0.0.0/0
Je ne vais pas détailler ici les différentes règles, ce sont celles de base, plus fail2ban pour SSH.
Disons que vous souhaitez bloquer l'adresse IP 16.32.64.128 ; sur le web, on trouve :
iptables -A INPUT -s 16.32.64.128 -j DROP
Pour un résultat :
…
432 458K ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:25
51 2604 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:80
0 0 REJECT all -- 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
0 0 DROP all -- 16.32.64.128 0.0.0.0/0
Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
…
Or, problème : si la machine derrière l'IP 16.32.64.128 tente de se connecter au service web, sur le port 80, la 9ème règle répondra donc d'abord à la requête avec la 11ème (en dernière place donc), qui, cette dernière, spécifiait de bloquer complètement tout le trafic en provenance.
Conclusion, c'est l'échec.
Pour résoudre ça, il faut donc que notre nouvelle règle se retrouve avant d'autres règles qui joueraient en sa faveur.
Cette solution existe : c'est l'option --insert (-I, --insert chain [rulenum] rule-specification), à la place de --append (-A),
avec [rulenum] qui indique le numéro de la ligne où la nouvelle règle s'écrira avant (man 8 iptables explique bien mieux que moi).
Du coup, oubliez "iptables -A INPUT -s 16.32.64.128 -j DROP", et faites place à "iptables -I INPUT 3 -s 16.32.64.128 -j DROP"
avec "3", la position de la nouvelle règle, donc juste après "771K 99M ACCEPT all -- 0.0.0.0/0 0.0.0.0/0 ctstate RELATED,ESTABLISHED". (à adapter à vos besoins bien sûr !)
Ainsi, pour se simplifier la tâche, nous pouvons donc créer cette fonction en bash pour ainsi BAN simplement une adresse ip :
function ban() {
mode=${2:-"DROP"}
iptables --table filter --insert INPUT 3 --source $1 --jump $mode
}
et ça fonctionne comme ça :
Simple, non ?
Bien sûr, ceux qui l'ont remarqué peuvent spécifier une deuxième option (nommée mode), qui par défaut est DROP, comme REJECT, voire ACCEPT même ; ainsi, en spécifiant ACCEPT, vous pouvez de cette façon autoriser complètement une adresse IP, la vôtre par exemple, lorsque sur un serveur distant, vous voulez ne pas être bloqué par votre firewall ;) (tout le contraire de ban ^^')
C'est magique ! :D
Toujours agaçant de rechercher cette information, alors je vais la mettre ici :
NOTE : Avec la version d'iptables 1.4.16.3 (en tout cas, supérieur à 1.4.12), le module "state" (par exemple dans "--match state --state <state>") devient obsolète, et est donc remplacé par le module "conntrack", donc pour équivalent, faites --match conntrack --ctstate <state> (voir iptables-extensions(8)). Ainsi, je mets donc les commandes pour la nouvelle version.
L'interface reliée au net sera notée WAN, et celle qui permet donc de relier les machines qui n'ont pas accès au net, sera appelée LAN.
--table nat --append POSTROUTING --out-interface WAN --jump MASQUERADE
--table filter --append FORWARD --in-interface WAN --out-interface LAN --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT
--table filter --append FORWARD --in-interface LAN --out-interface WAN --jump ACCEPT
Ah oui, et bien sûr, il faut activer le transfert de paquets :
Pour du temporaire, jusqu'au prochain reboot : echo 1 > /proc/sys/net/ipv4/ip_forward
Mais sinon, ça se passe dans /etc/sysctl.conf : net.ipv4.ip_forward = 1
(Remarquez la ressemblance entre la hiérarchie net/ipv4/ip_forward et la variable net.ipv4.ip_forward, cela peut vous donner des idées sur certaines config si vous ne trouvez pas d'infos sur le web ;))
Article de Wikipedia : https://en.wikipedia.org/wiki/Network_Address_and_Port_Translation
Autre source, utilisant les mêmes règles : https://serverfault.com/questions/431593/iptables-forwarding-between-two-interface#431607
Comme je le pense, afficher les dates relatives comme "il y a 3 min" ou "il y a 10 jours" lors que l'on fait une capture d'écran est une mauvaise idée.
Du coup, au minimum, afficher la date absolu et la date relative entre parenthèses.
(via SebSauvage)