Détecter si Office est 32 bits ou 64 bits via le registre
Maintenant qu'Office est également livré avec une installation 64 bits, où dans le registre trouvez-vous si la version d'Office installée est 32 bits ou 64 bits?
Extrait d'un article de TechNet sur éditions 64 bits d'Office 2010 :
Si vous avez installé Office 2010 y compris Microsoft Outlook 2010, Outlook définit une clé de registre nommée Bitness de type REG_SZ sur l'ordinateur sur lequel il est installé. Le La clé de registre Bitness indique si l'installation d'Outlook 2010 est 32 bits ou 64 bits. Cela peut être utile aux administrateurs qui sont intéressé par l'audit des ordinateurs à déterminer les versions installées de Office 2010 dans leur organisation.
- Chemin du registre: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\14.0\Outlook
- si vous avez installé Office 2013, utilisez ceci Chemin du registre: HKEY_LOCAL_MACHINE\Software\Microsoft\Office\15.0\Outlook
- Clé de registre: Bitness
- Valeur: x86 ou x64
et ailleurs dans le même article:
À partir d'Office 2010, Outlook est disponible en tant qu'application 32 bits et une application 64 bits. La version (bitness) de Outlook que vous choisissez dépend de l'édition de Windows système d'exploitation (32 bits ou 64 bits) et l'édition d'Office 2010 (32 ou 64 bits) installée sur le ordinateur, si Office est déjà installé sur cet ordinateur.
Facteurs déterminant la faisabilité d'installer un 32 bits ou un 64 bits la version d'Outlook inclut le Suivant:
- Vous pouvez installer Office 2010 32 bits et Microsoft Outlook 2010 32 bits sur une édition 32 bits ou 64 bits prise en charge du système d'exploitation Windows. Vous pouvez installer la version 64 bits d'Office 2010 et Outlook 2010 64 bits uniquement sur un système d'exploitation 64 bits pris en charge.
- L'installation par défaut d'Office 2010 sur une édition 64 bits du système d'exploitation Windows est Office 2010 32 bits.
- Le nombre de bits d'une version installée d'Outlook est toujours identique à celui d'Office 2010, si Office est installé sur le même ordinateur. Autrement dit, une version 32 bits d'Outlook 2010 ne peut pas être installée sur le même ordinateur sur lequel des versions 64 bits d'autres applications Office 2010 sont déjà installées, tels que Microsoft Word 2010 64 bits ou Microsoft Excel 2010. Cette même procédure , une version 64 bits d'Outlook 2010 ne peut pas être installée sur le même ordinateur sur lequel des versions 32 bits d'autres applications Office sont déjà installées.
J'ai testé la réponse d'Otaku et il apparaît que la valeur du bit Outlook est définie même si Outlook n'est pas installé, même si l'article référencé n'indique pas clairement que ce serait le cas.
Pour ajouter à la réponse de vtrz, voici une fonction que j'ai écrite pour Inno Setup:
const
{ Constants for GetBinaryType return values. }
SCS_32BIT_BINARY = 0;
SCS_64BIT_BINARY = 6;
{ There are other values that GetBinaryType can return, but we're }
{ not interested in them. }
{ Declare Win32 function }
function GetBinaryType(lpApplicationName: AnsiString; var lpBinaryType: Integer): Boolean;
external '[email protected] stdcall';
function Is64BitExcelFromRegisteredExe(): Boolean;
var
excelPath: String;
binaryType: Integer;
begin
Result := False; { Default value - assume 32-bit unless proven otherwise. }
{ RegQueryStringValue second param is '' to get the (default) value for the key }
{ with no sub-key name, as described at }
{ http://stackoverflow.com/questions/913938/ }
if IsWin64() and RegQueryStringValue(HKEY_LOCAL_MACHINE,
'SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\Excel.exe',
'', excelPath) then begin
{ We've got the path to Excel. }
try
if GetBinaryType(excelPath, binaryType) then begin
Result := (binaryType = SCS_64BIT_BINARY);
end;
except
{ Ignore - better just to assume it's 32-bit than to let the installation }
{ fail. This could fail because the GetBinaryType function is not }
{ available. I understand it's only available in Windows 2000 }
{ Professional onwards. }
end;
end;
end;
Malheureusement, les méthodes d'Otacku et de @ clatonh ne fonctionnent pas pour moi - ni Outlook Bitness ni {90140000-0011-0000 -1000 -0000000FF1CE} dans le registre (pour Office 64 bits sans Outlook) .
Le seul moyen que j’ai trouvé, cependant, sans passer par le registre, est de vérifier le bitness d’un des exécutables Office à l’aide de la fonction API Windows GetBinaryType (depuis Windows 2000 Professional).
Par exemple, vous pouvez vérifier le bitness de Winword.exe, sous lequel le chemin est stocké.
HKEY_LOCAL_MACHINE\LOGICIEL\Microsoft\Windows\CurrentVersion\App Chemins\Winword.exe.
Voici le fragment de code MFC:
CRegKey rk;
if (ERROR_SUCCESS == rk.Open(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Winword.exe",
KEY_READ)) {
CString strWinwordPath;
DWORD dwSize = MAX_PATH;
if (ERROR_SUCCESS == rk.QueryStringValue(strWinwordPath,
strWinwordPath.GetBuffer(MAX_PATH), &dwSize)) {
strWinwordPath.ReleaseBuffer();
DWORD dwBinaryType;
if (::GetBinaryType(strWinwordPath, &dwBinaryType)) {
if (SCS_64BIT_BINARY == dwBinaryType) {
// Detected 64-bit Office
} else {
// Detected 32-bit Office
}
} else {
// Failed
}
} else {
// Failed
}
} else {
// Failed
}
Attention: l'interrogation du nombre de bits de l'application Outlook ne fonctionne PAS de manière fiable si elle est appelée dans un environnement .NET.
Ici, nous utilisons GetBinaryType () dans une DLL pouvant être appelée par n'importe quelle application:
- Si l'application hôte est en C/C++ 64 bits, GetBinaryType () renvoie SCS_32BIT_BINARY.
- Si l'application hôte est un fichier .NET 64 bits (nous avons testé "AnyCPU" sur un système 64 bits), GetBinaryType () renvoie SCS_64BIT_BINARY.
Avec exactement le même code DLL et le même chemin binaire Outlook ("c:/Program Files (x86)/...") sur le même ordinateur.
Cela signifie que vous devrez peut-être tester le fichier binaire vous-même à l'aide de l'entrée "IMAGE_NT_HEADERS.FileHeader.Machine".
Mon Dieu, je déteste les valeurs de retour incorrectes de certaines API Windows (voir aussi le mensonge GetVersion ()).
J'ai trouvé cette approche:
Si HKLM\Software\WOW6432Node existe, Windows est en 64 bits.
Si HKLM\Software\WOW6432Node\Microsoft\Office existe, Office est 32 bits.
Si HKLM\Software\WOW6432Node\Microsoft\Office n'existe pas, mais si HKLM\Software\Microsoft\Office existe, alors Office est en 64 bits.
Si HKLM\Software\WOW6432Node n'existe pas, Windows et Office sont en 32 bits.
Source: Forums Technet
J'ai trouvé le moyen de vérifier le bitness de bureau.
Nous pouvons vérifier le bitness Office 365 et 2016 à l'aide de cette clé de registre:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration
Plate-forme x86 pour 32 bits.
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\ClickToRun\Configuration
Plate-forme x64 pour 64 bits.
Vérifiez s'il vous plaît...
Voici ce que j'ai pu utiliser dans un VBScript pour détecter Outlook 64 bits:
Dim WshShell, blnOffice64, strOutlookPath
Set WshShell = WScript.CreateObject("WScript.Shell")
blnOffice64=False
strOutlookPath=WshShell.RegRead("HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\Outlook.exe\Path")
If WshShell.ExpandEnvironmentStrings("%PROCESSOR_ARCHITECTURE%") = "AMD64" And _
not instr(strOutlookPath, "x86") > 0 then
blnOffice64=True
wscript.echo "Office 64"
End If
Ce code InnoSetup fonctionne pour moi sous Win 10x64 et Office 2016 x86 (avec "HKLM\LOGICIEL\Microsoft\Office\ClickToRun\Configuration" et la clé "Plate-forme").
[Code]
const
RegOffice='SOFTWARE\Microsoft\Office\ClickToRun\Configuration';
RegOfficeKey='Platform';
/// <summary>
/// Get current HKLM version
/// </summary>
function GetHKLM: Integer;
begin
if IsWin64 then
Result := HKLM64
else
Result := HKLM32;
end;
/// <summary>
/// Check is Microsoft Office is installed or not
/// </summary>
function IsOfficeInstalled (): Boolean;
var
platform: string;
begin
RegQueryStringValue(GetHKLM(), RegOffice, RegOfficeKey, platform);
if platform = 'x86' then begin
SuppressibleMsgBox('Microsoft Office found (x86 version)' , mbConfirmation, MB_YESNO or MB_DEFBUTTON1, IDYES);
Result := True;
end else if platform = 'x64' then begin
SuppressibleMsgBox('Microsoft Office found (x64 version)', mbConfirmation, MB_YESNO or MB_DEFBUTTON1, IDYES);
Result := True;
end else begin
SuppressibleMsgBox('Microsoft Office NOT found' + platform + '.', mbConfirmation, MB_YESNO or MB_DEFBUTTON1, IDYES);
Result := False;
end;
end;
Vous pouvez rechercher dans le registre {90140000-0011-0000 -0000 -0000000FF1CE}. Si les nombres en gras commencent par 0 son x86, 1 est x64
Pour moi, c'était dans HKEY_LOCAL_MACHINE\LOGICIEL\Microsoft\Office\14.0\Registration {90140000-0057-0000-0000-0000000FF1CE}
Je n'ai pas une clé appelée bitness dans l'un de ces dossiers. J'ai une clé appelée "default" dans ces deux dossiers et la valeur est "unset" Mon ordinateur est venu avec Office 2010 Starter (je suppose 64 bits). Je l'ai enlevé et j'ai essayé de faire une installation complète de 32 bits Office. Je continue à recevoir le message suivant. le fichier est incompatible, vérifiez si vous avez besoin de la version x86 ou x64 du programme.
un conseil pour moi?
Dans mes tests, de nombreuses approches décrites ici échouent, car elles reposent sur des entrées du registre Windows qui s'avèrent ne pas être présentes de manière fiable, en fonction de la version d'Office, de la manière dont elle a été installée, etc. le registre du tout (Ok, donc cela ne fait pas strictement que la réponse à la question posée), mais écrivez un script qui:
- Instancie Excel
- Ajoute un classeur à cette instance Excel
- Ajoute un module VBA à ce classeur
- Injecte une petite fonction VBA qui renvoie le nombre de bits d'Office
- Appelle cette fonction
- Nettoie
Voici cette approche implémentée dans VBScript:
Function OfficeBitness()
Dim VBACode, Excel, Wb, Module, Result
VBACode = "Function Is64bit() As Boolean" & vbCrLf & _
"#If Win64 Then" & vbCrLf & _
" Is64bit = True" & vbCrLf & _
"#End If" & vbCrLf & _
"End Function"
On Error Resume Next
Set Excel = CreateObject("Excel.Application")
Excel.Visible = False
Set Wb = Excel.Workbooks.Add
Set Module = Wb.VBProject.VBComponents.Add(1)
Module.CodeModule.AddFromString VBACode
Result = Excel.Run("Is64bit")
Set Module = Nothing
Wb.Saved = True
Wb.Close False
Excel.Quit
Set Excel = Nothing
On Error GoTo 0
If IsEmpty(Result) Then
OfficeBitness = 0 'Alternatively raise an error here?
ElseIf Result = True Then
OfficeBitness = 64
Else
OfficeBitness = 32
End If
End Function
PS. Cette approche est plus lente que d’autres ici (environ 2 secondes sur mon PC), mais elle pourrait s’avérer plus fiable sur différentes installations et versions Office.
@clatonh: il s'agit du chemin du registre sur mon PC: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Registration {90140000-002A-0000-1000-0000000FF1CE} installation sur un système d'exploitation 64 bits.
J'ai déjà suivi aveuglément la réponse basée sur la documentation MSDN. Aujourd'hui, cela s'est avéré moins que nécessaire. Sur un ordinateur sur lequel Office Home et Student est installé, sans Outlook, HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\14.0\Outlook était présent, mais HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\14.0\Outlook ne l'était pas. J'ai maintenant changé mon code pour rechercher d'abord la version "plain" non-Wow6432Node. Si c'est le cas, ça sera utilisé. Sinon, il continuera en regardant la version de Wow6432Node. Ceci est vérifié dans un programme d'installation basé sur Inno Setup. Je ne sais pas quelles API utilisent Inno Setup. Si votre application n'accède pas au registre de la même manière, vous obtiendrez peut-être des résultats différents.
J'ai écrit ceci pour Outlook au début. Modifié un peu pour Word, mais cela ne fonctionnera pas sur une installation autonome car cette clé ne montre pas le bitness, seul Outlook le fait.
De plus, je l’ai écrit pour ne supporter que les versions actuelles d’Office, => 2010
J'ai dépouillé toute la configuration et le post-traitement ...
:checkarch
IF NOT "%PROCESSOR_ARCHITECTURE%"=="x86" SET InstallArch=64bit
IF "%PROCESSOR_ARCHITEW6432%"=="AMD64" SET InstallArch=64bit
IF "%InstallArch%"=="64bit" SET Wow6432Node=\Wow6432Node
GOTO :beginscript
:beginscript
SET _cmdDetectedOfficeVersion=reg query "HKEY_CLASSES_ROOT\Word.Application\CurVer"
@FOR /F "tokens=* USEBACKQ" %%F IN (`!_cmdDetectedOfficeVersion! 2^>NUL `) DO (
SET _intDetectedOfficeVersion=%%F
)
set _intDetectedOfficeVersion=%_intDetectedOfficeVersion:~-2%
:switchCase
:: Call and mask out invalid call targets
goto :case!_intDetectedOfficeVersion! 2>nul || (
:: Default case
ECHO Not installed/Supported
)
goto :case-install
:case14
Set _strOutlookVer= Word 2010 (!_intDetectedOfficeVersion!)
CALL :GetBitness !_intDetectedOfficeVersion!
GOTO :case-install
:case15
Set _strOutlookVer= Word 2013 (!_intDetectedOfficeVersion!)
CALL :GetBitness !_intDetectedOfficeVersion!
GOTO :case-install
:case16
Set _strOutlookVer= Word 2016 (!_intDetectedOfficeVersion!)
CALL :GetBitness !_intDetectedOfficeVersion!
goto :case-install
:case-install
CALL :output_text !_strOutlookVer! !_strBitness! is installed
GOTO :endscript
:GetBitness
FOR /F "tokens=3*" %%a in ('reg query "HKLM\Software%Wow6432Node%\Microsoft\Office\%1.0\Outlook" /v Bitness 2^>NUL') DO Set _strBitness=%%a
GOTO :EOF
EDIT: Solution sans toucher à RegistryKeys - im Sorry, op.
J'ai découvert qu'il existe une solution en C # - l'original se trouve ici: https://blogs.msdn.Microsoft.com/webdav_101/2016/07/26/sample-detecting-installed-Outlook-and- its-bitness/
Je l'ai un peu modifié pour mes besoins.
il suffit de passer le correct outlookPath à GetOutlookBitness ()
public enum BinaryType : uint
{
SCS_32BIT_BINARY = 0, // A 32-bit Windows-based application
SCS_64BIT_BINARY = 6, // A 64-bit Windows-based application.
SCS_DOS_BINARY = 1, // An MS-DOS – based application
SCS_OS216_BINARY = 5, // A 16-bit OS/2-based application
SCS_PIF_BINARY = 3, // A PIF file that executes an MS-DOS – based application
SCS_POSIX_BINARY = 4, // A POSIX – based application
SCS_WOW_BINARY = 2 // A 16-bit Windows-based application
}
[DllImport("kernel32.dll")]
static extern bool GetBinaryType(string lpApplicationName, out BinaryType lpBinaryType);
public int GetOutlookBitness(string FilePath)
{
int bitness = 0;
if (File.Exists(FilePath))
{
BinaryType type;
GetBinaryType(FilePath, out type);
switch (type)
{
case BinaryType.SCS_32BIT_BINARY:
bitness = 32;
break;
case BinaryType.SCS_64BIT_BINARY:
bitness = 64;
break;
}
}
return bitness;
}
J'ai trouvé un moyen beaucoup plus simple… .. À l'aide de Powershell, nous pouvons utiliser Excel comme un objet COM.
$user = $env:UserName
$msoExcel = New-Object -ComObject Excel.Application
$msoExcel | Select-Object -Property OperatingSystem | Out-File "\\SERVER\Path\To\Dump\msoVersion-$user.txt"
exit
Lorsque vous demandez le système d'exploitation de cette façon, nous obtenons des résultats étranges: regardez ici. PC3 est à moi.
J'espère que cela fonctionne pour vous les gars. Désolé pour le manque de code; mes scripts sont principalement fonctionnels.
Edit: N'oubliez pas d'ajouter le code pour fermer Excel après avoir récupéré les données.
Après avoir testé ce code hier, des tonnes d'Excel se sont ouvertes et se sont écrasées d'un coup.
Cela garantira que vous garderez les utilisateurs et les administrateurs heureux (:
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($msoExcel)
Remove-Variable msoExcel
Cet article Wikipedia déclare:
Sur les versions 64 bits de Windows, il existe deux dossiers pour les fichiers d’application; le dossier
"Program Files"contient des programmes 64 bits et le dossier"Program Files (x86)"contient des programmes 32 bits.
Donc, si le programme est installé sous C:\Program Files, il s’agit d’une version 64 bits. S'il est installé sous C:\Program Files (x86), il s'agit d'une installation 32 bits.
Une autre façon de détecter le nombre de bits d’Office consiste à rechercher la bibliothèque de types.
Par exemple, pour détecter le nombre de bits de Outlook, écrivez un fichier .JS comme suit:
function detectVersion()
var outlooktlib = "TypeLib\\{00062FFF-0000-0000-C000-000000000046}";
var HKCR = 0x80000000;
var loc = new ActiveXObject("WbemScripting.SWbemLocator");
var svc = loc.ConnectServer(null,"root\\default");
var reg = svc.Get("StdRegProv");
var method = reg.Methods_.Item("EnumKey");
var inparam = method.InParameters.SpawnInstance_();
inparam.hDefKey = HKCR;
inparam.sSubKeyName = outlooktlib;
var outparam = reg.ExecMethod_(method.Name,inparam);
tlibver = outparam.sNames.toArray()[0];
method = reg.Methods_.Item("GetStringValue");
inparam = method.InParameters.SpawnInstance_();
inparam.hDefKey = HKCR;
inparam.sSubKeyName = outlooktlib + "\\" + tlibver + "\\0\\win32";
inparam.sValueName = "";
outparam = reg.ExecMethod_(method.Name,inparam);
if(outparam.sValue) return "32 bit";
method = reg.Methods_.Item("GetStringValue");
inparam = method.InParameters.SpawnInstance_();
inparam.hDefKey = HKCR;
inparam.sSubKeyName = outlooktlib + "\\" + tlibver + "\\0\\win64";
inparam.sValueName = "";
outparam = reg.ExecMethod_(method.Name,inparam);
if(outparam.sValue) return "64 bit";
return "Not installed or unrecognizable";
}
Vous pouvez trouver l'ID typelib d'un autre composant Office et remplacer la première ligne de la fonction. Voici une brève liste d'identifiants intéressants:
{4AFFC9A0-5F99-101B-AF4E-00AA003F0F07} - Access
{00020905-0000-0000-C000-000000000046} - Word
{00020813-0000-0000-C000-000000000046} - Excel
{91493440-5A91-11CF-8700-00AA0060263B} - PowerPoint
{0002123C-0000-0000-C000-000000000046} - Publisher
{0EA692EE-BB50-4E3C-AEF0-356D91732725} - OneNote 2010+
{F2A7EE29-8BF6-4A6D-83F1-098E366C709C} - OneNote 2007
Tous les identifiants de lib ci-dessus ont été trouvés à l'aide de l'outil de Kit de développement logiciel (SDK) Windows OLE-COM Object Viewer, vous pouvez en savoir plus en l'utilisant.
L'avantage de cette approche est qu'elle fonctionne pour toutes les versions de office et permet de contrôler chaque composant qui vous intéresse. De plus, ces clés sont dans HKEY_CLASSES_ROOT et sont profondément intégrées au système. Il est donc très peu probable qu'elles ne soient pas accessibles, même dans un environnement de type bac à sable.
J'ai trouvé un moyen sûr et fiable dans mon script basé sur InnoSetup de comprendre si une application particulière est 32 bits ou 64 bits (dans mon cas, j'avais besoin de tester Excel), à l'aide d'une fonction API Win32. Cette fonction s'appelle GetBinaryType(), elle vient de `kernel32 '(malgré son nom, elle a une saveur de 32 et 64 bits) et regarde directement l'en-tête de l'exe.
NOTE WELL: La fonction detectVersion listée ci-dessus ne fonctionne pas . J'ai une version 64 bits d'Office et une version séparée avec la version 32. Les deux versions utilisant cette fonction renvoient «32 bits».
La vérification manuelle du registre conduit à la même conclusion: les rapports 64 bits et 32 bits (Office 2010 x64 et Office 2013 32 bits) rapportent 32 bits.
Personnellement, je pense que l'équipe d'Office doit simplement écrire et maintenir une clé de registre facile à obtenir quelque part. Tous les compléments doivent faire référence à cela, et actuellement, "deviner" est une mauvaise approche à obliger les développeurs à utiliser.
Vous n'avez pas besoin de le scripter. Regardez cette page que je suis tombé sur:
Résumer:
Le quatrième champ du code de produit indique le nombre de bits du produit.
{BRMMmmmm-PPPP-LLLL -p 000-D000000FF1CE} P000
0 pour x86, 1 pour x64 0-1 (Ceci est également valable pour MSOffice 2013)
Pas via le registre mais via des outils en ligne de commande:
https://stackoverflow.com/a/6194710/2885897
C:\Users\me> assoc .msg
.msg = Outlook.File.msg.15
C:\Users\me> ftype Outlook.File.msg.15
Outlook.File.msg.15 = "C:\Fichiers de programme (x86)\Microsoft Office\Racine\Office16\Outlook.EXE"/f "% 1"
Meilleur moyen simple: Insérez l'icône ABOUT dans votre application Office 2016. Exemple Excel
1) Ouvrez Excel -> Fichier -> Options -> Personnaliser le ruban
2) Vous verrez 2 panneaux. Choisissez les commandes de & personnaliser le ruban
3) À partir de Choisissez la commande, sélectionnez toutes les commandes
4) À partir de la liste en surbrillance obtenue à propos de (Excel)
5) Dans Personnaliser la douleur du ruban, mettez en surbrillance n'importe quel élément (par exemple, la vue) où vous souhaitez placer l'icône À propos de
6) Cliquez sur Nouveau groupe en bas.
7) Cliquez sur le bouton Ajouter situé entre les deux volets. TERMINÉ
Maintenant, lorsque vous cliquez sur l'onglet Affichage dans Excel et que vous cliquez sur, vous verrez 32 ou 64 bits.
J'ai gagné 7 64 bits + Excel 2010 32 bits. Le registre est HKEY_LOCAL_MACHINE\LOGICIEL\Microsoft\Office\14.0\Registration {90140000-002A-0000-1000-0000000FF1CE}
Donc, cela peut dire bitness de l'OS, pas bitness d'Office
La clé de registre Outlook Bitness n'existe pas sur ma machine.
Une façon de déterminer le bitume d'Outlook consiste à examiner Outlook.exe, lui-même, et à déterminer s'il s'agit d'un fichier 32 bits ou 64 bits.
Plus précisément, vous pouvez vérifier le type [IMAGE_FILE_HEADER.Machine] [1], ce qui renverra une valeur indiquant le type de processeur.
Pour un excellent contexte de cette discussion, à la lecture de l'en-tête PE d'un fichier, lisez this (lien obsolète) , qui indique;
La structure IMAGE_NT_HEADERS est l'emplacement principal où les détails du fichier PE sont stockés. Son décalage est donné par le champ e_lfanew dans IMAGE_DOS_HEADER au début du fichier. Il existe actuellement deux versions de la structure IMAGE_NT_HEADER, une pour les exécutables 32 bits et l'autre pour les versions 64 bits. Les différences sont si mineures que je les considérerai comme identiques aux fins de la présente discussion. La seule manière correcte, approuvée par Microsoft, de différencier les deux formats consiste à utiliser la valeur du champ Magic dans IMAGE_OPTIONAL_HEADER (décrite ci-après).
Un IMAGE_NT_HEADER est composé de trois champs:
typedef struct _IMAGE_NT_HEADERS {
DWORD Signature;
IMAGE_FILE_HEADER FileHeader;
IMAGE_OPTIONAL_HEADER32 OptionalHeader;
} IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;
et vous pouvez obtenir le code c # ici .
Le champ Magic se trouve au début de la structure IMAGE_OPTIONAL_HEADER, soit 2 octets au décalage 24 du début de _IMAGE_NT_HEADERS. Il a des valeurs de 0x10B pour 32 bits et 0x20B pour 64 bits.
Recherchez dans le registre le chemin d'installation du composant Office qui vous intéresse, par exemple. pour Excel 2010, consultez SOFTWARE (Wow6432Node)\Microsoft\Office\14.0\Excel\InstallRoot. Ce ne sera que dans le registre 32 bits ou le registre 64 bits, pas les deux.