<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Eduard Arbona</title>
    <description>The latest articles on DEV Community by Eduard Arbona (@earbona23).</description>
    <link>https://dev.to/earbona23</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4203591%2F84463252-b3b9-4565-acac-bddbe27af8bd.jpg</url>
      <title>DEV Community: Eduard Arbona</title>
      <link>https://dev.to/earbona23</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/earbona23"/>
    <language>en</language>
    <item>
      <title>A zero is not a measurement until you have run the positive control</title>
      <dc:creator>Eduard Arbona</dc:creator>
      <pubDate>Sat, 07 Nov 2026 16:13:58 +0000</pubDate>
      <link>https://dev.to/earbona23/a-zero-is-not-a-measurement-until-you-have-run-the-positive-control-5fca</link>
      <guid>https://dev.to/earbona23/a-zero-is-not-a-measurement-until-you-have-run-the-positive-control-5fca</guid>
      <description>&lt;p&gt;Everything below reads public files in &lt;code&gt;dotnet/aspnetcore&lt;/code&gt; through the GitHub API. No clone, no build, no credentials beyond a logged-in &lt;code&gt;gh&lt;/code&gt;. I ran each of these on 7 Nov 2026 against &lt;code&gt;main&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. The three rule lists, and the empty one
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api &lt;span class="s2"&gt;"repos/dotnet/aspnetcore/contents/eng/test-configuration.json?ref=main"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s1"&gt;'Accept: application/vnd.github.raw'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Swap &lt;code&gt;?ref=main&lt;/code&gt; for &lt;code&gt;?ref=release/11.0&lt;/code&gt; to check the shipping branch. Both end the same way:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="w"&gt;  &lt;/span&gt;&lt;span class="nl"&gt;"failOnRules"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="err"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"quarantineRules"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;quarantineRules&lt;/code&gt; is empty. &lt;code&gt;failOnRules&lt;/code&gt; is empty. Count the rules and all 14 are in &lt;code&gt;retryOnRules&lt;/code&gt;, with &lt;code&gt;localRerunCount: 3&lt;/code&gt; above them. So every rule in this file weakens a guard by allowing reruns; none of them switches a test off. That distinction is the whole point — a retried test still fails the build when it fails deterministically.&lt;/p&gt;

&lt;p&gt;Note the &lt;code&gt;Accept: application/vnd.github.raw&lt;/code&gt; header. Without it the contents API hands you base64 and you have to pipe through &lt;code&gt;base64 -d&lt;/code&gt;, whose flag differs across platforms. The raw header avoids that entirely.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Where quarantining actually happens
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api &lt;span class="s2"&gt;"search/code?q=QuarantinedTestAttribute+repo:dotnet/aspnetcore"&lt;/span&gt; &lt;span class="nt"&gt;--jq&lt;/span&gt; &lt;span class="s1"&gt;'.items[].path'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That returns several paths; the definition is &lt;code&gt;src/Testing/src/xunit/QuarantinedTestAttribute.cs&lt;/code&gt;. Quarantining in this repo is an attribute on the test, &lt;code&gt;[QuarantinedTest("&amp;lt;issue url&amp;gt;")]&lt;/code&gt;, not a config entry. Two mechanisms, one word — which is how censuses end up conflating them.&lt;/p&gt;

&lt;p&gt;(Treat code-search totals as an index figure, not a count. If you need a number, clone and grep. Everything I assert below comes from a file I fetched and grepped myself.)&lt;/p&gt;

&lt;h2&gt;
  
  
  3. The claim, and the control that makes it mean something
&lt;/h2&gt;

