cClaude.rocks ☕ Le blog

[Nouvelles technologies, sciences et coups de gueule…]

Menu

Cas d’utilisation

Parfois, vous voulez exĂ©cuter la commande cURL sur un serveur qui gĂšre plusieurs sites web (sur le mĂȘme port), mais vous ne souhaitez pas vraiment que cURL rĂ©solve le nom d’hĂŽte dans l’URL donnĂ©e.

Vous savez l’adresse IP du serveur, et cependant la rĂ©solution DNS ne vous permet pas d’atteindre le serveur depuis la machine sur laquelle vous souhaitez exĂ©cuter cURL.

Typiquement lors de la prĂ©paration du lancement d'un site Web ou du dĂ©bogage de problĂšmes avec un site dĂ©jĂ  en ligne, il peut parfois ĂȘtre utile de contourner les couches CDN et proxy lors de la demande de contenu du site en envoyant ces demandes Web directement Ă  une adresse IP spĂ©cifique sans utiliser l'enregistrement DNS public du site.

Cette pratique consistant Ă  « épingler » une requĂȘte Web directement sur un serveur peut ĂȘtre accomplie en modifiant votre fichier /etc/hosts, ce qui entraĂźnera le routage des requĂȘtes pour un nom de domaine spĂ©cifiĂ© (par exemple : « www.example.com ») Ă  partir de votre machine locale Ă  une adresse IP spĂ©cifiĂ©e (par exemple : 127.0.0.1) jusqu’à ce que les modifications que vous avez apportĂ©es Ă  /etc/hosts soient annulĂ©es.

Cependant, que faire si vous souhaitez Ă©pingler une seule requĂȘte Ă  une adresse IP, sans modifier les fichiers de configuration de votre systĂšme ? Heureusement, ce type d’épinglage de requĂȘtes « ad hoc » est possible via la ligne de commande avec cURL, qui fournit une option de rĂ©solution spĂ©ciale, formatĂ©e comme suit :

--resolve [DOMAIN]:[PORT]:[IP]

Cela acheminera toutes les requĂȘtes Web effectuĂ©es lors de l’exĂ©cution d’une commande cURL qui correspond Ă  un [DOMAINE] et un [PORT] donnĂ©s Ă  l’adresse [IP] spĂ©cifiĂ©e. Les valeurs spĂ©cifiĂ©es par cette option (qui peuvent ĂȘtre invoquĂ©es plusieurs fois dans une seule commande pour acheminer plusieurs combinaisons domaine/port vers diverses adresses IP) s’appliqueront Ă  la demande initiale, ainsi qu’à toutes les redirections que cURL sera amener Ă  suivre.


ඏ

Les solutions

Bricoler votre fichier hosts

Comme nous l’avons vu plus haut, il est possible de dĂ©finir le nom de domaine dans le fichier /etc/hosts et de l’associer Ă  l’adresse IP qui vous souhaitez utiliser.

Cependant, cela affectera l’ensemble de la machine et ce n’est pas nĂ©cessaire votre souhait.


Fabriquer une fausse entĂȘte http avec le bon nom d’hĂŽte

Une maniĂšre classique et facile Ă  comprendre est d’envoyer votre requĂȘte vers le serveur souhaiter en bricolant l’entĂȘte HTTP. Le serveur HTTP pourra alors traiter la rĂ©ponse pour le nom de serveur souhaiter.

ConcrĂštement si vous exĂ©cutez votre site de test HTTP « example.com » sur localhost (127.0.0.1) et souhaitez vĂ©rifier qu’il fonctionne :

curl --header "Host: example.com" http://127.0.0.1/

Utiliser cURL ainsi permettra de faire fonctionner le systĂšme de cookies au nom du domain « example.com » dans ce cas, mais cela Ă©chouera lamentablement si la page redirige vers un autre hĂŽte (dans le cas oĂč le suivi de redirection est activité : --location) car cURL enverra Ă©galement le faux entĂȘte Host: dans toutes les autres demandes.

L’option --header annule intelligemment l’entĂȘte Host: intĂ©grĂ©e donnĂ©e quand un entĂȘte personnalisĂ© est fourni afin que seul celui transmis par l’utilisateur soit envoyĂ© dans la demande.


Une meilleure façon de gĂ©nĂ©rer une fausse entĂȘte

