Augmenter la sécurité d’un site web utilisant SSL

Dernièrement je me suis fais présenter l’outil SSL Server Test de SSL Labs. C’est une application en ligne qui permet de tester la sécurité d’une site web. J’avais récemment installé un certificat SSL sur le serveur d’un ami. Il s’agit d’un certificat généré gratuitement par Let’s Encrypt. Donc, je croyais bien obtenir une bonne note. Eh bien… non! J’ai obtenu la note de B.

Voici les deux problèmes qui me limitaient à cette cote.

  • This server supports weak Diffie-Hellman (DH) key exchange parameters. Grade capped to B.
  • This server accepts RC4 cipher, but only with older browsers. Grade capped to B.

Le site web est hébergé sur Windows Server 2012 R2. Donc les prochaines étapes pour régler ces problèmes de sécurité ont seulement été testées avec cette version de Windows. Si vous les appliquez, voici ce qui pourrait arriver:

Cote B vers A-
Cote B vers A-

A- ce n’est pas A ou même A+, mais c’est un bon départ.

Tous ces problèmes peuvent se régler dans l’Éditeur du Registre. On peut le démarrer avec la commande regedit.exe

Pour régler le problème avec Diffie-Hellman on doit aller dans la clef suivante:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\SChannel\KeyExchangeAlgorithms
Si elle n’existe pas on doit créer la sous-clef Diffie-Hellman
Dans la clef Diffie-Hellman, on doit créer une valeur DWORD nommé Enabled dont la donnée est 0.

Maintenant passons à l’algorithme de chiffrement RC4 (Rivest Cipher 4) qui est désuet. On doit aller dans la clef suivante:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Ciphers
Il va ensuite falloir créer les trois sous-clefs suivantes: RC4 128/128, RC4 40/128 et RC4 56/128.
Pour chacune de ces clefs, on doit créer une valeur DWORD nommé Enabled dont la donnée est 0.

Registry Editor - SCHANNEL key
Éditeur du Registre – clef SCHANNEL

Vous pouvez maintenant fermer l’Éditeur du Registre et redémarrer votre serveur pour appliquer les modifications.

Si vous désirez annuler ces changements il suffit de mettre la valeur Enabled à 0xffffffff. Vous pouvez aussi simplement supprimer la valeur Enabled.

J’espère que cet article vous aidera à augmenter la sécurité de votre site en évitant d’exposer des méthodologies faibles ou insécures.

Utiliser Gogs comme un service Windows

Dans mon dernier article, j’avais expliqué comment démarrer MiNET comme un service Windows. On avait la chance que la fonctionnalité était intégrée à l’application. Par contre, ce n’est pas toujours le cas.

Cette fois-ci c’est l’application Gogs que j’aimerais utiliser comme service Windows. Gogs (Go Git Service) est une solution Git auto-hébergée codé en Go. Ce projet à code source ouvert hébergé sur GitHub a beaucoup de qualité, la plus grande étant sans doute sa facilité d’installation. Maintenant, il est temps de parler de l’un de ses défauts: il ne peut pas être installé nativement comme service Windows.

La documentation de Gogs nous dirige vers l’application NSSM pour palier à ce problème. NSSM (Non-Sucking Service Manager) se vante de ne pas être médiocre comme les autres outils de ce genre. L’application possède même une interface graphique pour installer, éditer ou supprimer un service créer à partir de NSSM. Par contre, dans cet article, c’est plutôt des lignes de commande que nous utiliserons.

En premier, il faut que le fichier app.ini de Gogs soit modifié pour que le paramètre RUN_USER porte le nom du PC. Pour connaitre le nom, vous pouvez utiliser la commande suivante:

echo %COMPUTERNAME%

Le fichier ini doit être modifié comme ceci:

RUN_USER = NOMDUPC$

Le signe de dollar à la fin du nom est important.

En second lieu, il faut s’assurer que NSSM a été installé dans votre %PATH%. Par exemple, le fichier nssm.exe peut être copié dans le dossier C:\WINDOWS\system32.

