VERSION 1.0 CLASS
BEGIN
  MultiUse = -1  'True
  Persistable = 0  'NotPersistable
  DataBindingBehavior = 0  'vbNone
  DataSourceBehavior  = 0  'vbNone
  MTSTransactionMode  = 0  'NotAnMTSObject
END
Attribute VB_Name = "clsRegistryAccess"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = True
Attribute VB_PredeclaredId = False
Attribute VB_Exposed = False
            '--------------------------------------------[-][x]--'
            '----------------[ Registry Access ]-----------------'
            '----------------------------------------------------'
            '     ______________________                         '
            '     Ime: clsRegistryAccess                         '
            '     Tip: Class Module                              '
            '     Verzija: 2.00                                  '
            '     Autor: Aleksandar Ruzicic - krckoorascic       '
            '     Koautor: -                                     '
            '     Kontakt: tesla.scg@gmail.com                   '
            '     Zavrseno: Subota, Novembar 13, 2004 02:38      '
            '     ______________________                         '
            '     Hvala:                                         '
            '     -The KPD-Team na njihovom API-Guide-u!         '
            '     -mladenovicz za svu pruzenu pomoc              '
            '     -svim ljudima sa EliteSecurity foruma          '
'-------------------------------------------------------------------------------'
'[-]Licence:                                                                    '
'Autor ovog koda nije odgovoran za bilo kakve komplikacije nastale koriscenjem  '
'ove klase, koristite ovaj kod na sopstvenu odgovornost! Kod je u potpunosti    '
'besplatan i moze biti distribuiran u bilo kom obliku sve dok ime autora i ova  '
'licenca stoje na pocetku koda. Ukoliko pronadjete neki bug obratite se autoru  '
'preko mail-a i posaljite moguce resenje (ako znate), a ako nesto izmenite      '
'dodajte vase ime u "polju" 'Koautor'.                                          '
'                                                                               '
'[-]Uvod - o Registry-ju                                                        '
'Registry je baza podataka u kojoj se cuvaju podesavanja za 32-o bitne verzije  '
'Microsoft Windows-a (9x/ME/NT/2000/XP/2003), i za aplikacije namenjene windows '
'platformama. Registry baza se nalazi u fajlovima SYSTEM.DAT i USER.DAT kao i u '
'CLASSES.DAT (u windows-u ME), koji se nalaze u %WinDir%\ folderu, za Win 9x/Me,'
'%WinDir%\System32\Config folderu za Win NT/2000/XP. Ove fajlove ne mozete rucno'
'editovati vec morate koristit tzv. Registry alate, kao sto je Registry Editor  '
'koji dolazi uz sve (32-o bitne) verzije windowsa (%WinDir%\regedit.exe).       '
'Koriscenjem ove klase mozete pristupiti registry bazi i imati sve mogucnosti   '
'kao i Registry Editor. Mislim da je sve ovo vama sigurno poznato [ako nije, ja '
'vam toplo preporucujem da se jos neko vreme ne bavite registry bazom :o)], ali '
'nije na odmet podsetiti se! Samo jos jedna napomena pre nego sto pocnete da se '
'"igrate" sa Registry-jem: BACKUPUJTE SYSTEM.DAT i USER.DAT (kao i CLASSES.DAT u'
'Win ME)!!! Jer veoma lako moze doci do pada sistema! (govorim vam ovo iz licnog'
'iskustva!). Toliko o registry-ju...                                            '
'                                                                               '
'Sadrzaj:                                                                       '
' [1] - rcMainKey (Enum)                                                        '
' [2] - rcRegType (Enum)                                                        '
' [3] - CreateKeyIfDoesntExists (Property)                                      '
' [4] - GetKeys (Private Function)                                              '
' [5] - CreateKey (Function)                                                    '
' [6] - KillKey (Function)                                                      '
' [7] - KeyExists (Function)                                                    '
' [8] - EnumKeys (Function)                                                     '
' [9] - WriteString (Function)                                                  '
' [10] - ReadString (Function)                                                  '
' [11] - WriteDWORD (Function)                                                  '
' [12] - ReadDWORD (Function)                                                   '
' [13] - WriteBinary (Function)                                                 '
' [14] - ReadBinary (Function)                                                  '
' [15] - KillValue (Function)                                                   '
' [16] - ValueExists (Function)                                                 '
' [17] - EnumValues (Function)                                                  '
' [18] - ExportToReg (Function)                                                 '
' [19] - generateReg (Private Function)                                         '
' [20] - ImportFromReg Function)                                                '
' [21] - StrToBin (Private Function)                                            '
' [22] - BinToStr (Private Function)                                            '
' [23] - isBinValid (Function)                                                  '
' _____________________________________                                         '
' [1] rcMainKey (Enum)                                                          '
' Enum (public) koji sadrzi sve root kljuceve (mada je moguce upisivati samo u  '
' sldecih 5: HKCR, HKCU, HKLM, HKUS, HKCC.                                      '
'                                                                               '
' [2] rcRegType (Enum)                                                          '
' Enum (Public) koji sadrzi sve vrste reg tipova, mada su u ovoj klasi samo     '
' pokrivena tri osnovna (REG_SZ, REG_DWORD, REG_BINARY).                        '
'                                                                               '
' [3] CreateKeyIfDoesntExists (Property)                                        '
' Property, Boolean, Let/Get; prilikom upisivanja neke vrednosti ukoliko kljuc  '
' u koji se upisuje ne postoji, ako je ovaj property podesen na true onda ce    '
' sporan kljuc biti napravljen (CreateKey).                                     '
'                                                                               '
' [4] GetKeys (Private Function)                                                '
' Privatna funkcija koja razdvaja putanju do kljuca u dva dela, MainKey i SubKey'
' takodje ova funkcija omogucuje koriscenje skracenica za root-ove, npr. umesto '
'       HKEY_LOCAL_MACHINE                                                      '
' mozete koristiti (a i ne morate)                                              '
'       HKLM                                                                    '
' skracenicu, sto je, priznacete, mnogo jednostavnije.                          '
' Skracenice su sledece (mislim da je ovo ocigledno, ali radi reda...):         '
'       HKEY_CLASSES_ROOT ........ HKCR                                         '
'       HKEY_CURRENT_USER ........ HKCU                                         '
'       HKEY_LOCAL_MACHINE ....... HKLM                                         '
'       HKEY_USERS ............... HKUS                                         '
'       HKEY_PERFORMANCE_DATA .... HKPD                                         '
'       HKEY_CURRENT_CONFIG ...... HKCC                                         '
'       HKEY_DYN_DATA ............ HKCR                                         '
'                                                                               '
' [5] CreateKey (Function)                                                      '
' Kreira novi kljuc (ako vec ne postoji) u registry-ju                          '
' CreateKey(sPath) As Long                                                      '
' sPath - string koji sadrzi putanju do kljuca koji ce kreira npr.              '
'       CreateKey("HKCU\Software\ES")                                           '
' Funcija vraca:                                                                '
' 0 - ako je doslo do greske                                                    '
' handle napravljenog kljuca - bas nekorisno :o)                                '
'                                                                               '
' [6] KillKey (Function)                                                        '
' Brise postojeci kljuc iz baze                                                 '
' KillKey(sPath) As Long                                                        '
' sPath - string koji sadrzi putanju do kljuca koji se brise npr.               '
'       KillKey("HKCU\Software\ES")                                             '
' Funkcija vraca:                                                               '
' 0 - ako je doslo do greske (kljuc nije obrisan, jer ne postoji)               '
' handle obrosanog kljuca (!?!)                                                 '
'                                                                               '
' [7] KeyExists (Function)                                                      '
' Proverava da li kljuc postoji                                                 '
' KeyExists(sPath) As Boolean                                                   '
' sPath - string koji sadrzi putanju do kljuca koji se proverava npr.           '
'        KeyExists("HKCU\Software\ES\Login")                                    '
' Funkcija vraca:                                                               '
' True - ako kljuc postoji                                                      '
' False - ako kljuc ne postoji                                                  '
'                                                                               '
' [8] EnumKeys (Function)                                                       '
' Vraca skup podkljuceva datog kljuca                                           '
' EnumKeys(sPath, Key() As String) As Long                                      '
' sPath - string koji sadrzi putanju do kljuca ciji se podkljucevi citaju       '
' Key() - prazan, nefiksiran array (!) koji ce biti popunjen imenima podkljuceva'
'       EnumKeys("HKCU\Software",Ime)                                           '
' Funkcija vraca:                                                               '
' -1 - ako je doslo do greske                                                   '
' broj podkljuceva                                                              '
' popunjen array koji je 0-based (imena nisu sortirana)                         '
'                                                                               '
' [9] WriteString (Function)                                                    '
' Upisuje string vrednost u bazu                                                '
' WriteString(sPath, sName, sValue) As Long                                     '
' sPath - string vrednost koja sadrzi putanju do kljuca u koji se upisuje       '
' sName - string koji sadrzi ime vrednosti koja se kreira/edituje               '
' sValue - string koji sadrzi vrednost koja upisuje                             '
'       WriteString("HKCU\Software\ES", "@", "http://www.elitesecurity.org")    '
' Napomena: za editovanje '(Default)' vrednosti kao ime mozete koristiti '@' ili'
' jednostavno mozete proslediti prazan string; vbNullString - ""                '
' Funkcija vraca:                                                               '
' 0 - ako je doslo do greske                                                    '
' handle kljuca u koji je upisana vrednost                                      '
'                                                                               '
' [10] ReadString (Function)                                                    '
' Vraca vrednost string vrednosti iz registry-ja                                '
' ReadString(sPath, sName, [Default]) As String                                 '
' sPath - string koji sadrzi putanju do kljuca iz kog se cita                   '
' sName - string koji sadrzi ime vrednosti koja se cita                         '
' sDefault - string, opcioni parametar (vbNullChar - Chr$(0)) koji je vracen ako'
' je doslo do greske prilikom citanja vrednosti (verovatno vrednost ne postoji) '
'       ReadString("HKCU\Software\ES", "Username", "krckoorascic")              '
' Funkcija vraca:                                                               '
' sDefault parametar - ako je doslo do greske                                   '
' string vrednost - ako je uspesno procitano                                    '
'                                                                               '
' [11] WriteDWORD (Function)                                                    '
' Upisuje DWORD vrednost u bazu                                                 '
' WriteDWORD(sPath, sName, lValue) As Long                                      '
' sPath - string koji sadrzi putanju do kljuca u koji se upisuje                '
' sName - string koji sadrzi ime vrednosti koja se kreira/edituje               '
' lValue - long vrednost koja se upisuje u bazu                                 '
'       WriteDWORD("HKCU\Software\ES", "AutoLogin", 1)                          '
' Funkcija vraca:                                                               '
' 0 - ako je doslo do greske                                                    '
' handle kljuca u koji je upisana vrednost                                      '
'                                                                               '
' [12] ReadDWORD (Function)                                                     '
' Vraca vrednost DWORD vrednosti iz registry-ja                                 '
' ReadDWORD(sPath, sName, [lDefault]) As Long                                   '
' sPath - string koji sadrzi putanju do kljuca iz koga se cita                  '
' sName - string koji sadrzi ime vrednosti koja se cita                         '
' lDefault - long, opcioni parametar (-1) koji je vracen ako je doslo do greske '
'       ReadDWORD("HKCU\Software\ES", "AutoLogin", 0)                           '
' Funkcija vraca:                                                               '
' lDefault parametar - ako je doslo do greske (vrednost verovatno nepostoji)    '
' long vrednost - ako je uspesno procitano                                      '
'                                                                               '
' [13] WriteBinary (Function)                                                   '
' Upisuje Binary vrednost u registry                                            '
' WriteBinary(sPath, sName, sValue) As Long                                     '
' sPath - string koji sadrzi putanju do kljuca u koji se upisuje vrednost       '
' sName - string koji sadrzi ime vrednosti                                      '
' sValue - string koji prestavlja vrednost koja se upisuje. Vrednost mora biti u'
' Hex formatu, ne mora biti UpperCase i mogu se koristiti razmaci posle svaka 2 '
' karaktera(nista sem "A-F", "0-9" i " "[razmak] nije dozvoljeno!)              '
'       WriteBinary("HKCU\Software\ES", "Password", "FF 20 3E 0B AF 00 00")     '
' Funkcija vraca:                                                               '
' 0 - ako je doslo do greske                                                    '
' handle kljuca u koji je upisana vrednost                                      '
'                                                                               '
' [14] ReadBinary (Function)                                                    '
' Vraca string koji predstavlja binary vrednost u registry-ju                   '
' ReadBinary(sPath, sName, [sDefault]) As String                                '
' sPath - string koji sadrzi putanju do lkuca iz koga se cita vrednost          '
' sName - string koji sadrzi ime vrednosti koja se cita                         '
' sDefault - string, opcioni parametar (vbNullChar - Chr$(0)) koji je vracen ako'
' je doslo do greske (kljuc, ili vrednost ne postoji)                           '
'        ReadBinary("HKCU\Software\ES", "Password", "FF 20 3E 0B AF 00 00")     '
' Funkcija vraca:                                                               '
' sDefault parametar - ako je doslo do greske prilikom citanja                  '
' string vrednost - ako je uspesno procitano (npr. "3E BE 00 00")               '
'                                                                               '
' [15] KillValue (Function)                                                     '
' Brise bilo koju vrednost iz registry-ja                                       '
' KillValue(sPath, sName) As Long                                               '
' sPath - string koji sadrzi putanju do kljuca u kome se nalazi vrednost        '
' sName - string koji sadrzi ime vrednosti koja se brise                        '
'        KillValue("HKCU\Software\ES", "Password")                              '
' Funkcija vraca:                                                               '
' 0 - ako je doslo do greske (vrednost nije obrisana)                           '
' handle kljuca u kome se nalazila vrednost (obrisano)                          '
'                                                                               '
' [16] ValueExists (Function)                                                   '
' Proverava da li neka vrednost postoji                                         '
' ValueExists(sPath, sName) As Boolean                                          '
' sPath - string koji sadrzi putanju do kljuca u kome se nalazi vrednost        '
' sName - string koji sadrzi ime vrednosti koja se proverava                    '
'       ValueExists("HKCU\Software\ES", "Username")                             '
' Funkcija vraca:                                                               '
' True - ako vrednost postoji                                                   '
' False - ako vrednost ne postoji                                               '
'                                                                               '
' [17] EnumValues (Function)                                                    '
' Vraca skupove imena vrednosti i vrednosti jednog kljuca                       '
' EnumValues(sPath, sName(), sValue(), [OnlyType]) As Long                      '
' sPath - string koji sadrzi putanju do kljuca iz koga se 'vade' vrednosti      '
' sName() - prazan, nefiksiran (!) string array koji ce biti ispunjen imenima   '
' sValue() - prazan, nefiksiran (!) variant array koji ce biti ispunjen         '
' vrednostima (ni jedan array nije sortiran)                                    '
' OnlyType - rcRegType, opcioni parametar (REG_NONE - 0) koji prestavlja filter '
' za citanje vrednosti (ako je OnlyType REG_SZ, samo string vrednosti ce biti   '
' iscitane, ako OnlyType nije dat [REG_NONE] onda su sve tri vrste vracene.     '
'        EnumValues("HKCU\Software", Ime, Vrednost, REG_BINARY)                 '
' Funkcija vraca:                                                               '
' -1 - ako je doslo do greske                                                   '
' broj procitanih vrednosti                                                     '
' popunjene array-e (imena i vrednosti) koji su 0-based                         '
'                                                                               '
' [18] ExportToReg (Function)                                                   '
' Generise .reg fajl (isto kao i Registry Editor)                               '
' ExportToReg(sPath, sRegFile [Output]) As Long                                 '
' sPath - string koji sadrzi putanju do kljuca od koga se pocinje               '
' sRegFile - string koji predstavlja putanju do .reg fajla (path\filename) koji '
' ce biti kreiran, ako fajl vec postoji bice vracena greska.                    '
' Output - textbox, opcioni parametar. Ako je naznacen u textboxu ce biti upisan'
' kljuc koji se trenutno cita (cisto da prikaze da se nesto desava, jer na malo '
' sporijim masinama moze da potraje ako se ceo root eksportuje)                 '
'        ExportToReg("HKCU\Software\ES", "C:\ES.reg")                           '
' Funkcija vraca:                                                               '
' 0 - ako je doslo do greske                                                    '
' 1 - ako je reg fajl uspesno generisan                                         '
'                                                                               '
' [19] generateReg (Private Function)                                           '
' Privatna rekruzivna funkcija koja zapravo vrsi eksportovanje, pozvana je od   '
' strane ExportToReg funkcije sa istim parametrima.                             '
' Funkcija vraca:                                                               '
' False - ako je doslo do greske                                                '
' True - ukoliko je uspesno iscitan kljuc (i upisan u reg)                      '
'                                                                               '
' [20] ImportFromReg (Function)                                                 '
' Ubacuje .reg fajl u registry bazu (isto kao i Registry Editor)                '
' ImportFromReg(sRegFile) As Long                                               '
' sRegFile - string koji sadrzi putanju do reg fajla koji se ubacuje u bazu     '
'       ImportFromReg("C:\ES.reg")                                              '
' Funkcija vraca:                                                               '
' 0 - ako je doslo do greske (ili ako fajl ne postoji)                          '
' 1 - ako je uspeno ubaceno u registry                                          '
'                                                                               '
' [21] StrToBin (Private Function)                                              '
' Koristi se kog WriteBinary funkcije; prebacuje npr. "BE 3E FF AB" u "¾>ÿ«"    '
' (vrednost koja ce biti pretvorena u byte array i snimljena u bazu)            '
'                                                                               '
' [22] BinToStr (Private Function)                                              '
' Koristi se kog ReadBinary funkcije; prebacuje npr. "¾>ÿ«" u "BE 3E FF AB"     '
' (vrednost u, nama, razumljivom formatu)                                       '
'                                                                               '
' [23] isBinValid (Function)                                                    '
' Proverava da li je data vrednost ispravna (za WriteBinary funkciju).          '
' isBinValid(sBin) As Boolean                                                   '
' sBin - string kome se proverava validnost                                     '
'        isBinValid("3E BE 00 AS") - ovde ce vratiti False                      '
' Funkcija vraca:                                                               '
' True - ukoliko string ne sadrzi nista sem "A"-"F" 0-9 i " "(razmak)           '
' False - ukoliko string nije ispravan (za upisivanje u bazu)                   '
'                                                                               '
'-------------------------------------------------------------------------------'
'Copyright © 2004, krckoorascic, tesla.scg@gmail.com                            '
'-------------------------------------------------------------------------------'