Aujourd’hui le protocole HTTPS devient la norme et simuler l’hĂŽte : l’en-tĂȘte ne suffit pas. Un serveur HTTPS doit Ă©galement obtenir le nom du serveur dĂ©jĂ  fourni dans la nĂ©gociation TLS afin de savoir quel certificat utiliser. Le nom est fourni dans le champ SNI. La commande cURL doit Ă©galement connaĂźtre le nom d’hĂŽte correct pour vĂ©rifier le certificat de serveur (les certificats de serveur sont rarement enregistrĂ©s pour une adresse IP). cURL extrait le nom Ă  utiliser dans les deux cas Ă  partir de l’URL fournie.

Comme nous ne pouvons pas simplement mettre l’adresse IP dans l’URL pour que cela fonctionne, nous inversons l’approche et donnons Ă  la place l’URL appropriĂ©e Ă  cURL mais avec une adresse IP personnalisĂ©e Ă  utiliser pour le nom d’hĂŽte que nous avons dĂ©fini. L’option --resolve de ligne de commande est notre amie :

curl --resolve example.com:443:127.0.0.1 https://example.com/

Sous le capot, cette option remplit le cache DNS de cURL avec une entrĂ©e personnalisĂ©e pour le port « example.com » 443 avec l’adresse 127.0.0.1, donc lorsque cURL veut se connecter Ă  ce nom d’hĂŽte, il trouve votre adresse spĂ©cialement conçue et s’y connecte au lieu de l’adresse IP que le « vrai » nom rĂ©soudrait autrement.

Cette mĂ©thode fonctionne Ă©galement parfaitement lorsque vous suivez des redirections, car toute autre utilisation du mĂȘme nom d’hĂŽte se rĂ©soudra toujours Ă  la mĂȘme adresse IP et la redirection vers un autre nom d’hĂŽte se rĂ©soudra alors correctement. Vous pouvez mĂȘme utiliser cette option plusieurs fois sur la ligne de commande pour ajouter des adresses personnalisĂ©es pour plusieurs noms. Vous pouvez Ă©galement ajouter plusieurs adresses IP pour chaque nom si vous le souhaitez.


Se connecter Ă  un autre hĂŽte par son nom

Comme indiquĂ© ci-dessus, --resolve est gĂ©nial si vous souhaitez pointer cURL vers une adresse IP connue spĂ©cifique. Mais parfois, ce n’est pas exactement ce que vous voulez non plus.

Imaginez que vous ayez un nom d’hĂŽte qui se rĂ©sout en un certain nombre de noms d’hĂŽtes diffĂ©rents, Ă©ventuellement un certain nombre de serveurs frontaux pour le mĂȘme site / service. Pas complĂštement inconnu. Imaginez maintenant que vous souhaitez Ă©mettre votre commande cURL vers un serveur spĂ©cifique parmi les serveurs frontaux. C’est un serveur qui sert « example.com » mais le serveur individuel est appelĂ© « host-47.example.com ».

Vous pouvez rĂ©soudre le nom d’hĂŽte dans une premiĂšre Ă©tape avant d’utiliser cURL et utilisez --resolve comme indiquĂ© ci-dessus.

Ou vous pouvez utiliser --connect-to, qui fonctionne Ă  la place sur la base d’un nom d’hĂŽte. En utilisant cela, vous pouvez faire en sorte que cURL remplace une paire spĂ©cifique de nom d’hĂŽte + numĂ©ro de port par une autre paire d’hĂŽte + numĂ©ro de port avant que le nom ne soit rĂ©solu !

curl --connect-to example.com:443:host-47.example.com:443 https://example.com/

Des combos fous

La plupart des options de cURL sont contrĂŽlĂ©es individuellement, ce qui signifie qu’il y a rarement une logique qui vous empĂȘche de les utiliser dans les combinaisons impressionnantes auxquelles vous pouvez penser.

--resolve, --connect-to et --header peuvent tous ĂȘtre utilisĂ©s dans la mĂȘme ligne de commande !

Connectez-vous Ă  un hĂŽte HTTPS exĂ©cutĂ© sur localhost, utilisez le nom correct pour SNI et la vĂ©rification de certificat, mais demandez toujours un hĂŽte distinct dans l’en-tĂȘte Host:? Bien sĂ»r pas de problĂšme:

curl --resolve example.com:443:127.0.0.1 https://example.com/ --header "Host: diff.example.com"

Tout ce qui précÚde avec libcurl ?

Lorsque vous avez fini de jouer avec les options cURL comme dĂ©crit ci-dessus et que vous souhaitez convertir vos lignes de commande en code libcurl Ă  la place, votre meilleur ami est d’invoquĂ© le paramĂštre : --libcurl.