Ensuite, on ouvre une fenêtre de terminal et on tape toutes ces commandes:

set gogspath=c:\gogs
set escapepath=^%PATH^%
nssm install gogs "%gogspath%\gogs.exe"
nssm set gogs AppDirectory "%gogspath%"
nssm set gogs AppParameters "web"
nssm set gogs DisplayName "Gogs - Go Git Service"
nssm set gogs Description "A painless self-hosted Git service."
nssm set gogs Start SERVICE_DELAYED_AUTO_START
nssm set gogs AppStdout "%gogspath%\gogs.log"
nssm set gogs AppStderr "%gogspath%\gogs.log"
nssm set gogs AppRotateFiles 1
nssm set gogs AppRotateBytes 1000000
nssm set gogs AppEnvironmentExtra "PATH=%escapepath%;%gogspath%;C:\Program Files\Git\bin"
nssm start gogs

Il est important de changer la ligne 1 pour y inscrire le chemin vers l’application Gogs. La ligne 13 doit aussi être changée si Git n’est pas dans le %PATH%. La dernière ligne va démarrer le service, donc ouvrez un navigateur web et testez que tout fonctionne.

Si vous désirez supprimer le service, c’est cette commande qu’il faut utiliser:

nssm remove gogs

Pour éditer un service déjà installé avec l’interface on utilise cette commande:

nssm edit gogs
NSSM Details
Édition du service Gogs à l’aide de NSSM

En terminant, je veux vous parler de Gitea. Il s’agit d’un fork de Gogs qui semble avoir le vent dans les voiles. Pour l’instant, je préfère encore demeurer avec Gogs, mais je garde un œil attentif sur ce projet.

Utiliser MiNET comme un service Windows

Dans un article précédent j’avais parlé du serveur Minecraft MiNET. Le serveur est facile à démarrer, il suffit de double cliquer sur l’exécutable. Le problème c’est que je veux qu’il roule de façon continue sur mon serveur Windows 2012. Donc, il faut qu’il soit installé comme un service Windows. Cela va masquer la fenêtre de console et faire en sorte que l’application va démarrer même si aucun utilisateur n’est connecté.

Heureusement pour nous, MiNET utilise Topshelf, il s’agit d’une infrastructure logicielle permettant la conception de services Windows en utilisant .NET.

Pour obtenir de l’aide, rien de plus simple, on écrit ceci:

MiNET.Service.exe help

En ce qui a trait au service, voici les paramètres importants:

  • install
  • start
  • stop
  • uninstall

Les noms sont assez explicites et je crois qu’il ne demande pas vraiment d’explication. Donc, pour installer le service on tape ceci:

MiNET.Service.exe install

Les informations par défaut faisaient mon bonheur. Dans la capture d’écran suivante, on peut voir le résultat.

MiNET Service Properties
MiNET Service Properties

Il ne reste plus qu’à démarrer le service avec cette ligne de commande:

MiNET.Service.exe start

Amusez-vous bien à MineCraft en multi-joueurs.
Minecraft

Simuler des évènements de touche sur Android

Dans cet article nous allons voir comment simuler des évènements de touche sur Android dans une application FireMonkey codée en C++. Pour faire cela nous allons utiliser la classe Instrumentation de l’API Android. Malheureusement cette classe n’est pas exposée dans la RTL. La bonne nouvelle est qu’il existe un outil pour générer les fichiers qui nous sont nécessaires. C’est à l’aide de Java2OP.exe que nous allons y arriver. Cette application par ligne de commande sert à générer des fichiers Delphi à partir de bibliothèques Java, d’où le nom Java To Object Pascal (Java2OP).

Donc avec cette commande nous obtiendrons le fichier Androidapi.Instrumentation.pas :

Java2OP.exe -classes android.app.Instrumentation -unit Androidapi.Instrumentation

La première fois que j’ai exécuté la commande, une erreur est survenue me disant que JDK était manquant. En cas de problème, je vous conseille de vous référer à l’aide où il y a une section Dépannage.

