From 78aa32bdb2820dae9d948954fb3455dd63fa7f5b Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Fri, 13 Nov 2026 00:19:24 +0100 Subject: [PATCH] febe-sonda legge un HAR troncato senza perdere la parte buona Chrome ha troncato due esportazioni del giro A quater (a 200 000 byte e a 57 MB, a meta di un corpo di risposta) e la sonda le rifiutava come file sbagliati. Ora da-har e richieste tengono le voci complete, scartano quella dentro cui il file finisce e lo dicono; un file rotto in qualunque altro modo resta rifiutato. Per richieste la voce scartata conta comunque come dati: si chiude dove si ferma e passa per le stesse regole di una voce intera, e ogni stringa JSON del testo interrotto conta come valore, cosi un nome che e un dato solo li non arriva nel file delle forme. In A quater: come esportare senza che il file si tronchi. Co-Authored-By: Claude Opus 5.5 --- docs/decisioni.md | 1 + docs/prove-dal-vivo.md | 15 + docs/stato.md | 16 + tests/Febe.Tests/Collection/HarFileTests.cs | 298 +++++++++++++++ tools/Febe.Sonda/HarFile.cs | 388 ++++++++++++++++++++ tools/Febe.Sonda/HarImporter.cs | 30 +- tools/Febe.Sonda/Program.cs | 20 + tools/Febe.Sonda/RequestShapes.cs | 104 ++++-- 8 files changed, 831 insertions(+), 41 deletions(-) create mode 100644 tests/Febe.Tests/Collection/HarFileTests.cs create mode 100644 tools/Febe.Sonda/HarFile.cs diff --git a/docs/decisioni.md b/docs/decisioni.md index f3d674d..cde4d43 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -318,3 +318,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-11-12 | `febe-sonda richieste --har --a `: descrive la forma delle richieste XHR/Fetch della pagina al sito (metodo, percorso con `{numero}`/`{testo}` al posto delle parti che non sono parole note del sito, nomi di parametri, intestazioni e campi del corpo, struttura delle variabili, nella query come nel corpo); dei valori solo il tipo, tranne elenchi chiusi uguali per tutti (`x-ig-app-id`, `x-asbd-id`, nomi e `doc_id`/`query_hash` delle operazioni, grandezza delle pagine solo per i nomi che la indicano, vero/falso). Un nome si tiene se è in un elenco chiuso, o se ha la forma di un nome del codice (senza punto, senza tre cifre di fila) e non compare da nessuna parte nel HAR come valore (indirizzi, cookie, intestazioni, corpi delle richieste e delle risposte, dati incorporati nelle pagine); altrimenti «(nome tolto)». Un corpo che non è un modulo né JSON si descrive intero, mai spezzato su «&» e «=». Le forme si distinguono per metodo, percorso, operazione (nome, intestazione `x-fb-friendly-name` o `x-root-field-name`) e identificativo dell'interrogazione, e le occorrenze si uniscono chiave per chiave. `OperationName` accetta anche il suffisso della pagina successiva (`…Query_connection`). Rifiuta HAR e file d'uscita dentro un repository, una cartella e un file d'uscita che esiste già | `da-har` butta via di proposito intestazioni, parametri e corpi delle richieste; per scrivere `richieste.instagram.json` serve la loro forma, e deve poter uscire dalla macchina di Alberto senza ripulitura: per costruzione non contiene valori personali | | 2026-11-12 | Ripulitura e verifica sul HAR vero: (1) un numero lungo con esponente o virgola (`1.2e+21`) si falsifica cifra per cifra, lasciando segno, punto ed esponente, così resta un numero JSON valido; (2) la verifica non cerca dentro i valori che l'elenco ammesso tiene di proposito (un tipo di file, una data, una dimensione), mai però nelle chiavi di dati, che la ripulitura falsifica sempre, e indica sotto quale chiave sopravvive un frammento, mai il frammento; (3) le parole degli indirizzi finti (`sito`, `altro`, `esempio`) e le estensioni dei file non contano come frammenti. Campioni del secondo HAR accorciati sulla copia **ripulita** e già verificata, non sui grezzi | Sul HAR del 12/11 `ripulisci` si fermava su un numero con esponente e `verifica` dava 223 falsi allarmi (frammenti come «script» dentro `text/javascript`). Accorciare la copia ripulita evita di aprire i grezzi anche solo per tagliarli: togliere elementi da una copia verificata non può aggiungere valori dei grezzi | | 2026-11-12 | Vocabolario dei lettori di Instagram: `profile.postCount` = `media_count` e una chiave nuova `highlight.cover` (`cover_media.cropped_image_version`), letta come una versione. Le griglie delle schede Reel e Con tag restano anteprime, non contenuti | Dal secondo HAR: `media_count` compare solo nella scheda del profilo; la copertina delle raccolte è nell'elenco delle raccolte del profilo; le anteprime delle schede non hanno `taken_at` né `video_versions` (regola 9: si legge solo ciò che i campioni mostrano) | +| 2026-11-13 | `febe-sonda da-har` e `richieste` leggono anche un HAR **troncato**: se il file finisce prima del suo JSON, e solo in quel caso, tengono le voci complete di `log.entries`, scartano quella dentro cui il file finisce e lo dicono a schermo e nel resoconto (`Truncated`, `DroppedEntry`). Per riconoscere il caso il lettore JSON lavora in modalità «dati non finiti»: la fine del file non è un errore, un errore di sintassi sì, e un file rotto in qualunque altro modo resta rifiutato. Per `richieste` la voce scartata conta comunque come dati: si chiude dove si ferma (il testo interrotto tenuto fino al taglio) e passa per le stesse regole di una voce intera (base64, pagine con blocchi incorporati, intestazioni, moduli); in più ogni stringa JSON del testo interrotto conta come valore, così un nome che è un dato solo lì viene tolto lo stesso. Resta fuori solo un valore tagliato a metà, di cui c'è solo l'inizio. Lettura comune in `HarFile` | Il 12/11 sera Chrome ha troncato due esportazioni dello stesso giro: la prima a 200 000 byte esatti, la seconda a 57 MB a metà di un corpo di risposta. Prima la sonda diceva solo «non è un file HAR valido (riga …)», senza distinguere un file tagliato da uno sbagliato, e non dava nulla della parte buona. La revisione avversaria ha trovato che la prima versione non contava i valori del testo interrotto né applicava alla voce scartata le regole di base64 e pagine: corretto prima del commit | diff --git a/docs/prove-dal-vivo.md b/docs/prove-dal-vivo.md index b00a703..38b4557 100644 --- a/docs/prove-dal-vivo.md +++ b/docs/prove-dal-vivo.md @@ -300,6 +300,21 @@ stessa preparazione (A ter 1 e A ter 2) e la stessa procedura alla fine (A ter 4 Niente storie questa volta: guardarle le segna come viste. +**Perché il HAR non si tronchi.** Il primo tentativo (12 novembre, sera) è arrivato troncato due volte: la prima +esportazione a 200 000 byte esatti, la seconda a 57 MB, quando Chrome ha smesso di scrivere a metà di una risposta, +dopo 141 voci. La parte completa arrivava solo alla pagina iniziale. Quasi tutto il peso sono i corpi di immagini e video che il pannello Rete tiene +insieme alle risposte di dati. Per restare leggeri: + +- apri Instagram e aspetta che la pagina iniziale sia caricata, poi **svuota il pannello Rete** (il cerchio barrato + in alto a sinistra) e solo allora comincia il giro: così nel file c'è solo il giro; +- non aprire post, reel o video e non lasciare che la pagina iniziale li faccia partire: per i seguiti e per la + griglia di un profilo bastano le miniature; +- esporta appena hai finito, e aspetta che il file sia scritto del tutto prima di rinominarlo. + +Se il file è troncato lo stesso, `febe-sonda` lo dice («Il file HAR è troncato») e legge comunque le voci complete, +scartando quella dentro cui il file finisce. Conta che cosa è arrivato con `febe-sonda richieste`: se mancano i seguiti o la seconda +pagina dei post, rifai il giro più corto (per esempio i seguiti in un file e lo scorrimento in un altro). + --- ## B. Prima sessione dal vivo, dopo M3 diff --git a/docs/stato.md b/docs/stato.md index 25699e2..d616c16 100644 --- a/docs/stato.md +++ b/docs/stato.md @@ -7,6 +7,22 @@ fra le sessioni; ciò che è da fare si legge nelle issue aperte. ## In breve +**13 novembre 2026, notte: il HAR dello scorrimento è troncato** (#35). + +- Alberto ha esportato il giro corto della parte A quater (seguiti e seconda pagina dei post). Il file è arrivato + troncato due volte: la prima a 200 000 byte esatti, la seconda a 57 MB, a metà del corpo di una risposta. +- `febe-sonda` ora legge un HAR troncato: tiene le voci complete, scarta quella dentro cui il file finisce e lo dice; + un file rotto altrove resta rifiutato. Per `richieste` i valori della voce scartata contano lo stesso, testo + interrotto compreso, così nessun nome che è un dato passa per via del taglio (`HarFile`, 16 casi in + `HarFileTests`, riga in `docs/decisioni.md`). Revisione avversaria (21 agenti): 6 rilievi confermati, tutti + corretti. Il principale: la prima versione non contava i valori del testo interrotto, né applicava alla voce + scartata le regole di base64 e delle pagine. +- Del giro sono arrivate 141 voci, e la parte completa si ferma alla pagina iniziale. Dopo la ripulitura restano 6 + campioni: pagina successiva del feed, griglia di Esplora, promozioni e configurazione della pagina. «Verifica + superata». Nessuno è fra i pezzi che servono: **seguiti e seconda pagina dei post mancano ancora.** In + `docs/prove-dal-vivo.md` (A quater) ora c'è come esportare senza che il file si tronchi: svuotare il pannello Rete + dopo il caricamento della pagina iniziale, niente video, esportare subito. + **12 novembre 2026, sera: il secondo HAR** (#35). - Alberto ha mandato un HAR senza filtro, un giro veloce su Instagram. Sulla sua macchina, fuori dal repository: diff --git a/tests/Febe.Tests/Collection/HarFileTests.cs b/tests/Febe.Tests/Collection/HarFileTests.cs new file mode 100644 index 0000000..7709021 --- /dev/null +++ b/tests/Febe.Tests/Collection/HarFileTests.cs @@ -0,0 +1,298 @@ +using System.Text; +using System.Text.Json.Nodes; +using Febe.Sonda; +using Febe.Tests.Support; + +namespace Febe.Tests.Collection; + +/// +/// A HAR export that the browser cut short. On 12 November 2026 Chrome stopped writing the same round twice: once at +/// exactly 200 000 bytes, once at 57 MB in the middle of a response body. The probe keeps the complete entries, leaves +/// out the one the file ends inside and says so; a file broken in any other way is still refused. For richieste +/// the left-out entry still counts as data, so that a name that is someone's value only there is removed all the same. +/// The HAR is synthetic, written by the test with invented values. +/// +[TestClass] +public sealed class HarFileTests +{ + /// Where the synthetic HAR is cut: inside the body of its last entry. + private const string CutMark = "CORPO-INTERROTTO"; + + /// A key of the first request's variables that is someone's name: a value only in the last entry. + private const string Person = "carla_verdi"; + + [TestMethod] + public void AWholeFileIsReadAsItIsEvenWithAByteOrderMark() + { + using var temp = new TempFolder("har"); + var har = temp.Combine("intero.har"); + File.WriteAllText(har, Har().ToJsonString(), new UTF8Encoding(encoderShouldEmitUTF8Identifier: true)); + + using var file = HarFile.Open(har, 256); + Assert.IsFalse(file.Truncated); + Assert.IsFalse(file.DroppedAnEntry); + Assert.AreEqual(3, file.Entries.GetArrayLength()); + Assert.IsNull(file.ReadDroppedEntry()); + } + + [TestMethod] + public void AFileCutInsideAnEntryKeepsTheEntriesBeforeIt() + { + using var temp = new TempFolder("har"); + using var file = HarFile.Open(Write(temp, "tagliato.har", CutInsideTheLastBody(Har())), 256); + Assert.IsTrue(file.Truncated); + Assert.IsTrue(file.DroppedAnEntry); + Assert.AreEqual(2, file.Entries.GetArrayLength()); + Assert.AreEqual("https://www.instagram.com/api/v1/prima/", file.Entries[0].GetProperty("request").GetProperty("url").GetString()); + Assert.AreEqual("https://www.instagram.com/api/v1/seconda/", file.Entries[1].GetProperty("request").GetProperty("url").GetString()); + + // The left-out entry, closed where it stops: the cut body is kept up to the cut. + using var dropped = file.ReadDroppedEntry()!; + var entry = dropped.Document.RootElement[0]; + Assert.AreEqual("https://www.instagram.com/api/v1/terza/", entry.GetProperty("request").GetProperty("url").GetString()); + var body = entry.GetProperty("response").GetProperty("content").GetProperty("text").GetString()!; + Assert.StartsWith("{\"utente\":{\"username\":\"" + Person + "\"}", body); + Assert.AreEqual(body, dropped.CutText); + } + + [TestMethod] + public void AFileCutBetweenEntriesOrAfterThemKeepsThemAll() + { + using var temp = new TempFolder("har"); + var text = Har().ToJsonString(); + + // Right after the comma that follows the second entry. + var third = text.IndexOf("https://www.instagram.com/api/v1/terza/", StringComparison.Ordinal); + var between = text.LastIndexOf("},{", third, StringComparison.Ordinal) + 2; + using (var file = HarFile.Open(Write(temp, "fra.har", text[..between]), 256)) + { + Assert.IsTrue(file.Truncated); + Assert.IsFalse(file.DroppedAnEntry); + Assert.AreEqual(2, file.Entries.GetArrayLength()); + Assert.IsNull(file.ReadDroppedEntry()); + } + + // After the array of entries, before the closing braces and the rest of «log». + var whole = Har(); + whole["log"]!["pages"] = new JsonArray(new JsonObject { ["id"] = "pagina" }); + var withPages = whole.ToJsonString(); + var afterEntries = withPages.IndexOf(",\"pages\"", StringComparison.Ordinal) + 3; + using (var file = HarFile.Open(Write(temp, "dopo.har", withPages[..afterEntries]), 256)) + { + Assert.IsTrue(file.Truncated); + Assert.IsFalse(file.DroppedAnEntry); + Assert.AreEqual(3, file.Entries.GetArrayLength()); + } + } + + [TestMethod] + public void AFileBrokenAnywhereElseIsStillRefused() + { + using var temp = new TempFolder("har"); + var text = Har().ToJsonString(); + var cut = CutInsideTheLastBody(Har()); + + // A syntax error in the second entry only, the first one whole, and the file also cut later. + var second = cut.IndexOf("/api/v1/seconda/", StringComparison.Ordinal); + var status = cut.IndexOf("\"status\":200,", second, StringComparison.Ordinal); + var broken = cut[..status] + "\"status\":200;" + cut[(status + "\"status\":200,".Length)..]; + StringAssert.Contains(Assert.ThrowsExactly(() => HarFile.Open(Write(temp, "sbagliato.har", broken), 256)).Message, "non è un file HAR valido"); + + // An entry that is not an object, after a whole one. + Assert.ThrowsExactly(() => HarFile.Open(Write(temp, "numeri.har", """{"log":{"entries":[{"a":1},2,{"b":"""), 256)); + + // Cut before the first entry is complete: nothing to keep. + var first = text[..(text.IndexOf("/api/v1/prima/", StringComparison.Ordinal) + 5)]; + Assert.ThrowsExactly(() => HarFile.Open(Write(temp, "presto.har", first), 256)); + + // Something after a whole file. + Assert.ThrowsExactly(() => HarFile.Open(Write(temp, "coda.har", text + "{}"), 256)); + + // Not a HAR: entries that are not under «log». + Assert.ThrowsExactly(() => HarFile.Open(Write(temp, "altro.har", """{"altro":{"entries":[{"a":1},{"b":"""), 256)); + } + + [TestMethod] + public void TextThatIsNotValidUnicodeInTheDroppedEntryDoesNotStopTheReading() + { + using var temp = new TempFolder("har"); + var head = Encoding.UTF8.GetBytes("""{"log":{"entries":[{"request":{"url":"https://www.instagram.com/api/v1/prima/"}},{"request":{"url":"x"""); + byte[] badUtf8 = [0xC3, 0x28]; + var tail = Encoding.UTF8.GetBytes("""y","headers":[{"name":"a","value":"\ud800"}]},"response":{"content":{"text":"CORPO"""); + var har = temp.Combine("unicode.har"); + File.WriteAllBytes(har, [.. head, .. badUtf8, .. tail]); + + using (var file = HarFile.Open(har, 256)) + { + Assert.IsTrue(file.DroppedAnEntry); + Assert.AreEqual(1, file.Entries.GetArrayLength()); + using var dropped = file.ReadDroppedEntry()!; + Assert.AreEqual("CORPO", dropped.CutText); + } + + Assert.AreEqual(1, HarImporter.Import(har, temp.Combine("grezzi")).Entries); + Assert.IsTrue(RequestShapes.Extract(har, temp.Combine("richieste.json")).DroppedEntry); + } + + [TestMethod] + [DataRow("abc", "abc")] + [DataRow("abc\\", "abc")] + [DataRow("abc\\u00", "abc")] + [DataRow("abc\\u00e8", "abcè")] + [DataRow("a\\\\", "a\\")] + [DataRow("a\\n", "a\n")] + public void AStringCutShortKeepsWhatWasWhole(string raw, string expected) => + Assert.AreEqual(expected, HarFile.PartialString(Encoding.UTF8.GetBytes(raw))); + + [TestMethod] + public void AStringCutInsideACharacterKeepsTheCharactersBeforeIt() + { + var bytes = Encoding.UTF8.GetBytes("perché"); + Assert.AreEqual("perch", HarFile.PartialString(bytes.AsSpan(0, bytes.Length - 1))); + } + + [TestMethod] + public void TheConversionOfACutFileWritesTheCompleteAnswersAndSaysItIsTruncated() + { + using var temp = new TempFolder("har"); + var har = Write(temp, "tagliato.har", CutInsideTheLastBody(Har())); + + var report = HarImporter.Import(har, temp.Combine("grezzi")); + Assert.IsTrue(report.Truncated); + Assert.IsTrue(report.DroppedEntry); + Assert.AreEqual(2, report.Entries); + Assert.AreEqual(2, report.DataResponses); + Assert.AreEqual(2, Directory.GetFiles(temp.Combine("grezzi"), "*.json").Length); + + var whole = Write(temp, "intero.har", Har().ToJsonString()); + Assert.IsFalse(HarImporter.Import(whole, temp.Combine("grezzi-interi")).Truncated); + } + + [TestMethod] + public void ANameThatIsAValueOnlyInsideTheCutBodyIsStillRemoved() + { + using var temp = new TempFolder("richieste"); + var report = RequestShapes.Extract(Write(temp, "tagliato.har", CutInsideTheLastBody(Har())), temp.Combine("tagliato.json")); + Assert.IsTrue(report.Truncated); + Assert.IsTrue(report.DroppedEntry); + Assert.AreEqual(2, report.Entries); + var output = File.ReadAllText(temp.Combine("tagliato.json")); + Assert.IsFalse(output.Contains(Person, StringComparison.Ordinal), output); + + // Control: without the third entry at all, the same key is a name like any other and stays. + var two = Har(); + two["log"]!["entries"]!.AsArray().RemoveAt(2); + Assert.IsFalse(RequestShapes.Extract(Write(temp, "corto.har", two.ToJsonString()), temp.Combine("corto.json")).Truncated); + StringAssert.Contains(File.ReadAllText(temp.Combine("corto.json")), Person); + } + + [TestMethod] + public void ANameInsideTheCutPartOfAnEmbeddedBlockIsStillRemoved() + { + using var temp = new TempFolder("richieste"); + + // A page cut inside the JSON block it embeds: the block never closes, so only its literals still name it. + var page = Har(body: "", mime: "text/html"); + RequestShapes.Extract(Write(temp, "pagina.har", CutInsideTheLastBody(page)), temp.Combine("pagina.json")); + Assert.IsFalse(File.ReadAllText(temp.Combine("pagina.json")).Contains(Person, StringComparison.Ordinal)); + } + + [TestMethod] + public void TheDroppedEntryCountsWithTheSameRulesAsAWholeOne() + { + using var temp = new TempFolder("richieste"); + + // A body in base64 and a page with an embedded block, both whole, in an entry cut later (in its timings). + var base64 = Convert.ToBase64String(Encoding.UTF8.GetBytes("{\"utente\":{\"username\":\"" + Person + "\"}}")); + var page = ""; + foreach (var (name, har) in new[] { ("base64", Har(body: base64, encoding: "base64")), ("pagina", Har(body: page, mime: "text/html")) }) + { + var entries = har["log"]!["entries"]!.AsArray(); + entries[2]!["timings"] = new JsonObject { ["wait"] = CutMark + new string('x', 200) }; + var text = har.ToJsonString(); + var cut = text[..(text.LastIndexOf(CutMark, StringComparison.Ordinal) + 6)]; + var output = temp.Combine(name + ".json"); + Assert.IsTrue(RequestShapes.Extract(Write(temp, name + ".har", cut), output).DroppedEntry, name); + Assert.IsFalse(File.ReadAllText(output).Contains(Person, StringComparison.Ordinal), name); + } + + // A base64 body cut in the middle: its first whole groups still decode. + var long64 = Convert.ToBase64String(Encoding.UTF8.GetBytes("{\"utente\":{\"username\":\"" + Person + "\",\"testo\":\"" + new string('x', 300) + "\"}}")); + var cut64 = Har(body: long64, encoding: "base64").ToJsonString(); + cut64 = cut64[..(cut64.IndexOf(long64, StringComparison.Ordinal) + 120)]; + RequestShapes.Extract(Write(temp, "base64-tagliato.har", cut64), temp.Combine("base64-tagliato.json")); + Assert.IsFalse(File.ReadAllText(temp.Combine("base64-tagliato.json")).Contains(Person, StringComparison.Ordinal)); + } + + private static string Write(TempFolder temp, string name, string text) + { + var path = temp.Combine(name); + File.WriteAllText(path, text); + return path; + } + + /// The HAR as text, cut a few characters after the mark in the body of its last entry. + private static string CutInsideTheLastBody(JsonObject har) + { + var text = har.ToJsonString(); + return text[..(text.LastIndexOf(CutMark, StringComparison.Ordinal) + 6)]; + } + + /// + /// Three answers of the site. The first is a GraphQL POST whose variables are keyed by ; that text + /// is a value only in the body of the third entry, which a cut file ends inside. + /// + private static JsonObject Har(string? body = null, string mime = "application/json", string? encoding = null) + { + static JsonObject Entry(string method, string url, string body, string mime = "application/json", string? encoding = null, JsonObject? postData = null) + { + var request = new JsonObject + { + ["method"] = method, + ["url"] = url, + ["headers"] = new JsonArray(new JsonObject { ["name"] = "Referer", ["value"] = "https://www.instagram.com/" }), + }; + if (postData is not null) + { + request["postData"] = postData; + } + + var content = new JsonObject { ["mimeType"] = mime, ["text"] = body }; + if (encoding is not null) + { + content["encoding"] = encoding; + } + + return new JsonObject + { + ["_resourceType"] = "xhr", + ["startedDateTime"] = "2026-11-12T23:40:00.000+01:00", + ["request"] = request, + ["response"] = new JsonObject + { + ["status"] = 200, + ["headers"] = new JsonArray(), + ["content"] = content, + }, + }; + } + + body ??= "{\"utente\":{\"username\":\"" + Person + "\"},\"testo\":\"" + CutMark + new string('x', 200) + "\"}"; + return new JsonObject + { + ["log"] = new JsonObject + { + ["version"] = "1.2", + ["entries"] = new JsonArray( + Entry("POST", "https://www.instagram.com/api/v1/prima/", """{"elementi":[{"nome":"mario"}]}""", + postData: new JsonObject + { + ["mimeType"] = "application/x-www-form-urlencoded", + ["text"] = "doc_id=1000000000001&variables=" + Uri.EscapeDataString("{\"seen\":{\"" + Person + "\":1}}"), + }), + Entry("GET", "https://www.instagram.com/api/v1/seconda/", """{"elementi":[{"nome":"lucia"}]}"""), + Entry("GET", "https://www.instagram.com/api/v1/terza/", body, mime, encoding)), + }, + }; + } +} diff --git a/tools/Febe.Sonda/HarFile.cs b/tools/Febe.Sonda/HarFile.cs new file mode 100644 index 0000000..d6fd284 --- /dev/null +++ b/tools/Febe.Sonda/HarFile.cs @@ -0,0 +1,388 @@ +using System.Buffers; +using System.Text; +using System.Text.Json; + +namespace Febe.Sonda; + +/// +/// A HAR exported from the browser's DevTools, read whole into one , with its +/// log.entries. An export cut short (Chrome may stop writing a large HAR in the middle of a response body) is +/// still read: the entries that are complete are kept, the one the file ends inside is left out of +/// , and says so. A file broken in any other way is refused, as before. +/// +internal sealed class HarFile : IDisposable +{ + private static readonly byte[] Utf8Bom = [0xEF, 0xBB, 0xBF]; + + private static readonly byte[] Prefix = Encoding.UTF8.GetBytes("{\"log\":{\"entries\":["); + + private static readonly byte[] Suffix = Encoding.UTF8.GetBytes("]}}"); + + private readonly ReadOnlyMemory _dropped; + + private readonly int _maxDepth; + + private HarFile(JsonDocument document, JsonElement entries, bool truncated, ReadOnlyMemory dropped, int maxDepth) + { + Document = document; + Entries = entries; + Truncated = truncated; + _dropped = dropped; + _maxDepth = maxDepth; + } + + public JsonDocument Document { get; } + + /// The array log.entries: in a cut file, its complete entries only. + public JsonElement Entries { get; } + + /// The file ends before its JSON does. + public bool Truncated { get; } + + /// The file ends inside an entry, which is not in (false if it ends between entries or after them). + public bool DroppedAnEntry => !_dropped.IsEmpty; + + /// The file is not JSON, or not a HAR, or is broken other than by being cut short. + public static HarFile Open(string path, int maxDepth) + { + ReadOnlyMemory json = File.ReadAllBytes(path); + if (json.Span.StartsWith(Utf8Bom)) + { + json = json[Utf8Bom.Length..]; + } + + var name = Path.GetFileName(path); + JsonDocument document; + var truncated = false; + var dropped = ReadOnlyMemory.Empty; + try + { + document = JsonDocument.Parse(json, new JsonDocumentOptions { MaxDepth = maxDepth }); + } + catch (JsonException ex) + { + if (Recover(json, maxDepth) is not { } recovered) + { + throw new InvalidDataException($"{name}: non è un file HAR valido (riga {ex.LineNumber + 1}).", ex); + } + + (document, dropped) = recovered; + truncated = true; + } + + if (document.RootElement.ValueKind != JsonValueKind.Object + || !document.RootElement.TryGetProperty("log", out var log) || log.ValueKind != JsonValueKind.Object + || !log.TryGetProperty("entries", out var entries) || entries.ValueKind != JsonValueKind.Array) + { + document.Dispose(); + throw new InvalidDataException($"{name}: non è un file HAR (manca «log.entries»)."); + } + + return new HarFile(document, entries, truncated, dropped, maxDepth); + } + + /// + /// The entry the file ends inside, closed where it stops (), so that richieste can + /// collect its values with the same rules as a whole entry; null if no entry was cut. Never written anywhere. + /// + public DroppedEntry? ReadDroppedEntry() => _dropped.IsEmpty ? null : CloseCut(_dropped.Span, _maxDepth); + + public void Dispose() => Document.Dispose(); + + /// + /// The complete entries of a HAR whose file ends early, as a new document {"log":{"entries":[…]}}, and the + /// bytes of the entry the file ends inside (empty if it ends between entries or after them); null when the file is + /// broken in any other way (a syntax error, a shape that is not a HAR, no complete entry). + /// + /// + /// The reader is told the data is NOT final: where the file simply stops, and + /// return false instead of throwing, while a real syntax error still throws. + /// + internal static (JsonDocument Document, ReadOnlyMemory Dropped)? Recover(ReadOnlyMemory json, int maxDepth) + { + var options = new JsonReaderOptions { MaxDepth = maxDepth }; + var ranges = new List<(int Start, int End)>(); + var droppedFrom = -1; + try + { + var reader = new Utf8JsonReader(json.Span, isFinalBlock: false, new JsonReaderState(options)); + if (!reader.Read() || reader.TokenType != JsonTokenType.StartObject + || !MoveToProperty(ref reader, "log") || !reader.Read() || reader.TokenType != JsonTokenType.StartObject + || !MoveToProperty(ref reader, "entries") || !reader.Read() || reader.TokenType != JsonTokenType.StartArray) + { + return null; + } + + while (true) + { + if (!reader.Read()) + { + break; // the file ends between two entries + } + + if (reader.TokenType == JsonTokenType.EndArray) + { + // Every entry is whole: the file must end later, after the array, and not because of a syntax error. + while (reader.Read()) + { + } + + break; + } + + if (reader.TokenType != JsonTokenType.StartObject) + { + return null; + } + + var start = (int)reader.TokenStartIndex; + if (!reader.TrySkip()) + { + droppedFrom = start; // the file ends inside this entry + break; + } + + ranges.Add((start, (int)reader.BytesConsumed)); + } + } + catch (JsonException) + { + return null; + } + + if (ranges.Count == 0) + { + return null; + } + + var length = Prefix.Length + Suffix.Length + ranges.Sum(r => r.End - r.Start + 1); + var buffer = new byte[length]; + var at = 0; + Prefix.CopyTo(buffer, at); + at += Prefix.Length; + for (var i = 0; i < ranges.Count; i++) + { + if (i > 0) + { + buffer[at++] = (byte)','; + } + + var (start, end) = ranges[i]; + json.Span[start..end].CopyTo(buffer.AsSpan(at)); + at += end - start; + } + + Suffix.CopyTo(buffer, at); + at += Suffix.Length; + var document = JsonDocument.Parse(buffer.AsMemory(0, at), new JsonDocumentOptions { MaxDepth = maxDepth }); + return (document, droppedFrom < 0 ? ReadOnlyMemory.Empty : json[droppedFrom..]); + } + + /// + /// Closes a JSON object that stops early: every token read whole is kept; a string value the data ends inside is + /// kept up to the cut (it is too, usually the response body Chrome stopped + /// writing); a name left without its value gets null; then the open objects and arrays are closed. + /// + internal static DroppedEntry CloseCut(ReadOnlySpan json, int maxDepth) + { + var buffer = new ArrayBufferWriter(); + var open = new Stack(); + var pendingName = false; + string? cut = null; + using (var writer = new Utf8JsonWriter(buffer, new JsonWriterOptions { MaxDepth = maxDepth + 1 })) + { + writer.WriteStartArray(); + var reader = new Utf8JsonReader(json, isFinalBlock: false, new JsonReaderState(new JsonReaderOptions { MaxDepth = maxDepth })); + while (reader.Read()) + { + switch (reader.TokenType) + { + case JsonTokenType.StartObject: + writer.WriteStartObject(); + open.Push(JsonTokenType.StartObject); + pendingName = false; + break; + case JsonTokenType.StartArray: + writer.WriteStartArray(); + open.Push(JsonTokenType.StartArray); + pendingName = false; + break; + case JsonTokenType.EndObject: + writer.WriteEndObject(); + open.Pop(); + break; + case JsonTokenType.EndArray: + writer.WriteEndArray(); + open.Pop(); + break; + case JsonTokenType.PropertyName: + writer.WritePropertyName(Text(ref reader)); + pendingName = true; + break; + case JsonTokenType.String: + writer.WriteStringValue(Text(ref reader)); + pendingName = false; + break; + case JsonTokenType.Number: + writer.WriteRawValue(reader.ValueSpan, skipInputValidation: true); + pendingName = false; + break; + case JsonTokenType.True: + case JsonTokenType.False: + writer.WriteBooleanValue(reader.TokenType == JsonTokenType.True); + pendingName = false; + break; + default: + writer.WriteNullValue(); + pendingName = false; + break; + } + + if (open.Count == 0) + { + break; + } + } + + // What the reader could not finish: separators, then perhaps the start of a string. + var rest = json[(int)reader.BytesConsumed..]; + var skip = 0; + while (skip < rest.Length && rest[skip] is (byte)' ' or (byte)'\t' or (byte)'\r' or (byte)'\n' or (byte)',' or (byte)':') + { + skip++; + } + + rest = rest[skip..]; + var valueExpected = pendingName || (open.Count > 0 && open.Peek() == JsonTokenType.StartArray); + if (valueExpected && rest.Length > 0 && rest[0] == (byte)'"') + { + cut = PartialString(rest[1..]); + writer.WriteStringValue(cut); + pendingName = false; + } + + if (pendingName) + { + writer.WriteNullValue(); + } + + while (open.Count > 0) + { + if (open.Pop() == JsonTokenType.StartObject) + { + writer.WriteEndObject(); + } + else + { + writer.WriteEndArray(); + } + } + + writer.WriteEndArray(); + } + + return new DroppedEntry(JsonDocument.Parse(buffer.WrittenMemory, new JsonDocumentOptions { MaxDepth = maxDepth + 1 }), cut); + } + + /// + /// Moves the reader to the value of the property of the object it is in, skipping the others; + /// false if the object ends, or the file does, first. + /// + private static bool MoveToProperty(ref Utf8JsonReader reader, string name) + { + while (reader.Read()) + { + if (reader.TokenType != JsonTokenType.PropertyName) + { + return false; + } + + if (reader.ValueTextEquals(name)) + { + return true; + } + + if (!reader.Read() || !reader.TrySkip()) + { + return false; + } + } + + return false; + } + + /// A string token as text; one that is not valid UTF-8 or UTF-16 is decoded leniently, never refused. + private static string Text(ref Utf8JsonReader reader) + { + try + { + return reader.GetString() ?? string.Empty; + } + catch (InvalidOperationException) + { + return Encoding.UTF8.GetString(reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan); + } + } + + /// + /// The text of a JSON string whose closing quote never came: the bytes after the opening quote, without an escape + /// or a UTF-8 character the cut left half written, unescaped; decoded leniently if it still does not read. + /// + internal static string PartialString(ReadOnlySpan raw) + { + // A closing quote inside the rest would mean the reader stopped for another reason: keep only up to it. + var end = 0; + while (end < raw.Length && raw[end] != (byte)'"') + { + end += raw[end] == (byte)'\\' ? 2 : 1; + } + + var text = raw[..Math.Min(end, raw.Length)]; + + // An escape cut in two: a lone backslash, or «\u» with fewer than four hexadecimal digits. + var backslash = text.LastIndexOf((byte)'\\'); + if (backslash >= 0 && text.Length - backslash < 6) + { + var run = 0; + while (backslash - run >= 0 && text[backslash - run] == (byte)'\\') + { + run++; + } + + var escape = text[backslash..]; + var whole = run % 2 == 0 || (escape.Length >= 2 && escape[1] != (byte)'u') || escape.Length == 6; + if (!whole) + { + text = text[..backslash]; + } + } + + for (var trim = 0; trim <= 3 && trim <= text.Length; trim++) + { + var candidate = new byte[text.Length - trim + 2]; + candidate[0] = (byte)'"'; + text[..^trim].CopyTo(candidate.AsSpan(1)); + candidate[^1] = (byte)'"'; + try + { + var reader = new Utf8JsonReader(candidate); + if (reader.Read() && reader.TokenType == JsonTokenType.String) + { + return reader.GetString() ?? string.Empty; + } + } + catch (Exception ex) when (ex is JsonException or InvalidOperationException) + { + // A UTF-8 character cut in two, or bytes that are not UTF-8: one byte less, then lenient decoding. + } + } + + return Encoding.UTF8.GetString(text); + } +} + +/// The entry a cut HAR ends inside, closed where it stops, as a one-element array; and the text cut short. +internal sealed record DroppedEntry(JsonDocument Document, string? CutText) : IDisposable +{ + public void Dispose() => Document.Dispose(); +} diff --git a/tools/Febe.Sonda/HarImporter.cs b/tools/Febe.Sonda/HarImporter.cs index fd8e3e9..f4c3332 100644 --- a/tools/Febe.Sonda/HarImporter.cs +++ b/tools/Febe.Sonda/HarImporter.cs @@ -20,6 +20,13 @@ namespace Febe.Sonda; /// Left out: page documents that embed no JSON. public sealed record HarImportReport(int Entries, int DataResponses, int Documents, int DocumentBlocks, int OtherHosts, int NotData, int WithoutBody, int NotJson, int DocumentsWithoutData) { + /// The file ends before its JSON does: counts the complete entries only, the one the + /// file ends inside is left out (). + public bool Truncated { get; init; } + + /// The file ends inside an entry, which is left out (not counted in ). + public bool DroppedEntry { get; init; } + public int Written => DataResponses + DocumentBlocks; } @@ -67,26 +74,9 @@ public static partial class HarImporter throw new InvalidOperationException($"La cartella «{folder}» non è vuota: indica una cartella nuova, solo per questa conversione."); } - JsonDocument document; - try + using (var file = HarFile.Open(har, BodyOptions.MaxDepth)) { - using var stream = File.OpenRead(har); - document = JsonDocument.Parse(stream); - } - catch (JsonException ex) - { - throw new InvalidDataException($"{Path.GetFileName(har)}: non è un file HAR valido (riga {ex.LineNumber + 1}).", ex); - } - - using (document) - { - if (document.RootElement.ValueKind != JsonValueKind.Object - || !document.RootElement.TryGetProperty("log", out var log) || log.ValueKind != JsonValueKind.Object - || !log.TryGetProperty("entries", out var entries) || entries.ValueKind != JsonValueKind.Array) - { - throw new InvalidDataException($"{Path.GetFileName(har)}: non è un file HAR (manca «log.entries»)."); - } - + var entries = file.Entries; Directory.CreateDirectory(folder); File.WriteAllText( Path.Combine(folder, "LEGGIMI.txt"), @@ -147,7 +137,7 @@ public static partial class HarImporter } } - return new HarImportReport(count, data, documents, blocks, otherHosts, notData, withoutBody, notJson, documentsWithoutData); + return new HarImportReport(count, data, documents, blocks, otherHosts, notData, withoutBody, notJson, documentsWithoutData) { Truncated = file.Truncated, DroppedEntry = file.DroppedAnEntry }; } } diff --git a/tools/Febe.Sonda/Program.cs b/tools/Febe.Sonda/Program.cs index 287bda3..2529978 100644 --- a/tools/Febe.Sonda/Program.cs +++ b/tools/Febe.Sonda/Program.cs @@ -143,6 +143,7 @@ static int FromHar(string[] args) } // Counts only: what the answers contain stays on this machine. + Truncation(report.Truncated, report.DroppedEntry); Console.WriteLine($"Lette {report.Entries} voci del file HAR; scritti {report.Written} campioni grezzi: {report.DataResponses} risposte di dati del sito, {report.DocumentBlocks} blocchi di dati incorporati in {report.Documents} pagine."); Console.WriteLine($"Lasciate fuori: {report.OtherHosts} di altri indirizzi (CDN, altri siti), {report.NotData} che non sono dati (file, immagini, script...), {report.WithoutBody} senza corpo, {report.NotJson} non JSON, {report.DocumentsWithoutData} pagine senza dati incorporati."); if (report.Written == 0 && report.WithoutBody > 0) @@ -155,6 +156,24 @@ static int FromHar(string[] args) return report.Written > 0 ? 0 : 1; } +static void Truncation(bool truncated, bool droppedEntry) +{ + if (!truncated) + { + return; + } + + if (droppedEntry) + { + Console.WriteLine("Il file HAR è troncato: finisce a metà di una voce, che è stata scartata; le voci complete prima di lei sono tenute."); + Console.WriteLine("Ciò che la pagina ha ricevuto dopo non c'è. Se manca qualcosa che serve, esporta di nuovo un giro più corto."); + } + else + { + Console.WriteLine("Il file HAR è troncato, ma fuori dalle voci: sono tutte intere e tutte tenute."); + } +} + static int RequestsFromHar(string[] args) { var har = Option(args, "--har"); @@ -176,6 +195,7 @@ static int RequestsFromHar(string[] args) return 3; } + Truncation(report.Truncated, report.DroppedEntry); Console.WriteLine($"Lette {report.Entries} voci del file HAR; descritte {report.SiteRequests} richieste della pagina al sito in {report.Shapes} forme distinte."); Console.WriteLine($"Nomi tolti perché potevano essere dati: {report.RemovedNames}."); Console.WriteLine($"Forme delle richieste in: {Path.GetFullPath(to)}"); diff --git a/tools/Febe.Sonda/RequestShapes.cs b/tools/Febe.Sonda/RequestShapes.cs index 15dae01..12f491d 100644 --- a/tools/Febe.Sonda/RequestShapes.cs +++ b/tools/Febe.Sonda/RequestShapes.cs @@ -12,7 +12,14 @@ namespace Febe.Sonda; /// Requests the page made to the site (XHR, Fetch) that were described. /// Distinct shapes written: same method, path pattern, operation and query identifier. /// Names (parameters, fields, keys) replaced because they could be data. -public sealed record RequestShapesReport(int Entries, int SiteRequests, int Shapes, int RemovedNames); +public sealed record RequestShapesReport(int Entries, int SiteRequests, int Shapes, int RemovedNames) +{ + /// The file ends before its JSON does: only its complete entries are described (). + public bool Truncated { get; init; } + + /// The file ends inside an entry, which is not described (its values still count as data). + public bool DroppedEntry { get; init; } +} /// /// Describes the SHAPE of the requests Instagram's own page makes to the site (decision of 12 November 2026, issue #34: @@ -126,31 +133,29 @@ public static partial class RequestShapes throw new InvalidOperationException($"Il file «{output}» esiste già: indica un file nuovo."); } - JsonDocument document; - try - { - using var stream = File.OpenRead(har); - document = JsonDocument.Parse(stream, DeepDocuments); - } - catch (JsonException ex) - { - throw new InvalidDataException($"{Path.GetFileName(har)}: non è un file HAR valido (riga {ex.LineNumber + 1}).", ex); - } - var shapes = new Dictionary(StringComparer.Ordinal); int count = 0, described = 0; Names names; - using (document) + bool truncated, droppedEntry; + using (var file = HarFile.Open(har, DeepDocuments.MaxDepth)) { - if (document.RootElement.ValueKind != JsonValueKind.Object - || !document.RootElement.TryGetProperty("log", out var log) || log.ValueKind != JsonValueKind.Object - || !log.TryGetProperty("entries", out var entries) || entries.ValueKind != JsonValueKind.Array) + var entries = file.Entries; + truncated = file.Truncated; + + // First pass: every value the HAR holds, wherever it is, the entry a cut file ends inside included. A name + // equal to one of them is never written. + var values = ValueCollector.Collect(entries); + droppedEntry = file.DroppedAnEntry; + if (file.ReadDroppedEntry() is { } dropped) { - throw new InvalidDataException($"{Path.GetFileName(har)}: non è un file HAR (manca «log.entries»)."); + using (dropped) + { + values.UnionWith(ValueCollector.Collect(dropped.Document.RootElement)); + ValueCollector.AddCutText(values, dropped.CutText); + } } - // First pass: every value the HAR holds, wherever it is. A name equal to one of them is never written. - names = new Names(ValueCollector.Collect(entries)); + names = new Names(values); foreach (var entry in entries.EnumerateArray()) { count++; @@ -191,7 +196,7 @@ public static partial class RequestShapes writer.Write('\n'); } - return new RequestShapesReport(count, described, shapes.Count, names.Removed); + return new RequestShapesReport(count, described, shapes.Count, names.Removed) { Truncated = truncated, DroppedEntry = droppedEntry }; } /// The path with each segment that is not a known word replaced by {numero} or {testo}. @@ -705,7 +710,7 @@ public static partial class RequestShapes /// Every value a HAR holds (addresses, cookies, header values, form values, strings of JSON requests and responses, /// data embedded in pages), to tell a name of the site's code from a piece of data used as a name. /// -internal static class ValueCollector +internal static partial class ValueCollector { private const int MaxBodyChars = 64 * 1024 * 1024; @@ -780,6 +785,63 @@ internal static class ValueCollector return values; } + /// + /// The text a cut HAR ends inside (usually a response body, possibly base64 or a page): besides what + /// already took from the closed entry, every JSON string literal in it counts as a value, keys + /// included, so that names inside a body or an embedded block cut in two are found too. More values only remove + /// more names. + /// + public static void AddCutText(HashSet values, string? text, bool decoded = false) + { + if (string.IsNullOrEmpty(text)) + { + return; + } + + Body(values, text); + foreach (Match literal in StringLiteral().Matches(text)) + { + string? value; + try + { + value = JsonSerializer.Deserialize(literal.Value); + } + catch (JsonException) + { + value = literal.Groups[1].Value; + } + + Add(values, value); + if (value is not null) + { + Address(values, value); + } + } + + // A base64 body cut anywhere: its first whole groups of four characters still decode. + if (!decoded && text.Length >= 8 && Base64Text().IsMatch(text)) + { + var length = text.Length / 4 * 4; + try + { + var bytes = Convert.FromBase64String(text[..length]); + AddCutText(values, Encoding.UTF8.GetString(bytes), decoded: true); + } + catch (FormatException) + { + // Not base64 after all. + } + } + } + + [GeneratedRegex(""" + "((?:[^"\\\r\n]|\\.){1,512})" + """, RegexOptions.CultureInvariant)] + private static partial Regex StringLiteral(); + + [GeneratedRegex("^[A-Za-z0-9+/]+=*$", RegexOptions.CultureInvariant)] + private static partial Regex Base64Text(); + private static void Add(HashSet values, string? value) { var text = value?.Trim();