'----[ API's ]----'
Private Declare Function RegOpenKey Lib "advapi32.dll" Alias "RegOpenKeyA" (ByVal hKey As Long, ByVal lpSubKey As String, phkResult As Long) As Long
Private Declare Function RegOpenKeyEx Lib "advapi32.dll" Alias "RegOpenKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, ByVal ulOptions As Long, ByVal samDesired As Long, phkResult As Long) As Long
Private Declare Function RegCloseKey Lib "advapi32.dll" (ByVal hKey As Long) As Long
Private Declare Function RegCreateKey Lib "advapi32.dll" Alias "RegCreateKeyA" (ByVal hKey As Long, ByVal lpSubKey As String, phkResult As Long) As Long
Private Declare Function RegDeleteKey Lib "advapi32.dll" Alias "RegDeleteKeyA" (ByVal hKey As Long, ByVal lpSubKey As String) As Long
Private Declare Function RegEnumKeyEx Lib "advapi32.dll" Alias "RegEnumKeyExA" (ByVal hKey As Long, ByVal dwIndex As Long, ByVal lpName As String, lpcbName As Long, ByVal lpReserved As Long, ByVal lpClass As String, lpcbClass As Long, lpftLastWriteTime As Any) As Long
Private Declare Function RegEnumValue Lib "advapi32.dll" Alias "RegEnumValueA" (ByVal hKey As Long, ByVal dwIndex As Long, ByVal lpValueName As String, lpcbValueName As Long, ByVal lpReserved As Long, lpType As Long, lpData As Any, lpcbData As Long) As Long
Private Declare Function RegQueryValueEx Lib "advapi32.dll" Alias "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As String, ByVal lpReserved As Long, lpType As Long, ByVal lpData As String, lpcbData As Long) As Long
Private Declare Function RegQueryValueExA Lib "advapi32.dll" (ByVal hKey As Long, ByVal lpValueName As String, ByVal lpReserved As Long, lpType As Long, ByRef lpData As Long, lpcbData As Long) As Long
Private Declare Function RegSetValueEx Lib "advapi32.dll" Alias "RegSetValueExA" (ByVal hKey As Long, ByVal lpValueName As String, ByVal Reserved As Long, ByVal dwType As Long, ByVal lpData As String, ByVal cbData As Long) As Long
Private Declare Function RegSetValueExA Lib "advapi32.dll" (ByVal hKey As Long, ByVal lpValueName As String, ByVal Reserved As Long, ByVal dwType As Long, ByRef lpData As Long, ByVal cbData As Long) As Long
Private Declare Function RegSetValueExB Lib "advapi32.dll" Alias "RegSetValueExA" (ByVal hKey As Long, ByVal lpValueName As String, ByVal Reserved As Long, ByVal dwType As Long, ByRef lpData As Byte, ByVal cbData As Long) As Long
Private Declare Function RegDeleteValue Lib "advapi32.dll" Alias "RegDeleteValueA" (ByVal hKey As Long, ByVal lpValueName As String) As Long