Pour commencer, on doit démarrer RAD Studio et créer un nouveau projet multi-périphériques C++Builder. Nous allons insérer un TMemo dans la Form. C’est dans ce contrôle que les touches de clavier simulées apparaitront. On doit bien sûr ajouter le fichier Androidapi.Instrumentation.pas au projet. À la compilation le fichier Androidapi.Instrumentation.hpp sera créé.

La simulation de touche de frappe doit se faire dans un thread, donc il faut aller dans le menu File / New / Other… et choisir Thread Object dans la section C++Builder Files. Vous pouvez donner le nom TInjectInput à la classe. Vous pouvez enregistrer le fichier et le nommer InjectInput.cpp. Dans ce fichier, il faut ajouter les en-têtes suivantes:

#include <Androidapi.JNI.GraphicsContentViewText.hpp>
#include "Androidapi.Instrumentation.hpp" // Fichier généré par Java2OP.exe

Dans l’évènement Execute on ajoute le code suivant:

    while(Terminated == false)
    {
        try
        {
            _di_JInstrumentation Instrumentation = TJInstrumentation::JavaClass->init();

            Graphicscontentviewtext::_di_JKeyEvent KeyEventDown = TJKeyEvent::JavaClass->init(
                TJKeyEvent::JavaClass->ACTION_DOWN, TJKeyEvent::JavaClass->KEYCODE_A);
            Instrumentation->sendKeySync(KeyEventDown);

            Graphicscontentviewtext::_di_JKeyEvent KeyEventUp = TJKeyEvent::JavaClass->init(
                TJKeyEvent::JavaClass->ACTION_UP, TJKeyEvent::JavaClass->KEYCODE_A);
            Instrumentation->sendKeySync(KeyEventUp);
        }
        catch(const Exception &)
        {
        }

        Sleep(5000);
    }

Cela aura comme effet de générer un événement de frappe avec la touche a enfoncée et ensuite un évènement avec la même touche relâchée. La méthode injectKeyEvent aurait aussi pu être meilleure, mais je voulais utiliser KeyEvent. Il est important de mettre le code dans un try/catch car lorsqu’on quitte l’application l’exception suivante est lancée:

java.lang.SecurityException: Injecting to another application requires INJECT_EVENTS permission

Il faut savoir que même si la permission INJECT_EVENTS est accordée, l’exception sera quand même lancée si l’application n’est pas signée.

Dans le fichier .h de la Form on ajoute le code suivant:

//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include <FMX.Controls.hpp>
#include <FMX.Forms.hpp>
#include <FMX.Controls.Presentation.hpp>
#include <FMX.Memo.hpp>
#include <FMX.ScrollBox.hpp>
#include <FMX.Types.hpp>
#include "InjectInput.h"
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
    TMemo *Memo1;
private:	// User declarations
    TInjectInput* FInjectInput;
public:		// User declarations
    __fastcall TForm1(TComponent* Owner);
    virtual __fastcall ~TForm1();
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

À la ligne 12 on ajoute l’en-tête. À la ligne 19 on ajoute une propriété privée. Finalement à la ligne 22 c’est le destructeur de Form.

Dans le fichier .cpp de la Form on ajoute le code suivant:

//---------------------------------------------------------------------------
#include <fmx.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.fmx"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
    FInjectInput = new TInjectInput(true);
    FInjectInput->Start();
}
//---------------------------------------------------------------------------

__fastcall TForm1::~TForm1()
{
    delete FInjectInput;
}
//---------------------------------------------------------------------------

Dans le constructeur on va créer le thread et le démarrer. On ajoute le destructeur pour libérer la mémoire.

Maintenant, il suffit de choisir le Target Android, compiler et déployer le code. On doit cliquer sur le contrôle TMemo et des a devraient apparaître à toutes les 5 secondes.

Traduction avec l’API MyMemory et CCAN/JSON

Dans cet article nous allons voir comment traduire du texte avec l’API web MyMemory. Je voulais utiliser celui de Google, mais il est payant. MyMemory n’a pas la même qualité de traduction que Google, mais le but est de faire une démonstration et non un produit commercial.