&lt;p&gt;Issue 67517 proposed quarantining &lt;code&gt;UserManagerTest&lt;/code&gt;. Check the paperwork first:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api repos/dotnet/aspnetcore/issues/67517 &lt;span class="nt"&gt;--jq&lt;/span&gt; &lt;span class="s1"&gt;'{number,title,state}'&lt;/span&gt;
gh api repos/dotnet/aspnetcore/pulls/67519 &lt;span class="nt"&gt;--jq&lt;/span&gt; &lt;span class="s1"&gt;'{number,state,merged,merged_at}'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The issue is &lt;code&gt;open&lt;/code&gt;. The PR is &lt;code&gt;closed&lt;/code&gt; with &lt;code&gt;"merged": false&lt;/code&gt; and &lt;code&gt;"merged_at": null&lt;/code&gt;. So the proposal exists and the change does not. Now measure the source rather than trusting either:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api &lt;span class="s2"&gt;"repos/dotnet/aspnetcore/contents/src/Identity/test/Identity.Test/UserManagerTest.cs?ref=main"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s1"&gt;'Accept: application/vnd.github.raw'&lt;/span&gt; | &lt;span class="nb"&gt;grep&lt;/span&gt; &lt;span class="nt"&gt;-ac&lt;/span&gt; QuarantinedTest
&lt;span class="c"&gt;# 0&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Do not stop here.&lt;/strong&gt; A zero proves nothing on its own: a typo'd pattern, a stale path, or a file &lt;code&gt;grep&lt;/code&gt; silently skipped all produce the same zero. Run the positive control — same pattern, same pipeline, a file where you know the thing exists:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api &lt;span class="s2"&gt;"repos/dotnet/aspnetcore/contents/src/Components/test/E2ETest/Tests/TempDataCookieTest.cs?ref=main"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s1"&gt;'Accept: application/vnd.github.raw'&lt;/span&gt; | &lt;span class="nb"&gt;grep&lt;/span&gt; &lt;span class="nt"&gt;-an&lt;/span&gt; QuarantinedTest
&lt;span class="c"&gt;# 129:    [QuarantinedTest("https://github.com/dotnet/aspnetcore/issues/70085")]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One hit, through the identical command. &lt;em&gt;Now&lt;/em&gt; the zero is a measurement. The test file is unchanged, and &lt;code&gt;grep -ac '\[Fact\]'&lt;/code&gt; on it returns 62 still-running facts.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;-a&lt;/code&gt; is deliberate. &lt;code&gt;grep&lt;/code&gt; treats a file containing a single NUL byte as binary and skips it without saying so — you get a zero that looks like an answer. &lt;code&gt;-a&lt;/code&gt; forces text mode. Any time you pipe unknown bytes into &lt;code&gt;grep&lt;/code&gt; and act on a zero, use it.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. The same discipline on the Identity side
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api &lt;span class="s2"&gt;"repos/dotnet/aspnetcore/contents/src/Identity/Extensions.Core/src/Rfc6238AuthenticationService.cs?ref=main"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;-H&lt;/span&gt; &lt;span class="s1"&gt;'Accept: application/vnd.github.raw'&lt;/span&gt; | &lt;span class="nb"&gt;grep&lt;/span&gt; &lt;span class="nt"&gt;-an&lt;/span&gt; &lt;span class="s1"&gt;'Mod = \|for (var i = -2\|_timestep'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You get &lt;code&gt;const int Mod = 1000000&lt;/code&gt;, &lt;code&gt;for (var i = -2; i &amp;lt;= 2; i++)&lt;/code&gt;, and &lt;code&gt;_timestep = TimeSpan.FromMinutes(3)&lt;/code&gt;. Six digits, five windows, three minutes each. Read the constants out of the source like this rather than from a doc comment or a blog: the comment is a lead, the code is the measurement.&lt;/p&gt;

&lt;h2&gt;
  
  
  The transferable rule
&lt;/h2&gt;

&lt;p&gt;Two leads, two different outcomes, same method. An issue title, a tracking issue's state, and a registered version string are all leads. The measurement is the line in the source — and a measurement of &lt;em&gt;absence&lt;/em&gt; isn't one until a positive control has proved your instrument can see presence.&lt;/p&gt;

</description>
      <category>dotnet</category>
      <category>testing</category>
      <category>security</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Tu herramienta de auditoría dice que es de solo lectura. ¿Quién lo comprueba?</title>
      <dc:creator>Eduard Arbona</dc:creator>
      <pubDate>Thu, 05 Nov 2026 02:36:49 +0000</pubDate>
      <link>https://dev.to/earbona23/tu-herramienta-de-auditoria-dice-que-es-de-solo-lectura-quien-lo-comprueba-5bpi</link>
      <guid>https://dev.to/earbona23/tu-herramienta-de-auditoria-dice-que-es-de-solo-lectura-quien-lo-comprueba-5bpi</guid>
      <description>&lt;p&gt;Casi todas las herramientas de auditoría de Microsoft 365 dicen lo mismo en su README: &lt;em&gt;read-only, no modifica tu tenant&lt;/em&gt;. Y casi todas lo dicen de la misma forma: como una promesa.&lt;/p&gt;