'----[ Constants ]----'
Private Const ERROR_SUCCESS = 0&
Private Const ERROR_BADDB = 1009&
Private Const ERROR_BADKEY = 1010&
Private Const ERROR_CANTOPEN = 1011&
Private Const ERROR_CANTREAD = 1012&
Private Const ERROR_CANTWRITE = 1013&
Private Const ERROR_OUTOFMEMORY = 14&
Private Const ERROR_INVALID_PARAMETER = 87&
Private Const ERROR_ACCESS_DENIED = 5&
Private Const ERROR_NO_MORE_ITEMS = 259&
Private Const ERROR_MORE_DATA = 234&
Private Const KEY_QUERY_VALUE = &H1&
Private Const KEY_SET_VALUE = &H2&
Private Const KEY_CREATE_SUB_KEY = &H4&
Private Const KEY_ENUMERATE_SUB_KEYS = &H8&
Private Const KEY_NOTIFY = &H10&
Private Const KEY_CREATE_LINK = &H20&
Private Const READ_CONTROL = &H20000
Private Const WRITE_DAC = &H40000
Private Const WRITE_OWNER = &H80000
Private Const SYNCHRONIZE = &H100000
Private Const STANDARD_RIGHTS_REQUIRED = &HF0000
Private Const STANDARD_RIGHTS_READ = READ_CONTROL
Private Const STANDARD_RIGHTS_WRITE = READ_CONTROL
Private Const STANDARD_RIGHTS_EXECUTE = READ_CONTROL
Private Const STANDARD_RIGHTS_ALL = &H1F0000
Private Const KEY_READ = STANDARD_RIGHTS_READ Or KEY_QUERY_VALUE Or KEY_ENUMERATE_SUB_KEYS Or KEY_NOTIFY
Private Const KEY_WRITE = STANDARD_RIGHTS_WRITE Or KEY_SET_VALUE Or KEY_CREATE_SUB_KEY
Private Const KEY_EXECUTE = KEY_READ
Private Const KEY_ALL_ACCESS = ((STANDARD_RIGHTS_ALL Or KEY_QUERY_VALUE Or KEY_SET_VALUE Or KEY_CREATE_SUB_KEY Or KEY_ENUMERATE_SUB_KEYS Or KEY_NOTIFY Or KEY_CREATE_LINK) And (Not SYNCHRONIZE))

