Cookies op Tweakers

Tweakers maakt gebruik van cookies, onder andere om de website te analyseren, het gebruiksgemak te vergroten en advertenties te tonen. Door gebruik te maken van deze website, of door op 'Ga verder' te klikken, geef je toestemming voor het gebruik van cookies. Wil je meer informatie over cookies en hoe ze worden gebruikt, bekijk dan ons cookiebeleid.

Meer informatie

Door , , 57 reacties
Bron: ZDNet

Microsoft.NetIn een reactie op recente berichten over het virus W32.Donut, heeft Microsoft gezegd dat de geruchten niet helemaal correct zijn. Het zou het eerste virus zijn dat bestanden van Microsoft's nieuwe .Net-technologie zou kunnen infecteren, maar de softwaregigant doet er alles aan om de op dit gebied tot nu toe ongeschonden reputatie van haar Web-services software te verdedigen. Volgens het bedrijf is het virus gewoon gebaseerd op een ouder Windows-virus, en heeft het niets met een fout in .Net te maken, zoals sommigen insinueerden.

W32.Donut is absoluut geen .Net-virus, aldus een productmanager van Microsoft. Het is gewoon een Windows-virus dat toevallig bestanden van .Net infecteert, maar met de eigenlijke technologie heeft het niks te maken. Er bevinden zich geen fouten in de beveiliging van Microsoft's software, zo blijft het bedrijf beweren, in tegenstelling tot Symantec's visie op de zaak. Het antivirusbedrijf blijft bij haar mening dat het virus de voorloper van een nieuwe generatie is, aangezien een klein gedeelte ervan in .Net-taal geschreven is.

Lees het hele verhaal bij ZDNet.

Moderatie-faq Wijzig weergave

Reacties (57)

Ik denk dat Microsoft en Symantec een iets andere definitie hebben van de term .NET virus. Als je een .NET virus ziet als iets waar een klein stukje .NET taal is gebruikt, dan is het een .NET virus ... maar Microsoft beschouwt een .NET virus waarschijnlijk als iets wat zich door het gehele netwerk verspreid en schade aanricht ... Dit virus volgens mij niet echt iets met de beveiliging van .NET te maken ... dus in mijn ogen is dit nou niet echt een .NET virus .. ik bedoel, love-letter-for-you.txt.vbs werd toch ook geen Visual Basic Script virus genoemd, maar een Windows virus...
Een virus is een stukje code dat in een ander bestand zit, de host.
Die vbs dingen waren geen viri, maar gewoon programma's (worms).
Als W32.Donut zich in .Net executables nestelt, is het een .Net-hosted virus.
Hu is het de vraag wat het precies doet, ik heb niet goed gelezen wat het nou doet, maar op zdnet staat ditte:
"It's a Windows virus that infects .Net files. It's not running in the .Net Framework as managed code. It's not finding some hole in the security model and exploiting it."

Volgens mij probeerd ms het af te schuiven op windows, maar het is wel degelijk een .Net virus. Het is geen managed code, maar blijkbaar unmanaged, dat is een beslissing geweest van ms om unmanaged code toe te laten in het .Net framework.
werd eigenlijk een worm genoemd maar we gaan niet zeiken :P
Als dit dan niet een echt .NET virus is zal er binnenkort wel weer een komen dat het wel is :z

Voor de rest is het eigenlijk woord tegen woord Symantec wil de eerste zijn die een .NET virus heeft ontdekt/gemaakt en Microsoft schuift het gewoon op een fout in hun oude Windows versie.
dat wou ik net zeggen, maar ik vind het wel knap dat er al een virus is, zonder dat je .net in de winkel kan kopen :)
Ne te koop niet maar, de beta versies zijn er al wel een poosje :) Microsoft heeft in november 2001 de Beta 3 versie van de dot.NET server al vrijgegeven aan de beta testers.
En reken maar de de verschillende anti-virus producenten, ook aangemeld zijn als beta testers :)
Dacht niet dat de specificaties en ontwikkelomgevingen pas beschikbaar zijn als .NET software 'in de winkels' ligt. Ontwikkelaar hebben al tijden de beschikking over beta-versies.
dat wou ik net zeggen, maar ik vind het wel knap dat er al een virus is, zonder dat je .net in de winkel kan kopen
Een paar maanden geleden heeft Microsoft enkele miljoenen DVD's bij gangbare magazines cadeau gedaan met Visual Studio.NET beta 2 en de hele .NET omgeving erbij. Meer heb je niet nodig om er 'iets' mee te maken.

