VirtualAlloc() in combinatie met vba: virtuele com add in?

[denpries]

Dag allen.

Ik heb een vraag. Ik programmeer aardig wat in vba, en ik heb laatst iets nieuws uitgeprobeerd:
vbWatchdog (http://www.everythingaccess.com/vbwatchdog.htm).

Ik kwam er alleen maar niet achter hoe het werkte, dus was ik op onderzoek uit gegaan. Uiteindelijk blijkt dat (volgens de enige echte comment) een "virtueel com object" in het geheugen wordt geinjecteerd, door middel van precompiled code, waarna een object aangemaakt kan worden welke vast en zeker beschreven staat in dit object, en daarna zijn ook alle functies beschikbaar welke daar bij horen.

Nu heb ik daar op zich vraagtekens bij: in theorie kun je dus vast ook nare dingen doen met zo iets?

Maar meer geinteresseerd ben ik naar de mogelijkheden die mij dit zelf zou bieden: ik zou essentiele delen van code welke ik liever niet aan iedereen geef kennelijk een stuk beter kunnen beveiligen met zo een oplossing.

Wie is bekend met dit fenomeen en kan mij er meer over vertellen? Misschien heb ik het wel heel erg verkeerd.

code:

‘ ———————————————-
‘ Virtual-COM initialization routine:
‘ ———————————————-
Private m_VCOMObject As Object

Private Sub Class_Initialize()

With m_Loader
.NativeCode = &#8220;%EEEE%::::PPPPPPPPPH+D$ XXXtNXXXXXXVSPPPPj PPPPPPPP4T)D$04P)D$,4&#8217;4 )D$($ PZ3D$@+D$ YQ3H +L$ XP3Q +T$0XPf55ntvf)B|+T$0+T$0+T$0R[YQ^VXP2CP<0tF1D$$kD$$@!L$$2CQ1D$$kD$$@!L$$2CR1D$$kD$$@!L$$2CS+\$,3BP1BP1rP3rP+T$( XXXXXXXXXXXXX[^tJAYAZQ4tPPPPH)D$@4pH)D$84'4 H)D$0$ PH+L$ H3AtH+D$ L3PtL+T$HXPf55{L+T$HL+T$HtqfA)B8ARA[YQXPA2CDHirF[Q^Z[IrzRM wGDDoeTtKTfdGVduCVduCGhiCGhygGhygCmzXGcH[D_J^DV VfF VX<TI@<_veu]flqomliCuelQxpdudatE@hrwIkzSMzvOizw_Mzw_MssLJssLZBCLZ@A]^@A]^TNa^oFmn^nIv@aSsbT?WeWnSg_DCgKjKWCgHe[wJGe;?@fj;Ifyr@cfMAmTN_rNKNzxilIhMnADMgDV@cm;<jihu?aE=]rdY\puMUpgDuAa;UqSWBSPSUG=LUFNNESSOPGVYEbGXQWROj__GHKjOj_MIHKj^x?IRh=XVh=XVKHa;r>cruLna=QKmvHmtvO]HXO]J\O]J\m]hV?]mXmQvgl=tdpaS RUqPBV \PRocNMQflywB>;gFluaO?jKF@UIO ai_vUJ[apwFqeFGfACZVu>[0&#8243;

.LoaderMem = VirtualAlloc(0, Len(.NativeCode), MEM_RESERVE_AND_COMMIT, PAGE_EXECUTE_RW)
If .LoaderMem = 0 Then Err.Raise ERR_OUT_OF_MEMORY

.RootObjectMem = VirtualAlloc(0, ROOTOBJECT_SIZE, MEM_RESERVE_AND_COMMIT, PAGE_EXECUTE_RW)
If .RootObjectMem = 0 Then Err.Raise ERR_OUT_OF_MEMORY

.vtbl_QueryInterface = .LoaderMem
.VTablePtr = VarPtr(m_Loader)
.Kernel32Handle = GetModuleHandleA(&#8220;KERNEL32&#8243;)
.GetProcAddress = GetProcAddress(.Kernel32Handle, &#8220;GetProcAddress&#8221;)
.SysFreeString = GetProcAddress(GetModuleHandleA(&#8220;OLEAUT32&#8243;), &#8220;SysFreeString&#8221;)
Set .HelperObject = New ErrEx_Helper
Call CopyMemory(ByVal .LoaderMem, ByVal .NativeCode, Len(.NativeCode))
Call CopyMemory(.RootObject, VarPtr(.VTablePtr), LenB(.VTablePtr))
.IgnoreFlag = TypeOf .RootObject Is VBA.Collection
Set .ClassFactory = (.RootObject)
Set .RootObject = Nothing
VirtualFree .LoaderMem, 0, MEM_RELEASE
Call .ClassFactory.Init(.Kernel32Handle, .GetProcAddress, OPTION_BASE + OPTION_FLAGS, VBA_VERSION, .HelperObject)
Set m_VCOMObject = .ClassFactory.GetErrEx()
End With

End Sub

en vanaf nu kan ie allerlei dingen doen zoals

code:

Sub DoFinally()
    Call m_VCOMObject.DoFinally
End Sub

Property Get IsEnabled() As Boolean
    IsEnabled = m_VCOMObject.IsEnabled
End Property

Property Get SourceProject() As String
    SourceProject = m_VCOMObject.SourceProject
End Property

Property Get SourceProjectFilename() As String
    SourceProjectFilename = m_VCOMObject.SourceProjectFilename
End Property

[denpries]

schopje

[Gomez12]

Maar meer geinteresseerd ben ik naar de mogelijkheden die mij dit zelf zou bieden: ik zou essentiele delen van code welke ik liever niet aan iedereen geef kennelijk een stuk beter kunnen beveiligen met zo een oplossing.

Als dit je doelstelling is, waarom maak je dan niet dll's aan in willekeurig welke (windows) programmeertaal dan ook en spreek je die niet vanuit vba aan?

Want in wezen als ik het zo zie lijkt het mij voornamelijk een custom oplossing die wel binnen vba past (je hebt totaal geen dll's nodig) maar wel extreem veel test-werk vereist omdat het totaal geen standaard oplossing is.

Ik heb met dat vbWatchDog deels zoiets van : Ze doen het omdat het kan en deels zoiets van : Het lost een probleem op voor specifiek deze usecase (makkelijk uitrolbare vba code zonder extra handelingen).
Ga je de usecase aanpassen dan krijgt bij mij al heel snel het idee : Omdat het kan de overhand. En dat soort ideeen zijn over het algemeen rampzalig voor debuggen etc.

Dus tja, zit je echt in de hoeken en gaten van vba te werken dan kan je dit gebruiken mits je je maar goed beseft wat de consequenties zijn (en waar je moet zoeken als iemand meld : Het werkt niet). Alleen jouw use-case is gewoon een standaard dingetje en lijkt me veel beter op te lossen met standaard methodieken.

[ZaZ]

Dit soort oplossingen zag je wel vaker om de grenzen van vb(a) te doorbreken. Je schrijft wat assembly en compile dat, slaat dat op in een string of byte-array en patch de virtual method table met een pointer naar de nieuwe executable data. Je kan dan echt van alles voor elkaar krijgen wat anders niet mogelijk is.
Dingen zoals 'veilig' subclassen, zeer snelle string operaties of hashes/checksums maken of zelfs COM objecten instantieren zonder gebruik te maken van registry of 'side by side'.

Een aantal nadelen zijn zoals Gomez12 al zegt de onderhoudbaarheid. Je zit ook met assembly te klooien op een erg low level niveau. Als je dat soort code in het wild loslaat heb je (grote) kans dat het op jouw computer werkt en op een andere grijpt data execution prevention weer in etc.
Het kan allemaal wel maar je moet wel weten wat je aan het doen bent.

Persoonlijk zou ik het niet gaan gebruiken als ik jou was. Wil je er toch meer in verdiepen zou ik eens zoeken naar het boek power techniques van Matthew Curland en misschien kijken en of je nog wat dingen van Paul Caton op het internet kan vinden. Een jaar of 10 geleden was ie redelijk populair met artikelen in dat wereldje.
Pin me niet vast op de namen van mensen of boeken want het is lang geleden dat ik het langs heb zien komen. Verbaast me dat het uberhaupt nog in mijn hoofd zit