[.net / c#] Uniek computer ID bepalen

[Dennis]

Hallo,

Voor een licentieservice die ik heb gebouwd ben ik opzoek naar een manier om een uniek computerID te berekenen. We hadden al gekeken naar wat implementaties; Macrovision gebruikt bijvoorbeeld een samentreksel van de serial van je harde schijf en van je BIOS nummer.

Het nummer moet niet té uniek zijn maar mag best afhankelijk zijn van hardware. Verder moet er rekening worden gehouden dat het ook onder Windows 9x en ME gebruikt moet kunnen worden. Op internet zijn er vrijwel geen implementaties te vinden, maar weet iemand nou een heel goede keuze?

Alvast bedankt.

[mulder]

Nou mijn internet (v34.11) gaf een heleboel informatie terug, oa:
http://discuss.fogcreek.c...asp?cmd=show&ixPost=46784

[H!GHGuY]

je kunt natuurlijk een uniek computer ID maken, maar wat als de gebruiker net dat component vervangt waar jij je licentie-nr van haalt ?

er zijn denk ik genoeg dingen die je kunt gebruiken:
- windows versie
- user/domain-name
- evt hardware
- bepaalde registersleutels
- landcode
etc etc

[dingstje]

HIGHGuY schreef op donderdag 09 juni 2005 @ 21:10:
er zijn denk ik genoeg dingen die je kunt gebruiken: [...]
- user/domain-name
[...]

Deze zou ik zeker niet gebruiken, aangezien mensen in een bedrijfsomgeving af en toe moeten veranderen van domein (ander gebouw, ander bedrijf, ...).

Ik zou gaan voor een combinatie van serial nummers van hardware en daarin een tolerantiegraad steken, zodat als er één stuk hardware niet overeenkomt het programma nog altijd draait.

[ Voor 1% gewijzigd door dingstje op 09-06-2005 23:01 . Reden: Quote fixed ]

[RobIII]

HIGHGuY schreef op donderdag 09 juni 2005 @ 21:10:
je kunt natuurlijk een uniek computer ID maken, maar wat als de gebruiker net dat component vervangt waar jij je licentie-nr van haalt ?

er zijn denk ik genoeg dingen die je kunt gebruiken:
- windows versie verandert na installatie van een SP al...
- user/domain-name zie dingstje
- evt hardware duh
- bepaalde registersleutels Makkelijk te vinden en easy te wijzigen
- landcode Makkelijk te vinden en easy te wijzigen
etc etc

Het hangt een beetje van de mate van beveiliging af die je wenst, maar echt makkelijk unieke ID's genereren kun je haast niet. Lees het linkje van Don Facundo hierboven maar eens door.

Wat je wél zou kunnen doen is een "dongle" verstrekken bij je software. Die dingen zijn niet zo heel erg duur (en neem je gewoon op in je prijs) en zijn dan nog het veiligst denk ik omdat de ID's erin niet veranderen en uniek zijn. Helaas blijf je houden dat software gekraakt kan worden (heb daar pas nog een topic over geplaatst, maar dat is helaas niet toegankelijk voor de meesten hier). "Ergens" in je software (op 1 of op 1.000.000 plaatsen, dat maakt niet uit) wordt de "licentiecheck" uitgevoerd. Je kunt dit zo ingewikkeld maken als je wil, maar tegen iemand met doorzettingsvermogen en kennis van zaken ben je dan toch nooit helemaal opgewassen. Niet dat de huis-tuin en keukengebruiker er omheen zou kunnen komen, maar een "specialist" vaak wel. En er hoeft er maar 1 te zijn die dat voor "de rest van de wereld" doet... Het is een beetje een afweging van investering en baten...

[ Voor 5% gewijzigd door RobIII op 09-06-2005 23:41 ]

[Tomatoman]

Je wilt een applicatie tegen piraterij beschermen, maar wat is precies de doelstelling? Gaat het om een applicatie die duizenden euro's per licentie kost of is het tientjeswerk? Mag een robuuste beveiliging ten koste gaan van gebruikersgemak? Kun je een (hardware) dongle toepassen?

Je kunt natuurlijk eenvoudigweg een serienummer uitgeven en het programma eenmalig vrijgeven via een server die het serienummer controleert. Dat ondervangt dat een programma vrijelijk wordt verspreid, maar vereist wel dat een gebruiker jou gaat bellen als hij Windows opnieuw installeert. Er zijn legio andere mogelijkheden, waarbij meer gebruikersgemak altijd ten koste gaat van de mate van beveiliging.

[H!GHGuY]

dat die enkele gemakkelijk te vinden en wijzigen zijn dat is waar
maar dan moet de gebruiker ook nog weten dat daarop gecheckt wordt...

bovendien struikel ik hier wat over:

Het nummer moet niet té uniek zijn maar mag best afhankelijk zijn van hardware.

er zijn wel duizend dingen te vinden die je kan gebruiken. dus jij moet gewoon die dingen nemen waarvan je denkt dat ze lokaal (uniek per pc) en redelijk permanent zijn.(evt combinaties)

Op internet zijn er vrijwel geen implementaties te vinden

dat is denk ik redelijk normaal ?

[pjvandesande]

Je programma uitrusten met een automatische update. En als iemand je dus binarie(s) heeft gekraakt worden ze bij een nieuwe update overschreven.
Update ze niet, dan worden bugs niet meer gefixt en nieuwe future's kunnen ze niet van genieten. In het update pakket dat je ontvangt log je gelijk informatie.

Ik heb ook de bedrijfs gegevens van het bedrijf in een serial gezet, dus ze konden niet zelf de bedrijfsgegevens invoeren, maar die werden uit de serial gehaalt. En bij alles dat ze printen staan hun bedrijfs gegevens er bij. Dus pak jij de serial van je buurman, print je bijvoorbeeld facturen met de naam van je buurman er op.

[akakiwi]

Kun je niet heel veilig aannemen dat de PC's binnen je netwerk allemaal een uniek netwerk Id toegekend gekregen hebben?
Dan kun je dat gewoon gebruiken. Dan is het ook nog eens makkelijk terug te zoeken waar die PC staat.

[Verwijderd]

Bij het programmeren met COM gebruikt men guid's, dat zijn nummers die uniek zijn, die gebaseerd zijn op een mac adres. Dus je zou je unieke nummer kunnen baseren op een mac adres.

[Dennis]

RobIII schreef op donderdag 09 juni 2005 @ 23:40:
Het hangt een beetje van de mate van beveiliging af die je wenst, maar echt makkelijk unieke ID's genereren kun je haast niet. Lees het linkje van Don Facundo hierboven maar eens door.

Wat je wél zou kunnen doen is een "dongle" verstrekken bij je software. Die dingen zijn niet zo heel erg duur (en neem je gewoon op in je prijs) en zijn dan nog het veiligst denk ik omdat de ID's erin niet veranderen en uniek zijn. Helaas blijf je houden dat software gekraakt kan worden (heb daar pas nog een topic over geplaatst, maar dat is helaas niet toegankelijk voor de meesten hier). "Ergens" in je software (op 1 of op 1.000.000 plaatsen, dat maakt niet uit) wordt de "licentiecheck" uitgevoerd. Je kunt dit zo ingewikkeld maken als je wil, maar tegen iemand met doorzettingsvermogen en kennis van zaken ben je dan toch nooit helemaal opgewassen. Niet dat de huis-tuin en keukengebruiker er omheen zou kunnen komen, maar een "specialist" vaak wel. En er hoeft er maar 1 te zijn die dat voor "de rest van de wereld" doet... Het is een beetje een afweging van investering en baten...

Op zich denk ik dat de manier die ik hier heb ontwikkeld redelijk veilig is en bijna onkraakbaar. Als iemand gaat proberen om hem te decompilen dan wens ik die persoon veel succes. Met het obfuscaten van code kan je dat iig knap ingewikkeld maken. Ohja dat ik zeg dat het bijna onkraakbaar is is misschien wel een extra uitdaging voor sommige mensen .

Dongles is geen optie, ik werk bij een klein softwarebedrijf en dit zou veel te lastig worden. De truc van updates gebruiken we al, dus inderdaad als je geen geldige licentie heb kun je geen updates downloaden.

Met niet te uniek bedoelde ik overigens dat als er iets wijzigt in de hardwareconfiguratie, dat in principe detecteerbaar moet zijn en op die manier niet meteen het programma blokkeert.

[RobIII]

Dennis schreef op vrijdag 10 juni 2005 @ 10:10:
[...]

Op zich denk ik dat de manier die ik hier heb ontwikkeld redelijk veilig is en bijna onkraakbaar. Als iemand gaat proberen om hem te decompilen dan wens ik die persoon veel succes. Met het obfuscaten van code kan je dat iig knap ingewikkeld maken. Ohja dat ik zeg dat het bijna onkraakbaar is is misschien wel een extra uitdaging voor sommige mensen .

Dongles is geen optie, ik werk bij een klein softwarebedrijf en dit zou veel te lastig worden. De truc van updates gebruiken we al, dus inderdaad als je geen geldige licentie heb kun je geen updates downloaden.

Met niet te uniek bedoelde ik overigens dat als er iets wijzigt in de hardwareconfiguratie, dat in principe detecteerbaar moet zijn en op die manier niet meteen het programma blokkeert.

Als je je code obfuscate is de CODE slecht leesbaar (of onleesbaar ), maar daarmee wordt je binary er niet minder leesbaar op En als je 'm decompiled krijg je écht niet je ge-obfuscate code terug hoor

En, zonder je willen afzeiken, "onkraakbaar" bestaat niet en ik snap niet waar je het "ego" vandaan haalt om dat te denken.

Als je niet met dongles wilt werken kun je het best met questa's idee in zee gaan.

[ Voor 11% gewijzigd door RobIII op 10-06-2005 10:30 ]

[Dennis]

RobIII schreef op vrijdag 10 juni 2005 @ 10:29:
Als je je code obfuscate is de CODE slecht leesbaar (of onleesbaar ), maar daarmee wordt je binary er niet minder leesbaar op En als je 'm decompiled krijg je écht niet je ge-obfuscate code terug hoor

Nee, maar de code die je wél terugkrijgt is wel lastiger leesbaar.

En, zonder je willen afzeiken, "onkraakbaar" bestaat niet en ik snap niet waar je het "ego" vandaan haalt om dat te denken.

Onkraakbaar bestaat inderdaad niet, maar het valt wel redelijk goed te beveiligen.

Als je niet met dongles wilt werken kun je het best met questa's idee in zee gaan.

Dat wordt bij mijn weten ook al gebruikt in de applicatie , alhoewel die niet door mij is ontwikkeld.

[Gerco]

Dennis schreef op vrijdag 10 juni 2005 @ 10:50:
Nee, maar de code die je wél terugkrijgt is wel lastiger leesbaar.

Je krijgt helemaal geen code terug Een kraker kijkt gewoon naar de machinecode die uitgevoerd wordt.

Voorbeeld:

code:

for(int SomeImportantNumber = 0; SomeImportantNumber < 10; SomeImportantNumber++) {
  printf("%d", SomeImportantNumber);
}

code:

for(int a=0;a<10;a++){printf("%d",a);}

Deze twee stukjes leveren precies dezelfde machinecode op (tikfouten voorbehouden) en een kraker zal niet eens weten of jij nu de eerste of de tweede variant gebruikt hebt.

Als je een manier gevonden hebt om de machinecode te obfuscaten lijkt me dat wel interessant om eens te bekijken als je die informatie wilt delen.

[ Voor 16% gewijzigd door Gerco op 10-06-2005 11:01 ]

[Dennis]

Gerco schreef op vrijdag 10 juni 2005 @ 10:59:
Deze twee stukjes leveren precies dezelfde machinecode op (tikfouten voorbehouden) en een kraker zal niet eens weten of jij nu de eerste of de tweede variant gebruikt hebt.

Als je een manier gevonden hebt om de machinecode te obfuscaten lijkt me dat wel interessant om eens te bekijken als je die informatie wilt delen.

Okay. Het is wel zo dat wij gebruik maken van dotfuscator, en die kan aardig wat dingen encrypten. Natuurlijk kan je dan nog steeds alles achterhalen, maar leuker wordt het er niet op voor mensen die dat als doelstelling hebben.

[pjvandesande]

Dennis schreef op vrijdag 10 juni 2005 @ 11:11:
[...]

Okay. Het is wel zo dat wij gebruik maken van dotfuscator, en die kan aardig wat dingen encrypten. Natuurlijk kan je dan nog steeds alles achterhalen, maar leuker wordt het er niet op voor mensen die dat als doelstelling hebben.

Je kan de call naar je functie die alles bekijkt gewoon overslaan.

Is wat simple gezegt, maar zo werkt het wel. En machine code krijg je niet obfuscaten (is dat een goed woord ).

[RobIII]

Dennis schreef op vrijdag 10 juni 2005 @ 10:50:
[...]

Nee, maar de code die je wél terugkrijgt is wel lastiger leesbaar.

Die is identiek aan de code die je terug krijgt van non-obfuscated code hoor
Zie Gerco hier boven mij

Dennis schreef op vrijdag 10 juni 2005 @ 10:50:
[...]
Onkraakbaar bestaat inderdaad niet, maar het valt wel redelijk goed te beveiligen.

Als je er genoeg tijd en geld in stopt wel, maar heb je al eens naar een Crack gezocht? Om maar eens iets te noemen; zo'n beetje iedere Game, zo'n beetje iedere app en zo'n beetje alle software in het algemeen van de "grote jongens" (en dan heb ik het over Microsoft, Adobe, Autodesk, <insert company name here>) is gekraakt of te kraken. Soms al binnen een dag (denk aan Nero en consorten). Die bedrijven hebben er het geld voor en investeren soms veel in beveiliging (denk aan de toch wel 1 van de betere beveiligingen: Windows XP). En toch weten ze het (soms op wat langere termijn, soms in no-time) te "breken". Wat ik dus bedoelde aan te geven is dat je niet te naïef moet zijn in dit soort dingen. Wat is "goed beveiligd"? Waar ligt de grens? Wat is de eis die je er aan stelt en is het de investering waard?

Dennis schreef op vrijdag 10 juni 2005 @ 11:11:
[...]

Okay. Het is wel zo dat wij gebruik maken van dotfuscator, en die kan aardig wat dingen encrypten. Natuurlijk kan je dan nog steeds alles achterhalen, maar leuker wordt het er niet op voor mensen die dat als doelstelling hebben.

Die lui "live and breathe" machine code. Die worden daar echt niet warm of koud van hoor. Alle cracks zijn OF afgeleid van door machine code te stappen, OF afgeleid van "inside weetjes", OF afgeleid van brakke beveiliging (in de trend van: "gooi de binary in een hex-editor en lees het passwoord )
Tevens is er, bij mijn weten, helemaal niks "encrypted" aan dotfuscated code. Het woord zegt het al: Obfuscated. Het is alleen onleesbaar gemaakt door dingen anders te schrijven. Om maar eens iets te noemen: Als je alle variabelen renamed van cusName naar i0O01O01i1l en cusAddress naar i0O01O01l1l krijg je leuke onleesbare code. Zoek de verschillen. En dan met 1000+ variabelen
Maar voor een compiler is het verschil even duidelijk en die compiled het dus gewoon naar dezelfde binary.

questa schreef op vrijdag 10 juni 2005 @ 11:15:
[...]


Je kan de call naar je functie die alles bekijkt gewoon overslaan.

Of de functie altijd dezelfde waarde laten teruggeven...

code:

function IsSerialValid() {
   ...
   ...
   ...
   return true;
}

Maar dan op machine code niveau. De betere beveiligingen verhaspelen dit soort functies een beetje en hebben er waarschijnlijk meer dan 1 (én functies die bijvoorbeeld kijken m.b.v. een hash of de binary is aangepast e.d.)

Zie overigens ook http://msdn.microsoft.com.../dotfuscator/dotf3e5x.asp
Ja, "strings" e.d. kunnen wel "encrypted" worden, maar daarmee je binary niet...

quote: http://msdn.microsoft.com.../dotfuscator/dotf8df7.asp

Goals of Obfuscation
The goal of obfuscation is to create confusion. As confusion builds, the ability of the human mind to comprehend multi-faceted intellectual concepts deteriorates. Note that this precept says nothing about altering the forward (executable) logic – only representing it incomprehensibly. When a well-written obfuscator tool goes to work on readable program instructions, a likely side effect is that the output will not only confuse a human interpreter, it will break a decompiler. While the forward (executable) logic has been preserved, the reverse semantics have been rendered non-deterministic. As a result, any attempt to reverse-engineer the instructions to a programming dialect like C# or VB will likely fail because the translation is ambiguous. Deep obfuscation creates a myriad of decompilation possibilities, some of which might produce incorrect logic if recompiled. The decompiler, as a computing machine, has no way of knowing which of the possibilities could be recompiled with valid semantics. Humans write and employ decompilers to automate decompilation algorithms that are too challenging for the mind to follow. It is safe to say that any obfuscator that confuses a decompiler will pose even more of a deterrence to a less-capable human attempting the same undertaking.

Primitive obfuscators essentially rename identifiers found in the code to something that is unreadable. They may use hashing techniques or arithmetically offset the character set to unreadable or unprintable characters. While superficially effective, it is obvious that these are reversible techniques, and as such, are hardly protective. PreEmptives obfuscation tools go far beyond this primitive renaming approach with additional ingenious ways of creating confusion that make it nearly impossible (and certainly not worth the effort) to reverse-engineer someone elses intellectual property.

Let wel dat ze het hier hebben over decompilers die over hun nek zouden gaan van dotfuscated code. Maar dan hebben ze het dus duidelijk niet over machine code. Kan ook niet, want dat zou de PC zélf de code niet eens meer kunnen runnen. De logica moet immers behouden blijven, al dan niet anders gerangschikt misschien. Het uiteindelijke model is natuurlijk hetzelfde. Er leiden meer wegen naar Rome.

Bekijk ook http://www.gotdotnet.com/...e/preemptive/default.aspx eens...

[ Voor 104% gewijzigd door RobIII op 10-06-2005 11:59 ]