Suite aux nombreuses demandes de la communauté pour améliorer les performances de la Raspberry pi 3 nous avons décidé d’écrire un tutoriel pour vous apprendre comment overclocker une Raspberry pi 3.

Pourquoi overclocker une Raspberry Pi 3 ?

Si la Raspberry Pi 3 a largement amélioré la puissance du processeur par rapport aux modèles précédents, cela peut néanmoins rester insuffisant pour certains usages.

En overclockant votre Raspberry Pi, vous pourrez améliorer encore un peu ses performances et permettre au processeur d’atteindre des fréquences de 1.5 GHz, contre seulement 1.2 GHz par défaut.

La puissance ainsi récupérée peut par exemple être utile lorsqu’il s’agit d’améliorer la fluidité des jeux un peu trop gourmands, tel que Minecraft, ou encore lors de la lecture de vidéos.

Le matériel nécessaire pour overclocker la Raspberry Pi 3

Si les modifications pour overcloker une Raspberry Pi sont essentiellement logicielles, ces modifications ont néanmoins un véritable impact au niveau physique qu’il convient de prendre en compte.

Premier point important, augmenter la puissance de calcul du processeur entraîne un risque de surchauffe, ce qui pourrait être dangereux pour la Raspberry Pi, mais aussi tout ce qui l’entoure, puisque certains ont pu mesurer des pointes de chaleur à près de 100°C !

Second point à prendre en compte, augmenter la puissance de calcul du processeur entraîne également une augmentation de sa consommation d’énergie, ce qui pourrait poser problème si l’alimentation électrique de la Raspberry Pi n’est pas suffisamment performante.

Si vous souhaitez overclocker votre Raspberry Pi vous devrez donc vous équiper de deux accessoires indispensables :

• Une alimentation de bonne qualité (nous vous recommandons une alimentation 5v 0.3A, trouvable par exemple ici sur Amazon)
• Un système de refroidissement. De nombreuses solutions existent, mais toutes ne se valent pas. Comme overclocker une Raspberry Pi 3 augmente fortement sa température, nous vous conseillons de vous orienter vers un système mettant en œuvre à la fois un refroidissement passif (dissipateur thermique), et un refroidissement actif (ventilateur). Vous pouvez pour cela trouver chez Amazon des kits comme celui-ci proposant des boîtiers adaptés et livrés avec des ventilateurs et supportant l’ajout de dissipateurs thermiques.

Il existe des boîtiers pour la Raspberry Pi spécialement conçus pour utiliser un ventilateur et supportant l’ajout de dissipateurs thermiques.

Avec ces quelques précautions, vous devriez pouvoir overclocker votre Raspberry Pi sans danger.

Modifier le fichier de configuration pour overclocker la Raspberry Pi 3

Maintenant que vous avez tout le matériel en main passons aux choses sérieuses !

S’il était relativement simple d’overclocker les précédents modèles de la Raspberry Pi (il suffisait d’utiliser la commande sudo raspi-config), cela est désormais plus compliqué avec la Raspberry Pi 3, et il est maintenant nécessaire de mettre les mains dans les fichiers de configuration.

Pour overclocker la Raspberry Pi 3, nous allons modifier le fichier /boot/config.txt, lequel contient un certain nombre de réglages chargés au démarrage de la Raspberry Pi et permettant de déterminer son comportement, et notamment l’utilisation du processeur.

Afin de modifier ce fichier, vous devez donc démarrer une fenêtre de terminal sur votre Raspberry Pi, et taper la commande suivante :

sudo nano /boot/config.txt

Cette commande va ouvrir le fichier /boot/config.txt avec l’éditeur de texte nano, et la commande sudo va demander au système d’exécuter cette action avec un compte administrateur (le /boot/config.txt étant très important, seuls les comptes administrateur peuvent le modifier).

Maintenant que le fichier est ouvert, vous allez devoir le modifier pour qu’il contienne les lignes suivantes :

core_freq=500 #Fréquence du GPU

