Den bortglömda humanitära katastrofen

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/karolina-linden/">Karolina&nbsp;Lindén</a> | 25 november 2024<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%2Fden-bortglomda-humanitara-katastrofen%2F&amp;t=Den+bortgl%C3%B6mda+humanit%C3%A4ra+katastrofen"    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=Den+bortgl%C3%B6mda+humanit%C3%A4ra+katastrofen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-bortglomda-humanitara-katastrofen%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%2Fden-bortglomda-humanitara-katastrofen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den bortglömda humanitära katastrofen&body=https://kvartal.se/artiklar/den-bortglomda-humanitara-katastrofen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/157664/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/157664/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="kv-art-ext-sep"></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%2Fden-bortglomda-humanitara-katastrofen%2F&amp;t=Den+bortgl%C3%B6mda+humanit%C3%A4ra+katastrofen"    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=Den+bortgl%C3%B6mda+humanit%C3%A4ra+katastrofen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-bortglomda-humanitara-katastrofen%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%2Fden-bortglomda-humanitara-katastrofen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den bortglömda humanitära katastrofen&body=https://kvartal.se/artiklar/den-bortglomda-humanitara-katastrofen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/157664/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/157664/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 9 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/157664"    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-157664">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "157664"></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 ">Parallellt med händelseutvecklingen i Ukraina och Gaza är det sedan våren 2023 inbördeskrig i Sudan. Uppskattningsvis 150 000 personer har dödats och över 11 miljoner har flytt sina hem. Runt 25 miljoner människor är i behov av humanitär hjälp. Svält i sin värsta form har deklarerats för första gången på decennier.</p>
</div>
<div class="rest-of-article ">
<p>Medierapporteringen om kriget är nästan obefintlig. Det finns flera skäl till det. Dels är Afrika en underrapporterad kontinent generellt. Sudans historia av diktatur och låga nivå av pressfrihet gör dessutom att journalister som vill bevaka kriget måste hantera både säkerhetsrisker kopplat till kriget, men också risker från själva statsapparaten. Rent logistiskt har också vissa utrikeskorrespondenter vittnat om svårigheter att få visum. För de som ändå vill bevaka kriget är bakgrunden dessutom komplicerad och det finns inget skåpmatsnarrativ att hänga upp rapporteringen på, vilket gör det mer arbetskrävande att skriva om.</p>
<p>Kanske kan den här texten underlätta något i det avseendet.</p>
<p>Det finns många felaktiga föreställningar om varför det pågår <a href="https://ucdp.uu.se/country/625">ett inbördeskrig</a> i Sudan. Många blandar ihop landet med konflikter i Sahelregionen, dit Sudan gränsar.<sup>1</sup></p>
<p>Till skillnad från staterna i Sahel, som var franska kolonier och som nu sett ett franskt tillbakadragande följt av jihadism och ryska privata säkerhetsföretag, var Sudan tvärtom en brittisk-egyptisk koloni och har en helt annan roll och förutsättningar när det gäller geografi, historia och politiskt liv.</p>
<p>För andra förs tanken till tidigare konflikter i Sudan, primärt de som rört Sydsudan eller Darfur. De två inbördeskrigen om Sydsudan 1955–1972 och 1983–2005 samt Darfurkonflikten 2003–2020 handlade framför allt om etnicitet, religion och fördelningen av resurser. Sydsudan blev självständigt 2011 som en följd av inbördeskriget. Darfur, ett område stort som Spanien i västra Sudan, spelar dock en stor roll även i det nuvarande inbördeskriget och det har <a href="https://www.hrw.org/report/2024/05/09/massalit-will-not-come-home/ethnic-cleansing-and-crimes-against-humanity-el">rapporterats</a> om att arabiska muslimska stammar utsatt afrikanska folkgrupper för etnisk rensning, likt i Darfurkonflikten i början av 00-talet.</p>
<h2>Cykler av revolutioner och militärkupper</h2>
<p>Vad rör då de centrala konfliktlinjerna i Sudans inbördeskrig? Kort sammanfattat är kriget en kamp om politisk makt och ekonomiska resurser mellan två militära aktörer i ett land som är fyra gånger större än Sverige till ytan och har en befolkning på över 50 miljoner: Sudans försvarsmakt (SAF), under ledning av general <strong>Abdel Fattah al-Burhan</strong>, och milisen Snabbstödsstyrkorna (RSF), under ledning av general <strong>Mohamed Hamdan Dagalo</strong>, känd som ”Hemedti”.</p>
<p>Sudans politiska liv har formats av cykler av revolution, militärkupper och diktatur. En anledning till detta är att militären har en dominerande ställning. Sedan självständigheten 1956 hade de avsatt tre civila regeringar. Händelserna 2019–2023 skulle komma att innebära en fjärde gång.</p>
<figure id="attachment_157707" aria-describedby="caption-attachment-157707" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-157707 size-full" src="https://kvartal.se/wp-content/uploads/2024/11/sdlzRoYBs4S50w-nl.jpg" alt="kvartal" width="1024" height="700" data-wp-pid="157707" srcset="https://kvartal.se/wp-content/uploads/2024/11/sdlzRoYBs4S50w-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2024/11/sdlzRoYBs4S50w-nl-300x205.jpg 300w, https://kvartal.se/wp-content/uploads/2024/11/sdlzRoYBs4S50w-nl-768x525.jpg 768w, https://kvartal.se/wp-content/uploads/2024/11/sdlzRoYBs4S50w-nl-600x410.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-157707" class="wp-caption-text">General Mohamed Hamdan Dagalo, ledaren för RSF. Foto: TT</figcaption></figure>
<p>Diktatorn <strong>Omar al-Bashir</strong> såg därmed SAF som ett hot mot sitt styre. Som motvikt valde han därför att befordra Hemedtis milis i Darfur till personlig vaktstyrka och skapade Snabbstödsstyrkorna (RSF) 2013. Beslutet skulle dock visa sig vara en felberäkning. År 2019 skulle både SAF och RSF avsätta honom efter 30 år vid makten.</p>
<p>För att hålla SAF, RSF, sitt parti och nationella underrättelse- och säkerhetstjänsten lojala delade al-Bashir ut ägande och kontroll över statliga företag, industri och naturresurser till dem. Det gjorde att de utvecklades till mäktiga ekonomiska aktörer med kontroll över en stor del av Sudans ekonomi. SAF kontrollerade ungefär 200 företag och industrier och var verksamt i en stor mängd branscher inom allt från telekommunikation och vattendistribution till fastigheter, drift av turistattraktioner och import av basvaror som bränsle och vete. RSF kontrollerade samtidigt i stort Sudans guldmarknad, men hade även ägande inom områden som bygg och entreprenad samt ägde jordbruksmark och fastigheter.</p>
<p>De militära aktörerna blev alltså förmögna medan Sudans ekonomi befann sig i djup kris. I december 2018 började folkliga protester mot höjda priser på basvaror. Demonstrationerna bytte snabbt fokus till att al-Bashir skulle avgå.</p>
<h2>En kort tid av optimism</h2>
<p>al-Burhan och Hemedti deltog båda i palatskuppen som avsatte al-Bashir 2019 till följd av de folkliga protesterna. Befolkningen lät sig dock inte nöjas med att al-Bashir ersattes med en ny general, utan krävde civilt styre. Efter internationell medling gick Sudan in i en demokratisk övergångsperiod där militära och civila aktörer skulle samregera. Både SAF och RSF ingick i denna. Några minns kanske detta som en optimistisk tid på Afrikas horn.</p>
<p>Den skulle komma att bli kort.</p>
<p>Den civilt ledda regeringen spillde inte någon tid och genomförde ett stort antal positiva reformer åren 2019–2021. De avskaffade sharialagarna, skilde stat och religion åt, ingick fredsavtalet i Juba (<em>Juba Peace Agreement</em>, JPA) som formellt avslutade Darfurkonflikten och genomförde flera reformer i ekonomin för att motverka fattigdom. Sudan kvalificerade sig för skuldavskrivning och fick åter delta i världshandeln efter att USA via <strong>Donald Trump</strong> lyfte sanktionerna mot Sudan efter 30 år.</p>
<p>Vad kunde gå fel?</p>
<p>Mycket, skulle det visa sig. Den civila övergångsregeringen hängde hela tiden på en skör tråd. Trots alla vackra ord hade de militära aktörerna inget som helst intresse av att lämna över sin makt eller de enorma ekonomiska tillgångar i form av statliga företag, naturresurser och industri som de lagt beslag på under al-Bashir-tiden. När den civila regeringen inrättade en anti-korruptionskommitté som delvis hade till syfte att återföra de företag och industri som kontrollerades av de militära aktörerna till civil statlig kontroll var måttet rågat. I oktober 2021 gjorde SAF och RSF en gemensam militärkupp och satte den civila premiärministern <strong>Abdalla Hamdok</strong> i husarrest. Civilbefolkningen gick åter ut i omfattande protester och skanderade att militären skulle återvända till kasernerna och lämna politiken i fred.</p>
<blockquote><p>Sudans guldgruvor har väckt Rysslands intresse.</p></blockquote>
<p>Internationell medling av bland annat FN, det regionala samarbetsorganet på Afrikas horn (IGAD) och Afrikanska unionen resulterade i en omfattande plan för att ”rädda” övergångsperioden. Att implementera fredsavtalet i Juba var en del av denna, men skulle komma att agera katalysator för krig. En central fråga i fredsavtalet var (som så ofta) att skapa en enad nationell armé och införliva miliserna i denna. Här gick SAF och RSF helt i klinch med varandra. RSF kunde inte acceptera att behöva lyda under SAF-befäl utan ville stå direkt under statsöverhuvudet. De ville också ha hela tio år på sig att genomföra förändringarna kopplade till reformen i säkerhetssektorn, vilket SAF inte kunde acceptera.</p>
<p>Så i stället för en återgång till övergångsstyre med sikte på allmänna val ökade spänningarna och i april 2023 utbröt kriget. Sudans huvudstad, som inte haft stridigheter på över 100 år, raserades.</p>
<p>Två generaler har alltså startat ett krig som raserar ett helt land och skapat världens största kris i nuläget. Hur är det möjligt?</p>
<h2>En arena för andra staters intressen</h2>
<p>Kriget i Sudan har nu pågått i 18 månader för att det finns omfattande intressen för andra stater i Sudan, och de är många. När FN:s särskilda sändebud för Sudan, <strong>Ramtane Lamamra</strong>, kallade intressenter i Sudans fredsprocess till möte deltog inte mindre än 32 stycken! Gulfstaterna, grannländer, FN:s säkerhetsråd, USA, EU, Afrikanska unionen, IGAD, Arabförbundet, med flera.</p>
<p>Sudan är intressant på grund av sitt strategiska läge, tillgången på naturresurser och sin roll i regionen. Sudan är ett av Afrikas till ytan största länder. Det har drygt 800 kilometer kust längs Röda havet, en av världens viktigaste vattenvägar. Flera stater uppvaktar Sudan för att få anlägga en militärbas i Port Sudan, däribland Ryssland. Sudan ligger mitt emellan MENA-regionen och subsahariska Afrika. Det har sju grannländer och överlappar Afrikas horn med Sahelregionen.</p>
<figure id="attachment_157704" aria-describedby="caption-attachment-157704" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-157704 size-full" src="https://kvartal.se/wp-content/uploads/2024/11/sdlGkRr_v7sZDk-nl.jpg" alt="kvartal" width="1024" height="684" data-wp-pid="157704" srcset="https://kvartal.se/wp-content/uploads/2024/11/sdlGkRr_v7sZDk-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2024/11/sdlGkRr_v7sZDk-nl-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2024/11/sdlGkRr_v7sZDk-nl-768x513.jpg 768w, https://kvartal.se/wp-content/uploads/2024/11/sdlGkRr_v7sZDk-nl-600x401.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-157704" class="wp-caption-text">Flyktingar från Sudan i ett läger i Tchad, hösten 2024. Foto: Sam Mednick/TT</figcaption></figure>
<p>Båda regionerna är tätt sammanflätade och har många konflikter som påverkar varandra. Nilens två bifloder (blå och vita Nilen) flyter samman i Khartoum innan den fortsätter norrut in i Egypten. Det har gjort att Sudan hamnat mitt emellan konflikten mellan Egypten och Etiopien om den stora damm i bifloden blå Nilen (<em>Grand Ethiopian Renaissance Dam</em>, GERD) som Etiopien byggt, vilken Egypten ser som ett existentiellt hot mot sin dricksvattenförsörjning.</p>
<p>Sudans guldgruvor (som kontrolleras av RSF) har väckt Rysslands intresse. De vaktas av Wagnergruppen och är en del i Rysslands försök att kringgå sanktionerna på grund av kriget i Ukraina. (Läs mer om Rysslands agerande i Sudan och Afrika <a href="https://www.foi.se/rapportsammanfattning?reportNo=FOI%20Memo%208090">här</a>.)</p>
<h2>Sammankopplade konflikter</h2>
<p>De största externa aktörerna är Förenade arabemiraten (FAE) och Egypten, som stöttar respektive sida med vapen och ekonomiskt stöd. FAE har bland annat under <a href="https://www.nytimes.com/2024/09/21/world/africa/uae-sudan-civil-war.html">humanitär täckmantel</a> levererat drönare, vapen och materiel till RSF. Egypten har <a href="https://www.wsj.com/world/africa/ignoring-u-s-calls-for-peace-egypt-delivered-drones-to-sudans-military-6f7fdcda">stöttat</a> med drönare, underrättelser och taktiskt stöd. Staterna förnekar själva detta, men motsägs av flera uppgifter. Rysslands band till RSF har gjort att Ukraina har stöttat SAF och <a href="https://www.kyivpost.com/post/27637">bidragit</a> med specialstyrkor för en offensiv i Khartoum. Iran har <a href="https://www.bloomberg.com/news/articles/2024-01-24/iran-supplies-sudan-army-with-drones-as-civil-war-continues">stöttat</a> SAF med drönare. Även Turkiet och Qatar ska ha <a href="https://www.economist.com/briefing/2024/08/29/the-ripple-effects-of-sudans-war-are-being-felt-across-three-continents">stöttat</a> med små och lätta vapen respektive finansiellt stöd till SAF.</p>
<blockquote><p>Konflikter har (som bekant) en tendens att sprida sig.</p></blockquote>
<p>Grannländerna har gett olika stöd till respektive sida baserat på dynamiken på Afrikas horn, där länder och konflikter är tätt sammankopplade. Egyptens stöd till SAF gör att rivalen Etiopien stöttar RSF. Eritrea, som ser Etiopien som sin fiende, stöttar därmed SAF.</p>
<figure id="attachment_157710" aria-describedby="caption-attachment-157710" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-157710 size-full" src="https://kvartal.se/wp-content/uploads/2024/11/sdlxxGQNMviylg-nl.jpg" alt="kvartal" width="1024" height="576" data-wp-pid="157710" srcset="https://kvartal.se/wp-content/uploads/2024/11/sdlxxGQNMviylg-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2024/11/sdlxxGQNMviylg-nl-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2024/11/sdlxxGQNMviylg-nl-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2024/11/sdlxxGQNMviylg-nl-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2024/11/sdlxxGQNMviylg-nl-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-157710" class="wp-caption-text">Strider i Khartoum, september 2024. Foto: Rashed Ahmed/TT</figcaption></figure>
<p>Och grannländerna påverkas även om de inte tar tydlig ställning. Sydsudans ekonomi hotas nu av kollaps eftersom kriget i Sudan gör att deras oljepipeline som går genom Sudan inte går att underhålla ordentligt. Stridigheterna i Darfur riskerar att spilla över på Tchad.</p>
<p>Flera varnar också för kriget skulle kunna få konflikten i Tigray i Etiopien att blossa upp igen.</p>
<h2>Det värsta har inte hänt ännu</h2>
<p>Man skulle kunna tro att den förfärliga situation vi nu ser skulle vara nog, men det kan bli värre, mycket värre. USA:s underrättelsechef skrev i sin årliga <a href="https://www.dni.gov/files/ODNI/documents/assessments/ATA-2024-Unclassified-Report.pdf">hotanalys</a> 2024 att Sudan, med sitt strategiska läge i Sahel och Nordafrika, på grund av kriget åter skulle kunna bli ett drivhus för terrorister och kriminella nätverk. ”Åter” är ett nyckelord här. Sudan huserade på 1990-talet <strong>Usama bin Ladin</strong> med den dåvarande diktatorn al-Bashirs goda minne.</p>
<p>Flera bedömare talar nu också om att Sudan håller på att kollapsa som stat och sönderfalla i två huvudsakliga maktcentra. Inom fältet kallas det för ett ”Libyenscenario”, med skillnaden att Sudan är ett större land med en ungefär sju gånger så stor befolkning, vilket gör att konsekvenserna kan bli ännu större. Sudankännaren <strong>Cameron Hudson</strong> <a href="https://www.csis.org/analysis/avoiding-libya-scenario-sudan#:~:text=Avoiding%20the%20%E2%80%98Libya%20Scenario%E2%80%99%20in%20Sudan.%20Photo:%20-/AFP/Getty%20Images.%20Commentary">ser framför sig</a> 25 miljoner människor på flykt, ett krigsherrestyre och en bottenlös avgrund som destabiliserar hela Afrikas horn.</p>
<p>Konflikter har (som bekant) en tendens att sprida sig och dra med sig andra i fallet. Ett Sudan i fritt sönderfall riskerar att dra med sig resten av regionen. Vilka konsekvenser detta får för fred och säkerhet, flyktingströmmar, internationell handel och sjöfart kan vi bara spekulera i, men de flesta förstår att det är ett scenario vi inte vill uppleva.</p>
<p>Här och nu dör kvinnor, män, barn och gamla som flyr en maktkamp mellan två generaler.</p>
<p>Nu vet du i alla fall varför.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="157664">  <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>
<ol>
<li>Enligt geografiska och klimatologiska definitioner ingår även Sudan i Sahelbältet, men som politisk definition brukar man oftast bara inkludera Mauretanien, Mali, Burkina Faso, Niger och Tchad.</li>
</ol>
</div>
</div>
<div class="author-byline">Karolina Lindén är verksam som analytiker på FOI, aktuell med <a href="https://foi.se/rapportsammanfattning?reportNo=FOI%20Memo%208616">rapporten</a> &#8221;Inbördeskrig i Sudan: en kamp om politisk makt och ekonomiska intressen&#8221;.
</div>
</div>
