cClaude.rocks ☕ Le blog

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

• curl another host

ᦿ

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 :

• Jouer avec des algorithmes célèbres comme le « jeu de la vie » de John Conway – « Game of Life », John Conway, 1970,
• Explorer l’univers des fractales
  • du flocon de Koch inventée en 1904 par le mathématicien suédois Helge von Koch,
  • l’ensemble de MandelBrot et l’Ensemble de Julia découvert par les mathématiciens Gaston Julia et Pierre Fatou en 1918.

• Ensemble de Julia (Définition)

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

  $$\begin{array}{r}{Z}_0=z\text{ et }{Z}_{n+1}=Z_n^2+C\end{array}$$

  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

  

  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

• Site officiel de Processing,
  • Code source de la dernière version sur GitHub,
  • Le Code source des versions précédentes étant dans un autre repository.
• https://processingfoundation.org/,
• Les fractales de Mandelbrot et Julia.
• Math and processing
• Outil permettant d’afficher des courbes en ligne : desmos

ᦿ

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 :

• 01:38:48 – « 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…

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

• Comment Doctolib se sert de nos données de santé - (copie locale)

ᦿ