Ajoutez simplement --libcurl example.c Ă  votre ligne de commande, et cURL gĂ©nĂ©rera le modĂšle de code C pour vous dans ce nom de fichier donnĂ©. Sur la base de ce modĂšle, l’utilisation correcte de ce code est gĂ©nĂ©ralement simple et vous aurez toutes les options Ă  lire de maniĂšre pratique.


ඏ

Références

኿


Processing est un carnet de croquis numérique flexible et un langage pour apprendre à coder dans le contexte des arts visuels.


ඏ

Présentation de Processing

C’est un excellent outil pour :

  • Ensemble de Julia (DĂ©finition)

    L’ensemble de Julia est construit à l’aide de la formule suivante :

    Z 0 = z  et  Z n + 1 = Z n 2 + C

    oĂč Z et C appartient Ă  l’ensemble de complexes et C est une constante.

  • Ensemble de Julia (Code)
    /*
    ** Julia.pde - Java Julia by MN Karthik.
    ** Any questions, comments, suggestions? You can contact me at mnkarthik@yahoo.com.
    **
    ** Modifications and adaptation to Processing by Mad Merv 2004 - http://www.madmerv.com
    ** Adaptation Claude CHOISNET 2021 to last processing version.
    */
    
    void setup() {
      background(0);
      size(600, 600);
    }
    
    void draw() {
      int sx=width;         // Screenwidth
      int sy=height;        // Screenheight
      double xmin=-(1.5);   // smallest real value (x-axis)
      double xmax=(1.5);    // largest real value (x-axis)
      double ymin=-(1.5);   // smallest imaginary value (y-axis)
      double ymax=(1.5);    // largest imaginary value (y-axis)
      double maxiter=512;   // Max number of iterations
    
      double old_x;         // temporary variable to store x-value
      double fx, fy;
      double ix=0.42;       // C Constant real part
      double iy=0.23;       // C Constant imaginary part
      int m;                // variable to store number of iterations
    
      double dx=(xmax-xmin)/sx; // how much to add for each x-pixel?
      double dy=(ymax-ymin)/sy; // how much to add for each y-pixel?
    
      int px;           // Variable storing current x-pixel
      int py=0;         // Variable storing current y-pixel
      double x;         // Variable storing current x-value
      double y=ymin;    // Variable storing current y-value
    
      stroke(0);
      while (py<sy) {
        px=0;
        x=xmin;
        py++;
        while (px<sx) {
          px++;
    
          fx=x;
          fy=y;
          m=0;
          do {
            old_x=fx;
            fx= fx*fx - fy*fy + ix;
            fy= 2*old_x*fy + iy;
            m++;
          } while (((fx*fx+fy*fy)<4) && (m<maxiter));
          stroke(m%50+((mouseX+mouseY)/2), m%12*(255/12), m%4*(255/4));
          line(px-3, py-3, px+10, py+10);
          x+=dx;
        }
        y+=dy;
      }
      stroke(0);
    }
    

    Voici une reprĂ©sentation graphique de l’ensemble de Julia pour C = 0.42 + 0.23i

    Ensemble de Julia

    Bon, on peut commencer par moins hardcore


Processing intÚgre de nombreuses fonctionnalités :

  • Exportation au format DXF: un format permettant d’échanger avec d’autres applications de CAO ou de DAO,
  • Exportation au format PDF,
  • Exportation au format SVG,
  • AccĂšs aux entrĂ©es-sorties de votre ordinateur sur Raspberry Pi et autres Linux,
  • Échanges rĂ©seaux : permettant de recevoir ou d’envoyer des donnĂ©es sur Internet,
  • Support de l’interface sĂ©rie (RS-232),
  • Le son : en sortie comme en entrĂ©e,
  • la vidĂ©o : rĂ©cupĂ©ration d’image depuis votre camĂ©ra, lecture de fichiers vidĂ©os ou exportation vidĂ©os.

L'outil est prévu pour manipuler simplement des objets en 2D ou en 3D.


ඏ

Usages

  • C’est l’outil pĂ©dagogique parfait permettant crĂ©er simplement des animations ou des images d’illustrations.

  • C’est un outil bien adaptĂ© aux Ă©tudiants comme aux enseignants.


ඏ

Un exemple « simple »

Non, en fait, ce n’est pas simple, mais en rĂ©alitĂ© la partie lourde du code est liĂ©e Ă  la dĂ©coration (l’affichage de la grille principalement).