&lt;p&gt;Una promesa en un README no sobrevive al segundo mantenedor. Alguien añade una comprobación, necesita un dato que solo se obtiene provocando un cambio, y seis meses después tu herramienta "de solo lectura" escribe en producción. Nadie mintió. Simplemente la propiedad no estaba sujeta a nada.&lt;/p&gt;

&lt;p&gt;Lo que sigue es cómo convertir esa frase en algo que falle la compilación cuando deja de ser cierta.&lt;/p&gt;

&lt;h2&gt;
  
  
  El problema, en concreto
&lt;/h2&gt;

&lt;p&gt;Microsoft Graph no separa lectura y escritura por endpoint, sino por &lt;strong&gt;verbo&lt;/strong&gt;. El mismo &lt;code&gt;/users/{id}&lt;/code&gt; es lectura con &lt;code&gt;GET&lt;/code&gt; y escritura con &lt;code&gt;PATCH&lt;/code&gt;. Así que "de solo lectura" se traduce a una invariante muy simple:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;En todo el módulo, la única llamada a Graph usa &lt;code&gt;GET&lt;/code&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Esa frase sí se puede comprobar con una máquina.&lt;/p&gt;

&lt;h2&gt;
  
  
  Paso 1: un único punto de salida
&lt;/h2&gt;

&lt;p&gt;La invariante no se puede verificar si hay quince sitios distintos que llaman a Graph. Lo primero es que haya uno:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="kr"&gt;function&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nf"&gt;Invoke-HygieneGraphRequest&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="kr"&gt;param&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;Parameter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Mandatory&lt;/span&gt;&lt;span class="p"&gt;)][&lt;/span&gt;&lt;span class="n"&gt;string&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nv"&gt;$Uri&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;int&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nv"&gt;$MaxPages&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;50&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="c"&gt;# El verbo va fijado aqui y no se expone como parametro. No es por comodidad:&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="c"&gt;# un parametro -Method convierte la invariante en una convencion, y una&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="c"&gt;# convencion la rompe el primero que tenga prisa.&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="n"&gt;Invoke-MgGraphRequest&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Method&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nx"&gt;GET&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Uri&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nv"&gt;$Uri&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-ErrorAction&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nx"&gt;Stop&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Lo importante no es el &lt;code&gt;GET&lt;/code&gt;. Es que &lt;strong&gt;no hay un parámetro &lt;code&gt;-Method&lt;/code&gt;&lt;/strong&gt;. Si lo hubiera, la invariante dependería de que todos los llamantes se porten bien, y eso no se puede verificar.&lt;/p&gt;

