Type
TMBIArray = array of TMemoryBasicInformation;
// retourner toutes les régions de mémoire virtuelle du processus actuel
function GetRegionList(a: integer) : TMBIArray;
var
p1, p2 : pointer;
mbi : TMemoryBasicInformation;
i1 : integer;
begin
SetLength(result, 200); // préallocation pour gain de temps
i1 := 0;
// p1 := nil; // commencer au début de la mémoire virtuelle
p1 := pointer(a);
p2 := nil;
while VirtualQuery(p1, mbi, sizeOf(mbi)) = sizeOf(mbi) do begin // retourner les sections de mémoire
if (mbi.State = MEM_COMMIT) and // si la section est allouée
(mbi.AllocationBase <> p2) and // et si l'adresse de base est différente de la précédente
(mbi.AllocationBase = mbi.BaseAddress) then begin // et si l'adresse est la bonne
if i1 = Length(result) then SetLength(result, i1+100); // augmenter l'allocation si nécessaire
result[i1] := mbi; // mémoriser tout le bloc d'information dans une case du tableau
inc(i1); // et compter cet élément
end;
p2 := mbi.AllocationBase; // mémoriser l'adresse de base
dword(p1) := dword(p1) + mbi.RegionSize; // et pointer un mot au-delà de la région traitée
end;
SetLength(result, i1); // allocation définitive si préallocation trop grande
end;
{
mbi.STATE:
(MEM_COMMIT, MEM_RESERVE, MEM_FREE, MEM_PRIVATE, MEM_MAPPED, MEM_IMAGE)
mbi.PROTECT:
(PAGE_READONLY, PAGE_READWRITE, PAGE_NOACCESS, PAGE_WRITECOPY, PAGE_EXECUTE,
PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE, PAGE_EXECUTE_WRITECOPY, PAGE_GUARD, PAGE_NOCACHE)
}
function TestGetRegionList(v: integer):integer; stdcall; export;
var
MBI: TMBIArray;
i,j: integer;
s,f: string;
pi,pf: integer;
begin
MBI := GetRegionList(0); // retourner la liste de toutes les régions de mémoire virtuelle du process
for i:=0 to high(MBI) do begin
if MBI[i].Protect<>PAGE_READONLY then begin
case MBI[i].Protect of
PAGE_READONLY: s := 'PAGE_READONLY';
PAGE_READWRITE: s := 'PAGE_READWRITE';
PAGE_NOACCESS: s := 'PAGE_NOACCESS';
PAGE_WRITECOPY: s := 'PAGE_WRITECOPY';
PAGE_EXECUTE: s := 'PAGE_EXECUTE';
PAGE_EXECUTE_READ: s := 'PAGE_EXECUTE_READ';
PAGE_EXECUTE_READWRITE: s := 'PAGE_EXECUTE_READWRITE';
PAGE_EXECUTE_WRITECOPY: s := 'PAGE_EXECUTE_WRITECOPY';
PAGE_GUARD: s := 'PAGE_GUARD';
PAGE_NOCACHE: s := 'PAGE_NOCACHE';
end;
pi := integer(MBI[i].BaseAddress);
pf := pi + integer(MBI[i].RegionSize-4);
f := 'rien';
while pi<pf do begin
if pinteger(pi)^=v then begin
f := 'trouvé';
pi := pf;
end;
pi := pi + 4;
end;
showmessage(inttostr(integer(MBI[i].BaseAddress))+': '+inttostr(MBI[i].RegionSize)+' '+f);
end;
end;
result := 0;
end;
// Cette fonction parcourt la mémoire virtuelle à partir d'une adresse de base
// et cherche une valeur spécifique.
// le paramètre prot indique le type de protection des pages dans lesquelles chercher,
// ou zéro pour chercher dans toutes les pages.
// le paramètre a donne l'adresse virtuelle de départ de la recherche.
// les paramètres V1 et V2 donnent deux valeurs dont la premire trouvée termine la recherche.
// La fonction retourne l'adresse virtuelle trouvée, ou zéro si rien n'est trouvé.
function FindValueInVirtualMemory(prot, a, v1,v2: integer):integer; stdcall; export;
var
MBI: TMBIArray;
i,j: integer;
s: string;
pi,pf: integer;
begin
MBI := GetRegionList(a); // retourner la liste de toutes les régions de mémoire virtuelle du process
for i:=0 to high(MBI) do begin
if (prot=0) or (MBI[i].Protect=prot) then begin
pi := integer(MBI[i].BaseAddress);
pf := pi + integer(MBI[i].RegionSize-4);
while pi<pf do begin
if (pinteger(pi)^=v1) or (pinteger(pi)^=v2) then begin
result := pi;
exit;
end;
pi := pi + 4;
end;
end;
end;
result := 0;
end;
// Cette fonction retourne l'adresse du début de la table des variables de Panoramic.
// Elle doit être appelée avec l'adresse d'une variable système en format flottant,
// comme NUMBER_CLICK par exemple.
function FindSymbolTableStartAddress(a_number_click: pinteger):integer; stdcall; export;
var
name, temp: string;
ptr: pinteger;
off, typ, p: integer;
begin
result := 0; // supposer "erreur"
ptr := a_number_click;
inc(ptr,-6); // pointer sur l'adresse du nom de NUMBER_CLICK
if pstring(ptr)^='NUMBER_CLICK' then begin
while ptr^<>0 do inc(ptr,-20);
inc(ptr,20);
result := integer(ptr);
end;
end;
// Cette fonction retourne l'adresse de l'élément 0 d'un tableau à 1 dimension dont la déclaration
// suit celle de la variable dont l'adresse est passée en paramètre. Cette variable DOIT être une
// variable flottante, de préférence une variable système comme NUMBER_CLICK.
{
Une case le la table de symboles des variables Panoramic a la structure suivante:
Longueur: 20 integer soit 80 octets
La première colonne donne l'offset par rapport au début du descripteur
La seconde colonne donne l'offset par rapport à adr(x%)
0 -12 adresse du string contenant le nom (terminé par NUL)
4 -8 type de variable 1=int 2=str 3=flo +3=tableau 1 dim +4=tableu 2 dim
8 -4
adr(x%) 12 0 donnée si type 1 (integer)
16 4 adresse du string terminé par NUL si type 2 (string)
20 8
adr(x) 24 12 1er mot de données sur 2 mots de 32 bits si type 3 (flottant)
28 16 2ème mot de données sur 2 mots de 32 bits si type 3 (flottant)
32 20 offset premier élément dans partie 818 tableau entier 1 dimension (multiple de 4)
36 24
40 28 offset premier élément dans partie 1622 tableau flottant 1 dimension (multiple de 8)
44 32
48 36
52 40
56 44 nombre d'éléments de première dimension si type=4 ou 7 (integer)
60 48 nombre d'éléments de première dimension si type=5 ou 8 (string)
64 52 nombre d'éléments de première dimension si type=6 ou 9 (flottant)
68 56 nombre d'éléments de seconde dimension si type=7 (integer)
72 60 nombre d'éléments de seconde dimension si type=8 (string)
76 64 nombre d'éléments de seconde dimension si type=9 (flottant)
La table de symboles a la structure suivante:
entête 4 mots de 32 bits
0 0 (poids fort de la longueur de la table ?)
4 longueur de la table = nombre de variables * 80 + 14
8 1
12 nombre de variables (y copris la case vide)
vide 1 case vide de 20 mots de 32 bits
système liste de cases des variables système, chacune de 20 mots de 32 bits
application liste de cases des variables application, chacune de 20 mots de 32 bits
}
function FindArrayAddress(adr_base:pinteger; nom:pstring):integer; stdcall; export;
var
name, temp: string;
ptr: pinteger;
off, typ, p: integer;
begin
result := 0; // supposer "erreur"
name := UpperCase(nom^);
typ := 6; // supposer "flottant" (ni % ni $)
if RightStr(name,1)='%' then typ := 4;
if RightStr(name,1)='$' then typ := 5;
ptr := adr_base; // prendre l'adresse de la table de symboles
temp := pstring(ptr)^; // prendre le nom de la variable
while temp<>name do begin // chercher la variable demandée
inc(ptr,20); // passer à la variable suivante
if ptr^=0 then exit; // fin de table ? non trouvé !
temp := pstring(ptr)^; // prendre le nom de la variable suivante
end;
inc(ptr); // pointer sur le type de variable
if ptr^<>typ then exit; // pas du type array du nom de la variable ? non trouvé !
case typ of
4: begin
inc(ptr,7); // pointer sur le offset
off := ptr^; // et le mémoriser
inc(ptr,12); // dépasser ce descripteur
end;
5: begin
end;
6: begin
inc(ptr,9); // pointer sur le offset
off := ptr^; // et le mémoriser
inc(ptr,10); // dépasser ce descripteur
end;
end;
case typ of
4: begin
while (ptr^<>0) do inc(ptr,20); // 80 octets: pointer au début du descripteur suivant
// while (ptr^<>818) and (ptr^<>819) do inc(ptr); // chercher en mémoire
p := FindValueInVirtualMemory(PAGE_READWRITE, 150000000, 818,819);
if p=0 then p := FindValueInVirtualMemory(PAGE_READWRITE, 0, 818,819);
ptr := pinteger(p);
inc(ptr,3+off); // 12+off*4: adresse de l'élément (0)
end;
6: begin
while (ptr^<>0) do inc(ptr,20); // 80 octets: pointer au début du descripteur suivant
p := FindValueInVirtualMemory(PAGE_READWRITE, integer(ptr), 1622, 1622);
if p=0 then p := FindValueInVirtualMemory(PAGE_READWRITE, 150000000, 1622, 1622);
if p=0 then p := FindValueInVirtualMemory(PAGE_READWRITE, 0, 1622, 1622);
ptr := pinteger(p);
inc(ptr,3+off*2); // 12+off*4*2: adresse de l'élément (0)
end
end;
result := integer(ptr);
end;
// Cette fonction retourne l'adresse de l'élément 0 d'un tableau à 1 dimension dont la déclaration
// suit immédiatement celle de la variable dont l'adresse est passée en paramètre.
function ArrayAddress(adr: pinteger):integer; stdcall; export;
var
ptr: pinteger;
off: integer;
begin
ptr := adr;
inc(ptr,20+5); // 80+20 octets: pointe sur la case "offset" du descripteur suivant
off := ptr^; // offset des données dans la zone réservée aux tableaux
ptr := adr;
inc(ptr,-3+20); // -12+80 octets: pointe sur le début du descripteur suivant:
while (ptr^<>818) and (ptr^<>819) do inc(ptr,20); // 80 octets: pointer au début du descripteur suivant
inc(ptr,3+off); // 12+off*4: adresse de l'élément (0)
result := integer(ptr);
end;
Accueil 
Calendrier
)