๊ฐ์๋จธ์ (Virtual Machine)์ด๋?
๊ฐ์ ๋จธ์ ์ ํ๋์ ๋ฌผ๋ฆฌ์ ์ปดํจํฐ ์์คํ ์์์ ์ํํธ์จ์ด๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ๊ฐ์ ๋ ๋ฆฝ์ ์ธ ๊ฐ์ ์ปดํจํฐ ํ๊ฒฝ์ ์์ฑํ๋ ๊ธฐ์ ์ ๋๋ค. ์ด ๊ฐ์ ๋จธ์ ๋ค์ ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ธ ์ด์์ฒด์ ๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ์ ์คํํ ์ ์์ต๋๋ค. ๊ฐ์ ๋จธ์ ์ ํ์ดํผ๋ฐ์ด์ (Hypervisor)๋ผ๋ ์ํํธ์จ์ด ๊ณ์ธต์ ํตํด ํธ์คํธ ์์คํ ์ ํ๋์จ์ด ์์์ ๋ถํ ํ๊ณ ๊ฐ ๊ฐ์ ๋จธ์ ์ ํ ๋นํ์ฌ ์คํํฉ๋๋ค.
CPU ๋ฒค๋๋?
CPU ๋ฒค๋๋ CPU(์ค์ ์ฒ๋ฆฌ ์ฅ์น)๋ฅผ ์ ์กฐํ๋ ํ์ฌ๋ฅผ ์๋ฏธํฉ๋๋ค. ๊ฐ ๋ฒค๋๋ ๊ณ ์ ์ ๋ฒค๋ ID๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ์ด๋ฅผ ํตํด CPU๊ฐ ์ด๋ํ์ฌ์์ ์ ์กฐ๋์๋์ง๋ฅผ ์๋ณํ ์ ์์ต๋๋ค.
๊ฐ์ ํ๊ฒฝ์์๋ ๊ฐ์ ๋จธ์ ์ ํ์ดํผ๋ฐ์ด์ (ex: VMware, VirtualBox ๋ฑ)๊ฐ ์ค์ ๋ฌผ๋ฆฌ์ CPU๋ฅผ ์๋ฎฌ๋ ์ดํธํ๊ฑฐ๋ pass-through ํํ๋ก ์ ๊ณตํ์ง๋ง, ์ด๋ฅผ ํตํด CPU ๋ฒค๋ ID๋ฅผ ํฌํจํ ๋ค์ํ ํ๋์จ์ด ์ ๋ณด๋ฅผ ์์ ํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ ํ๊ฒฝ์์๋ ํน์ ๋ฒค๋ ID๊ฐ ์กด์ฌํ๋ฉฐ, ํ์ดํผ๋ฐ์ด์ ์ ๋ฐ๋ผ ์ด๋ฌํ ์ ๋ณด๊ฐ ๋ค๋ฅด๊ฒ ๋ํ๋ ์ ์์ต๋๋ค.
CPU ๋ฒค๋ | ๋ฒค๋ ID |
Intel | GenuineIntel |
AMD | AuthenticAMD |
VIA Technologies | CentaurHauls |
Transmeta | GenuineTMx86 |
VMware | VMwareVMware |
VirtualBox | VirtualBox |
Microsoft Hyper-V | Microsoft Hv |
๊ฐ์ ๋จธ์ ์คํ ์ฌ๋ถ ํ์ธ
์์ ์ ๋ฆฌํ CPU ๋ฒค๋ ID๋ฅผ ์ฌ์ฉํ์ฌ ์์คํ ์ด ๊ฐ์ ๋จธ์ ์์ ์คํ ์ค์ธ์ง cpp ์ฝ๋๋ฅผ ํตํด ํ์ธํ ์ ์์ต๋๋ค. intrin.h ํค๋ ํ์ผ์ ์ ์๋ __cpuid ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฅผ ๊ฐํธํ๊ฒ ํ ์ ์์ต๋๋ค.
- __cpuid(info, function_id): intrin.h ํค๋ ํ์ผ์ ์ ์๋ ํจ์๋ก, function_id ๊ฐ์ ๋ฐ๋ผ cpuid ๋ช ๋ น์ ์คํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ info ๋ฐฐ์ด์ EAX, EBX, ECX, EDX ๋ ์ง์คํฐ์ ๊ฐ์ ์ ์ฅํฉ๋๋ค.
์ด๋ฅผ ์ฌ์ฉํ์ฌ ํ๋ก๊ทธ๋จ์ด ๋์ํ๊ณ ์๋ ์์คํ ์ ๋ฒค๋ ID๋ฅผ ์ ์ ์๋ค.
#include <iostream>
#include <array>
#include <intrin.h>
void cpuid(int info[4], int function_id) {
__cpuid(info, function_id);
}
int main() {
std::array<int, 4> cpui;
cpuid(cpui.data(), 0);
std::cout << "Vendor ID: "
<< std::string(reinterpret_cast<const char*>(&cpui[1]), 12) << std::endl;
return 0;
}
์ฝ๋๋ฅผ ํ์ฅํ์ฌ ํ๋ก๊ทธ๋จ์ด ๊ฐ์๋จธ์ ์์ ์คํ์ค์ธ์ง ์ฌ๋ถ๋ฅผ ํ์ธํ ์ ์๋ค.
#include <iostream>
#include <array>
#include <intrin.h>
bool checkCpuVendor(const char* vendor) {
std::array<int, 4> cpui;
__cpuid(cpui.data(), 0);
char vendor_id[13];
memcpy(vendor_id, &cpui[1], 4); // EBX
memcpy(vendor_id + 4, &cpui[3], 4); // EDX
memcpy(vendor_id + 8, &cpui[2], 4); // ECX
vendor_id[12] = '\\0';
return strcmp(vendor_id, vendor) == 0;
}
bool checkVirtualEnvironment() {
// Check common CPU vendors used by virtual environments
if (checkCpuVendor("KVMKVMKVM") || checkCpuVendor("Microsoft Hv") || checkCpuVendor("VMwareVMware")) {
return true;
}
// Check for hypervisor bit
std::array<int, 4> cpui;
__cpuid(cpui.data(), 1);
bool isHypervisor = cpui[2] & (1 << 31);
if (isHypervisor) {
return true;
}
return false;
}
int main() {
if (checkVirtualEnvironment()) {
std::cout << "This system is running in a virtual environment." << std::endl;
} else {
std::cout << "This system is not running in a virtual environment." << std::endl;
}
return 0;
}
๊ฒฐ๋ก
์ต์ ๋์ฌ์จ์ด๋ ๊ฐ์๋จธ์ ์์์ ๋ถ์์ ํผํ๊ธฐ ์ํด ํ์ฌ ์์คํ CPU ์ ๋ณด๋ฅผ ์กฐํํ์ฌ ์คํ์ ๊ฒฐ์ ํ๋ ์ฝ๋๋ฅผ ํฌํจํ๊ณ ์์ต๋๋ค. ์ด๋ก ์ธํด ๊ฐ์๋จธ์ ์์์ ํ์ง๋ฅผ ํผํ๊ณ ๋ณด์ ์ฐ๊ตฌ์๋ค์ด ๋ถ์ํ๊ณ ๋์ํ๊ธฐ ์ด๋ ต๊ฒ ๋ง๋ญ๋๋ค.
'๐ฆพ ๋ณด์ ๐ฆพ > ๋์ฌ์จ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋์ฌ์จ์ด] ๊ฐ์ ๋จธ์ ์์ ์ ์ฑ์ฝ๋๋ฅผ ์คํํ๋ ๊ฒ์ ์์ ํ๊ฐ? (0) | 2024.06.25 |
---|