OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <stdint.h> | |
6 #include <windows.h> | |
7 | |
8 #include "base/macros.h" | |
9 #include "sandbox/win/src/interception_internal.h" | |
10 #include "sandbox/win/src/internal_types.h" | |
11 #include "sandbox/win/src/sandbox_utils.h" | |
12 #include "sandbox/win/src/service_resolver.h" | |
13 | |
14 namespace { | |
15 enum Version { | |
16 VERSION_PRE_XP_SP2 = 0, // Not supported. | |
17 VERSION_XP_SP2, | |
18 VERSION_SERVER_2003, // Also includes XP Pro x64 and Server 2003 R2. | |
19 VERSION_VISTA, // Also includes Windows Server 2008. | |
20 VERSION_WIN7, // Also includes Windows Server 2008 R2. | |
21 VERSION_WIN8, // Also includes Windows Server 2012. | |
22 VERSION_WIN8_1, | |
23 VERSION_WIN10, | |
24 VERSION_WIN_LAST, // Indicates error condition. | |
25 }; | |
26 | |
27 #if !defined(_WIN64) | |
28 // Whether a process is running under WOW64 (the wrapper that allows 32-bit | |
29 // processes to run on 64-bit versions of Windows). This will return | |
30 // WOW64_DISABLED for both "32-bit Chrome on 32-bit Windows" and "64-bit | |
31 // Chrome on 64-bit Windows". WOW64_UNKNOWN means "an error occurred", e.g. | |
32 // the process does not have sufficient access rights to determine this. | |
33 enum WOW64Status { WOW64_DISABLED, WOW64_ENABLED, WOW64_UNKNOWN, }; | |
34 | |
35 WOW64Status GetWOW64StatusForCurrentProcess() { | |
36 typedef BOOL(WINAPI * IsWow64ProcessFunc)(HANDLE, PBOOL); | |
37 IsWow64ProcessFunc is_wow64_process = reinterpret_cast<IsWow64ProcessFunc>( | |
38 GetProcAddress(GetModuleHandle(L"kernel32.dll"), "IsWow64Process")); | |
39 if (!is_wow64_process) | |
40 return WOW64_DISABLED; | |
41 BOOL is_wow64 = FALSE; | |
42 if (!is_wow64_process(GetCurrentProcess(), &is_wow64)) | |
43 return WOW64_UNKNOWN; | |
44 return is_wow64 ? WOW64_ENABLED : WOW64_DISABLED; | |
45 } | |
46 #endif // !defined(_WIN64) | |
47 | |
48 class OSInfo { | |
49 public: | |
50 struct VersionNumber { | |
51 int major; | |
52 int minor; | |
53 int build; | |
54 }; | |
55 | |
56 struct ServicePack { | |
57 int major; | |
58 int minor; | |
59 }; | |
60 | |
61 OSInfo() { | |
62 OSVERSIONINFOEX version_info = {sizeof(version_info)}; | |
63 GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&version_info)); | |
64 version_number_.major = version_info.dwMajorVersion; | |
65 version_number_.minor = version_info.dwMinorVersion; | |
66 version_number_.build = version_info.dwBuildNumber; | |
67 if ((version_number_.major == 5) && (version_number_.minor > 0)) { | |
68 // Treat XP Pro x64, Home Server, and Server 2003 R2 as Server 2003. | |
69 version_ = | |
70 (version_number_.minor == 1) ? VERSION_XP_SP2 : VERSION_SERVER_2003; | |
71 if (version_ == VERSION_XP_SP2 && version_info.wServicePackMajor < 2) | |
72 version_ = VERSION_PRE_XP_SP2; | |
73 } else if (version_number_.major == 6) { | |
74 switch (version_number_.minor) { | |
75 case 0: | |
76 // Treat Windows Server 2008 the same as Windows Vista. | |
77 version_ = VERSION_VISTA; | |
78 break; | |
79 case 1: | |
80 // Treat Windows Server 2008 R2 the same as Windows 7. | |
81 version_ = VERSION_WIN7; | |
82 break; | |
83 case 2: | |
84 // Treat Windows Server 2012 the same as Windows 8. | |
85 version_ = VERSION_WIN8; | |
86 break; | |
87 default: | |
88 version_ = VERSION_WIN8_1; | |
89 break; | |
90 } | |
91 } else if (version_number_.major == 10) { | |
92 version_ = VERSION_WIN10; | |
93 } else if (version_number_.major > 6) { | |
94 version_ = VERSION_WIN_LAST; | |
95 } else { | |
96 version_ = VERSION_PRE_XP_SP2; | |
97 } | |
98 | |
99 service_pack_.major = version_info.wServicePackMajor; | |
100 service_pack_.minor = version_info.wServicePackMinor; | |
101 } | |
102 | |
103 Version version() const { return version_; } | |
104 VersionNumber version_number() const { return version_number_; } | |
105 ServicePack service_pack() const { return service_pack_; } | |
106 | |
107 private: | |
108 Version version_; | |
109 VersionNumber version_number_; | |
110 ServicePack service_pack_; | |
111 | |
112 DISALLOW_COPY_AND_ASSIGN(OSInfo); | |
113 }; | |
114 | |
115 } // namespace | |
116 | |
117 sandbox::ServiceResolverThunk* GetThunk(bool relaxed) { | |
118 // Create a thunk via the appropriate ServiceResolver instance. | |
119 sandbox::ServiceResolverThunk* thunk = NULL; | |
120 | |
121 // No thunks for unsupported OS versions. | |
122 OSInfo os_info; | |
123 if (os_info.version() <= VERSION_PRE_XP_SP2) | |
124 return thunk; | |
125 | |
126 // Pseudo-handle, no need to close. | |
127 HANDLE current_process = ::GetCurrentProcess(); | |
128 | |
129 #if defined(_WIN64) | |
130 // ServiceResolverThunk can handle all the formats in 64-bit (instead only | |
131 // handling one like it does in 32-bit versions). | |
132 thunk = new sandbox::ServiceResolverThunk(current_process, relaxed); | |
133 #else | |
134 if (GetWOW64StatusForCurrentProcess() == WOW64_ENABLED) { | |
135 if (os_info.version() >= VERSION_WIN10) | |
136 thunk = new sandbox::Wow64W10ResolverThunk(current_process, relaxed); | |
137 else if (os_info.version() >= VERSION_WIN8) | |
138 thunk = new sandbox::Wow64W8ResolverThunk(current_process, relaxed); | |
139 else | |
140 thunk = new sandbox::Wow64ResolverThunk(current_process, relaxed); | |
141 } else if (os_info.version() >= VERSION_WIN8) { | |
142 thunk = new sandbox::Win8ResolverThunk(current_process, relaxed); | |
143 } else { | |
144 thunk = new sandbox::ServiceResolverThunk(current_process, relaxed); | |
145 } | |
146 #endif | |
147 | |
148 return thunk; | |
149 } | |
OLD | NEW |