Många intressanta program egenskaper som determinism eller informationsflöde säkerhet är hyperproperties, det vill säga, de relaterar flera utföranden av samma program. Hyperegenskaper kan verifieras med relationslogik, men dessa logiker kräver dedikerad verktygsstöd och är svåra att automatisera. Alternativt, konstruktioner såsom självkomposition representerar flera utföranden av ett program genom ett produktprogram, vilket minskar hyperegenskaper av det ursprungliga programmet för att spåra egenskaper hos produkten. Befintliga konstruktioner stöder dock inte till fullo procedurspecifikationer, till exempel, för att härleda en uppringares determinism från en uppringares determinism, vilket gör verifieringen icke-modulär. Vi presenterar modulära produktprogram, en ny typ av produktprogram som tillåter hyperproperties i procedurspecifikationer och därmed kan resonera om samtal modulärt. Vi tillhandahåller en allmän formalisering av vår produktkonstruktion och bevisar att den är bra och komplett. Vi visar dess uttrycksfullhet genom att tillämpa den på informationsflödessäkerhet med avancerade funktioner som avklassificering och uppsägningskänslighet. Modulära produktprogram kan verifieras med hjälp av off-the-shelf kontrollörer; vi har implementerat vår strategi för både säkert informationsflöde och allmänna hyperproperties med hjälp av Viper verifieringsinfrastruktur. Vår utvärdering visar att modulbaserade produktprogram kan användas för att bevisa hyperegenskaper för utmanande exempel i rimlig tid. separat och endast med användning av specifikationerna för andra förfaranden. Modularitet är avgörande för skalbarhet och för att verifiera bibliotek utan att känna till alla sina kunder. Fullt modulärt resonemang om hyperproperties kräver således förmågan att formulera relationsspecifikationer, som relaterar olika utföranden av ett förfarande, och att tillämpa dessa specifikationer där förfarandet kallas. Som ett exempel, påståendet om (x) sedan {y:=x} another {y:= anrop f(x)} kan bevisas vara deterministisk om f: s relationsspecifikation garanterar att dess resultat deterministiskt beror på dess insats. Relationella programlogiker [10, 39, 41] gör det möjligt att direkt bevisa allmänna hyperproperties. Det är dock svårt att automatisera relationslogiken och kräver att man bygger särskilda verktyg. Alternativt minskar självkomposition [8] och produktprogram [6, 7] en hyperproperty till en vanlig spår egendom, vilket gör det möjligt att använda off-the-shelf program kontrollanter för att bevisa hyperproperties. Båda tillvägagångssätt konstruera ett nytt program som kombinerar beteendet hos flera körningar av det ursprungliga programmet. Men på grund av deras konstruktion, inget tillvägagångssätt stöder modulär verifiering baserad på relationsspecifikationer: Procedur samtal i det ursprungliga programmet kommer att dupliceras, vilket innebär att det inte finns någon enda programpunkt där en relationsspecifikation kan tillämpas. För ovan nämnda exempel, självkomposition ger följande program: om (x) sedan {y:=x} other {y:= call f(x)}; om (x ′ ) sedan {y ′ :=x ′ } other {y ′ := call f(x ′ )} Determinism kan nu verifieras genom att bevisa spår egenskapen att identiska värden för x och x ′ i det ursprungliga tillståndet innebär identiska värden för y och y ′ i det slutliga tillståndet. Ett sådant bevis kan dock inte använda en relationsspecifikation för förfarande f (som uttrycker att f är deterministiskt). En sådan specifikation avser flera utföranden av f, medan varje uppmaning i självkomposition tillhör en enda utförande. I stället kräver verifiering en exakt funktionell specifikation av f, som exakt bestämmer dess resultatvärde i form av indata. Verifiering av sådana exakta funktionella specifikationer ökar verifieringen ansträngningen och är i strid med data abstraktion (t.ex., en samling kanske inte vill lova den exakta iterationsordningen); sluta dem är bortom den senaste tekniken för de flesta förfaranden [40]. Befintliga produktprogram gör det möjligt att anpassa eller kombinera vissa påståenden och kan därmed lyfta detta krav i vissa fall, men detta kräver manuell ansträngning under konstruktionen, beror på de använda specifikationerna, och löser inte problemet i allmänhet. Vissa tekniker för att bevisa likvärdighet mellan olika program använder produktkonstruktioner som möjliggör användning av relationsspecifikationer mellan olika funktioner. De kan dock inte utnyttja de inneboende fördelarna med att kombinera ett program med sig själv i motsats till ett godtyckligt annat program [22, 25]. I detta papper presenterar vi modulära produktprogram, en ny typ av produktprogram som möjliggör modulära resonemang om hyperproperties. Modulära produktprogram gör det möjligt att bevisa k-säkerhetshyperproperties, dvs. hyperproperties som relaterar finita prefix för k-utförandespår, för godtyckliga värden av k [12]. Vi uppnår detta genom en omvandling som, till skillnad från befintliga produkter, inte duplicerar slingor eller procedursamtal, vilket innebär att för varje slinga eller samtal i det ursprungliga programmet, det finns exakt ett uttalande i k-produkten där en relationell specifikation kan tillämpas. Precis som befintliga produktprogram kan modulbaserade produkter resoneras om att använda off-the-shelf programkontrollanter. Vi demonstrerar den uttrycksfullhet modulära produktprogram genom att tillämpa dem för att bevisa säkert informationsflöde, som kan uttryckas som en 2-säkerhetshyperproperty. Vi visar hur modulbaserade produkter gör det möjligt att bevisa traditionell icke-interferens med hjälp av naturligt och koncist informationsflöde ACM
REF föreslår ett modulärt produktprogram som tillåter hyperproperties i procedurspecifikationer.
Modular Product Programs
{'venue': 'ESOP', 'journal': None, 'mag_field_of_study': ['Computer Science']}