Pour analyser la réponse en JSON, au lieu d’utiliser la classe TJSONObject de la RTL, c’est la bibliothèque CCAN/JSON qui sera utilisée. Cette bibliothèque à code source ouvert est codée en C. Je l’ai choisie car dans une étude comparative sur 41 bibliothèques JSON elle semblait bien classée.

JSON Parsing Time
Temps d’analyse des bibliothèques JSON

J’ai dû exclure toutes celles en C++11, car j’utilise encore principalement le compilateur bcc32. Le facteur principal était simplement la facilité d’intégration. Si ça ne compilait pas dans les minutes suivant le téléchargement, je passais à la prochaine dans la liste.

La première étape est de créer un nouveau projet FireMonkey. Dans la Form il faut insérer un TRESTClient, un TRESTRequest, un TRESTResponse, trois contrôles TEdit, un TComboBox et un TButton.Vous pouvez donner comme texte à votre bouton le mot « Traduire ».

Voici ce à quoi l’interface devrait ressembler:

Il faut ajouter le fichier json.c qui se trouve trouve dans le dossier \ccan\json au projet pour qu’il soit compilé. Je n’ai pas eu de problème pour l’utiliser avec les plateformes Win32, Win64 et OS X.

Dans votre fichier cpp voici l’en-tête à utiliser.

extern "C"
{
    #include "json.h"
}

Il ne faut pas oublier qu’il s’agit de code en C et non C++, c’est pourquoi il faut ajouter un peu plus de code.

Voici le code à ajouter dans votre constructeur pour initialiser les contrôles:

    TListBoxItem* ListItems;

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Anglais";
    ListItems->TagString = L"en";

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Chinois (simplifié)";
    ListItems->TagString = L"zh-CN";

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Russe";
    ListItems->TagString = L"ru";

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Latin";
    ListItems->TagString = L"la";

    // On sélectionne le premier item par défaut
    ComboBox1->ItemIndex = 0;

    // Message à afficher quand la propriété Text est vide
    Edit1->TextPrompt = L"Texte à traduire";

    // Le nombre de match par défaut est mis à zéro
    Edit3->Text = L"0";

    // On n'écrit pas dans les champs de résultat
    Edit2->ReadOnly = true;
    Edit3->ReadOnly = true;

Voici le code à ajouter dans l’évènement OnClick du bouton:

    if(Edit1->Text.IsEmpty() == true || ComboBox1->ItemIndex < 0)
    {
        Edit2->Text = "";
        Edit3->Text = "0";
        return;
    }

    String LQuery = Edit1->Text;
    String LTarget = ComboBox1->ListItems[ComboBox1->ItemIndex]->TagString;

    RESTClient1->BaseURL = "http://api.mymemory.translated.net/get" \
        "?q=" + Edit1->Text +
        "&langpair=fr|" + LTarget;

    RESTRequest1->Execute();

    // Conversion en UTF-8
    TBytes LUTF8Array = TEncoding::UTF8->GetBytes(RESTResponse1->JSONText + "0");
    LUTF8Array[LUTF8Array.High] = '\0'; // Le caractère nul de terminaison est requis

    JsonNode* LRootNode = json_decode((char *)&LUTF8Array[0]);
    if(LRootNode != NULL)
    {
        JsonNode* LResponseNode = json_find_member(LRootNode, "responseData");
        if(LResponseNode != NULL && LResponseNode->tag == JSON_OBJECT)
        {
            JsonNode* LTextNode = json_find_member(LResponseNode, "translatedText");
            if(LTextNode != NULL && LTextNode->tag == JSON_STRING)
            {
                TBytes LUTFAnswer;
                LUTFAnswer.Length = strlen(LTextNode->string_);
                memcpy(&LUTFAnswer[0], LTextNode->string_, LUTFAnswer.Length);
                Edit2->Text = TEncoding::UTF8->GetString(LUTFAnswer);
            }
            JsonNode* LMatchNode = json_find_member(LResponseNode, "match");
            if(LMatchNode != NULL && LMatchNode->tag == JSON_NUMBER)
            {
                Edit3->Text = LMatchNode->number_;
            }
        }
        json_delete(LRootNode);
    }