De eerste beta dateert al van eind 2000 en is ook wijd verspreid (alhoewel het toen nog barstte van de bugs).
Het kan idd heel goed dat het een virus is dat gewoon per toeval de juiste bestanden aanpakt, maar voor hetzelfde geld is het natuurlijk een virus dat zich al deels door .Net heen weet te breken. Dit hoeft natuurlijk geen voltooid virus te zijn maar als test hoe erdoor te komen is het prima geschikt, en zoals je hier ziet lukt het al aardig. Ik denk dat het er tussen in zit, het is wel speciaal voor .net gemaakt maar is nog niet een virus dat grote schade aan moet gaan richten.
Wij hebben op school geleerd dat in elke 10 regels code gemiddeld 1 fout zit. .NET software (die servers software) zal uit miljoenen regels code bestaan, dus zullen er echt wel beveiligings gaten in zitten. Het is tenslotte ook maar geschreven door mensen, en mensen maken fouten.
Tevens hebben we het nu over testen, je kan niet alles testen dus zullen er heus nog wel fouten in zitten die nog niet gevonden zijn. (kijk maar naar de fouten in IE en windows)

edit:

ik heb het dan ook over typ fouten, en syntax fouten. deze worden gevonden door de compiler, de semantische fouten kan je alleen vinden door te testen.
Elke 10 regels is wel dik overdreven (hoewel - bij M$?? :P)
Elke 300 of 400 mischien - maar ik ben 100% zeker dat als in mijn code elke 10 regels een fout staat dat ik niet lang mijn job kan behouden. De meeste "fouten" komen ook enkel voor in onvoorziene omstandigheden, die normaalgezien zich helemaal niet zouden mogen voordoen.
juist... helemal gelijk... maar als jij een simpel programma maakt met een paar loops e.d. en ik moet zelf bijv een beginwaarde geven.. dan test ik altijd 0, 1, -1 en meestal nog anderen... Dat zijn standaarden die je test.

Als je een telefoonnummer uit een database wil halen.. maar die database is leeg en je houd daar geen rekening meer dan kan hij in de loop blijven zitten en daar niet meer uitkomen.. dat weet je zelf ook..

Moet gewoon van te voren een overzichtelijk plan maken.. my part in psd formaat of whatever.. vaak zijn het onnodige slordigheden
zal wel mee vallen hoor, elke 1000 regels is wat waarschijnlijker... als je elke tien regels een fout maakt, dan ben je een verdomd slechte programmeur (no offence)

syntax fouten hebben geen enkele relatie met beveiligingsfouten.
1000 regels code is al heeel veel hoor...
In veel programmeertalen zit je heel snel op veel regels code; in C++ zit je met een beetje een class-declaratie in een header zo al op zo'n honderd regels.
In veel van mijn programma's laat ik variabelen binnen een klasse niet direct benaderen, maar via accessor functies. Dat is dus al zeker weer een regel voor de variabele, vervolgens nog 1 regel voor elke accessor in de header, en nog drie regels voor de implementatie van de accessor.
Elke variabele zorgt dus voor 1 + 2*1 + 2*3 = 9 regels code.
Even kortzichtig commentaar voorkomen: nee, we kunnen niet allemaal globale variabelen gebruiken en visual basic is handig, maar dan alleen voor front-ends en kleine programma's.
:? Duh :?

Voor een HTML pagina wel |:(

We hebben het hier over _echte_ programma's.
Een beetje programma zit al gauw in de duizenden regels code.
1000 regels veel?????? ja mischien als je een verslag aan het tikken bent op school ofzo over het leven van de goudvis...

Zou eens moeten weten hoeveel regels code dit script van tweakers bedraagd... dat zijn er echt niet maar 100

1000 is net niks...
offtopic:
[quote]
1000 regels code is al heeel veel hoor..
[/quote]

We hebben het hier dan ook niet over scripts maar over echte programma's. Ik heb voor eigen gebruik een string class in C++ geschreven, m'n header file is 477 regels en m'n implementatie file is 507 regels, zit je toch al bijna aan de 1000 regels code en dan heb je nog niks....
om een lang verhaal kort te maken, 1000 regels is niet erg veel.
was dat niet elke 1000 of elke 10000... elke 10??? dan krijg je een programma nooit aan het lopen...
Ik ken die theorie ja. Volgens mij kwam het eropneer dat er gemiddeld in elke 10 regels code, 1 semantische fout zit. Maar doordat er uiteindelijk ook een aantal fouten bv door testen eruitgehaald wordt, is kom je in de praktijk uit op een veel gunstiger verhouding (1:300 lijkt mij ook wel een aardige ja).
Nog steeds geen verhouding om echt trots op te zijn, maar ja, programmeren is nog maar een jong vak en uiteindelijk leert men wel hoe je het moet doen :).