'----[ Enums ]----'
Public Enum rcMainKey
    HKEY_CLASSES_ROOT = &H80000000
    HKEY_CURRENT_USER = &H80000001
    HKEY_LOCAL_MACHINE = &H80000002
    HKEY_USERS = &H80000003
    HKEY_PERFORMANCE_DATA = &H80000004
    HKEY_CURRENT_CONFIG = &H80000005
    HKEY_DYN_DATA = &H80000006
End Enum

Public Enum rcRegType
    REG_NONE = 0
    REG_SZ = 1
    REG_EXPAND_SZ = 2
    REG_BINARY = 3
    REG_DWORD = 4
    REG_DWORD_LITTLE_ENDIAN = 4
    REG_DWORD_BIG_ENDIAN = 5
    REG_LINK = 6
    REG_MULTI_SZ = 7
    REG_RESOURCE_LIST = 8
    REG_FULL_RESOURCE_DESCRIPTOR = 9
    REG_RESOURCE_REQUIREMENTS_LIST = 10
End Enum

'----[ Dim's ]----'
Private hKey             As Long
Private mainKey          As Long
Private sKey             As String
Private lBufferSize      As Long
Private lDataSize        As Long
Private ByteArray()      As Byte
Private createNoExists   As Boolean

'----[ CreateKeyIfDoesntExists ]----'
Public Property Let CreateKeyIfDoesntExists(ByVal offon As Boolean)
    createNoExists = offon