Pour utiliser ce code, vous n’aurez qu’à modifier ce que retournent les 2 premiùres fonctions.

Ici, on cherche Ă  rĂ©soudre le systĂšme d’équation suivant :

Y = 2X + 1
Y = -(XÂČ) + 4

qu’il faudra traduire comme suit :

return 2.0*x +1.0;
return -( x * x ) + 4.0;

Si vous souhaitez utiliser un autre systĂšme d’équations, il suffit d’adapter les 2 lignes correspondantes.

Bon presque, car il reste encore à s’assurer que la solution se trouve dans l’espace d’affichage


  • Le code correspondant

    Dans un cadre pédagogique, il est possible de mettre le code concernant l'affichage dans une autre classe, et de limiter le code au strict minimum.

    // USER FUNCTION
    float y1(float x) { // The function to plot
      // return 2.0 * x * x -8.0;
      return 2.0*x +1.0;
    }
    
    float y2(float x) { // The function to plot
      return -( x * x ) + 4.0;
    }
    
    //______________________________________________________________________
    void setup() {
      size(1000, 500); // SIZE OF SCREEN
      noLoop();
    }
    
    void draw() {
      background(255);
      draw_grid();
      translate(width/2, height/2);
      draw_functions();
    }
    
    //______________________________________________________________________
    // can be other TAB..
    final int steps = 100;
    float X, Y1, Y2, Xo=0, Y1o, Y2o;
    final float f_start_x = -10, f_stop_x = 10;
    final float dx = (f_stop_x - f_start_x )/float(steps);
    final float epsilon = 1;
    
    //consts
    final color RED  = color(255, 0, 0);
    final color BLUE = color(0, 0, 255);
    
    void draw_functions() {
      strokeWeight(1);
      for ( int i = 0; i< steps; i++) {
        X = f_start_x + dx * i;
        if ( i == 0 ) Xo=X;                      // need a dummy init for first line
        Y1 = y1(X);
        if ( i == 0 ) Y1o=Y1;
        Y2 = y2(X);
        if ( i == 0 ) Y2o=Y2;
        if ( abs(Y2 - Y1) <= epsilon ) {
          println("solution near i "+i+" X "+nf(X, 1, 2)+" Y1 "+nf(Y1, 1, 2)+" Y2 "+nf(Y2, 1, 2));
        }
    
        // draw it: // in processing draw y negativ! // scale to GRID by w
        stroke(RED);
        line(Xo*w, -Y1o*w, X*w, -Y1*w);
        circle(X*w, -Y1*w, 2);
        stroke(BLUE);
        line(Xo*w, -Y2o*w, X*w, -Y2*w);
        circle(X*w, -Y2*w, 2);
    
        // remember for next loop draw line
        Y1o = Y1;
        Y2o = Y2;
        Xo = X;
      }
    }
    
    final int x = 0, y = x, w = 25, h = w, offset = 0;
    void draw_grid() {
      // grid of rectangles
      int gridx = width / w;
      int gridy = height / h;
      //int many = gridx*gridy;
      noFill();
      stroke(0);
      for (int i = 0; i < gridx; i++) {
        for (int j=0; j <gridy; j++ ) {
          rect(x+i*(w+offset), y+j*(h+offset), w, h);   // or any other shape/text on that position
        }
      }
      // add
      // https://discourse.processing.org/t/math-and-processing/9292/7 @CHRISIR
      // small lines with numbers ||||||||||| : for x axis
      pushMatrix();
      translate(width/2, height/2);
      strokeWeight(3);
      textSize(15);
      textAlign(CENTER);
      fill(0); // BLACK
      stroke(0); // BLACK
      for (int i = -gridx/2 + 1; i < gridx/2; i++) {
        float dx = 1;
        float X =  dx * i;
        if (X==0) {
          continue;  // skip this number
        }
        float xToDraw = getXtoDraw(X);
        float yToDraw = getYtoDraw(0);
        line(xToDraw, yToDraw, xToDraw, yToDraw+11);
        text( i, xToDraw-1, yToDraw+29-1);
      }//for
      textAlign(LEFT);
      strokeWeight(1);
      popMatrix();
    
      // small lines with numbers : for y axis
      pushMatrix();
      translate(width/2, height/2);
      stroke(0); // BLACK
      fill(0);  // BLACK
      textSize(15);
      textAlign(CENTER);
      strokeWeight(3);
    
      for (int i = -gridy/2 + 1; i < gridy/2; i++) {
        float dx = 1;
        float Y =  dx * i;
        if (Y==0 || Y==-1) {
          continue;  // skip these numbers
        }
        float xToDraw = getXtoDraw(0);
        float yToDraw = getYtoDraw(Y);
        line(xToDraw, yToDraw, xToDraw+11, yToDraw);
        text(i,
          xToDraw+24, yToDraw);
      }
    
      textAlign(LEFT);
      strokeWeight(1);
      popMatrix();
      // show arrows and texts X and Y
      decoration();
      fill(255);
      ellipse(width/2, height/2, 5, 5);       // show center point
    }
    
    void decoration () {
      stroke(0);
      strokeWeight(3);
    
      // vertical line
      line ( width/2, 0, width/2, height);
    
      // horizontal line
      line ( 0, height/2, width, height/2);
    
      // texts X and its arrow ---
      fill(0);
      textSize(24);
      text ( "X", width-17, height/2+31);
    
      pushMatrix();
      noFill();
      strokeWeight(3.0);
      strokeJoin(MITER);
      beginShape();
    
      float f = 3.0;
      translate(width-f*7, height/2);
      vertex(3.5*f, -3.0*f);
      vertex(6.5*f, 0.0*f);
      vertex(3.5*f, 3.0*f);
      endShape();
      strokeWeight(1);
      popMatrix();
    
      // texts Y and its arrow ---
      fill(0);
      textSize(24);
      text ( "Y", width/2+10, 22);
      pushMatrix();
      noFill();
      strokeWeight(3.0);
      strokeJoin(MITER);
      beginShape();
      translate(width/2, 22);
      vertex( -3.0*f, -3.5*f);
      vertex( 0.0*f, - 6.5 * f);
      vertex( 3.0*f, - 3.5 * f);
      endShape();
      popMatrix();
    }
    
    // ---------------------- HELPER FUNCTIONS ----------------------
    
    float getXtoDraw(float xin_) {
      return xin_*w;
    }
    
    float getYtoDraw(float yin_) {  // in processing draw y negativ!
      return -yin_*w;
    }
    //
    