Overigens betekent dit niet automatisch dat er op elke x regels er een beveiliginsfout moet zitten!
Hoe infecteert dit ding .NET? Door in windows te lopen en dan de .NET runtimes aan te passen zeker?
In dat geval hebben we het niet over een .NET virus, maar over een Win32 virus (hey, het is W32 :P )
Pas als het een virus lukt om binnen de .NET omgeving schade toe te brengen aan het systeem kan je zeggen dat het om een .NET virus gaat.

Nimda kan ook Linux systemen die samba draaien infecteren, maar daarmee is het nog geen Linux virus.
Wat verwacht microsoft dan?!? Dat .Net bestanden virus-vrij zullen blijven? Als het zo makkelijk was om een virus-vrij OS te maken dan was dat al wel eerder gebeurd.

Niet echt verwonderlijk. Het eerste schaap is over de dam en er zullen er meer volgen.
Het gaat er niet om of de bestanden van een .net server geinfecteerd kunnen worden maar of het virus een lek in de .net technologie gebruikt!
Ja, het gaat erom dat de beveliging van .Net goed genoeg is, en dat is blijkbaar niet zo, want je kan zonder pardon blijkbaar dingen doen die niet mogen.
Een virus vrij OS is inderdaad nog niet echt voor deze tijd maar Kijk eens naar de *nix varianten?? zoalng je niet onder root ingelogd bent komt een virus niet ver... dus is het niet interessant om er een te maken..

Moet wel toegeven dat er nog niet veel mensen *nix systemen gebruiken dus de "doelgroep" voor de virussen is kleiner
Een *nix virus mag dan inderdaad niet het hele OS besmetten (tenzij jij, of het process dat 'lek' bleek, inderdaad als root was ingelogd), het blijft nog steeds een feit dat een verkeerd geconfigureerde browser met teveel Java permissies zonder pardon bij alle lokale user-data kan. Dit houdt in dat het je documenten, data en allerlei andere zaken die een *nix user doorgaans in z'n home-dir (de enige dir waar 'ie doorgaans zelf schrijf-rechten in heeft) heeft staan, gewoon net zo hard toegankelijk zijn als bij een Windows box.

Dus ook je persoonlijke adreslijsten met email-adressen, je browser-favorites, je SSH RSA keys, en op de meeste moderne *nixen zelfs je complete mailbox/maildir. Een trojan dat 'per ongeluk' door een *nix user gestart wordt, kan dus eigenlijk net zoveel schade aanrichten als een Windows-trojan; je OS zal alleen niet geinfecteerd raken (maar dat is met de meeste mail-trojans zowieso vaak niet eens het geval).

Zo veilig is een *nix systeem dus ook niet. Veiligheid hangt allemaal af van het bewustzijn van de eindgebruiker van z'n eigen 'digitale' kwetsbaarheid. Een domme gebruiker op een veilig OS is een stuk gevaarlijker i.v.m. virussen en trojans dan een slimme gebruiker op een 'onveilig' OS.
Het is daarom ook de truc om bijna geen rechten te hebben als je het net op gaat.............

Daarom log je niet in onder root.. maar onder "less than shit" om het maar zo te zeggen... net genoeg permissie voor een paar dingen... zodat je vrij kan internetten..

Maar je hebt gelijk ook *nix systemen zijn niet helemaal veilig.. Maar het is en blijft wel een feit dat een *nix virus een veel kleinere overlevingskans heeft dan een windows virus... tenzij het virus op een of andere manier rott rechten kan verkrijgen (in alle tig *nix varianten)

Van een *nix trojan heb ik zowieso nog nooit van gehoord... althans een type trojan zoals sub-seven, back..., netbus ed.... Ik kan het natuurlijk verkeerd hebben.
*nix virussen/trojans bestaan wel degelijk, al zijn ze inderdaad een stuk zeldzamer (en dus ook meteen een stuk minder gevaarlijk, qua besmettingsrisico) dan windows virussen.

De reden heeft echter weinig met de veiligheid van *nix of Windows te maken; er zijn nu eenmaal vele malen meer Windows PC's op deze aardbol dan *nix PC's. Een virus-auteur zou dan waarschijnlijk kiezen voor 't platform waarop de verspreiding mogelijk het grootst is: het Windows platform dus (gewoon een kwestie van: welk platform heeft de meeste 'onwetende' eindgebruikers). Daarbij komt de meeste virusmakers voornamelijk alleen VB beheersen (als je uberhaupt al van 'beheersen' kunt spreken), en VB voor *nix bestaat naar mijn weten gewoon niet.

