<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/oscar-swartz/">Oscar &nbsp;Swartz</a> | 1 juli 2023<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmassovervaka-oss-inte-ylva%2F&amp;t=Mass%C3%B6vervaka+oss+inte%2C+Ylva%21"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Mass%C3%B6vervaka+oss+inte%2C+Ylva%21+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmassovervaka-oss-inte-ylva%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmassovervaka-oss-inte-ylva%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Massövervaka oss inte, Ylva!&body=https://kvartal.se/artiklar/massovervaka-oss-inte-ylva/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/100610/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/100610/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmassovervaka-oss-inte-ylva%2F&amp;t=Mass%C3%B6vervaka+oss+inte%2C+Ylva%21"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Mass%C3%B6vervaka+oss+inte%2C+Ylva%21+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmassovervaka-oss-inte-ylva%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fmassovervaka-oss-inte-ylva%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Massövervaka oss inte, Ylva!&body=https://kvartal.se/artiklar/massovervaka-oss-inte-ylva/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/100610/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/100610/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 15 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/100610"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-100610">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "100610"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Bästa Ylva,</p>
</div>
<div class="rest-of-article ">
<p>Jag förstår att du vill göra vad du kan för att förhindra sexuella övergrepp mot barn. Du har nu klättrat till en av de mäktigaste positionerna i Europa. Du har makt. EU-kommissionen har lagt fram ett förslag som kommit att kallas Chatcontrol.<sup>1</sup></p>
<p>Nu har media förstått: Kommissionen vill verkligen införa ett system för överstatlig avläsning av allas internetkommunikation i EU. Även sådan som krypteras.</p>
<p>Kritiker talar om teknik och integritet. Det är bra. Men få granskar grunden för er övervakningsstat: Hur många barn kan egentligen räddas från sexuella övergrepp med hjälp av massavlyssning i jämförelse med andra metoder som inte aktivt undergräver EU-medborgarnas säkerhet och integritet. Och vad ska de räddas från egentligen?</p>
<h2>Kampen mot barnporr – ett politiskt vapen</h2>
<p>Den 25 maj 2007 hamnade jag på en hearing med temat:<em> Sweden – a safe haven for pirates</em>?</p>
<p>”Child pornography is great!” hojtade en av Danmarks mest kända advokater från scenen. ”Det är great eftersom politiker förstår barnporr! Genom att spela det kortet kan vi få dem att agera, och börja blockera sajter. Och när de har gjort det kan vi få dem att blockera fildelningssajter.”</p>
<p>Som familjeminister i Tyskland blev din nuvarande chef, <strong>Ursula von der Leyen</strong>, känd under öknamnet ”Zensursula”, när hon pressade fram just en sådan lag för att blockera ”barnporr”. Hon hänvisade till Sverige där en del internetoperatörer ingått ”frivilliga” avtal som lät polisen styra om deras trafik i enlighet med hemliga blockeringslistor. Kort senare lade Sveriges EU-kommissionär <strong>Cecilia Malmström </strong>fram samma sak på europeisk nivå.</p>
<p>”Karlsruhe”, som den tyska författningsdomstolen brukar kallas, upphävde snart den tyska lagen: den bröt mot konstitutionen. Malmströms EU-direktiv skars ned: Obligatorisk blockering av sajter avvisades av Europaparlamentet.</p>
<blockquote><p>Varje textkommunikation måste kunna skannas med mål att upptäcka groomning, det vill säga kontakt med underårig i sexuellt syfte.</p></blockquote>
<p>Skam den som ger sig! Ylva Johansson, du blev kommissionär för inrikes frågor 2019, samtidigt som Ursula von der Leyen blev EU-kommissionens ordförande. Redan i maj 2022 lade Kommissionen sedan fram ett förslag för att, som det heter, ”förebygga och bekämpa sexuella övergrepp mot barn”.<sup>2</sup> Det är förrädiskt, för vem kan väl vara emot?</p>
<p>Ni kräver nu att varje bild eller video på varje användares mobil, platta eller dator, ska kunna skannas och analyseras innan filen laddas upp till sociala medier eller skickas till mamma, kollega, kompis, tidskrift, myndighet, journalist etcetera. CSAM = <em>Child Sexual Abuse Material</em> (”barnporr”), ska upptäckas med hjälp av smarta igenkänningstekniker. Inte bara gamla kända bilder och videor, utan också nytt material. Flaggas en bild som misstänkt sänds den till en ny myndighet i Haag, <em>EU Centre</em>, för personlig bedömning.</p>
<p>Inte nog med det. Varje textkommunikation måste kunna skannas med mål att upptäcka groomning, det vill säga kontakt med underårig i sexuellt syfte. Även kommunikation som idag är totalsträckskrypterad (E2EE = <em>End-to-End Encryption</em>) ska kunna läsas. E2EE innebär att ingen annan än sändare och mottagare kan läsa meddelandena, inte heller den som driver tjänsten. Detta gäller idag WhatsApp, Signal, Telegram, Apple Messages och många andra appar. E2EE är grunden för säker kommunikation på nätet. När ”indikatorerna” slår till ska dock varje misstänkt meningsutbyte skickas till EU Centre för inspektion.</p>
<h2>Det är Facebooks maskiner som felflaggar bilder</h2>
<p>Ylva, i ett passionerat pressmeddelande som banar väg för direktivet nämner du att CSAM har ökat exponentiellt.<sup>3</sup> Under 2010 upptäcktes 1 miljon material [= bilder och videos]. 2019 var det hela 17 miljoner. Du skriver att det rör sig om: ”barn som blir våldtagna, pedofiler som våldtar”. Ja du Ylva, man tappar tron på mänskligheten och framtiden när man ser att siffran år 2022 var uppe i 32 miljoner!</p>
<p>Det där är siffror från NCMEC, <em>National Center for Missing and Exploited Children,</em> en privat organisation med särställning. USA-baserade <em>Electronic Service Providers</em> är enligt lag förpliktigade att rapportera CSAM till just NCMEC. En del av utgifterna täcks därför av amerikanska justitiedepartementet. Resten kommer från donatorer, både allmänheten och stora tech-företag.</p>
<p>Jag gick till deras redovisning, Ylva, för att läsa om vidrigheterna. Det råkade bli år 2020 eftersom det då fanns kompletterande data. Nästan 22 miljoner rapporter kom in till NCMEC via deras tipslinje CyberTipline. En procent kom från allmänheten och 99 procent från <em>Electronic Service Providers, </em>hela 95 procent av dessa från Facebook, 20 307 216 rapporter.<sup>4</sup></p>
<p>Det är svårt att veta vad för material Facebook skickar vidare till NCMEC. Men hallå, Ylva, är det inte nästan omöjligt att tro att ”pedofiler som våldtar” lägger ut sina alster just där av alla ställen, hårt övervakat av en anmäl-klickande allmänhet och Meta-koncernen själv?</p>
<blockquote><p>De hade delat den ikoniska svartvita bilden från 1972 av en nioårig naken flicka som flyr sin napalmbombade by i Vietnam.</p></blockquote>
<p>Lägligt nog undersökte Facebook saken själv under oktober och november 2020.<sup>5</sup> 90 procent av materialet hade rapporterats tidigare. Sex stycken videor stod för över häften av alla de ca 4 miljoner rapporter man gjorde under perioden. Det kan ju knappast ha varit våldtäktsvideor eftersom sådana omedelbart skulle ha spärrats. Gissningsvis var det något oskyldigt som vanliga människor fann helt okej att dela vilt (2 miljoner gånger totalt!) men som Facebooks maskinella skanning identifierade som CSAM och autorapporterade <em>en masse</em> till NCMEC. Facebook undersökte sedan 150 konton som ursprungligen hade laddat upp materialet och fann att 75 procent av dessa inte hade ”onda avsikter”. Det handlade om till exempel humor innehållande barn.</p>
<p>År 2016 fick vi insikt i procedurerna: en norsk skribent och Norges statsminister <strong>Erna Solberg</strong> fick samma ”barnporrbild” borttagen från sina Facebook-sidor. Skribenten blev avstängd. De hade delat den ikoniska svartvita bilden från 1972 av en nioårig naken flicka som flyr sin napalmbombade by i Vietnam, en milstolpe inom fotojournalistik.<sup>6</sup></p>
<p>Google har bäst koll i världen på vad som finns på nätet. Deras egen presentation av sitt anti-CSAM-arbete känns trygg.<sup>7</sup></p>
<p>“Googles team jobbar dygnet runt med att identifiera, ta bort och rapportera detta innehåll med hjälp av en kombination av branschledande automatiska detekteringsverktyg och specialutbildade granskare. Vi får även rapporter från tredje part och användare som kompletterar vårt pågående arbete. Vi rapporterar material som visar sexuellt övergrepp mot barn till National Center for Missing and Exploited Children (NCMEC), som fungerar som mellanhand och övergripande rapportcenter i USA för frågor som rör utnyttjande av barn. NCMEC skickar dessa rapporter till brottsbekämpande myndigheter runt om i världen.”</p>
<p>Men, Ylva, Google skickade år 2020 bara en halv miljon rapporter till NCMEC från hela webben, jämfört med Facebooks 20 miljoner på sin plattform, varav 2 miljoner på två månader rörde några humorvideos – eller vad det nu var.</p>
<h3>Ungdomars sexualitet riskerar att kriminaliseras</h3>
<p>Ylva, du påstår att siffrorna för CSAM hos NCMEC rusar på grund av följande: För att få tillgång till material med barnvåldtäkter måste man själv bidra med lika vidrigt material. Forskarna håller inte med. Den stora ökningen sägs sammanfalla med maskinell skanning med den nya tekniken PhotoDNA.<sup>8</sup> I praktiken står ju Facebook för de där enorma absoluta talen. Av 32 miljoner rapporter år 2022 skickade NCMEC vidare runt 15 promille till polisväsenden jorden runt som angelägna ärenden.</p>
<blockquote><p>Nästan alla nakenbilder på personer som inte fyllt 18 räknas.</p></blockquote>
<p>Ylva, i ditt skarpa förslag skriver du att CSAM (det vill säga illegal ’barnporr’) ”är ett resultat av fysiska sexuella övergrepp som har begåtts mot barn”. Men så är det ju inte enligt EU:s egen definition.<sup>9</sup></p>
<p>Bilder och videor på sexuella aktiviteter som utförs av eller involverar personer under 18 ingår i CSAM. Men i 26 av 27 EU-länder ligger samtyckesåldern för sex lägre än 18.<sup>10</sup> I 60 procent av länderna rentav 3–4 år lägre. Det innebär att i 26 länder kan ”ett barn” ha ömsesidig sex med en annan lovlig person utan att något övergrepp sker, vare sig fysiskt, moraliskt eller juridiskt. (Jag vet vad alla undrar och svaret är Malta, där ju även abort är nästan totalförbjudet.) När de inblandade dokumenterar sina eskapader med en mobilkamera uppstår dock illegal ”barnporr”, CSAM. Ja nästan alla nakenbilder på personer som inte fyllt 18 räknas som CSAM. Även material där vuxna spelar barn. Dessutom tecknade bilder som är ”verklighetstrogna”.</p>
<p>Internet Watch Foundation (IWF, brittisk motsvarighet till NCMEC) bedömde 2022 att hela 78 procent av CSAM-material nu var egenproducerat, en procentsats som bara ökar.<sup>11</sup> En parlamentarisk grupp i Storbritannien var så konfunderad av sådan ’sexting’ att de skrev en rapport med titeln: <em>Selfie Generation: What’s behind the rise of self-generated indecent images of children online?</em><sup>12</sup> Uppåt 40 procent av 13–17-åringar tycker det är normalt att dela självtagna sexbilder med kompisar. Ofta begår de därigenom formellt brottsliga handlingar (produktion och spridning av ”barnporr”), i USA ibland med förödande och livslånga straffrättsliga effekter för ungdomarna själva. Detta oroar juridikforskare, vilka snarare rekommenderar avkriminalisering än massavlyssning.</p>
<p>Det hela är inte oproblematiskt. En del av det självgenererade materialet tillkommer på tragiska och brottsliga vis, exempelvis genom <em>”</em><em>sextortion”</em>, där typfallet är någon som förmår en tjej att ta en webbcambild för att sedan hota med spridning till lärare, föräldrar, kamrater om hon inte skickar fler och grövre bilder. Även killar drabbas när de tror att en onaniscen beskådas av en tjej fast den egentligen spelas in och delas av en jämnårig mobbare. Uppåt 20 procent av ungdomar tror att deras kompisar skickar vidare sexting-bilder utan lov. Dessa inser kanske inte i sändögonblicket att de där intima bilderna som sedan kan cirkulera på nätet drivit ungdomar till självmord.</p>
<h3>Chatcontrol stoppar inte pedofilerna</h3>
<p>Du träffar förstås rätt ibland, Ylva. Tyvärr finns ju material som dokumenterar när vuxna, inte sällan föräldrar, begår grymma fysiska sexuella övergrepp mot barn, alltså den enda typen av all så kallad CSAM som du väljer att skrämma folk med. I Ekots lördagsintervju i Sveriges Radio P1 beskrev du det grafiskt. Du hävdade där, otroligt nog, att det blir fritt fram att tvinga barn köra in köksredskap i kroppen om du inte får massavlyssna.<sup>13</sup> Det kanske finns sådant material, men det är i praktiken immunt mot era åtgärder eftersom det då byts via tillitsbaserade nätverk på ”<em>dark web”</em>, inte via Facebook. Sådana nätverk sprängs idag regelbundet av samarbetande ordningsmakt i olika länder, fast då med helt andra metoder än massavlyssning av vår kommunikation via vanliga sociala medier.<sup>14</sup></p>
<p>Ja, det finns vuxna som ägnar sig åt groomning, som i chattar försöker få underåriga att ställa upp på sex framför kameran eller mötas i verkliga livet. Men även där liknar situationen den med ”<em>self-generated CSAM”</em>.<sup>15,</sup><sup>16</sup> I forskningen tas upp att groomning ofta sker genom att något äldre ungdomar/unga vuxna försöker få till sex med (i många fall villiga) yngre. Ofta är de dessutom bekanta, inte okända. Pubertera(n)de barn visar sig inte sällan själva vara sexuellt sökande och drivande. De kan försätta sig i dumma och farliga situationer de sedan skäms över och håller tyst om. Saker som kräver andra lösningar än massavlyssning.</p>
<p>Hur kan ni hamna så fel? Det finns en hyllad metod inom till exempel genusvetenskapen som kallas WPR-analys, formulerad av feministiska statsvetarprofessorn <strong>Carol Bacchi</strong> (”WPR = <em>What’s the Problem Represented to be?</em>”).<sup>17</sup></p>
<p>Normalt tänker vi oss att det finns objektiva problem ”där ute” i världen som väntar på att rationellt åtgärdas genom en policy eller lag.</p>
<p>WPR utgår tvärtom från en viss policy och arbetar sig bakåt för att avslöja<em> vilket problem lagstiftarna föreställde sig</em><em>.</em> Sedan formuleras kritiska frågor: Kunde problemet ha tänkts på ett annat vis? Vilka dolda antaganden fanns? I vilken historisk kontext formulerades problemet? Vilka intressenter fanns det?</p>
<blockquote><p>De skrämmande mångmiljonsiffrorna kommer från det ”barnporrindustriella komplexet” där organisationer hetsar upp stämningen för att få fler donationer och resurser.</p></blockquote>
<p>Ylva, lösningarna i det förslag som kallas Chatcontrol (såsom skanning av alla meddelanden, minimerande av kontaktmöjligheter mellan vuxna och icke-vuxna, åldersgräns för appar) indikerar hur ni ser problemet. Kommissionen upprepar på flera ställen nästan vällustigt en framtidsfantasi: Att i realtid, genom skanning av alla EU-medborgares kommunikation, kunna avbryta pågående övergrepp mot ett barn. Det behövs bara att en video flimrar förbi i EU Centre eller att en misstänkt chatt snappas upp för att en operatör ska trycka på knappen till Europol, i byggnaden bredvid, som då genast släpper lös en insatsstyrka på rätt plats i unionen.</p>
<p>Er problemformulering ser ut så här: Det finns två klart åtskilda grupper i världen. Predatoriska gubbar, som använder diverse tricks för att lura till sig sex. Samt oskyddade och okunniga barn som blir lurade till sex, både fysiskt och online. Kan vi bara hålla isär grupperna och fånga gubbarna har vi löst problemet.</p>
<p>Jag har visat på stora problem med den synen. Ni borde gå tillbaka till ritbordet och fråga: I en värld där åldern för könsmognad faller, där alla barn och ungdomar har spetsteknik i sina händer, hur ger vi dem egenmakt på nätet? Och vad ska vi göra för att de ska kunna hantera sin egen sexualitet och kontakter på nätet där det även finns vuxna som har mindre ädla och även rent otäcka motiv? Forskare avråder från att främst varna för okända gubbar, eftersom dessa är en minoritet vad gäller sexuellt utnyttjande och problemskapande för unga<sup>18,</sup><sup>19</sup> En rad organisationer har producerat handledningar för hur man kan stärka säkerheten för barn på nätet, till exempel UNICEF<sup>20</sup>och WHO.<sup>21</sup> Det kan handla om att blocka, anmäla, våga anförtro sig till föräldrar och lärare, och inte minst förstå att de själva kan skada andra genom mobbning och obetänksamhet. Organisationer och stora techbolag jobbar hårt med frågorna. Undervisning är centralt. Lärare måste uppgraderas.</p>
<p>De där skrämmande mångmiljonsiffrorna kommer från det ”barnporrindustriella komplexet” där organisationer hetsar upp stämningen för att få fler donationer och resurser. NCMEC har 400 anställda och chefen tjänar 6 miljoner kronor per år.<sup>22</sup> Men inte ens de påstår i sina paradfall att de spränger nätverk som producerar våldtäktsmaterial. Ofta stoltserar de med att en ostraffad typ fångats med några nedladdade bilder på sin hårddisk.</p>
<h3>Är kontroll över vår kommunikation det verkliga målet?</h3>
<p>Jag kan inte hitta resonemang om hur stor nyttan (och skadan) av massavlyssning skulle bli. Hur många barn kommer att räddas genom just era åtgärder? Jämfört med andra, mindre ingripande, åtgärder? Hur stor blir marginalnyttan av att göra intrång i allas privata mobiler och datorer? En docent i datavetenskap påpekade att nyttan tycks rätt begränsad om man tar dina egna siffror på allvar. Av 15 miljoner påstått utsatta barn i EU säger du att 100 om året kan räddas genom massavlyssning.<sup>23</sup> Sannolikt kommer sådant förfarande att underkännas av både EU-domstolen och Europadomstolen för mänskliga rättigheter.<sup>24</sup></p>
<p>Eventuellt skulle du kunna hävda, Ylva, att så kallade spårningsorder om massavlyssning av appar eller tjänster inte alltid kommer att brukas. Ditt förslag om att motarbeta sexuella övergrepp mot barn innehåller många delar men just massavlyssningen verkar viktigast: Utan den blir vi blinda, påstår du ofta, samtidigt som du vilseleder genom att påstå att det skulle vara domstolar som 24 månader i taget kommer att beordra avlyssning. Enligt förslaget kan det vara en enskild byråkrat i något EU-land.</p>
<blockquote><p>Alla möjligheter att hantera ett problem ska uttömmas innan man griper till åtgärder som äventyrar användarnas säkerhet och integritet.</p></blockquote>
<p>Ylva, för en internetveteran och öppenhetsaktivist känns det som att återigen lyssna på domedagsprofeter under fildelningens barndom när en hel ungdomsgeneration ansågs bete sig fel. En WPR-analys hade visat samma binära problemformulering som er. Ungdomarna var då predatorer. Kulturskaparna måste skyddas från denna flock.</p>
<p>Det uppstod mängder av förslag på avlyssning, övervakning, blockering, avstängning från nätet. Internetleverantörer skulle tvingas strypa internetförbindelser så att bara e-post och kreditkortsbetalningar kunde skickas från datorn, medan de skulle ge bandbredd med fullt ös in till datorn. Vi skulle alla vara betalande konsumenter av information som de där uppe skulle sända till oss därnere.</p>
<p>Det dubbelriktade nätet, där alla kan ta del av <em>och</em> sprida information, ställer oss inför nya utmaningar hela tiden, även vad gäller sexualitet.</p>
<p>Inom en rad områden finns principen <em>ultima ratio</em>, sista utvägen. Man ska försöka med alla rimliga åtgärder innan man tar till det sista vapnet. Inom straffrätten ska en kriminalisering ske endast om man försökt lösa problem på andra vis, kanske genom beskattning, sociala insatser, utbildning.</p>
<p>Ylva, ditt förslag visar att vi behöver en <em>ultima ratio</em> för internet. Alla möjligheter att hantera ett problem ska uttömmas innan man griper till åtgärder som äventyrar användarnas säkerhet och integritet samt undergräver privat kommunikation. Du har inte visat att EU behöver massavlyssna sin befolkning.</p>
<p>&nbsp;</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="100610">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<p>1,<a href="https://chatcontrol.eu/"> https://chatcontrol.eu/</a></p>
<p>2, Europeiska kommissionen, Generaldirektoratet för migration och inrikes frågor. 2022-05-11. ”Förslag till Europaparlamentets och rådets förordning om fastställande av regler för att förebygga och bekämpa sexuella övergrepp mot barn.” Förslag COM(2022) 209 final. <a href="https://eur-lex.europa.eu/legal-content/SV/TXT/?uri=COM%3A2022%3A209%3AFIN">https://eur-lex.europa.eu/legal-content/SV/TXT/?uri=COM%3A2022%3A209%3AFIN</a>.</p>
<p>3, <a href="https://ec.europa.eu/commission/presscorner/detail/sv/speech_20_1413">https://ec.europa.eu/commission/presscorner/detail/sv/speech_20_1413</a></p>
<p>4, 2020 CyberTipline Reports by Electronic Service Providers (ESP). NCMEC. <a href="https://www.missingkids.org/cybertiplinedata#archives">https://www.missingkids.org/cybertiplinedata#archives</a></p>
<p>5, ”Preventing Child Exploitation on Our Apps”. 2021-02-23. <a href="https://about.fb.com/news/2021/02/preventing-child-exploitation-on-our-apps/">https://about.fb.com/news/2021/02/preventing-child-exploitation-on-our-apps/</a></p>
<p>6, <a href="https://www.politico.eu/article/norwegian-prime-minister-facebook-wrong-to-censor-vietnam-war-picture/">https://www.politico.eu/article/norwegian-prime-minister-facebook-wrong-to-censor-vietnam-war-picture/</a></p>
<p>7, ”Googles kamp mot material som visar sexuellt utnyttjande av barn på webben.” <a href="https://transparencyreport.google.com/child-sexual-abuse-material/reporting?hl=sv">https://transparencyreport.google.com/child-sexual-abuse-material/reporting?hl=sv</a></p>
<p>8, Bursztein, Elie, Einat Clarke, Michelle DeLaune, David M. Elifff, Nick Hsu, Lindsey Olson, John Shehan, Madhukar Thakur, Kurt Thomas, and Travis Bright. 2019. ”Rethinking the Detection of Child Sexual Abuse Imagery on the Internet.” <em>In</em> <em>The World Wide Web Conference</em>, 2601–7. San Francisco CA USA: ACM. <a href="https://doi.org/10.1145/3308558.3313482">https://doi.org/10.1145/3308558.3313482</a>.</p>
<p>9, ”Europaparlamentets och rådets direktiv 2011/92/EU av den 13 december 2011 om bekämpande av sexuella övergrepp mot barn, sexuell exploatering av barn och barnpornografi samt om ersättande av rådets rambeslut 2004/68/RIF.” 2011. <em>Europeiska unionens officiella tidning</em>, L 335: 1–14. <a href="https://doi.org/10.3000/19770820.L_2011.335.swe">https://doi.org/10.3000/19770820.L_2011.335.swe</a>.</p>
<p>10, <a href="http://fra.europa.eu/en/publication/2017/mapping-minimum-age-requirements/consent-sexual-activity-adult">http://fra.europa.eu/en/publication/2017/mapping-minimum-age-requirements/consent-sexual-activity-adult</a></p>
<p>11, Internet Watch Foundation. 2023. <em>The Annual Report 2022</em>. Cambridge. UK: Internet Watch Foundation IWF. <a href="https://annualreport2022.iwf.org.uk/wp-content/uploads/2023/04/IWF-Annual-Report-2022_FINAL.pdf">https://annualreport2022.iwf.org.uk/wp-content/uploads/2023/04/IWF-Annual-Report-2022_FINAL.pdf</a>.</p>
<p>12, AAPG on Social Media. 2020. <em>Se</em><em>lfie Generation: What’s behind the Rise of Self-Generated Indecent Images of Children Online?</em> The All-Party Parliamentary Group on Social Media. <a href="https://uploads-ssl.webflow.com/6109364ea51f0b14f7efeb5c/613b6ef4224bfeb57bfb0ca0_APPG%20on%20Social%20Media%20-%20Selfie%20Generation.pdf">https://uploads-ssl.webflow.com/6109364ea51f0b14f7efeb5c/613b6ef4224bfeb57bfb0ca0_APPG%20on%20Social%20Media%20-%20Selfie%20Generation.pdf</a>.</p>
<p>13, <a href="https://sverigesradio.se/avsnitt/ylva-johansson-behovs-fler-sakra-vagar-in-i-eu">https://sverigesradio.se/avsnitt/ylva-johansson-behovs-fler-sakra-vagar-in-i-eu</a></p>
<p>14, FBI. 2017-05-05. <em>”Playpen’ Creator Sentenced to 30 Years: ’Dark Web ‘Hidden Service’ Case Spawned Hundreds of Child Porn Investigations</em>.<em>”</em> <a href="https://www.fbi.gov/news/stories/playpen-creator-sentenced-to-30-years">https://www.fbi.gov/news/stories/playpen-creator-sentenced-to-30-years</a>.</p>
<p>15, The Berkman Center for Internet and Society. 2008. “ENHANCING CHILD SAFETY AND ONLINE TECHNOLOGIES.”. Harvard University. <a href="https://cyber.harvard.edu/pubrelease/isttf/">https://cyber.harvard.edu/pubrelease/isttf/</a></p>
<p><a href="#_ftnref16" name="_ftn16"></a><span style="font-size: 13.3333px;">16, </span>Finkelhor, David, Heather Turner, and Deirdre Colburn. 2022. <em>Prevalence of Online Sexual Offenses Against Children in the US</em>. <em>JAMA Network Open</em> 5 (10). <a href="https://jamanetwork.com/journals/jamanetworkopen/fullarticle/2797339">https://jamanetwork.com/journals/jamanetworkopen/fullarticle/2797339</a></p>
<p>17, <a href="https://www.adelaide.edu.au/press/titles/engaging">https://www.adelaide.edu.au/press/titles/engaging</a> (fri PDF, kapitel 2).</p>
<p>18, <a href="https://jamanetwork.com/journals/jamanetworkopen/fullarticle/2797339">https://jamanetwork.com/journals/jamanetworkopen/fullarticle/2797339</a></p>
<p>19, https://www.who.int/publications/i/item/9789240062085</p>
<p>20, <a href="https://www.unicef-irc.org/publications/650-child-safety-online-global-challenges-and-strategies.html">https://www.unicef-irc.org/publications/650-child-safety-online-global-challenges-and-strategies.html</a></p>
<p>21, <a href="https://www.who.int/publications/i/item/9789240062085">https://www.who.int/publications/i/item/9789240062085</a></p>
<p>22, <a href="https://www.missingkids.org/content/dam/missingkids/pdfs/2021-NCMEC-Form-990.pdf">https://www.missingkids.org/content/dam/missingkids/pdfs/2021-NCMEC-Form-990.pdf</a> (Form 8868, sidan 8)</p>
<p>23, <a href="https://sverigesradio.se/avsnitt/2178032#378">https://sverigesradio.se/avsnitt/2178032#378</a></p>
<p>24, <a href="https://www.theguardian.com/world/2023/may/08/eu-lawyers-plan-to-scan-private-messages-child-abuse-may-be-unlawful-chat-controls-regulation">https://www.theguardian.com/world/2023/may/08/eu-lawyers-plan-to-scan-private-messages-child-abuse-may-be-unlawful-chat-controls-regulation</a></p>
</div>
</div>
<div class="author-byline">Oscar Swartz är ekonom, genusvetare, frihetlig skribent och it-entreprenör. Han grundade internetleverantören Bahnhof och var medgrundare av gaymagasinet QX. Swartz gjorde sin militärutbildning på t<span style="font-weight: 400;">olkskolan och </span><span style="font-weight: 400;">läste ryska och öststatskunskap på Uppsala universitet.</span>
</div>
</div>

Massövervaka oss inte, Ylva!
Bilder: Pixabay och Unsplash. Collage: Kvartal.
Missvisande statistik från Facebook används nu som ursäkt för att driva igenom överstatlig övervakning av all kommunikation inom EU, skriver Oscar Swartz i ett öppet brev till kommissionären för inrikes frågor, Ylva Johansson.
Ordet barnporr tystar allt motstånd, men granskar man det som påstås vara en exponentiell ökning av bilder av övergrepp mot barn visar sig den stora majoriteten vara autorapporterat material som folk delat utan onda syften. Lagförslaget Chatcontrol riskerar att kriminalisera ungdomar och skapa ett övervakningssamhälle – men kommer knappast att hindra de verkliga övergreppen, menar Swartz.