Het grootste deel van het werk dat een beveiligingsproduct betrouwbaar houdt, is onzichtbaar. Gebruikers zien een scan voltooid, een dreiging geblokkeerd, een update die 's nachts is toegepast. Ze zien het onderliggende platform niet. Runtimes, beheerde bibliotheken, native drivers, en Windows Alle vereisten moeten actueel blijven en samenwerken op miljoenen eindpunten. Onze migratie naar .NET 10 is een voorbeeld van hoe we dat platform in beweging houden en waar dit artikel zich op richt.
Het zou gemakkelijk zijn om deze upgrades als onderhoudstaken af te doen en verder te gaan. Maar dat doet ze tekort. Onze code draait continu, met verhoogde bevoegdheden, vlakbij enkele van de meest gevoelige onderdelen van onze systemen. Windows .
Elke afhankelijkheid in onze stack, van de runtime en externe bibliotheken tot native drivers en besturingssysteemvereisten, beïnvloedt de omgeving waarin onze software draait. Wanneer één ervan verandert, moet mogelijk alles wat ervan afhankelijk is ook veranderen.
Het probleem: platforms raken achterop doordat ze stilstaan.
In endpointbeveiliging staat de grond nooit stil. Windows Het evolueert. Bedreigingen evolueren. Hardware evolueert, van ARM64-laptops naar machines met veel meer geheugen en snellere opslag dan de machines waarvoor onze code oorspronkelijk is geschreven.
Een platform dat stilstaat, blijft niet hetzelfde. Het raakt achterop. Elke gemiste release van een afhankelijkheid of runtime vergroot de kloof tussen het ecosysteem waarop we hebben gebouwd en het ecosysteem dat vandaag de dag stabiel is.
Een moderne runtime, en .NET 10 in het bijzonder, kan ons betere beveiliging, snellere code-uitvoering, een kleiner geheugenverbruik en uitgebreidere diagnostiek bieden. Het biedt onze ontwikkelaars ook verbeteringen in de taal en tools die hen helpen efficiënter te werken.
Ook voor beveiligingssoftware staat er veel op het spel:
- Een webapplicatie kan met een implementatie worden teruggedraaid. Software die al op het apparaat van een klant is geïnstalleerd, kan dat niet.
- Onze code draait met hoge privileges, in combinatie met kernelstuurprogramma's en beveiliging tegen manipulatie.
- Een runtimefout treft niet slechts één server. Het kan miljoenen machines beïnvloeden.
Daarom behandelen we een runtime-upgrade met dezelfde zorgvuldigheid als een beveiligingsfunctie.
De uitdaging: alles beweegt synchroon.
Malwarebytes voor Windows Het is geen op zichzelf staand programma. Het is een gecoördineerd systeem: een gebruikersinterface, verschillende langlopende processen. Windows services, een installatieprogramma, een zelfupdateproces, een plug-ininterface en door derden beheerde afhankelijkheden.
Deze bevinden zich boven de native drivers en onze detectie-engine. De .NET 10-migratie omvatte de beheerde onderdelen van Malwarebytes waarbij de oorspronkelijke kern ongewijzigd blijft. Maar de verschillende lagen moeten nog steeds samenwerken.
De migratie moest aan meerdere eisen tegelijk voldoen:
- Beveiligingsgevoelige code moest zich voor en na de wijziging identiek gedragen.
- De native drivers en anti-sabotagelagen moesten correct blijven functioneren met de beheerde code.
- Het installatie- en updateproces moest de nieuwe runtimebestanden implementeren en de oude verwijderen.
- Plugins en afhankelijkheden van derden moesten compatibel blijven.
- Bestaande Malwarebytes De installaties moesten blijven functioneren.
- Onze geautomatiseerde validatie moest uitgebreid genoeg zijn om het resultaat te kunnen vertrouwen zonder elk pad handmatig te hoeven inspecteren.
De grens tussen beheerde en native code verdiende bijzondere aandacht. Beheerde code in onze services communiceert met native componenten via interfaces zoals P/Invoke en COM. Een runtime-wijziging kan subtiele gevolgen hebben voor de manier waarop deze verschillende onderdelen van de service met elkaar communiceren. Malwarebytes Communiceren en samenwerken.
Die verschillen komen mogelijk nooit aan het licht tijdens een demonstratie. Ze kunnen slechts op één machine van de 10.000 opvallen. Het is daarom cruciaal om ze te vinden voordat klanten ze ontdekken.
Niet elke update ziet er hetzelfde uit.
Er zijn drie belangrijke redenen waarom we een afhankelijkheid bijwerken: we kiezen ervoor, het onderliggende platform dwingt ons ertoe, of een beveiligingslek maakt het noodzakelijk. Elk van deze redenen brengt een andere tijdslijn met zich mee.
Optionele modernisering. We kunnen ervoor kiezen om over te stappen naar een nieuwe runtime, een nieuwe hoofdversie van een bibliotheek of een nieuwe platformfunctionaliteit om te profiteren van nieuwe functies, bugfixes of beveiligingsverbeteringen.
Wijzigingen in de basislijn. Naarmate platformvereisten evolueren, kunnen sommige oudere compatibiliteitsbeperkingen modernisering in de weg staan. De overstap naar .NET 10 stelde ons bijvoorbeeld in staat om de basislijn van de applicatie bij te werken en een nieuwere, ondersteunde runtime te gebruiken. Als onderdeel van diezelfde wijziging, Windows Ondersteuning voor versie 7 is afgeschaft.
Gedwongen patches. Soms wordt een kwetsbaarheid ontdekt in een bibliotheek die we leveren of een systeem waarvan we afhankelijk zijn. De wijziging is dan niet langer optioneel en we hebben geen controle meer over de timing. Wat we wél kunnen controleren, is onze paraatheid: het testen, het releaseproces en de gefaseerde uitrol die ons in staat stellen snel te reageren zonder nieuwe problemen te introduceren.
Verschillende redenen en verschillende tijdschema's, maar in alle gevallen is dezelfde zorgvuldige aanpak vereist.
De .NET-migratie: Waarom we het gedaan hebben
Overstappen naar .NET 10 biedt Malwarebytes een veiligere, ondersteunde en capabelere basis voor Windows , met diverse cumulatieve voordelen:
Beveiliging. Een moderne runtime profiteert van Microsofts voortdurende beveiligingsinspanningen, waaronder veiligere standaardinstellingen, sterkere cryptografie en oplossingen voor geheugen- en interoperabiliteitsfouten. Door gebruik te blijven maken van een runtime die actief door Microsoft wordt ondersteund, kunnen we patches blijven toepassen wanneer kwetsbaarheden worden ontdekt.
Een ondersteunde basis. Het is misschien geen aantrekkelijke reden, maar .NET 10 zorgt ervoor dat we op een ondersteund, actief ontwikkeld platform blijven dat beter aansluit op nieuwere versies. Windows Het maakt het gemakkelijker om toekomstige bugfixes, functies en verbeteringen als routinewerk te implementeren in plaats van als eenmalige projecten.
Diagnostiek en observeerbaarheid. Modern .NET beschikt over krachtigere ingebouwde traceer-, meet- en crashdiagnostiek. In een beveiligingsproduct is het belangrijk om te begrijpen hoe code zich in de praktijk gedraagt. Betere diagnostiek helpt ons betrouwbaarheidsproblemen te identificeren en op te lossen.
Prestaties en geheugenefficiëntie. Recente .NET-releases hebben de just-in-time compiler, de garbage collector en de kernbibliotheken verbeterd. Onze processen draaien de hele dag op de achtergrond, dus hoe efficiënt ze werken en hoe goed ze het geheugen beheren, is belangrijk. Deze mogelijkheden bieden ons meer kansen om de efficiëntie te verbeteren, hoewel de impact per component zal verschillen.
De .NET-migratie: hoe we het hebben aangepakt
Het leidende principe is eenvoudig: ga nooit sneller te werk dan het bewijs toelaat.
We zijn begonnen met het isoleren van het werk op een aparte branch. We hebben het platform opnieuw ingesteld en alle beheerde afhankelijkheden vernieuwd, zodat de nieuwe runtime en de codebase het eens waren over welke componenten precies moesten worden meegeleverd.
Daardoor kwamen al snel enkele minder voor de hand liggende gevolgen van de upgrade aan het licht: bibliotheken die waren hernoemd of in de runtime waren opgenomen, bestanden die niet langer nodig waren en nieuwe bestanden die in hun plaats moesten worden geleverd.
Implementatie wordt vaak over het hoofd gezien en fouten kunnen kostbaar zijn. Een runtime-migratie gaat niet alleen over de code die draait, maar ook over wat er op de schijf van de klant terechtkomt.
Onze installatie- en updateservice moest de nieuwe bestandsstructuur van de runtime leren kennen. Ze moesten afhankelijkheden verwijderen die de runtime nu zelf levert, stoppen met het verzenden van hernoemde bestanden en vervangende bestanden op een nette manier leveren, zowel bij nieuwe installaties als bij in-place updates.
Een correcte implementatie is het verschil tussen een upgrade die gebruikers niet eens merken en een upgrade die tot problemen met de ondersteuning leidt.
Nadat de build correct functioneerde, verschoof de focus naar de validatie.
De migratie omvatte:
- Uitgebreide geautomatiseerde tests voor alle services, installatie- en updateprocessen.
- Compatibiliteitsvalidatie aan de hand van configuraties uit de praktijk en eerdere installaties.
- Prestatiebenchmarking om regressies in opstart-, geheugen- en scangedrag op te sporen.
- De kanarieziekte werd gefaseerd ingevoerd, beginnend met kleine populaties en pas uitgebreid wanneer uit de resultaten bleek dat dit veilig was.
- Continue monitoring en geautomatiseerde regressiedetectie in het veld.
- Samenwerking tussen verschillende disciplines, waaronder platformontwikkeling, kwaliteitsborging, installatie en updates, en release engineering.
“We zijn nooit sneller te werk gegaan dan het bewijsmateriaal toeliet. Elke poort moest vanzelf op groen springen.”
De .NET-migratie: de afwegingen
Niets hiervan was gratis, en de keuzes hielden bewuste afwegingen in.
De keerzijde van de branch was dat er sprake kon zijn van afwijking. Door de migratie te isoleren, werd de hoofdcodebasis beschermd, maar hoe langer die branch bestond, hoe meer deze kon afwijken van de actieve ontwikkeling. We hebben dat risico beheerst door frequente integraties uit te voeren in plaats van één grote, risicovolle samenvoeging tot het einde uit te stellen.
De afweging bij de uitrol was snelheid. Gefaseerde implementatie betekende ook dat klanten de update later ontvingen dan bij een grootschalige release. We hebben die afweging geaccepteerd. Ervaringen bij kleinere groepen geven ons de mogelijkheid om problemen op te sporen voordat een update een veel groter aantal apparaten bereikt.
De afweging bij AOT was flexibiliteit. Compilatie vooraf kan de opstartprestaties verbeteren, maar kan ook het dynamische gedrag beperken. We hebben het selectief toegepast, component voor component, in plaats van standaard overal.
Wat de .NET 10-migratie betekent voor klanten
Het beste resultaat van infrastructuurprojecten is dat klanten ervan profiteren zonder er zelf over na te hoeven denken.
Op .NET 10 zijn die voordelen voor Malwarebytes Tot onze klanten behoren:
- Verbeterde betrouwbaarheid dankzij een volledig ondersteunde en actief onderhouden runtime.
- Een veiliger fundament dat profiteert van de voortdurende beveiligingsverbeteringen van het platform.
- Toegang tot nieuwe .NET-functies en bugfixes.
- Betere ondersteuning voor nieuwere versies van Windows .
- Nieuwere .NET-tools kunnen ons helpen om sneller nieuwe beveiligingsoplossingen te ontwikkelen en te implementeren.
Lessen die de moeite waard zijn om te onthouden
Elk van deze updates – de runtime, de baselines, de beveiligingspatches – zorgt ervoor dat het team een aantal overtuigingen nog sterker in zijn of haar schoenen laat staan.
Platformupgrades zijn strategische investeringen in alles wat erop gebouwd is. Modernisering werkt bovendien het beste wanneer deze continu plaatsvindt: hoe langer een platform achterloopt, hoe moeilijker de uiteindelijke upgrade kan worden.
Automatisering is met name belangrijk bij veranderingen van deze omvang. Dat geldt ook voor de kleine, minder opvallende beslissingen die jaren eerder zijn genomen, zoals het handhaven van duidelijke grenzen tussen componenten en het hebben van een productieproces dat precies weet wat er wordt verzonden.
Die fundamenten maken grotere veranderingen mogelijk.
“Technische schuld groeit net als financiële schuld. De goedkoopste upgrade is degene die je nooit hebt uitgesteld.”
Wat volgt?
Geen enkele upgrade is een eindpunt. Elke upgrade is een stap in een groter proces: continu moderniseren, in weloverwogen stappen, zodat het platform nooit achterop raakt. De basislijn zal opnieuw verschuiven. Kwetsbaarheden zullen onverwacht opduiken. Elk van deze kwetsbaarheden zal aan dezelfde discipline onderworpen worden: dezelfde tests, dezelfde gefaseerde uitrol en hetzelfde bewijsmateriaal voordat we verdergaan.
Die discipline is de basis van een product dat elke dag, op elke machine, zonder aarzeling draait.
Malwarebytes voor Windows op .NET 10 is uitgebracht in versie 5.6.0. Dit is de nieuwste stap in een langdurige strategie om te investeren in het onderliggende platform, zodat de bescherming die erop wordt geboden steeds beter kan worden.
“Een van de beste cyberbeveiligingspakketten ter wereld.”
Volgens CNET.Lees hun recensie →