Verder las ik in een reactie hierboven:
Daarom log je niet in onder root.. maar onder "less than shit" om het maar zo te zeggen... net genoeg permissie voor een paar dingen... zodat je vrij kan internetten..
Meestal is het 'gewoon' om onder je reguliere user-id het net op te gaan; da's dus minder dan 'root', maar zeker niet 'less-than-shit'; dat wil je ook helemaal niet, want je wilt wel kunnen e-mailen etc. En dan niet als 'nobody', maar gewoon als jezelf. Je home-directory blijft dus kwetsbaar op deze manier.

Inderdaad, internetten zonder privileges zou 't beste zijn; maar dat werkt functioneel gewoon niet; waar zou je je persoonlijke mail kwijt moeten (en onder welke rechten zou die moeten worden opgeslagen)? En je nieuwsgroepen waar je lid van bent? En die ssh keys die je nodig hebt om remote in te loggen? Zonder privileges kun je niks. Daar is nu juist een home-dir voor uit gevonden; daar heb je alle privileges die je nodig hebt om normaal met een systeem te kunnen werken...
De veiligheid van *nix t.o.v Windows wordt ook veroorzaakt door het feit dat er veel meer verschillende user agents in gebruik zijn. Onder windows wordt door 80% van de populatie outlook gebruikt voor het lezen van mail. Onder *nix is het meest populaire programma veel minder populair.

Daarnaast zijn *nix user agents vaak veel minder uitgebreid qua features. Waar zitten bij bijv. outlook de meeste veiligheidsrisico's? Bij allerlei features. Het grootste probleem was (als het goed is is het nu opgelosd) dat outlook bij attachments soms naar het mime-type en soms naar zijn eigen magic database kijkt. Dit op zo'n manier dat de security laag denkt dat er sprake is van een plaatje, en toestemming geeft om het af te spelen. De afspeel routines herkennen het vervolgens als een executable en starten het programma in plaats van het programma als gekraak uit je speakers te laten komen.
Daarnaast zijn *nix user agents vaak veel minder uitgebreid qua features.
Je bedoelt waarschijnlijk dat Outlook nog niet voor *nix beschikbaar is, neem ik aan. Want er zijn toch echt wel *genoeg* uitgebreide mail-agents voor *nix.

