Irans agenda för att
påverka omvärlden

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-170555"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="910" data-tin="1009" data-pid="170555" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="SXJhbnMgYWdlbmRhIGbDtnIgYXR0PGJyPnDDpXZlcmthIG9tdsOkcmxkZW4=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci82LTU4LWlyYW5zLWFnZW5kYS1mb3ItYXR0LXBhdmVya2Etb212YXJsZGVuLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNi01OC1pcmFucy1hZ2VuZGEtZm9yLWF0dC1wYXZlcmthLW9tdmFybGRlbi5tcDM=">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/arvin-khoshnood/">Arvin&nbsp;Khoshnood</a>, <a href="https://kvartal.se/medverkande/magnus-norell/">Magnus&nbsp;Norell</a> och <a href="https://kvartal.se/medverkande/ardavan-khoshnood/">Ardavan&nbsp;Khoshnood</a> | 19 mars 2025<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%2Firans-agenda-for-att-paverka-omvarlden%2F&amp;t=Irans+agenda+f%C3%B6r+att%3Cbr%3Ep%C3%A5verka+omv%C3%A4rlden"    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=Irans+agenda+f%C3%B6r+att%3Cbr%3Ep%C3%A5verka+omv%C3%A4rlden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Firans-agenda-for-att-paverka-omvarlden%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%2Firans-agenda-for-att-paverka-omvarlden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Irans agenda för att<br>påverka omvärlden&body=https://kvartal.se/artiklar/irans-agenda-for-att-paverka-omvarlden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170555/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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%2Firans-agenda-for-att-paverka-omvarlden%2F&amp;t=Irans+agenda+f%C3%B6r+att%3Cbr%3Ep%C3%A5verka+omv%C3%A4rlden"    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=Irans+agenda+f%C3%B6r+att%3Cbr%3Ep%C3%A5verka+omv%C3%A4rlden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Firans-agenda-for-att-paverka-omvarlden%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%2Firans-agenda-for-att-paverka-omvarlden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Irans agenda för att<br>påverka omvärlden&body=https://kvartal.se/artiklar/irans-agenda-for-att-paverka-omvarlden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/170555/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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 class="listen" href="https://kvartal.se/artiklar/irans-agenda-for-att-paverka-omvarlden/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</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 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/7c0068bf-e4e6-41ec-af59-cdfbc7416744"    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-170555">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "170555"></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 ">Sedan den islamiska revolutionen 1979, då landets kung <strong>Mohammad Reza Shah Pahlavi</strong> störtades och islamiska republiken etablerades, har landets regim på olika sätt försökt sprida sin revolution samt påverka och förfölja iranier i exil.</p>
</div>
<div class="rest-of-article ">
<p>Påverkansoperationerna mot iranier i exil inleddes omedelbart. Tiotusentals iranier flydde under de första åren och ännu fler lämnade Iran under det långa kriget mot Irak på 1980-talet. Och de flesta som flydde hade familj och vänner kvar i landet.</p>
<p>Konsekvensen blev att den iranska regimen haft många möjligheter att utöva utpressning mot iranier både i och utanför Iran, något som utnyttjats till fullo. Detta kan ta sig olika uttryck med alltifrån mord på regimmotståndare utanför Iran, även i Sverige<sup>1</sup>, till påtryckningar mot iranier i exil att spionera och infiltrera de nya hemländernas olika institutioner.<sup>2</sup></p>
<p>Till detta ska läggas en trend som i och för sig inte är helt ny, men som uppmärksammats under det senaste året. Det gäller det faktum att regimen i Teheran försökt mörda svenska medborgare<sup>3</sup>, samt rekryterar kriminella gäng för att utföra dåd i Sverige.<sup>4</sup></p>
<p>Ett annat, ofta mycket effektivt sätt, att bedriva påverkansoperationer är via etablerade exiliranier, som förmås hjälpa regimen i Teheran att sälja in sitt budskap genom akademiska artiklar, konferenser och föreläsningar. Ett sådant initiativ kom till allmän kännedom under 2024 då tusentals läckta e-postmeddelanden från Iran visade hur forskare/akademiker i Väst rekryterats av iranska utrikesdepartementet för att i olika sammanhang föra fram den iranska regimens ståndpunkter.<sup>5</sup> Även här dök svenska exempel upp.<sup>6</sup></p>
<p>Det bör understrykas att hotet främst riktar sig mot exiliranier som är kritiska till regimen i Teheran och aktivt arbetar mot den, och därmed är de mest utsatta. Det är ett betydligt större problem än vad svenskar i gemen känner till. Lägg därtill att svenska regeringar under lång tid inte på allvar har stått upp mot de iranska operationerna, så har vi ett stort och möjligen växande problem att hantera.</p>
<h2>Makt genom ett nätverk av institutioner</h2>
<p>Islamiska Republiken Iran är en totalitär stat där all makt är koncentrerad hos den högste ledaren, <strong>Ali Khamenei</strong>. Efter att ha tillträtt som landets diktator 1989 konsoliderade han snabbt sin makt över samtliga statliga institutioner. Genom sitt kontrollorgan, <em> Ledarens hus </em>(<em>Beyt-e rahbari</em>), övervakar han varje aspekt av den islamiska regimens politik och säkerställer att alla avgörande beslut, i synnerhet gällande säkerhets- och utrikesfrågor, fattas i enlighet med hans vilja.<sup>7</sup> Således genomsyras hela samhället av övervaknings- och kontrollmekanismer.</p>
<p>Khamenei utövar makt genom ett nätverk av institutioner som direkt eller indirekt rapporterar till honom. En av dessa institutioner är <em>Väktarrådet</em>, som övervakar val och godkänner kandidater, vilket säkerställer att endast de mest lojala individerna kan inneha politiska ämbeten.<sup>8</sup> Khamenei har även absolut kontroll över domstolsväsendet, som används för att kväsa oppositionen genom summariska rättsprocesser, långa fängelsestraff och i många fall avrättningar. Den islamiska regimen kontrollerar även media och utbildningssektorn för att säkerställa den ideologiska indoktrineringen.</p>
<blockquote><p>Nyligen skrev Ryssland och regimen i Iran ett 20-årigt strategiskt avtal.</p></blockquote>
<p>Utöver Väktarrådet är två av de mest betydelsefulla institutionerna för att upprätthålla Khameneis makt Islamiska revolutionsgardet (IRGC) och Underrättelseministeriet (VAJA).</p>
<p>Islamiska Republikens utrikespolitik är starkt präglad av <em>Umm al-Qura</em>-doktrinen, som innebär att Iran betraktar sig självt som den islamiska världens ledare och därför har en skyldighet att sprida sin ideologi globalt med syftet att etablera ett islamistiskt världsstyre. Inom ramen för doktrinen anser regimen sig ha rätt att prioritera sin egen överlevnad framför muslimska liv och islamiska mål, om det gynnar dess makt och säkerställer högste ledarens auktoritet.</p>
<h2>Europa som strategisk arena</h2>
<p>Den islamiska regimen betraktar Europa som en strategiskt viktig arena för att både främja sina egna geopolitiska intressen och begränsa inflytandet från sina fiender, särskilt USA och Israel. Ett av regimens viktigaste mål här är att neutralisera oppositionella grupper och individer som verkar för att störta regimen.</p>
<p>Utöver att bekämpa oppositionen har den islamiska regimen även politiska, ekonomiska och militära intressen i Europa. Genom diplomatiska kanaler försöker Teheran stärka sina relationer med europeiska länder för att motverka internationella sanktioner och skaffa sig teknologiska resurser, inte minst för sin militärindustri. Den islamiska regimen har under lång tid försökt kringgå sanktioner genom att smuggla teknologi och material som är avgörande för dess kärnenergiprogram och militära utveckling.<sup>9</sup> Forsknings- och industrispionage är därför inte helt ovanligt.</p>
<p>Islamiska Republiken upprätthåller nära relationer med Ryssland och Kina, två länder som delar dess intresse av att utmana den liberala världsordningen. Särskilt Ryssland har spelat en central roll genom att erbjuda både militärt stöd till regimen utöver diplomatiskt skydd i internationella organisationer som FN.</p>
<p>I gengäld har den islamiska regimen bistått Ryssland med strategiskt viktiga resurser. Ett av de mest uppmärksammade exemplen är Islamiska Republikens stöd till Rysslands krig i Ukraina, där Iran har försett Ryssland med drönare och missiler som har använts mot ukrainska städer. Genom detta samarbete har Iran befäst sin roll som en av de främsta aktörerna som underminerar europeisk säkerhet. Nyligen skrev också Ryssland och regimen i Iran ett 20-årigt strategiskt avtal.<sup>10</sup></p>
<p>Islamiska Republikens långsiktiga strategi i Europa bygger på en kombination av diplomati och underrättelseoperationer, inklusive påverkanskampanjer och terrorism.</p>
<h2>Underrättelseministeriets centrala roll</h2>
<p>Underrättelseministeriet i Iran, formellt känt som <em>Vezarat-e Ettela’at-e Jomhori-e Eslami</em> (VAJA), är en av landets främsta och mest centrala säkerhetsinstitutioner. Det bildades 1983 och har sedan dess varit djupt involverat i både inhemska och internationella operationer. Ministeriet spelar en avgörande roll i övervakning samt infiltration av oppositionella grupper samt genomförande av både subversiva så väl som terroroperationer på global nivå.<sup>11</sup></p>
<p>Ministeriet använder sig av en kombination av klassisk underrättelseverksamhet och rena terroroperationer, där mord på dissidenter och övervakning av oppositionella är centrala inslag. Genom samarbete med Islamiska revolutionsgardet och andra säkerhetsorgan säkerställer underrättelseministeriet att den islamiska regimen kan behålla sin makt genom ständigt och oavbrutet förtryck. Ministeriet är, som framgår av namnet, en del av regeringen och styrt av presidenten, men i valet av minister är det Khamenei som har slutordet.<sup>12</sup></p>
<p>Under ledning av <strong>Esmaeil Khatib</strong>, som utnämndes av president <strong>Ebrahim Raisi</strong> 2021 och fick fortsatt förtroende efter att <strong>Masoud Pezeshkian</strong> blev ny president, har underrättelseministeriet blivit mer aggressivt. Khatib har nära kopplingar till både Högste ledaren Ali Khamenei och Revolutionsgardet, vilket tyder på en ökad samordning mellan dessa organisationer.<sup>13</sup>​ Ministeriet har historiskt varit ansvarigt för omfattande utrensningar av dissidenter och har genomfört politisk förföljelse, tortyr, avrättningar och spionage både i Iran och utomlands​.<sup>14</sup></p>
<p>Underrättelseministeriet opererar också genom Irans diplomatiska nätverk, vilket exemplifieras av fallet med den iranska diplomaten <strong>Assadollah Assadi</strong>, som 2018 planerade en terrorattack i Paris mot iranska oppositionella men stoppades av europeiska säkerhetstjänster.<sup>15</sup> ​Det har även intima underrättelsesamarbeten med både Ryssland och Kina, vilket har gett Iran tillgång till avancerad övervakningsteknik och metoder för att bekämpa sina motståndare.<sup>16</sup></p>
<h2>Islamiska revolutionsgardets roll</h2>
<p>Islamiska revolutionsgardet grundades 1979 som en paramilitär organisation lojal mot den Islamiska revolutionen. Det innehåller samma sektioner som den reguljära militären men är betydligt mäktigare än den. Revolutionsgardets flygvapen kontrollerar till exempel den islamiska regimens missiler och är även de som konstruerar dem. Vidare har Revolutionsgardet omfattande ekonomiska och politiska aktiviteter inom Iran och internationellt​.<sup>17</sup></p>
<p>En av de mest inflytelserika enheterna är Qods-styrkan, som är organisationens enhet för utrikesoperationer. De har till uppgift att genomföra asymmetrisk krigföring, terrorism och subversiva operationer. Revolutionsgardet har spelat en nyckelroll i att stödja Hizbollah i Libanon, Hamas i Gaza, Houthi-rebellerna i Jemen, Shia-miliser i Irak och Syrien, samt andra proxygrupper i Mellanöstern​. Genom dessa grupper har Iran kunnat destabilisera regimer och expandera sitt inflytande i regionen.<sup>18</sup></p>
<p>Qods-styrkan har också varit direkt involverad i flera internationella terroristattacker och mord på oppositionella. Ett exempel är bombningen av det judiska AMIA-centret i Buenos Aires 1994, där Qods-styrkan och Hizbollah, enligt argentinska utredare, genomförde attacken där 85 människor dödades och över 300 skadades på direkt order från Irans högsta ledning​. Revolutionsgardet har också försökt genomföra attacker i Europa, som planeringen av mordförsök på oppositionella i Frankrike, Danmark och Nederländerna​.</p>
<p>Efter Qods-styrkan är nog Revolutionsgardets underrättelsegren den mäktigaste enheten. Organisationen konkurrerar ofta med Underrättelseministeriet om inflytande och har egna nätverk för spionage, cyberkrigföring och terrorism.</p>
<h2>Aggressiva operationer</h2>
<p>Iran har sedan 1979 genomfört en rad aggressiva operationer på global nivå. Dessa operationer inkluderar politiska mord, terrorism, spionage, cyberkrigföring och systematisk användning av diplomater för att genomföra subversiva handlingar.<sup>19</sup> Syftet med dessa operationer är att eliminera oppositionella, stärka regimens inflytande utomlands och underminera Irans fiender, särskilt västliga demokratier, Israel och rivaliserande länder i Mellanöstern.</p>
<blockquote><p>En särskilt anmärkningsvärd aspekt av Irans internationella operationer är dess systematiska användning av diplomater som underrättelseagenter och terrorister.</p></blockquote>
<p>Under de senaste fyra decennierna har mer än 160 iranier mördats av regimens agenter i olika länder, liksom av lokala ombud och legosoldater.<sup>20</sup> Ett av de mest uppmärksammade fallen är Mykonos-attentatet i Berlin 1992, där fyra iranska dissidenter sköts ihjäl på en restaurang. Den tyska rättsprocessen som följde pekade ut den iranska statens högsta ledning som ansvarig för attacken, vilket ledde till en diplomatisk kris mellan Iran och Europa. Andra exempel på politiska attentat inkluderar mordet på prins <strong>Shahriar Shafigh</strong> i Paris 1979, mordet på Irans sista premiärminister under shahens styre, <strong>Shapour Bakhtiar</strong>, i Frankrike 1991 samt mordet på <strong>Reza Mazlouman</strong> som senare bytte namn till <strong>Kourosh Aryamanesh</strong>, också i Frankrike i maj 1996. Aryamanesh var vice utbildningsminister innan den islamiska revolutionen och förblev en högljudd kritiker mot islamistregimen i Iran.</p>
<p>Utöver dessa riktade mord har Iran också försökt genomföra flera storskaliga terroristattacker i västvärlden. År 2018 arresterades <strong>Assadollah Assadi</strong>, en iransk diplomat stationerad i Österrike, för att ha planerat en bombattack mot en sammankomst för iranska oppositionella i Paris. Utredningen visade att Assadi var en operativ ledare för Underrättelseministeriet i Europa och använde diplomatiska resurser för att smuggla sprängmedel till attentatsmännen.<sup>21</sup> I ett annat fall avslöjade amerikanska myndigheter 2011 en iransk komplott att mörda Saudiarabiens ambassadör i Washington genom att använda mexikanska narkotikakarteller som utförare.<sup>22</sup> Dessa exempel visar att Iran är villigt att använda extrema medel för att eliminera sina motståndare även på västerländsk mark.</p>
<h2>Spioneri i Europa, Nordamerika och Latinamerika</h2>
<p>Spionage är en annan central komponent i Irans verksamhet. Underrättelseministeriet och Revolutionsgardet har upprättat omfattande nätverk av agenter i Europa, Nordamerika och Latinamerika, där de bedriver övervakning av oppositionella, rekryterar sympatisörer och försöker påverka politiska beslutsfattare.<sup>23</sup> I Sverige och Tyskland har flera individer gripits för att ha spionerat på exiliranier och rapporterat till underrättelseministeriet.<sup>24</sup> I Latinamerika har Iran använt sitt diplomatiska nätverk för att etablera underrättelseoperationer och smuggla vapen till sina allierade, såsom Hizbollah.<sup>25</sup></p>
<p>En särskilt anmärkningsvärd aspekt av Irans internationella operationer är dess systematiska användning av diplomater som underrättelseagenter och terrorister. Fallet med Assadollah Assadi är det mest kända exemplet, men iranska diplomater har även utvisats från Nederländerna, Frankrike och Tyskland för inblandning i mordförsök på oppositionella. Irans ambassader fungerar ofta som logistiska baser för underrättelse- och terroristverksamhet, där diplomater utnyttjar sin status för att koordinera operationer utan att direkt riskera åtal.<sup>26</sup><a href="#_ftnref1" name="_ftn1"></a></p>
<p><em>Del två i denna artikelserie publiceras imorgon.</em></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="170555">  <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><a href="https://www.svd.se/a/fe6514f7-c96b-356f-b578-3c14d48e5c66/sapo-skyddar-irans-flyktingspioner">https://www.svd.se/a/fe6514f7-c96b-356f-b578-3c14d48e5c66/sapo-skyddar-irans-flyktingspioner</a>; <a href="https://ardavan.se/rafsanjani-ahmad-reza-jalali-och-konsten-att-manipulera/">https://ardavan.se/rafsanjani-ahmad-reza-jalali-och-konsten-att-manipulera/</a></li>
<li><a href="https://www.tv4.se/artikel/3NSKIhooInC1dFVHCwos4G/misstanken-irans-ambassad-foersoekte-rekrytera-svensk-polis">https://www.tv4.se/artikel/3NSKIhooInC1dFVHCwos4G/misstanken-irans-ambassad-foersoekte-rekrytera-svensk-polis</a></li>
<li><a href="https://www.expressen.se/nyheter/sverige/iranskt-agentpar-misstanks-ha-planerat-mord-pa-svenskar/">https://www.expressen.se/nyheter/sverige/iranskt-agentpar-misstanks-ha-planerat-mord-pa-svenskar/</a></li>
<li><a href="https://sakerhetspolisen.se/ovriga-sidor/nyheter/nyheter/2024-05-30-iran-anvander-kriminella-i-sverige.html">https://sakerhetspolisen.se/ovriga-sidor/nyheter/nyheter/2024-05-30-iran-anvander-kriminella-i-sverige.html</a>; <a href="https://www.dn.se/sverige/iran-anvander-sig-av-kriminella-gang-i-fler-lander/">https://www.dn.se/sverige/iran-anvander-sig-av-kriminella-gang-i-fler-lander/</a></li>
<li><a href="https://content.iranintl.com/en/investigates/inside-tehran-softwar/index.html">https://content.iranintl.com/en/investigates/inside-tehran-softwar/index.html</a>;  <a href="https://www.tv4.se/artikel/4f72OQx4G6N0Mk0NTxiX8Y/iranexperten-rouzbeh-parsi-kopplas-till-paverkansnaetverk">https://www.tv4.se/artikel/4f72OQx4G6N0Mk0NTxiX8Y/iranexperten-rouzbeh-parsi-kopplas-till-paverkansnaetverk</a></li>
<li><a href="https://www.tv4.se/artikel/4f72OQx4G6N0Mk0NTxiX8Y/iranexperten-rouzbeh-parsi-kopplas-till-paverkansnaetverk">https://www.tv4.se/artikel/4f72OQx4G6N0Mk0NTxiX8Y/iranexperten-rouzbeh-parsi-kopplas-till-paverkansnaetverk</a></li>
<li><a href="https://onlinelibrary.wiley.com/doi/10.1111/mepo.12400">https://onlinelibrary.wiley.com/doi/10.1111/mepo.12400</a>; Hovsepian-Bearce, Y. (2016), <em>The Political Ideology of Ayatollah Khamenei: Out of the Mouth of the Supreme Leader,</em> New York: Routledge; Khoshnood, Arvin (2012), <em>Sista ordet: Beslutsfattande i Islamiska republiken Irans utrikespolitik. Orientaliska studier</em>, 130, 16–48.</li>
<li><a href="https://besacenter.org/irans-presidential-elections-have-nothing-to-do-with-democracy/">https://besacenter.org/irans-presidential-elections-have-nothing-to-do-with-democracy/</a></li>
<li><a href="https://www.svt.se/nyheter/lokalt/skane/salde-ventiler-till-iran-kan-ha-begatt-sanktionsbrott">https://www.svt.se/nyheter/lokalt/skane/salde-ventiler-till-iran-kan-ha-begatt-sanktionsbrott</a></li>
<li><a href="https://www.sverigesradio.se/artikel/ryssland-och-iran-fordjupar-samarbetet-iranexperten-otroligt-viktigt-for-regimen">https://www.sverigesradio.se/artikel/ryssland-och-iran-fordjupar-samarbetet-iranexperten-otroligt-viktigt-for-regimen</a></li>
<li><a href="http://dx.doi.org/10.1080/08850609708435351">http://dx.doi.org/10.1080/08850609708435351</a></li>
<li>Khoshnood, Arvin (2012). Sista ordet – Beslutsfattande i Islamiska republiken Irans utrikespolitik. Orientaliska studier, 130, 16-48.</li>
<li><a href="https://besacenter.org/esmaeil-khatib-iran-intelligence/">https://besacenter.org/esmaeil-khatib-iran-intelligence/</a></li>
<li><a href="https://besacenter.org/iran-is-a-threat-to-swedish-national-security/">https://besacenter.org/iran-is-a-threat-to-swedish-national-security/</a></li>
<li><a href="https://doi.org/10.1080/08850607.2023.2295205">https://doi.org/10.1080/08850607.2023.2295205</a></li>
<li><a href="https://besacenter.org/iran-china-deal-security-implications/">https://besacenter.org/iran-china-deal-security-implications/</a>; <a href="https://besacenter.org/russia-iran-intelligence-pact/">https://besacenter.org/russia-iran-intelligence-pact/&#8217;</a></li>
<li><a href="https://doi.org/10.51870/CEJISS.A140301">https://doi.org/10.51870/CEJISS.A140301</a></li>
<li>Ibid.</li>
<li><a href="http://dx.doi.org/10.1080/08850609708435351">http://dx.doi.org/10.1080/08850609708435351</a>; <a href="https://doi.org/10.51870/CEJISS.A140301">https://doi.org/10.51870/CEJISS.A140301</a>; <a href="https://doi.org/10.1080/08850607.2023.2295205">https://doi.org/10.1080/08850607.2023.2295205</a>; <a href="https://www.washingtoninstitute.org/sites/default/files/pdf/Levitt-20180808-CTCSentinel.pdf">https://www.washingtoninstitute.org/sites/default/files/pdf/Levitt-20180808-CTCSentinel.pdf</a></li>
<li><a href="https://besacenter.org/mideast-security-and-policy-studies/iran-political-assassinations/">https://besacenter.org/mideast-security-and-policy-studies/iran-political-assassinations/</a></li>
<li><a href="https://doi.org/10.1080/08850607.2023.2295205">https://doi.org/10.1080/08850607.2023.2295205</a></li>
<li><a href="https://www.justice.gov/opa/pr/two-men-charged-alleged-plot-assassinate-saudi-arabian-ambassador-united-states">https://www.justice.gov/opa/pr/two-men-charged-alleged-plot-assassinate-saudi-arabian-ambassador-united-states</a></li>
<li><a href="https://doi.org/10.51870/CEJISS.A140301">https://doi.org/10.51870/CEJISS.A140301</a>; <a href="https://besacenter.org/iran-is-a-threat-to-swedish-national-security/">https://besacenter.org/iran-is-a-threat-to-swedish-national-security/</a></li>
<li><a href="https://besacenter.org/iran-is-a-threat-to-swedish-national-security/">https://besacenter.org/iran-is-a-threat-to-swedish-national-security/</a>; <a href="https://www.washingtoninstitute.org/sites/default/files/pdf/Levitt-20180808-CTCSentinel.pdf">https://www.washingtoninstitute.org/sites/default/files/pdf/Levitt-20180808-CTCSentinel.pdf</a></li>
<li><a href="https://doi.org/10.51870/CEJISS.A140301">https://doi.org/10.51870/CEJISS.A140301</a></li>
<li><a href="https://doi.org/10.1080/08850607.2023.2295205">https://doi.org/10.1080/08850607.2023.2295205</a></li>
</ol>
</div>
</div>
<div class="author-byline">Arvin Khoshnood är expert på Iran och Mellanöstern. Han har examina i bland annat statsvetenskap och underrättelseanalys vid Lunds universitet.</p>
<p>Magnus Norell är statsvetare samt freds- och konfliktforskare.</p>
<p>Ardavan Khoshnood är docent i akutsjukvård vid Lunds universitet samt kriminolog och statsvetare.
</p></div>
</div>
