Please use this identifier to cite or link to this item: http://dx.doi.org/10.14279/depositonce-10594
For citation please use:
Full metadata record
DC FieldValueLanguage
dc.contributor.advisorFeldmann, Anja-
dc.contributor.authorShukla, Apoorv-
dc.date.accessioned2020-10-09T09:47:16Z-
dc.date.available2020-10-09T09:47:16Z-
dc.date.issued2020-
dc.identifier.urihttps://depositonce.tu-berlin.de/handle/11303/11704-
dc.identifier.urihttp://dx.doi.org/10.14279/depositonce-10594-
dc.description.abstractToday, we rely heavily upon Internet-connected devices, applications, and services. Such reliance makes it crucial for the underlying networks to be reliable and secure. However, network outages, bugs in network devices such as switches and routers, and security compromises of the critical network infrastructure happen and sometimes, incur losses in revenue. This makes network management and control critically important. Networking devices such as IP-based routers and ethernet-based switches are fixed-function devices that are vertically integrated, i.e., the control and data plane are bundled together. These devices can only be configured by network operators and, thus, notably lag behind in terms of providing useful and custom abstractions for network management and orchestration. This necessitated the need for new network management and control paradigms. Software-defined Networking (SDN) emerged as a paradigm that introduced programmability. SDN decouples the previously distributed control plane from the data plane and outsources the control to a logically centralized software SDN controller running on commodity hardware. SDN controller manages and controls several data plane devices (e.g., SDN switches) through a well-known interface known as OpenFlow while offering a multitude of opportunities regarding management and control through programmability of the control plane. However, the SDN switches remain as fixed-function devices that can only be configured via OpenFlow but not programmed. To enhance SDNs, Programming Protocol-independent Packet Processors (P4) language was introduced. P4 is a domain-specific language that allows data plane programmability by writing custom programs known as P4 programs that run on data plane switches (e.g., P4 switches). These programs dictate P4 switches how to process packets even after those switches are already deployed. At the network level, a P4 network, generally, comprises of an SDN controller that manages and controls underlying P4 switches. Together, SDN and P4 are complementary and can operate in conjugation with each other. Hereby, programmable networks emerged as a generic term for networks such as Software-defined Networks (SDNs) or P4 networks. However, as the switch (e.g., a P4 switch) and the networks (e.g., SDNs and P4 networks) get increasingly programmable, complex bugs and faults surface especially, during runtime under diverse workloads to pose unprecedented threats. To give an example of a single P4 switch, a programmer writes a P4 program defining packet processing and then deploys it on a P4 switch. However, programming errors or P4 switch-specific errors manifesting as bugs result in an abnormal switch behavior under active traffic. This necessitates the detection and elimination of bugs. Zooming out from a P4 switch to the network-level (e.g., SDNs and P4 networks), data plane faults such as software or hardware bugs, switch failures, misconfigurations of switches, and attacks are ubiquitous. Even worse, the network control plane or SDN controller remains unaware of the existence of such data plane faults which results in control-data plane inconsistency. This necessitates sound mechanisms that verify the actual network data plane behavior against the expected network control plane behavior during runtime. To address the aforementioned challenges, the goal of this dissertation is to develop runtime verification mechanisms for the following scenarios ranging from a single switch to the network-level, namely, (i) a P4 switch, (ii) SDNs, and (iii) P4 networks. We make the following contributions: (i) We present the design, implementation, and evaluation of P6, a system that detects, localizes, and patches bugs at runtime in a P4 program deployed on a P4 switch to perform end-to-end runtime verification. P6 leverages techniques such as machine learning and static analysis-guided fuzzing to detect, dynamic fault localization-based techniques to localize, and software libraries to patch the bugs in P4 programs. Furthermore, P6 detects P4 switch target platform-specific bugs. Our evaluation of the P6 prototype on a single P4 switch across different switch targets shows that it successfully detects, localizes, and patches software bugs existing in the publicly-available P4 application programs while outperforming even the advanced baseline approaches. (ii) We present the design, implementation, and evaluation of PAZZ, a system that leverages network coverage-guided fuzzing via Binary Decision Diagrams (BDDs) for detection and bloom-filters used by custom per-switch tagging for localization of control-data plane inconsistency in SDNs. Our evaluation of the PAZZ prototype shows that it can quickly detect and localize the control-data plane inconsistency between one or many source-destination pairs in various topologies and configurations of different scale while outperforming baseline approaches. (iii) We present the design, implementation, and evaluation of P4CONSIST, a system that leverages In-band Network Telemetry (INT)-based per-switch tagging in P4 switches, depth-frst search, and symbolic execution for the detection of control-data plane inconsistency in P4 networks. Our evaluation of the P4CONSIST prototype shows that it can rapidly detect the control-data plane inconsistency between one or many source-destination pairs in diverse topologies and configurations of different scale.en
dc.description.abstractHeutzutage verlassen wir uns vermehrt auf Geräte, Anwendungen und Services, die mit dem Internet verbunden sind. Diese Abhängigkeit erfordert es, dass das zugrundeliegende Netzwerk zuverlässig und sicher ist. Netzwerkausfälle, Fehler in Netzwerkgeräten wie Switches und Router, sowie Beeinträchtigungen der Sicherheit von kritischen Netzwerkinfrastrukturen passieren und bringen Umsatzverluste mit sich. Aus diesem Grund sind Netzwerkmanage- ment und -kontrolle unerlässlich. Netzwerkgeräte wie IP-basierte Router und Ethernet-basierte Switches sind traditionell als vertikal integrierte Geräte mit fest verbauter Funktionalität, d.h. gebündelter Kontroll- und Datenebene, bekannt. Solche Geräte können durch Netzbetreiber lediglich konfiguriert werden, weshalb sie deutliche Nachteile im Bereich der Abstraktion von Netzwerkmanagement und -orchestrierung haben. Hieraus entstand die Notwendigkeit neuer Paradigmen für Netzwerkkontrolle und -management. Software-Defined Networking (SDN) entstand als Paradigma, das Programmierbarkeit von Netzwerken ermöglicht. SDN trennt die zuvor verteilte Kontrollebene von der Datenebene, die nun in einem logisch-zentralisierten SDN Controller konsolidiert wird und als Software auf Standardhardware ausgeführt werden kann. Der SDN Controller managt und kontrolliert mehrere Geräte auf Datenebene (z.B. SDN Switches), über eine als OpenFlow bekannte Schnittstelle und bietet gleichzeitig, durch die Programmierbarkeit der Kontrollebene, eine Reihe von Möglichkeiten. Nichtsdestotrotz verbleiben SDN Switches als Geräte mit fest verbauter Funktionalität, die lediglich konfiguriert, nicht aber programmiert werden können. Um die Programmierbarkeit zu ermöglichen, wurde die Program- miersprache Protocol-independent Packet Processors (P4) entwickelt. P4 ist eine domänen- spezifische Sprache, welche die Programmierbarkeit der Datenebene, durch das Entwickeln von benutzerdefinierten Programmen (sogenannten P4 Programmen), die auf Switches der Datenebene (z.B. P4 Switches) ausgeführt werden, ermöglicht. Diese Programme geben vor wie Pakete verarbeitet werden sollen, selbst wenn die P4 Switches bereits im Einsatz sind. Auf Netzwerkebene besteht ein P4 Netzwerk aus einem SDN Controller, der die untergeordneten P4 Switches managt und kontrolliert. Insgesamt sind SDN und P4 komplementär und können in Verbindung miteinander eingesetzt werden. Als Resultat entwickelte sich der Begriff programmierbare Netzwerke als Sammelbegriff, sowohl für Software-defined Networks (SDNs), als auch P4 Netzwerke. Mit der erhöhten Programmierbarkeit von Switches (z.B. P4 Switch), sowie Netzwerken (z.B. SDNs und P4 Netzwerke), treten insbesondere zur Ausführung unterschiedlicher Arbeitslasten komplexe Bugs und Fehler zu Tage, die bis dato nie dagewesene Bedrohungen darstellen. Um ein Beispiel für einen einzelnen P4 Switch zu nennen: Ein Programmierer schreibt ein P4 Programm, das die Paketverarbeitung definiert und stellt dieses dann auf einem P4 Switch bereit. Programmierfehler oder P4 Switch-spezifische Fehler manifestieren sich jedoch als Bugs, die in einem ungewöhnlichen Switch-Verhalten unter unterschiedlichem Datenverkehr resultieren. Sowohl die Erkennung als auch die Beseitigung von Bugs erlangen daher größte Bedeutung. Wenn der Fokus von einem P4 Switch auf die Netzwerkebene (z.B. SDNs und P4 Netzwerke) verlagert wird, zeigt sich, dass Fehler auf der Datenebene wie Software- oder Hardwarebugs, Hardwarefehler, Fehlkonfigurationen und Angriffe allgegenwärtig sind. Schlimmer noch: die Netzwerk-Kontrollebene oder der SDN Controller sind im Unklaren über die Existenz solcher Fehler auf Datenebene, was zu Inkonsistenzen zwischen Kontroll- und Datenebene führt während der Datenverkehr über das Netzwerk fließt. Dies erfordert solide Mechanismen, die das tatsächliche Verhalten der Datenebene mit dem erwarteten Verhalten der Kontrollebene während der Laufzeit vergleichen, um erforderliche Korrekturmaßnahmen einleiten zu können. Um die zuvor beschriebenen Herausforderungen zu adressieren, ist das Ziel dieser Dissertation die Entwicklung von Mechanismen zur Verifikation während der Laufzeit für die folgen den Szenarien, die von einem einzelnen Switch bis zur Netzwerkebene reichen, (i) einem P4 Switch, (ii) SDNs und (iii) P4 Netzwerke. Wir leisten folgende Beiträge: (i) Wir präsentieren das Design, die Implementierung und Evaluation von P6, einem System, welches Fehler in einem P4 Programm, ausgeführt auf einem P4 Switch, automatisch zur Laufzeit erkennen, lokalisieren und beheben kann, um Ende-zu-Ende Laufzeit Verifikation zur ermöglichen. P6 nutzt hierfür Techniken wie durch maschinelles Lernen und statische Analyse geleitetes Fuzzing zur Erkennung, dynamische Lokalisierungsmechanismen zur Lokalisierung und Softwarebibliotheken zur Behebung von Fehlern in P4 Programmen. Außerdem kann P6 plat- tformspezifische Fehler von P4 Switches erkennen. Unsere Evaluation des P6 Prototypen auf einem einzelnen P4 Switch mit einer Reihe verschiedener Zielplattformen zeigt, dass P6 verschiedenste existierende Fehler in öffentlich verfügbaren P4 Programmen, erfolgreich erkennen, lokalisieren und beheben kann und dabei sogar fortschrittliche Basisansätze übertrifft. (ii) Wir präsentieren das Design, die Implementierung und Evaluation von PAZZ, einem System zur Erkennung und Lokalisierung von Inkonsistenzen zwischen der Kontroll- und Datenebenen in SDNs, welches auf dem Netzwerkabdeckung basiertem Fuzzing mit Binary Decision Diagrams (BDDs) und Bloom Filtern zur Lokalisierung von Fehlern mittels benutzerdefinierter Markierungen von Paketen beruht. Unsere Evaluation des PAZZ Prototypen zeigt, dass er in der Lage ist, Inkonsistenzen der Kontroll- und Datenebene zwischen einem oder mehreren Quelle-Ziel Paaren in verschiedenen Topologien und Konfigurationen unter- schiedlicher Größenordnungen, schnell zu erkennen und zu lokalisieren, sowie die Basisansätze zu übertreffen. (iii) Wir präsentieren das Design, die Implementierung und Evaluation von P4CONSIST, einem System zur Erkennung von Inkonsistenzen zwischen der Kontroll- und Datenebene mithilfe von per-Switch Tagging basierend auf In-band Network Telemetry (INT) für P4 Switches, Tiefensuche und symbolischer Ausführung. Unsere Evaluation des P4CONSIST Prototypen zeigt, dass er in kürzester Zeit in der Lage ist, Inkonsistenzen zwischen der Kontroll- und Datenebene und einem oder mehrerer Quelle-Ziel Paaren in diversen Topologien und Konfigurationen unterschiedlicher Größenordnungen zu erkennen.de
dc.description.sponsorshipBMBF, 01IS17052, Software Campus 2.0 (TU Berlin)en
dc.language.isoenen
dc.rights.urihttps://creativecommons.org/licenses/by/4.0/en
dc.subject.ddc003 Systemede
dc.subject.ddc004 Datenverarbeitung; Informatikde
dc.subject.otherprogrammable networksen
dc.subject.othernetwork verificationen
dc.subject.othernetwork virtualizationen
dc.subject.otherSDNen
dc.subject.otherP4en
dc.subject.othersecurityen
dc.subject.otherprogrammierbare Netzwerkede
dc.subject.othervirtueller Switchde
dc.subject.otherverdeckte Kanälede
dc.subject.otherLeistungde
dc.subject.otherCloud-Sicherheitde
dc.subject.otherSicherheit im Rechenzentrumde
dc.titleTowards runtime verification of programmable networksen
dc.typeDoctoral Thesisen
tub.accessrights.dnbfreeen
tub.publisher.universityorinstitutionTechnische Universität Berlinen
dc.contributor.grantorTechnische Universität Berlinen
dc.contributor.refereeFeldmann, Anja-
dc.contributor.refereeSchmid, Stefan-
dc.contributor.refereeSmaragdakis, Georgios-
dc.contributor.refereeCrowcroft, Jon-
dc.date.accepted2019-12-16-
dc.title.translatedAuf dem Weg zur Laufzeitüberprüfung programmierbarer Netzwerkede
dc.type.versionacceptedVersionen
Appears in Collections:FG Internet Network Architectures (INET) » Publications

Files in This Item:
shukla_apoorv.pdf
Format: Adobe PDF | Size: 2.68 MB
DownloadShow Preview
Thumbnail

Item Export Bar

This item is licensed under a Creative Commons License Creative Commons