&lt;h2&gt;
  
  
  Paso 2: la prueba que lo sujeta
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="n"&gt;Describe&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s1"&gt;'El modulo no escribe en el tenant'&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;

    &lt;/span&gt;&lt;span class="n"&gt;It&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s1"&gt;'ningun fichero contiene un verbo de escritura de Graph'&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="nv"&gt;$ficheros&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;Get-ChildItem&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Path&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nv"&gt;$ModuloRaiz&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Recurse&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Include&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s1"&gt;'*.ps1'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s1"&gt;'*.psm1'&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="nv"&gt;$infractores&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="kr"&gt;foreach&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;$f&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="kr"&gt;in&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nv"&gt;$ficheros&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
            &lt;/span&gt;&lt;span class="nv"&gt;$texto&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;Get-Content&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-LiteralPath&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nv"&gt;$f&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;FullName&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Raw&lt;/span&gt;&lt;span class="w"&gt;
            &lt;/span&gt;&lt;span class="kr"&gt;if&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;$texto&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-match&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s1"&gt;'-Method\s+(POST|PATCH|PUT|DELETE)'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
                &lt;/span&gt;&lt;span class="s1"&gt;'{0}:{1}'&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-f&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nv"&gt;$f&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;Name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="bp"&gt;$Matches&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
            &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="nv"&gt;$infractores&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;Should&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-BeNullOrEmpty&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;

    &lt;/span&gt;&lt;span class="n"&gt;It&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s1"&gt;'solo hay un sitio que llame a Graph'&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="nv"&gt;$llamadas&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;Select-String&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Path&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$ModuloRaiz&lt;/span&gt;&lt;span class="s2"&gt;\**\*.ps1"&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="se"&gt;`
&lt;/span&gt;&lt;span class="w"&gt;                                  &lt;/span&gt;&lt;span class="nt"&gt;-Pattern&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s1"&gt;'Invoke-MgGraphRequest'&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-AllMatches&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="c"&gt;# Una sola: la de Invoke-HygieneGraphRequest. Si aparece otra, alguien&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="c"&gt;# se salto el punto de salida unico y la primera prueba deja de cubrirlo.&lt;/span&gt;&lt;span class="w"&gt;
        &lt;/span&gt;&lt;span class="p"&gt;@(&lt;/span&gt;&lt;span class="nv"&gt;$llamadas&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;Count&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;Should&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Be&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nx"&gt;1&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;La segunda prueba es la que de verdad importa, y es la que casi nadie escribe. Sin ella, la primera se puede burlar sin querer: basta con que alguien llame a &lt;code&gt;Invoke-MgGraphRequest&lt;/code&gt; directamente con &lt;code&gt;GET&lt;/code&gt;, y a partir de ahí ya hay dos caminos, uno de ellos sin guardia.&lt;/p&gt;

&lt;h2&gt;
  
  
  Lo que esto NO prueba
&lt;/h2&gt;

&lt;p&gt;Y aquí es donde conviene ser honesto, porque una prueba que se cree más de lo que mide es peor que ninguna.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No prueba que no haya efectos de escritura.&lt;/strong&gt; Un &lt;code&gt;GET&lt;/code&gt; puede tener efectos secundarios en el servidor. En Graph, en la práctica, no los tiene en los endpoints de lectura de directorio, pero la prueba no lo demuestra: lo asume.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Es una comprobación de texto, no de comportamiento.&lt;/strong&gt; Un verbo construido en tiempo de ejecución (&lt;code&gt;-Method $v&lt;/code&gt;) se le escapa. Por eso la segunda prueba, la del punto de salida único, no es opcional: es la que cierra ese hueco.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No cubre lo que hagan los módulos de los que dependes.&lt;/strong&gt; Si importas algo que escribe, tu suite no se entera.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Esas tres limitaciones están en el README del módulo, no solo en este artículo. Una herramienta de seguridad que no publica sus puntos ciegos está pidiendo que confíes en ella por fe.&lt;/p&gt;

&lt;h2&gt;
  
  
  El patrón, generalizado
&lt;/h2&gt;

&lt;p&gt;La idea no es de PowerShell ni de Graph:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Escribe la propiedad como una frase que una máquina pueda refutar. &lt;em&gt;"Es seguro"&lt;/em&gt; no vale. &lt;em&gt;"La única llamada a la red usa GET"&lt;/em&gt; sí.&lt;/li&gt;
&lt;li&gt;Reduce los puntos donde la propiedad puede romperse hasta que quede uno.&lt;/li&gt;
&lt;li&gt;Escribe la prueba que falla cuando se rompe.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escribe también la prueba de que sigue habiendo un solo punto.&lt;/strong&gt; Es la que evita que la propiedad se degrade en silencio.&lt;/li&gt;
&lt;li&gt;Publica lo que la prueba no cubre.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;El paso 4 es el que separa una invariante de un comentario con suerte.&lt;/p&gt;

&lt;h2&gt;
  
  
  Si quieres verlo entero
&lt;/h2&gt;

&lt;p&gt;Está en &lt;code&gt;M365TenantHygiene&lt;/code&gt; y &lt;code&gt;EntraHygiene&lt;/code&gt;, los dos MIT y en la PowerShell Gallery:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="n"&gt;Install-Module&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nx"&gt;M365TenantHygiene&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-Scope&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nx"&gt;CurrentUser&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;El mismo módulo aplica otra idea emparentada que merece su propio artículo: distinguir &lt;em&gt;"no encontré nada"&lt;/em&gt; de &lt;em&gt;"no pude mirar"&lt;/em&gt;. Una comprobación que no pudo ejecutarse informa &lt;code&gt;Skipped&lt;/code&gt; con el motivo, nunca un resultado limpio. Un informe de auditoría que confunde esas dos cosas es peor que no tener informe, porque produce tranquilidad sin cobertura.&lt;/p&gt;

&lt;p&gt;Si encuentras un hueco en el razonamiento, dímelo. Prefiero el comentario incómodo.&lt;/p&gt;

</description>
      <category>security</category>
      <category>powershell</category>
      <category>azure</category>
      <category>devops</category>
    </item>
    <item>
      <title>The parser survey a USENIX paper left as future work</title>
      <dc:creator>Eduard Arbona</dc:creator>
      <pubDate>Sun, 01 Nov 2026 12:02:35 +0000</pubDate>
      <link>https://dev.to/earbona23/the-parser-survey-a-usenix-paper-left-as-future-work-59kh</link>
      <guid>https://dev.to/earbona23/the-parser-survey-a-usenix-paper-left-as-future-work-59kh</guid>
      <description>&lt;p&gt;description: Cookie Crumbles surveyed cookie handling across browsers and 13 frameworks, then left the server-side parser study as future work. Three years later it still did not exist, so I built it.&lt;/p&gt;

&lt;p&gt;tags: security, dotnet, go, webdev&lt;br&gt;
In 2023, Squarcina, Adão, Veronese and Maffei presented Cookie Crumbles:&lt;/p&gt;

&lt;p&gt;Breaking and Fixing Web Session Integrity at the 32nd USENIX Security&lt;/p&gt;

&lt;p&gt;Symposium. It is a good paper. It surveys cookie integrity across the top three&lt;/p&gt;

&lt;p&gt;browsers and 13 web frameworks, and it finds session integrity problems in nine&lt;/p&gt;

&lt;p&gt;of them.&lt;br&gt;
Section 4.3 describes a third stage of the work: feeding crafted Cookie&lt;/p&gt;

&lt;p&gt;headers to the server-side parsers and comparing what each one understood. Then&lt;/p&gt;

&lt;p&gt;it says this:&lt;br&gt;
We acknowledge that this approach does not constitute a systematic evaluation&lt;/p&gt;

&lt;p&gt;of server-side parsing inconsistencies. However, our initial analysis provided&lt;/p&gt;

&lt;p&gt;strong evidence of the pervasiveness of the issue. We leave such comprehensive&lt;/p&gt;

&lt;p&gt;study as future work.&lt;br&gt;
That sentence is an invitation, and as far as I can tell nobody took it. So I&lt;/p&gt;

&lt;p&gt;built the bench: &lt;a href="https://github.com/earbona23/http-parser-differentials" rel="noopener noreferrer"&gt;https://github.com/earbona23/http-parser-differentials&lt;/a&gt;&lt;br&gt;
Why a disagreement is the bug, not a wrong answer&lt;br&gt;
The instinct with a comparison table is to look for the loser. That is the&lt;/p&gt;

&lt;p&gt;wrong instinct.&lt;br&gt;
HTTP is parsed many times on the way to your code. A CDN parses it. A reverse&lt;/p&gt;

&lt;p&gt;proxy parses it. A WAF parses it. Your framework parses it. Each of those is&lt;/p&gt;

&lt;p&gt;free to be reasonable and still differ, because the grammars are old, widely&lt;/p&gt;

&lt;p&gt;extended, and full of cases the RFCs never pinned down.&lt;br&gt;
The security consequence does not need either parser to be wrong. It needs them&lt;/p&gt;

&lt;p&gt;to be different. A gateway that inspects a field and an application that reads&lt;/p&gt;

&lt;p&gt;another value for that same field are both behaving exactly as written. The gap&lt;/p&gt;

&lt;p&gt;between them is where the request you blocked and the request you served stop&lt;/p&gt;

&lt;p&gt;being the same request.&lt;br&gt;
That is the class the bench is built to make visible.&lt;br&gt;
What it does&lt;br&gt;
Two benches. Each one starts a small reflector program per implementation on&lt;/p&gt;

&lt;p&gt;127.0.0.1, sends byte-identical input to all of them over a raw socket, and&lt;/p&gt;

&lt;p&gt;prints what each one parsed.&lt;br&gt;
Cookie header, 39 vectors, five implementations: ASP.NET Core&lt;/p&gt;

&lt;p&gt;(RequestCookieCollection), Go (net/http), PHP (native $_COOKIE), the&lt;/p&gt;

&lt;p&gt;algorithm of the npm cookie package that Express and Koa use, and Python&lt;/p&gt;

&lt;p&gt;(http.cookies). Duplicate names, case, percent-decoding, quoting, separators,&lt;/p&gt;

&lt;p&gt;whitespace, control and high bytes, repeated Cookie headers.&lt;br&gt;
Multipart, 17 vectors, four implementations: ASP.NET Core (ReadFormAsync),&lt;/p&gt;

&lt;p&gt;Go (mime/multipart), PHP, Python (email with an HTTP policy). Duplicate&lt;/p&gt;

&lt;p&gt;field names, quoting of the name parameter, repeated and malformed&lt;/p&gt;

&lt;p&gt;Content-Disposition, bare LF line endings, boundary handling, RFC 2231&lt;/p&gt;

&lt;p&gt;encoded names, preamble and epilogue.&lt;br&gt;
Raw sockets matter here. An HTTP client library will refuse to send half of&lt;/p&gt;

&lt;p&gt;these vectors, and if it quietly normalises one of them you end up measuring&lt;/p&gt;

&lt;p&gt;your own client instead of the parser. I learned that the hard way on an&lt;/p&gt;

&lt;p&gt;unrelated piece of work, when a harness of mine encoded a header as ASCII&lt;/p&gt;

&lt;p&gt;before sending it and I spent an afternoon analysing a bug I had written.&lt;br&gt;
What came out&lt;br&gt;
Six of 39 cookie vectors and seven of 17 multipart vectors put one&lt;/p&gt;

&lt;p&gt;implementation on its own. The numbers in the repository are measured against&lt;/p&gt;

&lt;p&gt;.NET 10.0.14, Go 1.21, PHP 8, Node 24 and Python 3, and they will move. Rerun&lt;/p&gt;

&lt;p&gt;rather than trusting my table.&lt;br&gt;
Two results worth pulling out, because they point in opposite directions.&lt;br&gt;
Case. Cookie: A=1; a=2 is two cookies to Go, PHP, Node and Python. To&lt;/p&gt;

&lt;p&gt;ASP.NET Core it is one, because the collection is built with&lt;/p&gt;

&lt;p&gt;StringComparer.OrdinalIgnoreCase. RFC 6265 gives no case-folding rule and&lt;/p&gt;

&lt;p&gt;browsers treat the two as distinct entries. This one is already known upstream&lt;/p&gt;

&lt;p&gt;and tracked by the ASP.NET team themselves.&lt;br&gt;
A comma. Cookie: a=1,b=2 returns the cookie to the other four. ASP.NET&lt;/p&gt;

&lt;p&gt;Core returns nothing at all, and not just for that pair: a comma in a value&lt;/p&gt;

&lt;p&gt;discards the rest of the header from that point. That is fail-closed, which is&lt;/p&gt;

&lt;p&gt;the safe direction, but it is a surprising amount of silence for one character.&lt;br&gt;
Standing alone is not the same as being wrong&lt;br&gt;
This is the part I would want a reviewer to hold me to.&lt;br&gt;
Three of the seven multipart cases where ASP.NET Core differs from its peers&lt;/p&gt;

&lt;p&gt;are cases where it is stricter. It rejects a duplicated&lt;/p&gt;

&lt;p&gt;Content-Disposition, it rejects bare LF line endings, and it rejects a fake&lt;/p&gt;

&lt;p&gt;boundary planted inside a field value. Go and Python accept all three; PHP&lt;/p&gt;

&lt;p&gt;accepts two. On that evidence its multipart parser is in better shape than the&lt;/p&gt;

&lt;p&gt;others, and a table that only counts divergences would tell you the opposite.&lt;br&gt;
A flag in the output is a pointer. The verdict needs a human who checks the&lt;/p&gt;

&lt;p&gt;direction: a parser that drops a field fails closed, a parser that invents or&lt;/p&gt;

&lt;p&gt;merges one does not, and those are not the same finding.&lt;br&gt;
A bench is only as good as its weakest reflector&lt;br&gt;
An early version of my multipart reflector printed the file size for .NET and&lt;/p&gt;

&lt;p&gt;not for the other three. Four parsers agreed perfectly, and my comparison&lt;/p&gt;

&lt;p&gt;reported a divergence, because the signatures it compared included a field only&lt;/p&gt;

&lt;p&gt;one of them emitted. I was measuring my own code.&lt;br&gt;
I fixed the reflector rather than documenting the false positive, which I think&lt;/p&gt;

&lt;p&gt;is the right order, and the story is in the README so the next person building&lt;/p&gt;

&lt;p&gt;one of these checks their shapes first.&lt;br&gt;
What this is not&lt;br&gt;
It is not a vulnerability disclosure. Everything in it is public, documented&lt;/p&gt;

&lt;p&gt;behaviour of public parsers, exercised against local reflectors written for the&lt;/p&gt;

&lt;p&gt;repository. Nothing in it touches a system I do not own, and every byte stays on&lt;/p&gt;

&lt;p&gt;loopback.&lt;br&gt;
If you run it against a version I did not, and something in the output looks&lt;/p&gt;

&lt;p&gt;like a security bug in a product, take it to that product's security team before&lt;/p&gt;

&lt;p&gt;you write about it.&lt;br&gt;
MIT licensed. Issues and additional implementations welcome, particularly Java,&lt;/p&gt;

&lt;p&gt;Ruby and Rust, which I did not cover.&lt;/p&gt;

</description>
      <category>computerscience</category>
      <category>security</category>
      <category>webdev</category>
    </item>
    <item>
      <title>How I Detect the Illicit Consent Grant Attack in Microsoft Entra ID</title>
      <dc:creator>Eduard Arbona</dc:creator>
      <pubDate>Sat, 24 Oct 2026 01:02:31 +0000</pubDate>
      <link>https://dev.to/earbona23/how-i-detect-the-illicit-consent-grant-attack-in-microsoft-entra-id-4ioc</link>
      <guid>https://dev.to/earbona23/how-i-detect-the-illicit-consent-grant-attack-in-microsoft-entra-id-4ioc</guid>
      <description>&lt;p&gt;&lt;em&gt;Eduard Arbona — identity security engineer. Contributions merged into Maester and Azure Sentinel; author of EntraTripwire.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most people picture an account takeover as a stolen password. In Microsoft Entra ID, one of the quietest and most durable takeovers never touches the password at all. It is the illicit consent grant, and if you only watch for failed sign-ins you will miss it completely.&lt;/p&gt;

&lt;p&gt;Here is how it works, why multi-factor authentication does not save you, and the exact signal I use to catch it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The attack, start to finish
&lt;/h2&gt;

&lt;p&gt;An attacker registers an application in their own tenant, usually multi-tenant so it can be consented from anywhere. They craft a normal OAuth 2.0 authorization URL that asks for delegated permissions such as &lt;code&gt;Mail.Read&lt;/code&gt;, &lt;code&gt;Mail.Send&lt;/code&gt;, &lt;code&gt;Files.Read.All&lt;/code&gt;, and critically &lt;code&gt;offline_access&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Then they phish a link. The victim clicks it and lands on the real &lt;code&gt;login.microsoftonline.com&lt;/code&gt; page. They sign in, they pass MFA, everything looks legitimate, because it is. The only unusual part is a consent screen asking them to let "Some App" read their mail. People click through consent screens all day.&lt;/p&gt;

&lt;p&gt;The moment the victim consents, Entra ID creates a service principal and an OAuth permission grant in the victim's own tenant. The application receives an access token, and because of &lt;code&gt;offline_access&lt;/code&gt;, a refresh token. From that point the attacker reads the mailbox through Microsoft Graph using tokens, on their own schedule, from their own infrastructure.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why your usual defenses do not fire
&lt;/h2&gt;

&lt;p&gt;This is the part that surprises people:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The password was never captured&lt;/strong&gt;, so a password reset does not revoke access. The refresh token keeps working.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MFA already succeeded&lt;/strong&gt; during the consent flow. Re-prompting for MFA later does nothing to a token refresh.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;There is no malware&lt;/strong&gt; on any endpoint, so EDR has nothing to find.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sign-in logs look normal.&lt;/strong&gt; The victim had a legitimate interactive sign-in. The ongoing access shows up as app-only Graph calls, not as suspicious logins.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Revoking this requires removing the grant and the service principal. Until you do, the attacker has quiet, persistent mailbox access that survives most of your incident response reflexes.&lt;/p&gt;

&lt;h2&gt;
  
  
  The signal I actually watch
&lt;/h2&gt;

&lt;p&gt;The event you want lives in the Entra ID audit log, not the sign-in log. The operation is &lt;strong&gt;"Consent to application"&lt;/strong&gt; (and the related delegated permission grant events), available through Microsoft Graph at &lt;code&gt;auditLogs/directoryAudits&lt;/code&gt; and surfaced in Microsoft Sentinel as the &lt;code&gt;AuditLogs&lt;/code&gt; table.&lt;/p&gt;

&lt;p&gt;A consent is not automatically malicious. What makes one worth an alert is the combination:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The app is &lt;strong&gt;not from a verified publisher&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;The granted delegated scopes include &lt;strong&gt;mail or file access plus &lt;code&gt;offline_access&lt;/code&gt;&lt;/strong&gt; (persistence is the tell).&lt;/li&gt;
&lt;li&gt;The consent was performed by an &lt;strong&gt;ordinary user&lt;/strong&gt;, not an admin, often to an app that was &lt;strong&gt;registered very recently&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;The app's reply URL points to an &lt;strong&gt;unfamiliar domain&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Here is the shape of the Sentinel KQL I use to pull the high-signal cases out:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;AuditLogs
| where OperationName == "Consent to application"
| mv-expand target = TargetResources
| mv-expand mod = target.modifiedProperties
| where tostring(mod.displayName) == "ConsentAction.Permissions"
| extend grantedPerms = tostring(mod.newValue)
| where grantedPerms has "offline_access"
    and (grantedPerms has "Mail.Read"
      or grantedPerms has "Mail.ReadWrite"
      or grantedPerms has "Mail.Send")
| extend actor = tostring(InitiatedBy.user.userPrincipalName)
| project TimeGenerated, actor, grantedPerms, Result
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One thing to check first: the exact shape of &lt;code&gt;modifiedProperties&lt;/code&gt; varies between tenants and log versions, so treat the parsing as a starting point and confirm the field layout in your own &lt;code&gt;AuditLogs&lt;/code&gt; before you trust the rule. I validate my detections against the official KQL parser and map each one to a MITRE ATT&amp;amp;CK technique so I know what I am actually covering and what I am not.&lt;/p&gt;

&lt;h2&gt;
  
  
  Closing the door, not just watching it
&lt;/h2&gt;

&lt;p&gt;Detection is half the job. The configuration change that removes most of the risk is tightening the consent policy:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Restrict user consent to &lt;strong&gt;verified publishers and low-risk permissions only&lt;/strong&gt;, and route everything else through an &lt;strong&gt;admin consent request workflow&lt;/strong&gt;. A human reviews before mail access is ever granted.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review enterprise applications&lt;/strong&gt; and their granted permissions on a schedule. Old, forgotten, over-permissioned apps are exactly what an attacker hides behind.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Alert on every new consent&lt;/strong&gt; to an app requesting mail or &lt;code&gt;offline_access&lt;/code&gt;, using the query above.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I also take a deception angle with a tool I published, EntraTripwire: plant decoy applications and credentials that nothing legitimate should ever consent to or touch, and score whoever does. A consent grant against a decoy app is a near-zero-false-positive signal that someone is probing your tenant.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this matters more than it looks
&lt;/h2&gt;

&lt;p&gt;The illicit consent grant is attractive to attackers precisely because it is boring to defenders. It does not trip the alarms everyone tunes first. It is a configuration-and-token problem wearing the clothes of a normal user action.&lt;/p&gt;

&lt;p&gt;If you run Entra ID, two things are worth doing this week: pull your last ninety days of "Consent to application" events and look for mail plus &lt;code&gt;offline_access&lt;/code&gt; grants to unverified apps, and check whether user consent is still wide open in your tenant. Both take minutes. Both can surface a problem that your password policy and your MFA were never going to catch.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;I build read-only security tooling for Microsoft Entra ID and M365. The consent-monitoring work in this article is open source on my GitHub (earbona23), and a related analytic rule is merged into Microsoft's Azure Sentinel repository.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>azure</category>
      <category>entraid</category>
      <category>microsoftgraph</category>
    </item>
  </channel>
</rss>
