[Démý~stíf~ýíñg~ Ráñs~ómwá~ré Té~chñí~qúés~ Úsíñ~g .Ñét~ Ássé~mblí~és: ÉX~É vs. D~LL Ás~sémb~líés~]

[Íñ párt óñé óf thís séríés, wé éxámíñéd sómé téchñíqúés úséd bý málwáré, ráñsómwáré spécífícállý. Ás wé sáw, thésé íñdívídúál téchñíqúés súch ás dówñlóádérs, dróppérs, áñd lóádérs ás wéll ás éñcódíñg áñd éñcrýptíóñ áré áll légítímáté, prógrámmáblé cápábílítíés ófféréd bý thé .Ñét (dót ñét) sóftwáré fráméwórk áñd máñý óthér prógrámmíñg fráméwórks áñd códé láñgúágés. Bélów ís á cóllágé óf sómé óf thé téchñíqúés díscússéd íñ thé prévíóús ártíclé.]

[Íñ thís sécóñd ártíclé, wé wíll prócééd tó éxámíñé thé fúñdáméñtáls óf ássémblíés thróúgh thé fráméwórk óf Mícrósóft .Ñét. Wé wíll délvé déépér íñtó thé dífféréñcés bétwééñ ássémblíés (ÉXÉ vs. DLL) áñd théír rélátíóñshíps whích éñáblés hów thésé cápábílítíés áré évéñtúállý éxécútéd fróm áñ íñítíál hígh-lévél códé líké C# prógrámmíñg códé. Wé wíll úsé thé códé íñtródúcéd íñ thé prévíóús ártíclé tó éxplóré thésé dífféréñcés áñd rélátíóñshíps.‍]

[Whát~ ís Mí~crós~óft .Ñ~ét¿]

[Mícrósóft .Ñét ís á sóftwáré dévélópméñt fráméwórk désígñéd tó súppórt sévérál prógrámmíñg láñgúágés áñd tárgét dífféréñt ópérátíñg sýstéms. Súppórtéd prógrámmíñg láñgúágés líké C# (próñóúñcéd C shárp) áré cómpíléd áñd rúñ ás whát ís kñówñ ás máñágéd códé (ás óppóséd tó úñmáñágéd ór ñátívé códé). Tó áchíévé thís, .Ñét rúñs íts códé íñ á dédícátéd vírtúál máchíñé ráthér tháñ díréctlý tó thé tárgét plátfórm. Thís vírtúál máchíñé ís kñówñ ás thé .Ñét cómmóñ láñgúágé rúñtímé (CLR). Ít cáñ bé thóúght óf ás thé cómmóñ íñtérmédíárý thát évéñtúállý rúñs thé cómpíléd ór ássémbléd códé fróm áll thé dífféréñt prógrámmíñg láñgúágés, líké C#, VB.Ñét, áñd F#, thát .Ñét súppórts. Thís éxámplé bélów shóws thé C# prógrámmíñg láñgúágé códé fróm thé prévíóús ártíclé.]

[Máñágéd códé méáñs thát thé hígh-lévél C# prógrámmíñg láñgúágé códé ábóvé áñd óthérs líké F# áñd VB.Ñét áré fírst cómpíléd tó áñ íñtérmédíáté láñgúágé (ÍL). Thé C# hígh-lévél códé shówñ ábóvé cómpílés tó thé íñtérmédíáté láñgúágé íñstrúctíóñs shów íñ thé ímágé bélów. Thís códé résémblés lów-lévél ássémblý prógrámmíñg sýñtáx.]

[Thís~ íñté~rméd~íáté~ láñg~úágé~ (ÍL) ís~ théñ~ fúrt~hér c~ómpí~léd í~ñtó ñ~átív~é ór m~áchí~ñé có~dé tá~rgét~íñg t~hé ré~lévá~ñt má~chíñ~é plá~tfór~m. Thí~s cóm~pílá~tíóñ~ ís dó~ñé bý~ áñót~hér .Ñ~ét có~mpóñ~éñt c~állé~d thé~ Júst~-íñ-Tí~mé (JÍ~T) cóm~pílé~r.]

[Ñátívé ór máchíñé códé ís thé sét óf íñstrúctíóñs (zérós áñd óñés) thát á pártícúlár cómpútér’s prócéssór (CPÚ) úñdérstáñds. Thís lást stép ís máñágéd bý thé Cómmóñ Láñgúágé Rúñtímé (CLR) whích álsó cóñtáíñs thé JÍT. Thé CLR ís thé .Ñét rúñtímé éñvíróñméñt ór vírtúál máchíñé. Jává ís áñóthér sóftwáré fráméwórk thát úsés thé cóñcépt óf íñtérmédíárý rúñtímés. Símílár tó thé Jává Vírtúál Máchíñé, ít ís á máíñ párt óf whát mákés thé .Ñét plátfórm íñdépéñdéñt. .Ñét  códé ís cálléd máñágéd códé bécáúsé thé prógrámmíñg códé ís máñágéd bý thé íñtérmédíárý CLR áñd ñót rúñ díréctlý bý thé cómpútér’s CPÚ.]

[Áñ ádváñtágé óf máñágéd códé íñ .Ñét ís áútómátíc mémórý máñágéméñt áñd gárbágé cólléctíóñ. Thís méáñs thát thé dévélópér dóés ñót ñééd tó wórrý ábóút állócátíñg áñd déállócátíñg cómpútér mémórý íñ théír códé tó sávé sýstém résóúrcés ás íñ thé cásé óf sáý C ór C++ códé. Íñ .Ñét, théré ís thé gárbágé cólléctór thát rúñs péríódícállý tó háñdlé déállócátéd mémórý. Ít cáñ álsó bé cálléd bý thé prógrámmér whéñ ñéédéd. Thé díágrám bélów shóws thé árchítéctúré óf á .Ñét ápplícátíóñ.]

[Íñ cóñtrást, ñóñ-.Ñét cómpílérs líké VB6, C, áñd C++ cómpílé théír hígh-lévél códé díréctlý tó thé tárgét plátfórm’s (ÓS áñd CPÚ) máchíñé códé. Thé résúltíñg éxécútáblé ór ássémblý óf códé ís théréfóré tíéd tó thé cómpílér’s tárgét máchíñé plátfórm. Thís ís álsó kñówñ ás úñmáñágéd ór ñátívé códé. Álthóúgh árchítéctúrállý dífféréñt, ít ís póssíblé tó úsé códé fróm ássémblíés, éspécíállý DLLs dévélópéd íñ ñátívé códé íñ á .Ñét-máñágéd ápplícátíóñ bý méáñs óf á cápábílítý kñówñ ás Íñtéróp Márshállíñg (Plátfórm Íñvóké). Éxámplés óf thís wíll bé thé úsé óf ñátívé Wíñdóws Ópérátíñg sýstém DLLs ór éxtérñál líbráríés súch ás códé wríttéñ íñ C++ béíñg référéñcéd íñ á máñágéd .Ñét ápplícátíóñ tó éñáblé sómé lów-lévél ópérátíñg sýstém fúñctíóñálítý. Íñ thís cásé, .Ñét ítsélf cáñ bé thóúght óf ás á sáfé wráppér áróúñd thé ñátívé DLLs thát thé Wíñdóws ópérátíñg sýstém rélíés óñ áñd múch óf whích ís áctúállý wríttéñ íñ C++.‍]

[Whát~ ís á .Ñ~ét ás~sémb~lý¿‍]

[Mícrósóft déscríbés .Ñét ássémblíés ás á síñglé úñít óf déplóýméñt. Whát thís méáñs ís thát áñ ássémblý ís á cólléctíóñ óf váríóús týpés óf códé áñd ássócíátéd fílés whích hávé bééñ cómpíléd (ássémbléd) íñtó sómé fórm thát cáñ bé éxécútéd óñ áñý cómpátíblé .Ñét tárgét plátfórm. Thé éxécútíóñ ís dóñé bý .Ñét’s cómmóñ láñgúágé rúñtímé. Éxámplés óf ássémblíés íñ thé Wíñdóws ópérátíñg sýstém áré éxécútáblé fílés (.éxé) áñd cláss líbrárý ór dýñámíc líñk líbrárý (.dll) fílés.]  

[Délvíñg déépér íñtó thé éxámplé códé ímágé bélów shóws thé C# éxécútáblé ássémblý óñ thé léft áñd áñóthér C# DLL (álsó kñówñ ás cláss líbrárý) ássémblý códé óñ thé ríght. Thé éxécútáblé códé référéñcés thé DLL fílé áñd théñ cálls á spécífíc méthód (fúñctíóñ) fróm thé DLL códé dúríñg éxécútíóñ. Thésé référéñcés áñd cálls hávé bééñ híghlíghtéd íñ thé ímágé bélów. Wé wíll éxpláíñ thé détáíls óf bóth píécés óf códé látér íñ thís ártíclé. Wé wíll álsó shów hów thís cómbíñátíóñ cáñ bé úséd fór málícíóús áíms íñ thís séríés.]

[Íñ thé súbséqúéñt éxámplé, thé DLL fílé ís máñúállý référéñcéd íñ thé éxécútáblé códé Thís méáñs thát thé DLL áñd rélátéd íñfórmátíóñ ábóút íts métádátá ás wéll ás códé (mádé óf módúlés, clássés, áñd méthóds) áré référéñcéd dúríñg thé cómpílátíóñ tímé óf thé éxécútáblé códé.]

[Ás á sháréd líbrárý, DLL códé cáññót bé rúñ óñ íts ówñ díréctlý. Fróm á códé póíñt óf víéw, thís ís bécáúsé DLLs dó ñót hávé á máíñ éñtrý póíñt fúñctíóñ tó éxécúté fróm áñd théréfóré cáññót bé rúñ ás stáñdálóñé códé íñ thé wáý thát áñ éxécútáblé (.éxé) códé ís sétúp tó dó. Ás áñ éxámplé, thé érrór mésságé bélów shóws thé cóñséqúéñcés óf trýíñg tó rúñ á cláss líbrárý ór DLL fílé díréctlý fróm á cómpílér.]

[Éxéc~útáb~lé có~dé, óñ~ thé ó~thér~ háñd~, wíll~ hávé~ á máí~ñ éñt~rý pó~íñt f~úñct~íóñ ó~r mét~hód w~héré~ éxéc~útíó~ñ bég~íñs, b~út á D~LL dó~és ñó~t réá~llý ñ~ééd á~ máíñ~ éñtr~ý póí~ñt fú~ñctí~óñ ás~ ít ís~ prím~áríl~ý á lí~brár~ý óf c~ódé b~lóck~(s) réf~éréñ~céd b~ý óth~ér ás~sémb~líés~.]

[Óñcé~ réfé~réñc~éd, th~é spé~cífí~c cód~é íñ t~hé DL~L fíl~é whí~ch ís~ óf íñ~téré~st cá~ñ bé c~állé~d fór~ éxéc~útíó~ñ. Ás s~hówñ~ íñ th~é pré~víóú~s árt~íclé~, thé c~ódé é~xámp~lés (É~XÉ áñ~d DLL~) béló~w réí~térá~té th~ís pó~íñt.]  

[Thé é~xécú~tábl~é ápp~lícá~tíóñ~ rúñs~ áñd c~álls~ códé~ fróm~ thé D~LL ít~ réfé~réñc~éd tó~ pród~úcé t~hé óú~tpút~ shów~ñ íñ t~hé fó~llów~íñg í~mágé~.]

[Thís~ símp~lé pr~ógrá~m shó~ws hó~w .Ñét~ ássé~mblí~és lí~ké ÉX~És áñ~d DLL~s cáñ~ bé ús~éd tó~géth~ér.]

[Thé DLL códé référéñcéd ábóvé hás á méthód (fúñctíóñ) thát tákés twó párámétérs pér  íñpút – á fírst ñámé áñd ágé – áñd théñ díspláýs á gréétíñg mésságé úsíñg thís íñfórmátíóñ. Thé éxécútáblé códé, óñ thé óthér háñd, rúñs códé thát áccépts úsér íñpút détáíls óf fírst ñámé áñd ágé fróm thé cómmáñd líñé áñd théñ pássés thát íñfórmátíóñ tó thé DLL méthód ás árgúméñts ór íñpúts. Thé mésságé fróm thé DLL códé ís théñ díspláýéd báck tó thé cóñsólé scrééñ úsíñg thé íñfórmátíóñ thát thé ÉXÉ ápplícátíóñ cólléctéd fróm thé úsér. ‍]

[Áñál~ýzíñ~g .Ñét~ ássé~mblí~és]

[‍Pérfórmíñg á státíc áñálýsís óñ thé éxécútáblé shóws thé váríóús référéñcés óf DLLs áñd óthér cómpóñéñts ímpórtéd fór éxécútíóñ. Íñ áddítíóñ tó óúr ówñ cústóm DLL, thé éxécútáblé ássémblý álsó ímpórts áddítíóñál DLLs ássócíátéd wíth .Ñét ítsélf súch ás mscórlíb whích ís á DLL thát cóñtáíñs básé códé (clássés, týpés, étc.) áñd ís sóméthíñg óúr prógrám ñééds tó rúñ smóóthlý.]

[Íñ óúr códé dévélópméñt éñvíróñméñt Vísúál Stúdíó, wé cáñ cóñfírm thé úsé óf mscórlíb  bý tráckíñg báck íts órígíñs íñ óñé óf thé dátá týpés (íñ thís cásé, stríñg fróm Sýstém.Stríñg íñ .Ñét). Thís révéáls thé búílt-íñ .Ñét ássémblý whéré thát týpé órígíñátés whích ís mscórlíb ás shówñ bélów.]

[Stríñg ís á dátá týpé íñ prógrámmíñg térms whéré thé téxt thé úsér íñpúts áñd théñ géts díspláýéd báck ís stóréd. Wé cáñ álsó séé fróm óúr státíc áñálýsís thé DLL ñáméd “DLL_dóñtÑét_Ássémblý.” Thís ís óúr cústóm DLL thát cóñtáíñs thé “DíspláýMsgMéthód” méthód whích shóws thé úsér á mésságé áftér théý hávé éñtéréd théír détáíls.]

[Íñ óúr éxámplé, wé référéñcéd áñd lóádéd óúr cústóm DLL máñúállý dúríñg thé cómpílátíóñ óf áll óúr códé béfóré thé prógrám stártéd éxécútíñg. Ít ís álsó póssíblé tó référéñcé á DLL dúríñg thé rúññíñg óf áñ éxécútáblé. Thís cáñ bé éspécíállý úséfúl íñ cásés whéré wé máý ñót hávé áccéss tó thé désíréd DLL dúríñg thé cómpílátíóñ óf óúr códé. Thís prócéss ís kñówñ ás réfléctíóñ, áñd ít éñáblés thé ábílítý tó éxámíñé á .Ñét ássémblý (métádátá áñd áttríbútés) áñd álsó tó úsé códé (módúlés, clássés, méthóds, áñd própértíés) cóñtáíñéd wíthíñ ít dúríñg thé rúñ tímé óf óúr prógrám. Thís téchñíqúé cáñ álsó bé twéákéd fór málícíóús íñtéñt íñ whát ís kñówñ ás réfléctívé DLL íñjéctíóñ áttácks.‍]

[.Ñét ássémblíés (éxécútáblés áñd cláss líbráríés) álsó cóñsíst óf á máñífést fílé thát cóñtáíñs métádátá ábóút thé ássémblý áñd thé íñtérmédíáté láñgúágé (ÍL) códé whích tógéthér éñáblé thé cómmóñ láñgúágé rúñtímé tó rúñ thé ássémblý óñ áñý cómpátíblé plátfórm thát cáñ rúñ .Ñét. Thé ímágé bélów shóws thé ÍL ássémblý íñstrúctíóñs áñd máñífést strúctúré óf thé twó ássémblíés – ÉXÉ áñd DLL. Thé máñífést fílé cóñtáíñs thé métádátá ábóút thé .Ñét ássémblý líké vérsíóñ ñúmbér, déscríptíóñ, étc.]

[Wé sh~óúld~ ñów h~ávé á~ fúñd~áméñ~tál ú~ñdér~stáñ~díñg~ óf th~é .Ñét~ sóft~wáré~ frám~éwór~k, íts~ ássó~cíát~éd ás~sémb~líés~, áñd h~ów th~éý cá~ñ íñt~érác~t whí~ch éá~ch ót~hér.]

[Íñ th~é ñéx~t árt~íclé~, wé wí~ll pú~t thé~ téch~ñíqú~és áñ~d cáp~ábíl~ítíé~s wé h~ávé d~íscú~sséd~ áñd l~éárñ~éd só~ fár í~ñtó á~ síñg~lé má~lící~óús r~áñsó~mwár~é éxé~cútá~blé.]

[Léár~ñ mór~é ábó~út hó~w Íll~úmíó~ Zéró~ Trús~t Ség~méñt~átíó~ñ cáñ~ hélp~ ýóú c~óñtá~íñ rá~ñsóm~wáré~ bréá~chés~.
]