ඏ

Installation

Pour les plateformes classiques, vous trouverez tout ici : https://processing.org/download.

  • Installation Linux 64 bits
    cd ~/Downloads/
    wget https://github.com/processing/processing4/releases/download/processing-1277-4.0b2/processing-4.0b2-linux64.tgz
    
    tar xvf processing-4.0b2-linux64.tgz
    cd ~/Downloads/processing-4.0b2
    ./install.sh
    

La derniĂšre version ne fonctionne pas sur Raspberry PI. Le support des machines 32 bits semble avoir Ă©tĂ© abandonnĂ©, et la version Linux 64bits ne fonctionne pas sur un processeur ARM. AprĂšs avoir fait quelques essais, je pense que c’est finalement que trĂšs temporaire. Puisque c’est la cross-compilation qui semble ĂȘtre la limite actuelle (le fait de compiler depuis un couple (systĂšme,architecture) vers un autre couple (systĂšme,architecture)).


ඏ

Références

኿


Ce billet a été édité le : 2021-11-20

Le Dossier Médical Partagé

DĂ©but 2019, j’avais commencĂ© Ă  Ă©crire un article suite Ă  la vidĂ©o diffusĂ©e de l’espace des sciences de Rennes oĂč j’avais Ă©tĂ© Ă©tonnĂ© de cette confĂ©rence qui n’était qu’un moment de communication de la « CNAM » et oĂč j’avais Ă©tĂ© Ă©tonnĂ© du manque de recul des intervenants, une vision technocratique et technologique.

Leur discours m’a convaincu qu’ils Ă©taient dans la communication et qu’ils n’avaient pas pris la mesure des problĂšmes liĂ©s Ă  la mise en place du « Dossier MĂ©dical Personnalisé ».

En particulier, l’aspect sĂ©curitĂ© prĂ©sentĂ© dans la confĂ©rence est de la poudre aux yeux, il ne parle clairement pas de l’usage que peu ĂȘtre fait de ces donnĂ©es contre l’intĂ©rĂȘt des patients. En ce sens, cette confĂ©rence m’avait choquĂ© de la part de l’espace des sciences puisque le contenu de cette confĂ©rence ne permet pas d’informer le spectateur, et pire elle l’embrouille. Les critĂšres de sĂ©curitĂ© prĂ©sentĂ©, montre que la chaĂźne de stockage de l’information, vise Ă  dĂ©responsabiliser les diffĂ©rents intervenants. Ce dĂ©coupage garanti le fait que les diffĂ©rents intervenants seront facilement protĂ©gĂ©s lĂ©galement, mais ne permet pas de garantir que les donnĂ©es ne seront pas utilisĂ©es de maniĂšre douteuse.