End Property
Public Property Get CreateKeyIfDoesntExists() As Boolean
    CreateKeyIfDoesntExists = createNoExists
End Property
'----[ GetKeys ]----'
Private Function GetKeys(sPath As String, sKey As String) As rcMainKey
Dim pos As Integer, mk As String
    
    sPath = Replace$(sPath, "HKEY_CURRENT_USER", "HKCU", , , vbTextCompare)
    sPath = Replace$(sPath, "HKEY_LOCAL_MACHINE", "HKLM", , , vbTextCompare)
    sPath = Replace$(sPath, "HKEY_CLASSES_ROOT", "HKCR", , , vbTextCompare)
    sPath = Replace$(sPath, "HKEY_USERS", "HKUS", , , vbTextCompare)
    sPath = Replace$(sPath, "HKEY_PERFORMANCE_DATA", "HKPD", , , vbTextCompare)
    sPath = Replace$(sPath, "HKEY_DYN_DATA", "HKDD", , , vbTextCompare)
    sPath = Replace$(sPath, "HKEY_CURRENT_CONFIG", "HKCC", , , vbTextCompare)
    
    pos = InStr(1, sPath, "\")

    If (pos = 0) Then
        mk = UCase$(sPath)
        sKey = ""
    Else
        mk = UCase$(Left$(sPath, 4))
        sKey = Right$(sPath, Len(sPath) - pos)
    End If
    
    Select Case mk
        Case "HKCU": GetKeys = HKEY_CURRENT_USER
        Case "HKLM": GetKeys = HKEY_LOCAL_MACHINE
        Case "HKCR": GetKeys = HKEY_CLASSES_ROOT
        Case "HKUS": GetKeys = HKEY_USERS
        Case "HKPD": GetKeys = HKEY_PERFORMANCE_DATA
        Case "HKDD": GetKeys = HKEY_DYN_DATA
        Case "HKCC": GetKeys = HKEY_CURRENT_CONFIG
    End Select
    
End Function
'----[ CreateKey ]----'
Public Function CreateKey(ByVal sPath As String) As Long
    
    hKey = GetKeys(sPath, sKey)

    If (RegCreateKey(hKey, sKey, mainKey) = ERROR_SUCCESS) Then
        RegCloseKey mainKey
        CreateKey = mainKey 'uspesno kreiran kljuc
    Else
        CreateKey = 0 'greska
    End If

End Function
'----[ KillKey ]----'
Public Function KillKey(ByVal sPath As String) As Long

    hKey = GetKeys(sPath, sKey)

    If (RegOpenKeyEx(hKey, sKey, 0, KEY_ALL_ACCESS, mainKey) = ERROR_SUCCESS) Then
        RegDeleteKey mainKey, ""   'izbrisemo kljuc
        RegCloseKey mainKey
        KillKey = mainKey 'uspesno izbrisan kljuc
    Else
        KillKey = 0 'greska
    End If

End Function
'----[ KeyExists ]----'
Public Function KeyExists(ByVal sPath As String) As Boolean

    hKey = GetKeys(sPath, sKey)

    If (RegOpenKeyEx(hKey, sKey, 0, KEY_ALL_ACCESS, mainKey) = ERROR_SUCCESS) Then
        KeyExists = True 'postoji
        RegCloseKey mainKey
    Else
        KeyExists = False ' ne postoji
    End If

End Function
'----[ EnumKeys ]----'
Public Function EnumKeys(ByVal sPath As String, Key() As String) As Long
    Dim sName As String, RetVal As Long
    
    hKey = GetKeys(sPath, sKey)
    
    If (RegOpenKey(hKey, sKey, mainKey) = ERROR_SUCCESS) Then

        EnumKeys = 0 'vraceni array je 0-based
        sName = Space(255)
        RetVal = Len(sName)
        
        While RegEnumKeyEx(mainKey, EnumKeys, sName, RetVal, ByVal 0&, _
                           vbNullString, ByVal 0&, ByVal 0&) <> ERROR_NO_MORE_ITEMS
            
            ReDim Preserve Key(EnumKeys) 'povecavamo array (+1)
            
            Key(EnumKeys) = Left$(sName, RetVal) 'dodajemo ime kluca u array
                        
            'pripremamo vrednosti za sledeci kljuc
            EnumKeys = EnumKeys + 1
            sName = Space(255)
            RetVal = Len(sName)
            
        Wend
    
        RegCloseKey mainKey
    Else
        EnumKeys = -1 'kljuc ne postoji
    End If
    
End Function
'----[ WriteString ]----'
Public Function WriteString(ByVal sPath As String, ByVal sName As String, _
                                                   ByVal sValue As String) As Long
                            

    If (KeyExists(sPath) = False) Then 'ako kljuc ne postoji,
        If (createNoExists = True) Then 'i ako je CreateKeyIfDoesntExists = True
            CreateKey sPath  ' napravimo ga ;o)
        Else
            WriteString = 0 'greska!
            Exit Function
        End If
    End If
    
    hKey = GetKeys(sPath, sKey)
    
    If (sName = "@") Then sName = "" '(Default)
    
    If (RegOpenKeyEx(hKey, sKey, 0, KEY_WRITE, mainKey) = ERROR_SUCCESS) Then
        If (RegSetValueEx(mainKey, sName, 0, REG_SZ, ByVal sValue, Len(sValue)) = ERROR_SUCCESS) Then
            RegCloseKey mainKey
            WriteString = mainKey 'uspesno sacuvano!
        Else
            WriteString = 0 'greska
      End If
    Else
         WriteString = 0 'greska
    End If

End Function
'----[ ReadString ]----'
Public Function ReadString(ByVal sPath As String, ByVal sName As String, _
                           Optional sDefault As String = vbNullChar) As String
    
    Dim sData As String, lDuz As Long
    
    hKey = GetKeys(sPath, sKey)

    If (RegOpenKeyEx(hKey, sKey, 0, KEY_READ, mainKey) = ERROR_SUCCESS) Then
        sData = Space(255)     'kreiramo buffer
        lDuz = Len(sData)
        If (RegQueryValueEx(mainKey, sName, 0, REG_SZ, sData, lDuz) = ERROR_SUCCESS) Then
            RegCloseKey mainKey
            sData = Trim$(sData) 'uklanjamo razmake na pocetku i na kraju stringa
            ReadString = Left$(sData, Len(sData) - 1) 'vracamo procitanu vrednost
        Else 'ako je doslo do greske (mozda vrednost ne postoji)
                ReadString = sDefault 'vracamo default vrednost
        End If
    Else
        ReadString = sDefault
    End If

End Function
'----[ WriteDWORD ]----'
Public Function WriteDWORD(ByVal sPath As String, ByVal sName As String, _
                                                  ByVal lValue As Long) As Long

    If (KeyExists(sPath) = False) Then 'ako kljuc ne postoji,
        If (createNoExists = True) Then 'i ako je CreateKeyIfDoesntExists = True
            CreateKey sPath  ' napravimo ga ;o)
        Else
            WriteDWORD = 0 'greska!
            Exit Function
        End If
    End If

    hKey = GetKeys(sPath, sKey)

    If (RegOpenKeyEx(hKey, sKey, 0, KEY_WRITE, mainKey) = ERROR_SUCCESS) Then
        If (RegSetValueExA(mainKey, sName, 0, REG_DWORD, lValue, 4) = ERROR_SUCCESS) Then
            RegCloseKey mainKey
            WriteDWORD = mainKey 'uspesno ubaceno u bazu
        Else
            WriteDWORD = 0 'greska
        End If
    Else
        WriteDWORD = 0 'greska
    End If

End Function
'----[ ReadDWORD ]----'
Public Function ReadDWORD(ByVal sPath As String, ByVal sName As String, _
                         Optional lDefault As Long = -1) As Long
    Dim lData As Long
    
    hKey = GetKeys(sPath, sKey)
    
    If (RegOpenKeyEx(hKey, sKey, 0, KEY_READ, mainKey) = ERROR_SUCCESS) Then
        If (RegQueryValueExA(mainKey, sName, 0, REG_DWORD, lData, 4) = ERROR_SUCCESS) Then
            RegCloseKey mainKey
            ReadDWORD = lData
        Else
            ReadDWORD = lDefault 'vrednost ne postoji
        End If
    Else
        ReadDWORD = lDefault 'izgleda da kljuc ne postoji!
    End If

End Function
'----[ WriteBinary ]----'
Public Function WriteBinary(ByVal sPath As String, ByVal sName As String, _
                                                   ByVal sValue As String) As Long
    Dim l As Long, lDuz As Long, B() As Byte
    
    If (KeyExists(sPath) = False) Then 'ako kljuc ne postoji,
        If (createNoExists = True) Then 'i ako je CreateKeyIfDoesntExists = True
            CreateKey sPath  ' napravimo ga ;o)
        Else
            WriteBinary = 0 'greska!
            Exit Function
        End If
    End If

    hKey = GetKeys(sPath, sKey)
    
    '"prevodimo" vrednost
    sValue = StrToBin(sValue)
   
    If (RegOpenKeyEx(hKey, sKey, 0, KEY_WRITE, mainKey) = ERROR_SUCCESS) Then
      
        lDuz = Len(sValue)
        ReDim B(lDuz) As Byte
      
        For l = 1 To lDuz 'pravimo byte array
            B(l) = Asc(Mid$(sValue, l, 1))
        Next
        
        If (lDuz = 0) Then ' (zero-length binary value)
            ReDim B(1) As Byte
            B(1) = 0
        End If
      
        If (RegSetValueExB(mainKey, sName, 0, REG_BINARY, B(1), lDuz) = ERROR_SUCCESS) Then
            RegCloseKey mainKey
            WriteBinary = mainKey 'uspesno upisano u bazu
        Else
            WriteBinary = 0 'greska
        End If
    Else
         WriteBinary = 0 'kljuc ne postoji
    End If

End Function
'----[ ReadBinary ]----'
Public Function ReadBinary(ByVal sPath As String, ByVal sName As String, _
                           Optional sDefault As String = vbNullString) As String
    
    Dim lDuz As Long, sData As String
    
    hKey = GetKeys(sPath, sKey)
    
    If (RegOpenKeyEx(hKey, sKey, 0, KEY_READ, mainKey) = ERROR_SUCCESS) Then
        lDuz = 1
        RegQueryValueEx mainKey, sName, 0, REG_BINARY, 0, lDuz
        sData = Space(lDuz)
        If (RegQueryValueEx(mainKey, sName, 0, REG_BINARY, sData, lDuz) = ERROR_SUCCESS) Then
            RegCloseKey mainKey
            ReadBinary = Trim$(BinToStr(sData))
        Else
            ReadBinary = sDefault
        End If
    Else
        ReadBinary = sDefault
    End If

End Function
'----[ KillValue ]----'
Public Function KillValue(ByVal sPath As String, ByVal sName As String) As Long

hKey = GetKeys(sPath, sKey)

    If (RegOpenKeyEx(hKey, sKey, 0, KEY_READ, mainKey) = ERROR_SUCCESS) Then
        RegDeleteValue mainKey, sName 'brisemo vrednost
        RegCloseKey mainKey
        KillValue = mainKey
    Else
        KillValue = 0
    End If
    
End Function
'----[ ValueExists ]----'
Public Function ValueExists(ByVal sPath As String, ByVal sName As String) As Boolean
    
    hKey = GetKeys(sPath, sKey)
    Dim sData As String
    If (RegOpenKeyEx(hKey, sKey, 0, KEY_READ, mainKey) = ERROR_SUCCESS) Then
        If (RegQueryValueEx(mainKey, sName, 0, 0, sData, 1) = ERROR_SUCCESS) Then
            RegCloseKey mainKey
            ValueExists = True
        Else
            ValueExists = False 'vrednost ne postoji
        End If
    Else
        ValueExists = False 'izgleda da kljuc ne postoji
    End If
    
End Function
'----[ EnumValues ]----'
Public Function EnumValues(ByVal sPath As String, sName() As String, _
                sValue() As Variant, Optional OnlyType As rcRegType = -1) As Long
    Dim mainKey As Long, rName As String, Cnt As Long
    Dim rData As String, rType As Long, RetData As Long
    
    hKey = GetKeys(sPath, sKey)
    
    If RegOpenKey(hKey, sKey, mainKey) = ERROR_SUCCESS Then
        
        Cnt = 0
        rName = Space(255)
        rData = Space(255)
        RetVal = 255
        RetData = 255
        
        While RegEnumValue(mainKey, Cnt, rName, RetVal, 0, _
                           rType, ByVal rData, RetData) <> ERROR_NO_MORE_ITEMS
            If RetData > 0 Then
                
                If (OnlyType = -1) Or (OnlyType = rType) Then 'da li je trazeni tip?
                
                    ReDim Preserve sName(EnumValues) As String 'uvacavamo array-e
                    ReDim Preserve sValue(EnumValues) As Variant
                
                    sName(EnumValues) = Left$(rName, RetVal)
                
                    If (rType = REG_BINARY) Then 'prebacujmo u citljivu vrednost
                        sValue(EnumValues) = ReadBinary(sPath, sName(EnumValues))
                    ElseIf (rType = REG_DWORD) Then
                        sValue(EnumValues) = ReadDWORD(sPath, sName(EnumValues))
                    ElseIf (rType = REG_SZ) Then
                        sValue(EnumValues) = ReadString(sPath, sName(EnumValues), "")
                    End If
                    
                    EnumValues = EnumValues + 1
                
                End If
                
                Cnt = Cnt + 1
                rName = Space(255)
                rData = Space(255)
                RetVal = 255
                RetData = 255
                    
            End If
            
        Wend
        
        RegCloseKey hKey
    Else
        EnumValues = -1
    End If
    
End Function
'----[ ExportToReg ]----'
Public Function ExportToReg(ByVal sPath As String, ByVal sRegFile As String, _
                                         Optional ByVal Output As TextBox) As Long
    On Error GoTo errh
    Dim opened As Boolean, fn As Integer
    
    If (Dir(sRegFile) <> "") Then 'fajl vec postoji
        ExportToReg = 0 'greska
        Exit Function
    End If
    
    fn = FreeFile
    Open sRegFile For Output As #fn
        opened = True
        Print #fn, "REGEDIT4" & vbCrLf
    Close #fn
    opened = False
    
    If (generateReg(sPath, sRegFile, Output) = False) Then GoTo errh
    
    ExportToReg = 1 'uspesno generisan reg fajl
    Exit Function
errh:
    On Error Resume Next
    If (opened = True) Then Close #fn
    ExportToReg = 0
End Function
'----[ generateReg ]----'
Private Function generateReg(ByVal sPath As String, sRegFile As String, _
                                            Optional Output As TextBox) As Boolean
    On Error GoTo errh
    Dim keyName() As String, aName() As String, aValue() As Variant, x As Integer
    Dim u As Long, fn As Integer, tmp As String, opened As Boolean, l As Long
    Dim hasOutput As Boolean, nuls As String
    
    hasOutput = Not IsMissing(Output)
    
    sPath = Replace(sPath, "HKCU", "HKEY_CURRENT_USER", , , vbTextCompare)
    sPath = Replace(sPath, "HKLM", "HKEY_LOCAL_MACHINE", , , vbTextCompare)
    sPath = Replace(sPath, "HKCR", "HKEY_CLASSES_ROOT", , , vbTextCompare)
    sPath = Replace(sPath, "HKUS", "HKEY_USERS", , , vbTextCompare)
    sPath = Replace(sPath, "HKPD", "HKEY_PERFORMANCE_DATA", , , vbTextCompare)
    sPath = Replace(sPath, "HKDD", "HKEY_DYN_DATA", , , vbTextCompare)
    sPath = Replace(sPath, "HKCC", "HKEY_CURRENT_CONFIG", , , vbTextCompare)
    
    If (hasOutput = True) Then
        DoEvents
        Output.Text = sPath
    End If
        
    fn = FreeFile
    Open sRegFile For Append As #fn 'Append - dopisujemo!
        Print #fn, "[" & sPath & "]"
        If (ReadString(sPath, "") <> vbNullChar) Then '(Default)
            Print #fn, "@=" & Chr$(34) & ReadString(sPath, "", "") & Chr$(34)
        End If
        
        u = EnumValues(sPath, aName, aValue, REG_SZ) - 1
        For l = 0 To u
            If (Len(aName(l)) > 0) Then
                Print #fn, Chr$(34) & aName(l) & Chr$(34) & "=" & _
                           Chr$(34) & aValue(l) & Chr$(34)
            End If
        Next
        u = EnumValues(sPath, aName, aValue, REG_BINARY) - 1
        For l = 0 To u
            Print #fn, Chr$(34) & aName(l) & Chr$(34) & "=hex:" & _
                                                Replace(Trim$(aValue(l)), " ", ",")
        Next
        u = EnumValues(sPath, aName, aValue, REG_DWORD) - 1
        For l = 0 To u
            tmp = Hex$(aValue(l))
            If (Len(tmp) < 8) Then
                nuls = ""
                For x = 1 To 8 - Len(tmp)
                    nuls = nuls & "0"
                Next
                tmp = nuls & tmp
            End If
            Print #fn, Chr$(34) & aName(l) & Chr$(34) & "=dword:" & tmp
        Next
        
        Print #fn, ""
        
        On Error Resume Next
        Close #fn
        opened = False
        
        u = EnumKeys(sPath, keyName) - 1
        For l = 0 To u
        If (generateReg(sPath & "\" & keyName(l), sRegFile, Output) = False) _
        Then GoTo errh
        Next
        
    Close #fn
    opened = False
    
    generateReg = True
    Exit Function
errh:
    On Error Resume Next
    If (opened = True) Then Close #fn
    generateReg = False
End Function
'----[ ImportFromReg ]----'
Public Function ImportFromReg(ByVal sRegFile As String) As Long
    On Error GoTo noexists
    
    Dim Lines() As String, i As Long, sTemp As String, FileNum As Integer
    Dim Args() As String, k As Long, sLine As String, l As Long, tmp As String
    
    CreateKeyIfDoesntExists = True 'vazno!
    
    If (Dir(sRegFile) = "") Or (sRegFile = vbNullString) Then 'fajl ne postoji!
noexists:
        InportFromReg = 0
        Exit Function
    End If

    FileNum = FreeFile
    Open sRegFile For Binary As #FileNum
        sTemp = Input(LOF(FileNum), #FileNum)
    Close #FileNum
    
    Lines = Split(sTemp, vbCrLf) 'delimo u linije
    
    If (UCase$(Lines(0)) <> "REGEDIT4") Then
        InportFromReg = 0 'reg fajl nije validan!
        Exit Function
    End If

    For i = 1 To UBound(Lines)
        sLine = Replace(Trim$(Lines(i)), Chr$(34), vbNullString)

        If (Left$(sLine, 1) = "[") Then 'kljuc
            sLine = Mid$(sLine, 2, Len(sLine) - 2)
            
            If (Left$(sLine, 1) = "-") Then 'brisemo kljuc
                sTemp = Mid$(sLine, 2, Len(sLine) - 1)
                KillKey sTemp
            Else
                For k = i + 1 To UBound(Lines)
                    sTemp = Trim$(Replace(Lines(k), Chr$(34), ""))
                    
                    If (Left$(sTemp, 1) = "[") Then
                        i = k - 1
                        Exit For
                    End If
                    
                    If (sTemp = "") Or (InStr(1, sTemp, "=") < 1) Then GoTo jump
                    
                    Args = Split(sTemp, "=")
                    
                    If (Trim$(Args(1)) = "-") Then 'brisemo vrednost
                        KillValue sLine, Args(0)
                    Else 'upisujemo vrednost
                        If (LCase$(Left$(Args(1), 4)) = "hex:") Then 'binary
                            tmp = Replace(Mid$(Args(1), 5, Len(Args(1)) - 4), _
                                                                         ",", " ")
                            WriteBinary sLine, Args(0), tmp
                        ElseIf (LCase$(Left$(Args(1), 6)) = "dword:") Then 'DWORD
                            WriteDWORD sLine, Args(0), _
                                CLng(Val("&H" & Mid$(Args(1), 7, Len(Args(1)) - 6)))
                        Else 'string
                            WriteString sLine, Args(0), Args(1)
                            If (Args(0) = "@") And (Args(1) = "") Then _
                            KillValue sLine, "" '(value not set)
                        End If
                    End If
jump:
                Next
            End If
        End If
    Next
    
    InportFromReg = 1 'uspesno ubaceno u registry
End Function
'----[ StrToBin ]----'
Public Function StrToBin(sBin As String) As String
    Dim two() As String, q As Integer
    Dim bs As String, w As Integer
    sBin = Replace(sBin, " ", vbNullString) 'brisemo razmake
    
    If (sBin = vbNullString) Then Exit Function
    
    ReDim two(1 To Len(sBin)) As String
    
    w = 0
    For q = 1 To Len(sBin) Step 2 'dva po dva
        w = w + 1
        bs = Mid$(sBin, q, 2)
        If bs = "00" Then bs = vbNullChar
        two(w) = bs
    Next

    For q = 1 To UBound(two) / 2
        If two(q) = vbNullChar Then
            StrToBin = StrToBin & vbNullChar
        Else
            StrToBin = StrToBin & Chr$(Val("&H" & two(q)))
        End If
    Next
End Function
'----[ BinToStr ]----'
Public Function BinToStr(sStr As String) As String
    'prebacuje npr. "¾>ÿ«" u "BE 3E FF AB" - koristi se za binary vrednost
    Dim bs As String, ret As String, q As Integer, tStr As String
    
    ret = vbNullString
    For q = 1 To Len(sStr)
        bs = Mid$(sStr, q, 1)
        If bs = vbNullChar Then tStr = "00" Else tStr = CStr(Hex(Asc(bs)))
        If (Len(tStr) = 1) Then tStr = tStr & "0"
        ret = ret & " " & tStr
    Next
    
    BinToStr = ret
End Function
'----[ isBinValid ]----'
Public Function isBinValid(ByVal sBin As String) As Boolean
    Dim z As Integer, sTmp As String, iAsc As Integer
    
    sBin = UCase$(Replace(sBin, " ", vbNullString))
    
    For z = 1 To Len(sBin)
        sTmp = Mid$(sBin, z, 1) 'char by char...
        iAsc = Asc(sTmp)
        Debug.Print iAsc
        If (iAsc < 48) Or ((iAsc > 57) And (iAsc < 65)) Or (iAsc > 70) Then
           isBinValid = False
           Exit Function
        End If
    Next
    isBinValid = True
    
End Function