MaBibli 1.0.0
Gestion de bibliothèque personnelle auto-hébergée : catalogue, prêts, scan de code-barres, consultation hors-ligne. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Mathieu Limonier
@@ -0,0 +1,115 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
|
||||
namespace MaBibli.Api.Services.Couvertures;
|
||||
|
||||
/// <summary>
|
||||
/// Garde-fou SSRF : n'autorise la connexion qu'à des adresses IP publiquement routables.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// ⚠️ <b>Ce garde est la raison pour laquelle le proxy de couvertures est acceptable.</b> Le
|
||||
/// service .NET écoute sur <c>127.0.0.1</c> et vit sur un serveur YunoHost qui héberge d'autres
|
||||
/// applications, souvent sur des ports locaux. Un proxy qui irait chercher n'importe quelle URL
|
||||
/// permettrait de faire lire au serveur ce que le client ne peut pas atteindre lui-même —
|
||||
/// c'est-à-dire exactement ce que la contrainte « écouter sur 127.0.0.1 uniquement » cherche à
|
||||
/// empêcher.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// ⚠️ <b>La vérification est faite au moment de CONNECTER, pas avant la requête.</b> Résoudre le
|
||||
/// nom d'abord puis laisser <c>HttpClient</c> résoudre à nouveau laisserait passer un
|
||||
/// <i>DNS rebinding</i> : un nom qui répond une adresse publique à la vérification et
|
||||
/// <c>127.0.0.1</c> à la connexion. Ici, la socket se connecte <b>aux adresses déjà validées</b>,
|
||||
/// et à aucune autre.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public static class GardeAdresses
|
||||
{
|
||||
/// <summary>
|
||||
/// Rappel de connexion pour <see cref="SocketsHttpHandler.ConnectCallback"/>.
|
||||
/// </summary>
|
||||
public static async ValueTask<Stream> ConnecterAsync(
|
||||
SocketsHttpConnectionContext contexte, CancellationToken ct)
|
||||
{
|
||||
var adresses = await Dns.GetHostAddressesAsync(contexte.DnsEndPoint.Host, ct);
|
||||
var permises = adresses.Where(EstPubliquementRoutable).ToArray();
|
||||
|
||||
if (permises.Length == 0)
|
||||
{
|
||||
// Message volontairement muet sur ce qui a été résolu : l'appelant n'a pas à
|
||||
// apprendre la topologie du réseau du serveur.
|
||||
throw new HttpRequestException("Adresse non autorisée.");
|
||||
}
|
||||
|
||||
var socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
|
||||
|
||||
try
|
||||
{
|
||||
await socket.ConnectAsync(permises, contexte.DnsEndPoint.Port, ct);
|
||||
return new NetworkStream(socket, ownsSocket: true);
|
||||
}
|
||||
catch
|
||||
{
|
||||
socket.Dispose();
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Vrai si l'adresse est publiquement routable, c'est-à-dire hors de tout ce qui pourrait
|
||||
/// désigner le serveur lui-même ou son réseau local.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Liste <b>négative</b>, contrairement à la plupart des filtres du projet : ici, laisser
|
||||
/// passer une plage oubliée est une faille, alors qu'en écarter une de trop ne coûte qu'une
|
||||
/// couverture non mise en cache.
|
||||
/// </remarks>
|
||||
public static bool EstPubliquementRoutable(IPAddress adresse)
|
||||
{
|
||||
// Une adresse IPv4 encapsulée en IPv6 (::ffff:127.0.0.1) doit être jugée sur son IPv4,
|
||||
// sans quoi le bouclage passerait déguisé.
|
||||
if (adresse.IsIPv4MappedToIPv6)
|
||||
{
|
||||
adresse = adresse.MapToIPv4();
|
||||
}
|
||||
|
||||
if (IPAddress.IsLoopback(adresse))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (adresse.AddressFamily == AddressFamily.InterNetwork)
|
||||
{
|
||||
var o = adresse.GetAddressBytes();
|
||||
|
||||
return o[0] switch
|
||||
{
|
||||
0 => false, // 0.0.0.0/8 « ce réseau »
|
||||
10 => false, // 10.0.0.0/8 privé
|
||||
127 => false, // bouclage (déjà couvert, par sûreté)
|
||||
169 when o[1] == 254 => false, // 169.254.0.0/16 lien-local (métadonnées cloud)
|
||||
172 when o[1] >= 16 && o[1] <= 31 => false, // 172.16.0.0/12 privé
|
||||
192 when o[1] == 168 => false, // 192.168.0.0/16 privé
|
||||
192 when o[1] == 0 && o[2] == 0 => false, // 192.0.0.0/24 usages protocolaires
|
||||
100 when o[1] >= 64 && o[1] <= 127 => false, // 100.64.0.0/10 CGNAT
|
||||
>= 224 => false, // multicast et réservé
|
||||
_ => true,
|
||||
};
|
||||
}
|
||||
|
||||
if (adresse.AddressFamily == AddressFamily.InterNetworkV6)
|
||||
{
|
||||
if (adresse.IsIPv6LinkLocal || adresse.IsIPv6SiteLocal || adresse.IsIPv6Multicast
|
||||
|| adresse.Equals(IPAddress.IPv6Any))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// fc00::/7 : adresses locales uniques (l'équivalent IPv6 du privé).
|
||||
return (adresse.GetAddressBytes()[0] & 0xFE) != 0xFC;
|
||||
}
|
||||
|
||||
// Ni IPv4 ni IPv6 : on ne sait pas juger, donc on refuse.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
using MaBibli.Api.Data;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace MaBibli.Api.Services.Couvertures;
|
||||
|
||||
/// <summary>Résultat d'une demande de couverture : les octets, ou rien.</summary>
|
||||
public sealed record ResultatCouverture(byte[]? Octets, string? TypeContenu)
|
||||
{
|
||||
public static readonly ResultatCouverture Refusee = new(null, null);
|
||||
|
||||
public bool Trouvee => Octets is not null && TypeContenu is not null;
|
||||
}
|
||||
|
||||
public interface IServiceCouvertures
|
||||
{
|
||||
Task<ResultatCouverture> ObtenirAsync(string? url, CancellationToken ct);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Relaie une image de couverture <b>en même origine</b>, pour qu'elle puisse être mise en cache
|
||||
/// hors-ligne quel que soit son hébergeur.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>Pourquoi ce service existe.</b> Le cache hors-ligne des couvertures (lot A5) lit les octets
|
||||
/// par <c>fetch()</c>, ce qui exige un en-tête <c>Access-Control-Allow-Origin</c>. OpenLibrary
|
||||
/// l'envoie, mais le formulaire livre accepte <b>n'importe quelle URL</b> de couverture : ces
|
||||
/// images s'affichaient bien (une balise <c><img></c> n'a que faire du CORS) sans jamais
|
||||
/// pouvoir être mises en cache. Relayées par notre propre serveur, elles deviennent de même
|
||||
/// origine, et la question du CORS disparaît.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// ⚠️ <b>Un proxy est une surface d'attaque (SSRF), et il est borné par DEUX verrous
|
||||
/// indépendants</b> — les deux sont nécessaires, aucun ne suffit :
|
||||
/// </para>
|
||||
/// <list type="number">
|
||||
/// <item>
|
||||
/// <b>L'URL doit déjà exister en base</b> comme couverture d'un livre, d'une envie ou d'un
|
||||
/// numéro de revue. Le proxy
|
||||
/// ne va donc jamais chercher une URL choisie au moment de l'appel : seulement une valeur que
|
||||
/// l'application détient déjà.
|
||||
/// </item>
|
||||
/// <item>
|
||||
/// <b>La connexion n'est ouverte que vers une adresse publiquement routable</b>
|
||||
/// (<see cref="GardeAdresses"/>). C'est ce second verrou qui tient si quelqu'un enregistre
|
||||
/// d'abord une fiche portant une URL interne : la valeur serait en base, la connexion serait
|
||||
/// refusée quand même.
|
||||
/// </item>
|
||||
/// </list>
|
||||
/// <para>
|
||||
/// ⚠️ <b>Tout refus est indistinct</b> côté appelant (voir l'endpoint) : distinguer « pas en
|
||||
/// base » de « injoignable » ferait du proxy un oracle qui renseigne sur le réseau du serveur.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class ServiceCouvertures(HttpClient http, MaBibliDbContext db) : IServiceCouvertures
|
||||
{
|
||||
/// <summary>
|
||||
/// Plafond de lecture. Une couverture de livre pèse quelques dizaines de kilo-octets ; ce
|
||||
/// plafond n'est pas là pour trier les images mais pour qu'une URL pointant sur un très gros
|
||||
/// fichier ne puisse pas remplir la mémoire du serveur.
|
||||
/// </summary>
|
||||
public const int TailleMaximale = 5 * 1024 * 1024;
|
||||
|
||||
public async Task<ResultatCouverture> ObtenirAsync(string? url, CancellationToken ct)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(url)
|
||||
|| !Uri.TryCreate(url, UriKind.Absolute, out var uri)
|
||||
|| uri.Scheme != Uri.UriSchemeHttps)
|
||||
{
|
||||
// https uniquement : l'application est servie en https par YunoHost, une image en
|
||||
// clair y serait de toute façon bloquée par le navigateur (contenu mixte).
|
||||
return ResultatCouverture.Refusee;
|
||||
}
|
||||
|
||||
if (!await EstConnueAsync(url, ct))
|
||||
{
|
||||
return ResultatCouverture.Refusee;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
using var reponse = await http.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, ct);
|
||||
|
||||
// Les redirections sont suivies (3 au plus, voir Program.cs) : OpenLibrary répond
|
||||
// 302 sur ses couvertures. Chaque saut repasse par le garde d'adresses, qui agit à
|
||||
// la connexion — c'est lui qui borne, pas l'interdiction de rediriger.
|
||||
if (!reponse.IsSuccessStatusCode)
|
||||
{
|
||||
return ResultatCouverture.Refusee;
|
||||
}
|
||||
|
||||
var type = reponse.Content.Headers.ContentType?.MediaType;
|
||||
if (type is null || !type.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return ResultatCouverture.Refusee;
|
||||
}
|
||||
|
||||
if (reponse.Content.Headers.ContentLength > TailleMaximale)
|
||||
{
|
||||
return ResultatCouverture.Refusee;
|
||||
}
|
||||
|
||||
var octets = await LireBorneAsync(reponse.Content, ct);
|
||||
|
||||
return octets is null ? ResultatCouverture.Refusee : new ResultatCouverture(octets, type);
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
// Hôte injoignable, adresse refusée par le garde, délai dépassé : une couverture non
|
||||
// relayée reste un agrément perdu, jamais une erreur à propager.
|
||||
return ResultatCouverture.Refusee;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// L'URL est-elle déjà enregistrée comme couverture ? Comparaison <b>exacte</b> : c'est la
|
||||
/// valeur stockée qui autorise, pas une ressemblance.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// ⚠️ <b>Les numéros de revue en font partie</b> depuis qu'ils portent une couverture. Les
|
||||
/// oublier ici aurait produit exactement le défaut que ce service existe pour corriger :
|
||||
/// une image qui s'affiche en ligne et jamais hors-ligne, l'appel de mise en cache étant
|
||||
/// refusé par le relais.
|
||||
/// </remarks>
|
||||
private async Task<bool> EstConnueAsync(string url, CancellationToken ct) =>
|
||||
await db.Livres.AnyAsync(l => l.CoverUrl == url, ct)
|
||||
|| await db.LivresSouhaites.AnyAsync(s => s.CoverUrl == url, ct)
|
||||
|| await db.NumerosRevue.AnyAsync(n => n.CoverUrl == url, ct);
|
||||
|
||||
/// <summary>
|
||||
/// Lit au plus <see cref="TailleMaximale"/> octets, et rend <c>null</c> si le corps dépasse.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// ⚠️ Le <c>Content-Length</c> vérifié plus haut ne suffit pas : il est <b>absent</b> d'une
|
||||
/// réponse en <i>chunked</i>, et rien n'oblige un serveur distant à dire la vérité.
|
||||
/// </remarks>
|
||||
private static async Task<byte[]?> LireBorneAsync(HttpContent contenu, CancellationToken ct)
|
||||
{
|
||||
await using var flux = await contenu.ReadAsStreamAsync(ct);
|
||||
using var tampon = new MemoryStream();
|
||||
|
||||
var morceau = new byte[81920];
|
||||
int lus;
|
||||
|
||||
while ((lus = await flux.ReadAsync(morceau, ct)) > 0)
|
||||
{
|
||||
if (tampon.Length + lus > TailleMaximale)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
tampon.Write(morceau, 0, lus);
|
||||
}
|
||||
|
||||
return tampon.ToArray();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user