Netscape Mail, bijvoorbeeld. Compleet met alle achterdeurtjes die je ook in een Outlook verwacht (tenzij je weet hoe je zo'n client goed moet configureren).

Uiteindelijk komt het dus allemaal neer op de kennis en het bewustzijn van de gebruiker m.b.t. zijn eigen kwetsbaarheid. Zolang er gebruikers zijn die denken dat internet en privacy prima twee handen op 1 buik kunnen zijn, zonder zich verder te verdiepen in de mogelijkheden van encryptie, etc, zullen er voor kwaadwillenden altijd 'achterdeuren' te vinden zijn die wagenwijd openstaan.

En of die deur nu in een Windows of in een Unix server zit, feit blijft dat je er met een beetje kennis gewoon door naar binnen kunt lopen ;p

En zelfs dat kleine beetje benodigde kennis wordt tegenwoordig in scripts gestopt, zodat iedereen die een script kan starten, zich in principe 'hacker' kan noemen.
Even afgezien de beweringen, .Net code heeft beveiligingspolicies waar je U tegen zegt. De CLR (Common Language Runtime) beoordeelt ELKE module code uit de assembly van een programma op uitvoerrechten en niet alleen enkel meer of de user rechten heeft.
Ik denk dat het maken en runnen van .Net virussen een hele grote challenge is...

Victor
Je hebt weer een aantal dingen gehoord en bakt er een zin van, zit je toevallig in de sales?

In bepaalde classes wordt er gecheckt op permissions, bijv. om een socket te maken of een file te schrijven oid.

Helaas kan je niet dit soort dingen checken als je unmanaged code draait. En het .Net framework is de drempel om unmanaged code te maken heeeeel erg laag. Bij Java zal je JNI moeten gebruiken, en niet veel mensen vinden dat erg leuk.
De 'veiligheid' van het Windows platform (vanaf NT, althans) valt of staat door de zeer veer doorgevoerde integratie van componenten met de zgn. 'Trusted Computer Base' (TCB). Binnen de TCB moet ik toegeven dat Microsoft steeds beter z'n best begint te doen om de boel netjes op orde te krijgen. Maar let wel: zodra er een lek in de TCB blijkt te zitten, is meteen de HELE .Net architectuur die deeluitmaakt van die TCB spontaan 'untrusted'. Dit in tegenstelling tot andere OS'sen, waarbij bijv. het 'kraken' van een service niet noodzakelijk ook leidt tot het kraken van het gehele systeem (tenzij je een authenticatie service \[kerberos/nis] kraakt natuurlijk, of een service die draait met root permissies). Vindt je een gat in de .Net TCB, dan is het ook echt afgelopen met de veiligheid van .Net.

Deze in het ontwerp al zwakke veiligheid maakt dat .Net nooit zo veilig zal worden als de marketing mensen van Microsoft ons zo graag willen doen geloven.
Als je het over unmanaged code hebt, dan praat je ook niet over .Net, dus ook niet over een .Net virus, maar een 'klassiek' virus. En het ging nu eigenlijk over een .Net virus.

En nee, ik zit niet in sales.
Wacht maar tot je de windows api en de rest doorhebt... je hoeft echt niet veel te doen.... een programeur die een beetje verstand heeft van beveiliging die zal er niet veel problemen mee hebben.... En over beveiliging is heel wat documentatie te vinden op het net
Een andere wet is:

Door middel van testen kom je er niet achter of een systeem of applicatie 100% foutvrij is. Al test je 10000+ uur. Je kunt alleen voor 100% zeker zeggen dat, zodra je een fout hebt gevonden, het niet zo is
Dat is niet helemaal waar... er is een of andere mafkees geweest die programma's wiskundig bewees

Dan klopt het wel 100% (in theorie)

Een of andere universiteit in Nederland heeft dat geprobeerd en zo zelf een besturingssysteem gemaakt.. ik meen 6 of 7 fouten in totaal... we hebben het over een besturingssysteem... dat is niks als je kijkt wat er bij een besturingssysteem komt kijken..

Het grote nadeel is dat het gewoonweg goedkoper is om te testen en patches uit te brengen voor de fouten op te lossen dan om de hele zaak wiskundig te bewijzen.. want daar gaan heel wat man uren achter zitten en die mensen krijgen dik betaald omdat je behoorlijk wat koppie koppie nodig hebt om dat te kunnen doen
Natuurlijk kun je van programma's bewijzen dat ze correct zijn, het probleem zit 'm er meer in in hoe je formuleert wat de functionele eisen nu precies zijn. Kijk bijvoorbeeld maar eens hier voor een voorbeeldje van een bewijs van correctheid.

Het probleem is natuurlijk dat je dit soort bewijzen moet leveren voor elke loop en if ... then ... constructie. En dat is nogal lastig als de uitkomst van de ene constructie de invoer voor de andere bepaalt...

edit:
typo's
Dat is niet helemaal waar... er is een of andere mafkees geweest die programma's wiskundig bewees
Ja zeg! Niet zo denigrerend doen over Dijkstra he ;) GCL roelz gewoon.
Een aardige aanvulling hierop is:

"De kans dat je een fout vindt, is invers proportioneel aan de tijd dat je naar de code kijkt."

:)
De kans dat je de fout vind is gerelateerd aan het krtitische karakter van de werkzaamheden op dat moment.
OK,OK, rustig allemaal. Er is niets aan de hand mensen. Het is een .net niet virus!

Dan wordt het voor de anti virusschrijvers nog even doorbikkelen om een virus in elkaar te flansen dat het .net wel is en dat voor de officiele launch van .net te introduceren.

Suc6!
* 786562 VaagOH˛g meer gebruiksvriendelijkheid: dit virus is Windows.NET compatible

Dat maakt het voor potent´ele slachtoffers stukken makkelijker, nietwaar? :P ;) :D
Euhm, ik heb het 1 keer eerder gezien hier. Maar ik vraag me af: aangezien .NET code alleen runt onder de CLR van MicroSoft en ongeveer 90% van de PC-gebruikers die runtime nog niet heeft, waarom zou iemand dan een virus schrijven in de .NET taal ? Wat is overigens de .NET taal ? C# ?

Mas

Op dit item kan niet meer gereageerd worden.



Apple iOS 10 Google Pixel Apple iPhone 7 Sony PlayStation VR AMD Radeon RX 480 4GB Battlefield 1 Google Android Nougat Watch Dogs 2

© 1998 - 2016 de Persgroep Online Services B.V. Tweakers vormt samen met o.a. Autotrack en Carsom.nl de Persgroep Online Services B.V. Hosting door True