Le SMS de confiance prĂ©sentĂ©, j’ignore s’il est finalement en place, mais celui-ci ne sert Ă  rien puisque les fichiers sont accessibles par des tiers Ă  des « fins de recherche », et au final, c’est une protection contre les professionnels de santĂ©, mais en aucun cas pour vous protĂ©ger d’une « assurance » qui souhaiterais Ă©valuer prĂ©cisĂ©ment votre cas, puisqu’elle ne passera pas l’application.

Je n’ai pas pris le temps de finir l’article, et c’est finalement la chaĂźne « BLAST » qui avec seulement 2 ans de recul amĂšne les confirmations de mes craintes de l’époque.

Le DPM sera principalement le cheval de trois permettant la disparition de sĂ©curitĂ© sociale et donc de la CNAM (« Caisse National d’Assurance Maladie). Cet outil est dĂ©finitivement la solution permettant au secteur privĂ© de prendre la main sur la manne liĂ©e au marchĂ© de la santĂ©.

  • Dossier mĂ©dical partagĂ© et intelligence artificielle

    Le DMP pour Dossier Médical Partagé un outil qui pourrait produire le meilleur, mais va certainement produire le pire.

    Dossier médical partagé et intelligence artificielle
    Avec _Yvon MerliĂšre_, _Romain Farel_
    

    Le dossier médical partagé (DMP) se déploie actuellement dans tout le pays à vitesse accélérée.

    Les experts en intelligence artificielle s’associent aux promoteurs de ce nouvel outil au bĂ©nĂ©fice des patients et professionnels de santĂ©. Mais ce nouveau carnet de santĂ© numĂ©rique peut aussi susciter des questions chez les usagers comme chez les mĂ©decins. L’occasion pour l’Assurance Maladie de dialoguer avec les uns et les autres.

Quelques oppositions Ă  l’informatisation des donnĂ©es de santĂ©s :

La premiÚre vidéo contient une phrase assez extraordinaire :

  • – « on travaille sur la traduction d’un document mĂ©dical, de français en espagnol, en gardant le document crypté » — Et bien, moi je pense qu’une technologie qui est capable de faire cela, est largement capable de faire des statistiques ou du ciblage directement sur ces documents cryptĂ©s


  • L’anonymisation Ă  un point faible, si jamais on dispose d’une base de donnĂ©e complĂ©mentaire contenant des informations qui ne sont mĂȘme pas contenue dans la base initiale. Je pense qu’il est a la portĂ©e d’une bonne Ă©quipe d’ingĂ©nieur des dĂ©sanonymisĂ©s la base de donnĂ©e en s’appuyant sur le contenu de la base telle que celle construite pour gĂ©rer les rendez-vous, telle qu’elle est mise en place par DoctoLib.

  • Toute la sĂ©curitĂ© est basĂ© dĂ©crite est finalement basĂ©e sur le fait que l’état protĂšge les donnĂ©es
 et que l’on « restera vigilant » prĂ©cise la prĂ©sentatrice : MaĂ«tte Chantrel


Le prĂ©sent montre que l’état ne protĂšge pas ces donnĂ©es, elles sont aujourd’hui dans les mains d’une puissance Ă©trangĂšre et que la majoritĂ© de la population s’en fiche



ඏ

BLAST, Le souffle de l’info

Traçage Ă©pidĂ©miologique, dossier mĂ©dical partagĂ©, capteurs qui suivent nos rythmes biologiques en temps rĂ©el
 Cette numĂ©risation a de graves consĂ©quences : nos donnĂ©es de santĂ© sont devenues un business juteux sur lequel le gouvernement ferme les yeux, quand il n’en est pas complice.


ඏ

Au final, la vidĂ©o de BLAST prouve que la confĂ©rence de la CNAM Ă©tait probablement un mĂ©lange d’incompĂ©tence et de propagande



ඏ

Autre sources

኿


Navigation / 2 ⋙ 108

Les anciens billets sont Ă©galement disponibles dans les archives.

â„č 2006 - 2021 | 🏠 Retour Ă  l'accueil du domaine | 🏡 Retour Ă  l'accueil du blog