Le texte utilisé par CCAN/JSON utilise l’encodage UTF8, c’est pourquoi il y a des conversions. Sinon le code ressemble étrangement à ce que RAD Studio nous a habitués avec sa classe JSON.

Maintenant il ne reste qu’à exécuter l’application pour la tester.
Traduction macOS

Déboguer sur CyanogenMod avec RAD Studio

Dans un article précédant, datant de novembre 2014, j’expliquais comment déboguer sur la OUYA avec RAD Studio. Plusieurs choses ont changé depuis ce temps. Le plus important étant la vente de OUYA a Razer et le fait que le matériel cessera d’être supporté. Je croyais bien que ma petite boîte grise allait rester pour toujours à l’intérieur de l’un de mes tiroirs, jusqu’à ce que je tombe sur un article expliquant comment faire rouler CyanogenMod sur ma OUYA. CyanogenMod version 11 (CM11) est basé sur Android KitKat 4.4.x. Donc, présentement ma OUYA fonctionne comme Android 4.4.4. C’est ce que l’on peut voir sur la capture d’écran qui suit.

About tablet
Information sur la OUYA et le système d’exploitation

Ma motivation première pour transformer ma OUYA en appareil Android standard n’était pas nécessairement le développement d’applications. Comme beaucoup de gens, c’était de faire fonctionner Kodi version 16.1 (Jarvis). Le reste de l’article va se concentrer par contre sur ma seconde raison.

Pour utiliser RAD Studio avec CM11, il s’agit de faire les étapes habituelles que l’on ferait sur Android. La première étant de faire afficher la section avec les options pour développeur. Pour faire cela on doit aller dans les Settings dans la section About tablet. Ensuite on clique sept fois sur Build number.

Maintenant que la section Developer options des Settings est disponible, il faut s’assurer que les options Android debugging et ADB over network sont activées:

ADB over network
Activation du débogage par le réseau

L’adresse IP et le numéro de port qui se trouve juste en dessous de l’option l’option ADB over network vous seront utiles bientôt. Il faut d’abord se connecter à la OUYA. Pour cela l’application Android Debug Bridge (adb) située dans le dossier /<sdk>/platform-tools sera utilisée. Dans le SDK Manager pour Android on trouve ce chemin dans la section Adb location. Vous devez aller dans ce dossier et taper la ligne de commande suivante:
adb connect 192.168.1.115:5555
Si tout fonctionne le résultat devrait être: connected to 192.168.1.115:5555

Vous pouvez aussi taper cette commande pour voir la liste des dispositifs connectés:
adb devices
Si la liste est vide, c’est que la commande de connexion à échouer.

Ensuite, ouvrez ou créez un nouveau projet de type Multi-Device Application dans RAD Studio. Sélectionnez le Target Android. Dans la section Target de celui-ci, OUYA devrait apparaitre. Si ce n’est pas le cas il faut faire un Refresh.

OUYA Target
Le Target OUYA est sélectionné

Il est maintenant possible de compiler le fichier APK et de tester l’application directement sur la console. Une fois fermée, elle devrait être disponible avec les autres applications.

Si vous voulez simplement installer l’application, vous pouvez utiliser cette ligne de commande:
adb install "C:\Projets\Application\Android\Release\application\bin\application.apk"

Git: Réécrire l’histoire

Encore une fois je vais traiter de la modification des informations d’une soumission. Dernièrement j’ai encore migré plusieurs projets qui étaient sous Subversion vers Git. Donc j’ai dû faire appel à git filter-branch.

Ma première erreur a été de faire des soumissions sans changer le nom du committer / author. Heureusement mon adresse de courriel était la bonne. J’ai donc ouvert une fenêtre de Git Bash pour y coller ce code:

#!/bin/sh