arm_freq=1500 #Fréquence du CPU

over_voltage=4 #Puissance électrique envoyée au CPU/GPU (4 = 1.3V)

disable_splash=1 #Désactive l’affichage de l’écran d’alerte électrique

Notez que certaines lignes existent déjà probablement dans des versions différentes, dans ce cas, modifiez-les, et assurez-vous qu’elles ne soient pas commentées (c’est-à-dire que la ligne ne commence pas par un #).

Une fois que vous avez fait l’ensemble des modifications, enregistrez le fichier en utilisant le raccourci Ctrl+o et quittez le fichier avec le raccourci Ctrl+x.

Dernière étape, il ne vous reste plus qu’à redémarrer votre Raspberry Pi avec la commande reboot.

Vérifier si l’overclock est activé

Une fois que votre Raspberry Pi a fini son redémarrage, il ne vous reste plus qu’à vérifier qu’elle est bien overclockée.

Pour cela, il vous suffit de lancer la commande lscpu, celle-ci permet d’obtenir des informations sur le processeur. Si vous trouvez une valeur de 1500 pour CPU max MHz, félicitations, vous venez d’overclocker votre Raspberry Pi 3 !

Bonus, overclocker la Raspberry Pi 2

Petit bonus pour ceux qui voudraient améliorer les performances de leur Raspberry Pi 2, ou autres modèles plus anciens.

Cette fois, la manipulation est beaucoup plus simple, puisqu’il vous sera possible d’utiliser l’interface graphique de raspi-config. Procédez donc de la façon suivante :

Dans un terminal sur la Raspberry Pi, lancez la commande sudo raspi-config

Sélectionnez l’option Overclock, un message vous informant des dangers de l’overclock apparait, faites ok

Choisissez l’overclock qui vous convient (par exemple 1000MHz). Un message vous informant du changement apparait, faites ok

Choisissez Finish, un message vous demandera si vous souhaitez redémarrer, faites ok.

Voilà, votre Raspberry Pi est overclockée.

Attention, même si la Raspberry Pi 2 est overclockée de façon moins poussée que la 3, elle a tout de même tendance à chauffer et vous avez intérêt à prendre les mêmes précautions qu’avec la Raspberry Pi 3.

Conclusion

Vous savez désormais comment overclocker votre Raspberry Pi 3, et il ne vous reste plus qu’à profiter de ce petit regain de puissance.

Pour autant, n’oubliez pas que cette pratique amène la Raspberry Pi à fortement chauffer, ce qui peut diminuer sa durée de vie. Si vous voulez limiter les risques de crash et de destruction, équipez-vous en conséquence !

Sachez également que vous pouvez configurer encore d’avantage l’utilisation du processeur. Vous trouverez tous les paramètres utilisables ici sur le site de la fondation.

Cet article Comment overclocker la Raspberry Pi 3 (et la Raspberry Pi 2) est apparu en premier sur Raspbian-France.

Original post of RaspbianFrance.Votez pour ce billet sur Planet Libre.

Après avoir crée la requête dans ELASTICSEARCH me permettant de récupérer les services ESB qui ne seraient pas dans un état normal, il ne me reste plus qu’à gérer l’alerte avec XPACK

J’ai modifié ma requête pour en faire un template.

POST /_search/template/esb-alert-search
{
  "template":{
  "size": 0,
  "query": {
    "range": {
      "JOBSTART": {
        "gte": "{{date_min}}",
        "lte": "now"
      }
    }
  },
  "aggs": {
    "services": {
      "terms": {
        "field": "DEPLOYMENT_NAME"
      },
      "aggs": {
        "success": {
          "filter": {
            "term": {
              "STATUS": "sucess"
            }
          }
        },
        "errors": {
          "filter": {
            "term": {
              "STATUS": "error"
            }
          }
        },
        "percentage": {
          "bucket_script": {
            "buckets_path": {
              "numberOfSuccess": "success>_count",
              "numberOfErrors": "errors>_count"
            },
            "script": "params.numberOfErrors /(params.numberOfErrors+params.numberOfSuccess)"
          }
        },
        "services_error_filtered": {
          "bucket_selector": {
            "buckets_path": {
              "threesold": "percentage"
            },
            "script": "params.threesold > {{threeshold}}"
          }
        }
      }
    }
  }
  }
}

Ensuite, j’ai crée l’alerte qui loggue l’alerte dans les logs d’ELASTICSEARCH et peuple un index dédié aux alertes. Bien évidemment, on peut appeler un service REST pour créer un ticket dans un BUGTRACKER par exemple.

put _xpack/watcher/watch/esb-alert
{
  "trigger": {
    "schedule": {
      "interval": "30s"
    }
  },
  "input": {
    "search": {
      "request": {
        "indices": [
          "monitor2"
        ],
        "template": {
          "stored": "esb-alert-search",
          "params": {
            "date_min": "now-1d/d",
            "threeshold": "0.5"
          }
        }
      }
    }
  },
  "condition": {
    "script": {
      "inline": "return ctx.payload.aggregations.services.buckets.size() > 0"
    }
  },
  "actions": {
    "log": {
      "logging": {
        "level": "warn",
        "text": "Errors have occured in the logs"
      }
    }
  }
}

Maintenant les alertes sont disponibles dans mon index et visibles par exemple via un rapport KIBANA

Original post of Littlewing.Votez pour ce billet sur Planet Libre.

Jusqu'à présent, nous ne nous sommes pas occupés de l'apparence de notre application. Et vous l'avez sans doute remarqué, ce n'est pas très joli.
On peut heureusement améliorer légèrement les choses avec la bibliothèque ttk.

On ajoute alors ceci au début de notre code :

from tkinter import ttk

Nous allons ainsi pouvoir utiliser des widgets améliorés. Pour cela, rien de compliqué, on a juste à ajouter ttk devant. Ainsi, Button devient ttk.Button.

Pour activer un autre thème, il faut insérer ce bout de code pour choisir entre "clam", "alt", "default" et "classic" :

#('clam', 'alt', 'default', 'classic')
style = ttk.Style()
style.theme_use("clam")

Vous pouvez voir ci-dessous ce que ça change avec les interfaces avant/après côte à côte.

Notez que l'on peut aller encore plus loin en modifiant les couleurs, polices et bordures. Cela devient vite compliqué, mais c'est faisable. Par exemple :

theme = {
        'disabledfg':"#eeeeee",
        'dark': "#777777",
        'darker': "#333333",
        'darkest': "#777777",
        'lighter': "#777777",
        'lightest': "#ffffff",
        'selectbg': "#41B1FF",
        'selectfg': "#ffffff",
        'foreground': "#111111",
        'background': "#dddddd",
        'borderwidth': 1,
        'font': ("Droid Sans", 10)
        }

    style.configure(".", padding=5, relief="flat", 
            background=theme['background'],
            foreground=theme['foreground'],
            bordercolor=theme['darker'],
            indicatorcolor=theme['selectbg'],
            focuscolor=theme['selectbg'],
            darkcolor=theme['dark'],
            lightcolor=theme['lighter'],
            troughcolor=theme['darker'],
            selectbackground=theme['selectbg'],
            selectforeground=theme['selectfg'],
            selectborderwidth=theme['borderwidth'],
            font=theme['font']
            )

    style.map(".",
        foreground=[('pressed', theme['darkest']), ('active', theme['selectfg'])],
        background=[('pressed', '!disabled', 'black'), ('active', theme['lighter'])]
        )

    style.configure("TButton", relief="flat")
    style.map("TButton", 
        background=[('disabled', theme['disabledfg']), ('pressed', theme['selectbg']), ('active', theme['selectbg'])],
        foreground=[('disabled', theme['disabledfg']), ('pressed', theme['selectfg']), ('active', theme['selectfg'])],
        bordercolor=[('alternate', theme['selectbg'])],
        )

Ça ressemble maintenant à ça :

J'ai tenté de rassembler les couleurs ensemble au cas où vous voudriez bricoler. Afin d'aller plus loin, une bonne idée est d'aller fouiller dans le fichier de thème par défaut. Pour moi, il s'agit de /usr/local/lib/tcl/tk8.5/ttk/clamTheme.tcl.

Même si ce n'est pas notre priorité, on voit qu'il est possible de faire un peu tout ce que l'on veut au niveau de l'apparence.

Ça sera tout pour aujourd'hui. La prochaine fois, on parlera des évènements afin de contrôler la visionneuse au clavier.

Et voici le code final (avec un petit bug pour le défilement d'images corrigé).

#!/usr/bin/env python3.4
# -*- coding:Utf-8 -*- 

import os
import sys
import mimetypes
from tkinter import *
from tkinter import filedialog
from tkinter import ttk
from PIL import Image, ImageTk

img_extensions = ('.png', '.PNG', '.jpg', '.JPG', '.gif', '.GIF')


### Fonctions ###
def pick_img():
    img_path = filedialog.askopenfilename(\\
                initialdir=(os.path.expanduser("~")),\\
                filetypes=[('Images', img_extensions), ('Tout', '.*')],\\
                title="Image à ouvrir",\\
                parent=w)
    return img_path

def open_img(img_container, img_path):
    # Ouverture de l'image
    image = Image.open(img_path)
    # Dimensions de l'écran : 
    gap = 100 # marge par rapport aux bords de l'écran
    screen_width = w.winfo_screenwidth() - gap
    screen_height = w.winfo_screenheight() - gap

    if image.width > screen_width : 
        image = image.resize((screen_width, int(image.height * screen_width / image.width)), Image.ANTIALIAS)
    if image.height > screen_height :   
        image = image.resize((int(image.width * screen_height / image.height), screen_height), Image.ANTIALIAS)

    # Chargement de l'image en mémoire
    img = ImageTk.PhotoImage(image)

    # On met l'image dans le conteneur
    img_container.configure(image = img)
    # On s'assure que l'image sera bien gardée en mémoire
    img_container.image = img
    # Ainsi que son emplacement
    img_container.path = img_path

def chg_img(img_container):
    # change l'image affichée
    i = pick_img()
    if i: # On a bien choisi une image
        open_img(img_container,i)

def defile_img(img_container, sens):
    """
    On fait défiler les images dans un sens ou dans l'autre
    sens == "prev" : précédent,
    sens == "next" : suivant,

    On a besoin de passer le conteneur de l'image
    en argument pour retrouver l'emplacement de l'image courante.
    """
    # Emplacement de l'image actuelle : 
    cur_path = img_container.path
    # Dossier de l'image actuelle : 
    d = os.path.dirname(cur_path)
    # Liste des images
    l = os.listdir(d)

    # on ne garde que les images
    # "{}/{}".format(d,i) : on met le chemin complet vers l'image 
    # for i in l :pour toutes les images dans la liste l
    # if os.path.splitext(i)[1] in img_extensions : 
    #     si l'extension de l'image est dans la liste des extensions
    img_list = [ "{}/{}".format(d,i) for i in l if os.path.splitext(i)[1] in img_extensions ]

    # On met dans l'ordre
    img_list = sorted(img_list)

    # On ne fait tourner que si il y a plusieurs images
    if len(img_list) > 1:
        # on retrouve la position de l'image actuelle
        pos = img_list.index(cur_path)

        if sens == "next":
            newpos = pos + 1
            if newpos > len(img_list) -1: # fin de liste
                newpos = 0
        elif sens == "prev":
            newpos = pos - 1 # début de liste
            if newpos < 0:
                newpos = len(img_list) - 1
        open_img(img_container, img_list[newpos])

def change_colors(style):
    theme = {
        'disabledfg':"#eeeeee",
        'dark': "#777777",
        'darker': "#333333",
        'darkest': "#777777",
        'lighter': "#777777",
        'lightest': "#ffffff",
        'selectbg': "#41B1FF",
        'selectfg': "#ffffff",
        'foreground': "#111111",
        'background': "#dddddd",
        'borderwidth': 1,
        'font': ("Droid Sans", 10)
        }

    style.configure(".", padding=5, relief="flat", 
            background=theme['background'],
            foreground=theme['foreground'],
            bordercolor=theme['darker'],
            indicatorcolor=theme['selectbg'],
            focuscolor=theme['selectbg'],
            darkcolor=theme['dark'],
            lightcolor=theme['lighter'],
            troughcolor=theme['darker'],
            selectbackground=theme['selectbg'],
            selectforeground=theme['selectfg'],
            selectborderwidth=theme['borderwidth'],
            font=theme['font']
            )

    style.map(".",
        foreground=[('pressed', theme['darkest']), ('active', theme['selectfg'])],
        background=[('pressed', '!disabled', 'black'), ('active', theme['lighter'])]
        )

    style.configure("TButton", relief="flat")
    style.map("TButton", 
        background=[('disabled', theme['disabledfg']), ('pressed', theme['selectbg']), ('active', theme['selectbg'])],
        foreground=[('disabled', theme['disabledfg']), ('pressed', theme['selectfg']), ('active', theme['selectfg'])],
        bordercolor=[('alternate', theme['selectbg'])],
        )


### tkv ###

# Notre fenêtre principale
w = Tk()
w.title("tkv : visionneuse d'images") # Un titre
w.configure(background='#000000')     # Fond noir

#('clam', 'alt', 'default', 'classic')
style = ttk.Style()
style.theme_use("clam")
change_colors(style)

# Un conteneur dans la fenêtre
mainframe = ttk.Frame(w)
mainframe.pack(fill=BOTH,expand=True, padx=15, pady=15)

# Ouverture de l'image
img_path=""
if len(sys.argv) == 2:
    # On a une image en agument
    img_path = sys.argv[1]

if not os.path.isfile(img_path):
    # On va chercher une image sur le disque
    img_path = pick_img()
    if not img_path: # L'utilisateur n'a choisi aucune image, on quitte
        sys.exit(0)

    # Est-ce un fichier valide ?
mimtyp = mimetypes.guess_type(img_path)[0] # i.e 'image/jpeg'
if not mimtyp or "image" not in mimtyp :
    # Il n'y a pas le mot "image" dans le mimetype
    from tkinter import messagebox
    messagebox.showerror("Fichier invalide", "Le fichier demandé n'est pas une image.")
    sys.exit(1)

# Conteneur de l'image
img_widget = ttk.Label(mainframe)
img_widget.pack()

# Insertion de l'image dans le conteneur.
open_img(img_widget, img_path)

# Frame contenant les boutons en bas de la fenêtre : 
btnbox = ttk.Frame(mainframe)
btnbox.pack()

# Bouton ouvrir
b_open = ttk.Button(btnbox, text="Ouvrir", width=12, command=lambda: chg_img(img_widget))

# Boutons suivant et précédent
b_next = ttk.Button(btnbox, text="Suivant →", width=12, command=lambda: defile_img(img_widget, "next"))
b_prev = ttk.Button(btnbox, text="← Précédent", width=12, command=lambda: defile_img(img_widget, "prev"))

# On affiche les boutons dans la boîte les uns à côté des autres
b_open.pack(side=LEFT)
b_prev.pack(side=LEFT)
b_next.pack(side=LEFT)

# Démarrage du programme
w.mainloop()

sys.exit(0)

Original post of Thuban.Votez pour ce billet sur Planet Libre.

Voici une procédure de réinstallation propre de LineageOS en conservant les applis de son ancienne rom (ici Cyanogenmod, mais je pense ca marche pour d’autres aussi)

1. Installer Oandbackup depuis Fdroid et faire une sauvegarde complète de ses applications sur la mémoire interne du téléphone (dossier oandbackup) . Pensez à cocher la case dans les options pour copier faire une copie de l’APK de oandbackup dans le dossier de sauvegarde :)
2. Télécharger une nightly récente sur https://download.lineageos.org/
3. Télécharger l’utilitaire « su » permettant l’accès root https://download.lineageos.org/extras
4. Mettre ces fichiers zip sur la carte SD
5. Redémarrer en mode recovery (TWRP)
6. Effacer (« Wipe ») dalvik, system, data, cache . Gardez Internal storage !!!
7. Installez le zip de la rom, puis le zip de « su »
8. Redémarrez le téléphone. Ca va être long, plusieurs minutes à contempler l’animation de démarrage de LineageOS.
9. Réinstaller Oandbackup depuis l’APK qu’on a laissé sur la mémoire interne.
10. Restaurer toutes les applications depuis Oandbackup.

Et c’est fini !

J’ai testé sur un Nexus 5X qui était auparavant sur Cyanogen 14.1.

Le seul truc qui n’a pas marché chez moi fut la restauration des comptes sur l’appareil. En gros si le compte était géré par l’application, pas de soucis, il a bien été restauré. Par contre, si il était géré au niveau du téléphone (Paramètres->Comptes) alors j’ai dû le recréer.

Ce qui est cool, c’est que LineageOS intègre le dernier Android en date (7.1.1) et déjà les correctifs de sécurité de Google de Janvier 2017 (une centaine !)

Related Posts:

• Yalp Store : téléchargez les applications du Google Play Store sans Google Apps
• Android KitKat : en route vers BigBrother
• Pourquoi faut-il se méfier des applications de Whispersystem ?
• Cyanogen 10.1 RC2
• CyanogenMod 10 est sortie

Original post of Tuxicoman.Votez pour ce billet sur Planet Libre.

« Use Tor, Use Signal » est un slogan que l’on voit de plus sur les réseaux sociaux. Ce slogan se veut une recommandation à destination des militants se coordonnant via Internet. En France, une remarque revient souvent suite à ce slogan : « Et Silence alors ? ». Silence est un outil différent de Signal, avec un fonctionnement et un usage qui lui sont propre. Voyons donc ce qui les rassemble et ce qui les sépare.

Généalogie

Dans le monde Android

Au premier jour (en 2010), Moxie créa TextSecure dont l’objet était de pouvoir s’échanger des SMS chiffrés, de sorte que seuls l’expéditeur et le destinataire puissent lire le contenu du message.

Rappel : l'échange de SMS est un service fourni par l'opérateur téléphonique. Il ne nécessite pas d'accès à Internet (2G, 3G, 4G ou Wifi) mais seulement d'être relié au réseau de son opérateur comme pour les appels téléphoniques traditionnels.

En parallèle de TextSecure, Moxie créa RedPhone, dont l’objet était de pouvoir passer des appels de manière chiffrée. Contrairement à TextSecure, une connexion à Internet sur son téléphone était nécessaire.

À partir de début 2014, TextSecure a permis de s’échanger des messages «par Internet» (comme WhatsApp, Viber, etc), toujours chiffrés, en plus des traditionnels SMS. Très vite après, la fonctionnalité SMS a été supprimée.

Une bonne partie des utilisateurs de TextSecure souhaitant toujours pouvoir s’échanger des SMS chiffrés, un fork vu le jour sous le nom de SMSSecure.

Le fork est aux logiciels ce que le spin-off est à la série télé. On part d'une histoire commune et on en dérive une histoire différente, avec plus ou moins de succès.

Sous la pression de Moxie d’une société qui ne mérite pas d’être nommée ici, SMSSecure a été rebaptisé Silence en Avril 2016.

Dans le monde Apple

Pendant que TextSecure faisait sa mue et abandonnait les SMS, une version de Redphone pour les téléphones Apple voyait le jour sous le nom de Signal. Quelques semaines plus tard, Signal se voyait ajouter les mêmes fonctionnalités d’échange de messages que proposait TextSecure.

La grande réunion

En novembre 2015, TextSecure sur Android a été renommé Signal et à partir de ce moment-là, les utilisateurs de téléphones Apple ou Android ont pu s’appeler et s’échanger des messages de manière chiffrée par Internet. Sans que ni l’opérateur téléphonique du destinataire ni celui de l’expéditeur ne puissent savoir qui parle à qui, à quel moment et pour se dire quoi.

À partir d’avril 2016, on a donc la même situation qu’aujourd’hui :

• Signal, pour iOS et Android, chiffrant les appels et les messages, nécessitant Internet
• Silence, pour Android uniquement, chiffrant les SMS, ne nécessitant pas Internet

Qui choisir, Signal ou Silence ?

C’est la question qui revient souvent : « Mais alors c’est quoi le mieux ? Qu’est ce qu’il faut utiliser ? Signal ou Silence ? »

Si vous avez un téléphone Apple, la réponse est simple : *Signal*. 
Silence n'existe pas pour iOS.

Pour les autres, il faut bien comprendre ce que font et ne font pas les deux applications. Voyons donc le détail :

Les bases

Signal permet d’échanger :

• des appels vocaux chiffrés,
• des messages chiffrés,
• des SMS/MMS non chiffrés.

Silence permet d’échanger :

• des SMS/MMS chiffrés,
• des SMS/MMS non chiffrés.

Signal, pour les communications chiffrées, a besoin d’accès à Internet, peu importe comment : 2G, 3G, 4G ou Wifi. Silence, lui, repose uniquement sur la capacité de votre opérateur à transporter les SMS.

Qui voit quoi ?

Commençons par le plus simple : Silence.

Lorsqu’on échange des messages via Silence, les opérateurs (de l’expéditeur et du destinataire) savent grosso modo :

• qui a envoyé un message,
• à qui a été envoyé le message,
• à quelle heure.

Si vous souhaitez discuter de manière confidentielle avec une personne de sorte qu’on ne puisse jamais savoir que vous avez été en contact, n’utilisez pas Silence. Une réquisition auprès d’un des opérateurs permettra d’identifier la personne.

Les messages ne passent pas par Internet, aucun autre acteur n’est impliqué dans l’échange. C’est donc pratique pour discuter avec des gens dont vous vous foutez qu’on sache que vous leur parlez, tout en gardant une certaine confidentialité.

Ça se corse : Signal

Dans le cas de Signal, les opérateurs qui font office de fournisseurs d’accès à Internet (soit l’opérateur téléphonique soit le FAI du réseau wifi que vous utilisez) voient que votre téléphone communique avec l’entité qui est derrière Signal : OpenWhisper Systems (OWS par la suite) et voit des échanges avec Google.

Que fait Google dans cette histoire ? Et bien Google fournit la fonctionnalité qui permet en quelque sorte de réveiller votre téléphone pour qu’il aille vérifier auprès d’OWS qu’un message l’attend. Cela est très utile pour économiser la batterie de votre téléphone. Google ne sait pas avec qui vous communiquez ni ce que vous vous dites.

Les messages transitent par contre par OWS, l’association/fondation/entité qui édite Signal. OWS sait avec qui vous communiquez, à quel moment mais ne peut pas voir le contenu de vos échanges.

Si vous ne faites aucune confiance dans les opérateurs de votre pays, vous devriez plutôt utiliser Signal. En revanche, cela nécessite de faire confiance dans une entité américaine (OWS) sur laquelle vous n’avez aucune maitrise.

Il se fait tard, c’est sans doute approximatif mais le but n’est pas d’être exhaustif mais de faire une bonne intro à ces questions qui reviennent souvent. S’il y a des remarques pertinentes, l’article évoluera évidemment ;)

Et donc ?

Et donc les deux applications sont utiles et pertinentes. À vous de choisir laquelle utiliser en fonction de votre situation, des risques autour de vos communications. Pour ma part, j’utilise les deux applications au quotidien.

Original post of Libre Parcours.Votez pour ce billet sur Planet Libre.