git filter-branch --env-filter '
EMAIL="crayon@server.com"
CORRECT_NAME="Crayon"
if [ "$GIT_COMMITTER_EMAIL" = "$EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
fi
' --tag-name-filter cat -- --branches --tags

Si vous voulez l’utiliser il faut bien sûr changer les variables EMAIL et CORRECT_NAME pour y mettre vos informations.

Mon deuxième problème est survenu suite à l’application de fichiers Patch. La date soumission était celle de l’application de la patch, mais je voulais que ce soit celle où l’auteur avait fait sa soumission. J’ai donc utilisé ce code:

#!/bin/sh

git filter-branch --env-filter '
if [ "$GIT_COMMITTER_DATE" != "$GIT_AUTHOR_DATE" ]
then
    export GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
fi
' --tag-name-filter cat -- --branches --tags

Voici la liste de variables d’environnement mises à votre disposition pour effectuer d’autres tâches:

  • GIT_AUTHOR_NAME
  • GIT_AUTHOR_EMAIL
  • GIT_AUTHOR_DATE
  • GIT_COMMITTER_NAME
  • GIT_COMMITTER_EMAIL
  • GIT_COMMITTER_DATE

Il est important de savoir que si vous roulez ces scripts, l’historique de votre dépôt va être réécrit. Toutes les personnes qui ont un fork ou un clone devront prendre cette nouvelle version.

Ping avec TIdIcmpClient

Dans cet article, je vais vous donner le code pour faire une méthode qui effectue un Ping. Nous utiliserons la classe TIdIcmpClient de Indy.

Voici la déclaration de la méthode:

    bool __fastcall Ping(const String AIP, int ATimeout = 5000);

Le paramètre ATimeout est facultatif et sa valeur par défaut est 5 secondes.

Pour utiliser TIdIcmpClient, il faut bien sûr ajouter le fichier d’en-tête suivant à votre fichier cpp:

#include <IdIcmpClient.hpp>

Voici le code de la méthode:

bool __fastcall TForm1::Ping(const String AIP, int ATimeout)
{
    bool Result = false;

    TIdIcmpClient* LIcmpClient = NULL;
    try
    {
        LIcmpClient = new TIdIcmpClient(NULL);
        LIcmpClient->Host = AIP;
        LIcmpClient->Port = 0;
        LIcmpClient->ReceiveTimeout = ATimeout;
        LIcmpClient->IPVersion = TIdIPVersion::Id_IPv4;
        LIcmpClient->Protocol = Id_IPPROTO_ICMP;

        try
        {
            const String LToSend = " !\"#$%&'()*+,-./0123456789:;<=>?";
            LIcmpClient->Ping(LToSend, 0);
            if(LIcmpClient->ReplyStatus->ReplyStatusType == TReplyStatusTypes::rsEcho &&
                LIcmpClient->ReplyStatus->BytesReceived > 0 &&
                LIcmpClient->ReplyData.Pos(LToSend) > 0)
            {
                Result = true;
            }
        }
        catch(...)
        {
        }
    }
    __finally
    {
        delete LIcmpClient;
    }

    return Result;
}

Si tout fonctionne, la méthode retourne true. Ce n’est pas plus compliqué que cela. Par contre, il est important de dire que ce code est bloquant. Donc, pour ne pas geler l’interface utilisateur c’est important de le rouler dans un thread séparé.

Git: Modifier un message d’une soumission

Suite à une migration de Subversion vers Git, je me suis retrouvé avec des messages qui contiennent un « git-svn-id ». Oui, je sais, il suffisait d’ajouter le paramètre ‘–-no-metadata’ à la commande ‘git svn’.

Voici un exemple de message que j’obtiens:

libpng updated to 1.4.5

git-svn-id: https://wii-tac-toe.googlecode.com/svn/trunk@104 bba1cac1-252d-79fd-420d-80adb1f9fa09

Heureusement il existe un moyen de changer le message. C’est l’utilisation du paramètre ‘filter-branch‘ qui nous aidera à effectuer cette tâche. La commande suivante va effacer la ligne du message.

git filter-branch --msg-filter '
	sed -e "/^git-svn-id:/d"
'

L’application sed va servir à faire la modification. On utilise le paramètre -e pour lui spécifier une expression. Le ‘/^’ veut dire que la ligne débute par « git-svn-id: ». Le ‘/d’ à fin signifie que la ligne sera supprimée si elle correspond à l’expression.

La migration a aussi ajouté un saut de ligne avant d’insérer le « git-svn-id ». Si vous êtes dans la même situation que moi et que vous n’avez pas vous-mêmes ajouté des sauts de ligne dans vos messages, alors c’est facile de supprimer tous les sauts de lignes en plus des lignes qui contiennent le « git-svn-id ». Voici la commande que j’ai utilisée.

git filter-branch --msg-filter '
	sed -e "/^$/d;/^git-svn-id:/d"
'

L’expression ‘/^$/d’ supprime toutes les lignes vides.

Lorsque que vous devrez pousser les changements, il va falloir utiliser l’option ‘–force’ sinon ça ne fonctionnera pas.

MiNET, un autre serveur Minecraft PE

Dans mon dernier article j’avais expliqué comment installer PocketMine. J’ai eu un peu de difficulté avec ce serveur pour Minecraft Pocket Edition. J’ai donc décidé de regarder pour une alternative. Mon regard s’est posé sur MiNET. Il s’agit d’un projet à code source ouvert disponible sur GitHub. Il est codé en C# et à pour but la performance lors de parties multi-joueurs.

Tout d’abord il faut télécharger l’archive qui contient tout ce dont on aura besoin. Il suffit d’extraire le fichier minet-server.zip sur votre disque dur.

Avant même de démarrer le serveur je vous conseille de modifier les configurations. Pour cela il faut éditer le fichier server.conf. Le fichier comporte une liste de clefs. Chaque clef possède un nom et une valeur délimités par le signe égal (=). Le nom apparait à gauche du signe égal. L’utilisation d’un carré (#) en début de ligne signifie qu’il s’agit d’un commentaire. Une ligne commentée ou vide sera simplement ignorée.

Voici les configurations pour tester le serveur:

MaxNumberOfPlayers=10
motd=Mon serveur
WorldProvider=flat

Par défaut, le nombre de joueurs maximum permis sur le serveur est à 1000. Mettre la propriété MaxNumberOfPlayers à dix me semble plus normal pour un serveur méconnu. motd signifie Message Of The Day, c’est le texte qui apparait en dessous du nom du serveur dans le jeu. Vous pouvez y inscrire ce que vous voulez. Un texte de moins de 20 caractères semble avoir du sens. Pour tester le serveur il est préférable de mettre WorldProvider à flat. Ceci aura comme effet d’utiliser un monde de test.

Maintenant vous pouvez double cliquer sur le fichier MiNET.Service.exe. MiNET est compilé avec Visual Studio et nécessite au minimum le Framework .NET version 4.6. Donc, si vous avez le message suivant, il faudra cliquer sur Oui pour effectuer l’installation:

.NET Framework 4.6.1 est requis
.NET Framework 4.6.1 est requis

Il se peut aussi que Windows bloque l’exécution de l’application. Alors il faudra aller dans les Propriétés du fichier .exe et de toutes les DLL pour les débloquer:

MiNET Unblock
MiNET Unblock

Maintenant vous devriez être capable de démarrer le serveur sans erreur et de vous balader dans le mode de test.

Pour jouer dans un autre monde alors il faut le télécharger et l’installer. Vous pouvez aller sur le site planetminecraft.com dans la section Projects pour y télécharger un projet. J’ai eu quelques problèmes avec certains mondes, alors il faut simplement laisser tomber et en prendre un autre. Il faut extraire l’archive et modifier la propriété PCWorldFolder pour y mettre le chemin vers le dossier où se trouve l’information. Il va aussi falloir modifier WorldProvider pour y mettre anvil:

WorldProvider=anvil
PCWorldFolder=.\Worlds\Monde1

En terminant voici d’autres propriétés intéressantes ainsi que leur valeurs potentielles:
GameMode

  • Survival
  • Creative
  • Adventure
  • Spectator

Difficulty

  • Easy
  • Normal
  • Hard
  • Peaceful