แแ แแ แแก แแแแ แ แกแขแแขแแ Habrรฉ-แแ, แ แแแแแแช แแแแซแฆแแแ Qubes แแแแ แแชแแฃแ แกแแกแขแแแแก แแ แแก, แ แแช แแ แแแแแฎแแแก, โโแแ แแฆแฌแแ แก แแแกแ แแแแแงแแแแแแก แแแแแชแแแแแแแก. แญแ แแแแก แฅแแแแแ, แแแแแแแแแแ, แ แแ แแแแแแแกแฌแแ แแ แแแแก Qubes-แแก, แ แแแแ แช Windows-แแก แแแ แแแแก แแแชแแแก แกแแจแฃแแแแแแ แแแแแงแแแแแแก แแแแแแแแแก แแแแแงแแแแแแ แแ, แแแแแ แแ แแก, แจแแแแคแแกแแ แกแแกแขแแแแก แ แฃแกแฃแแแแแแแแ แแแแฎแแแ แแแแแแแก แ แแแแแแแแแก.
แ แแขแแ Qubes?
Windows 7-แแก แขแแฅแแแแฃแ แ แแฎแแ แแแญแแ แแก แแแกแ แฃแแแแแก แแกแขแแ แแแ แแ แแแแฎแแแ แแแแแแ แแแแ แแแ แจแคแแแแแ แแแแแแแ แแแ แแ OS-แแก แแฃแจแแแแแก แแ แแแแแแแแแก แแฃแชแแแแแแแแ, แจแแแแแแ แแแแฎแแแแแแแก แแแแแแแแกแฌแแแแแแ:
- แฃแแ แฃแแแแแงแแก แกแ แฃแแแ แแแแฅแขแแฃแ แแแฃแแ Windows 7-แแก แแแแแงแแแแแ แแแแฎแแแ แแแแแกแแแแก แแแแแฎแแแแแแแก แแ แกแฎแแแแแกแฎแแ แแแแแแแชแแแแแก (แแแ แจแแ แแก แแแขแแ แแแขแแก แกแแจแฃแแแแแแ) แแแงแแแแแแก แจแแกแแซแแแแแแแแ;
- แแแแแฎแแ แชแแแแแก แฅแกแแแฃแ แ แฃแ แแแแ แแฅแแแแแแแก แกแ แฃแแ แแ แจแแ แฉแแแแแ แแแแแ แแชแฎแแ แแแ แแแแแแก แกแแคแฃแซแแแแแ (แแแขแแแแแแฃแ แ แแฃแจแแแแ แแ แขแ แแคแแแแก แคแแแขแ แแชแแแก แ แแแแแ);
- แฃแแ แฃแแแแแงแแคแก แแแกแแฎแกแแแแ แแแแแแกแ แแ แแแฌแงแแแแแแแแแแก แจแแ แฉแแแแแแ แแแแแแจแแ แแแแก แจแแกแแซแแแแแแแแก.
แจแแแฆแฃแแแแแแก แแก แแแแ แแแ แแฃแแแกแฎแแแแก แแจแแแ แแ แแแแแแแแแฃแ แแแแฎแแแ แแแแแก, แ แแแแแ แแแแแฃแแแแแแแแ แแแแแแแกแขแ แแ แแแ แแแแแแแ แแฃแแแ แแ แจแแแฆแฃแแแแแ แแ แแ แแก แแแแแแจแแ แแแฃแแ แแแกแ แแแขแแแชแแฃแ แ แแแฅแแแแแแแแแก แแแแแแแแแกแแแ, แแ แแแแ แจแแกแแซแแ แจแแชแแแแแแแก แแ แแแกแขแ แฃแฅแชแแฃแแ แแ แแแ แแแฃแแ แแคแแฅแขแแแแก แแแแแ แแชแฎแแแกแแแ. แแแแ. แแแแแแจแ แจแแแ แแแแแแจแแแ แแ แแ แแก.
แแแแแกแแแแแก แซแแแแแกแแก แฉแแแ แกแฌแ แแคแแ แแแแแขแแแแ แจแแแฆแฃแแแแแแก แแแแฎแแ แชแแแแแแแก แแแแ แฉแแจแแแแแฃแแ แแ แแแแแขแแแแแ Windows แแแกแขแ แฃแแแแขแแแแก แแแแแงแแแแแแ, แ แแแแแ แกแแแแแแ แ แแฃแแแ แแแแแแแกแขแ แแขแแ แแก แฃแคแแแแแแแก แแฅแแแ แแแแฎแแแ แแแแแก แแคแแฅแขแฃแ แแ แจแแแฆแฃแแแ, แ แแช แแแก แแแแแแแชแแแแแก แแแกแขแแแแชแแแก แจแแกแแซแแแแแแแแก แฃแขแแแแแก.
แจแแแแแแ แแแแแกแแแแแ แแงแ แแแแแแชแแ แแแ แขแฃแแแแแแชแแแก แแแแแงแแแแแแ. แแแกแแขแแแแก แแแ แขแฃแแแแแแชแแแก แชแแแแแแ แแแกแขแ แฃแแแแขแแแ (แแแแแแแแแ, แแแ แขแฃแแแฃแ แ แงแฃแแ) แชแฃแแแ แแ แแก แจแแกแแคแแ แแกแ แฃแกแแคแ แแฎแแแแแก แแ แแแแแแแแแก แแแแแกแแญแ แแแแ แแ แฉแแแแแแแแแ แจแแแฆแฃแแแแแ แแแแฎแแแ แแแแแแ แฃแแแ แจแแแกแ แฃแแแก แกแขแฃแแ แแก แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แแแแกแแแแแแก แแฃแแแแแ แแแแแ แแแแ แแ แ แแแฃแแแ แแแแ (แจแแแแแแแจแ - แ แแแแ แช VM), แ แแช แแ แแแก แจแแชแแแแแแแก แ แแกแแก.
แแแแแแ แแฃแแแ, แฉแแแ แแแฅแแแแ Qubes-แแก, แ แแแแ แช แแแแฎแแแ แแแแแก แแแกแแขแแแแก แกแแกแขแแแแก แแแแแงแแแแแแก แแแแแชแแแแแแ, แแแแ แแ แแแฅแแแแ แแญแแ แกแขแฃแแ แแแแแ แแฃแจแแแแแก แกแขแแแแแฃแ แแแแจแ. แแแแแฌแงแแ Qubes-แแก แแแแแแแแแแแ แแแ แกแแแก แจแแแแฌแแแแ, แ แแแแแ แแฆแแแจแแฃแแ แจแแแฆแฃแแแแแ แซแแแแแ แแแ แแแ แฏแแแแ แแ แกแแกแขแแแแก แแแ แแแแแแแจแ, แแแแกแแแฃแแ แแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แจแแแแแแแแแก แแแแแ แแแ แแ แแแแฃแแแฃแ แ แแแขแแแ แแชแแ. แจแแแแแ แแแชแแแแ แแแแแแ แแแกแแฃแแ แ แฅแฃแแแกแแก แแแแแแกแ แแ แแแกแขแ แฃแแแแขแแแแ, แแ แแแแแแแก แแแแแญแ แแก แแแแแแแแแก แแแแแงแแแแแแ.
Xen แแแ แขแฃแแแแแแชแแแก แกแแฎแแแแ
Qubes แแแคแฃแซแแแแฃแแแ Xen แฐแแแแ แแแแแ แแ, แ แแแแแแช แแแชแแ แแแก แแ แแชแแกแแ แแก แ แแกแฃแ แกแแแแก, แแแฎแกแแแ แแแแก แแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแแ แแแแก แคแฃแแฅแชแแแแก. แงแแแแ แกแฎแแ แกแแแฃแจแแ แแแฌแงแแแแแแแแแแแ แแแแชแแแขแ แแ แแแฃแแแ dom0-แจแ, Linux-แแก แแแ แแแแก แกแแคแฃแซแแแแแ (Qubes for dom0 แแงแแแแแก Fedora แแแกแขแ แแแฃแชแแแก).
Xen แแฎแแ แก แฃแญแแ แก แแแ แขแฃแแแแแแชแแแก แ แแแแแแแแ แขแแแก (แแแแแแแแแแก แแแแแงแแแ Intel แแ แฅแแขแแฅแขแฃแ แแกแแแแก, แแฃแแชแ Xen แแฎแแ แก แฃแญแแ แก แกแฎแแแแก):
- แแแ แแแแ แขแฃแแแแแแชแแ (PV) - แแแ แขแฃแแแแแแชแแแก แ แแแแแ แขแแฅแแแแแก แแฎแแ แแแญแแ แแก แแแแแงแแแแแแก แแแ แแจแ, แ แแแแแแช แแแแแแแแแแแก แแแแขแแแแแ แแก แแแ แขแฃแแแแแแชแแแก, แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแแแขแแ แแแฃแแ แแแ แแแแก แแฅแแแ แกแแกแขแแแแแแกแแแแก (dom0 แแฃแจแแแแก แแ แ แแแแแจแ);
- แกแ แฃแแ แแแ แขแฃแแแแแแชแแ (HVM) - แแ แ แแแแแจแ, แขแแฅแแแแแก แแฎแแ แแแญแแ แ แแแแแแงแแแแแ แแ แแชแแกแแ แแก แ แแกแฃแ แกแแแแกแแแแก, แฎแแแ แงแแแแ แกแฎแแ แแแฌแงแแแแแแแ แแแฃแแแ แแแฃแแแ QEMU แแแแแงแแแแแแ. แแก แแ แแก แงแแแแแแ แฃแแแแแ แกแแแฃแ แ แแแ แกแฎแแแแแกแฎแแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแกแแจแแแแแ;
- แแแแ แแขแฃแ แแก แแแ แแแแ แขแฃแแแแแแชแแ (PVH - ParaVirtualized Hardware) - แแแ แขแฃแแแแแแชแแแก แ แแแแแ แขแแฅแแแแแก แแฎแแ แแแญแแ แแก แแแแแงแแแแแแ, แ แแแแกแแช, แแแแ แแขแฃแ แแกแแแ แแฃแจแแแแแกแแแแก, แกแขแฃแแ แแก แกแแกแขแแแแก แแแ แแแ แแงแแแแแก แฐแแแแ แแแแแ แแก แจแแกแแซแแแแแแแแแแ แแแแแขแแ แแแฃแแ แแ แแแแแ แแแก (แแแแแแแแแ, แกแแแ แแ แแแฎแกแแแ แแแ), แ แแช แแแแแ แแชแฎแแแก QEMU แแแฃแแแชแแแก แกแแญแแ แแแแแก. แแ I/O แจแแกแ แฃแแแแแก แแแแ แแ. Linux-แแก แแแ แแแ, แ แแแแแแช แแฌแงแแแ 4.11-แแแ, แจแแฃแซแแแ แแ แ แแแแแจแ แแแฃแจแแแก.
Qubes 4.0-แแแ แแแฌแงแแแฃแแ, แฃแกแแคแ แแฎแแแแแก แแแแแแแแแก แแแแ, แแแ แแแแ แขแฃแแแแแแชแแแก แ แแแแแแก แแแแแงแแแแแ แแแขแแแแแฃแแแ (แแแ แจแแ แแก Intel-แแก แแ แฅแแขแแฅแขแฃแ แแจแ แชแแแแแแ แแแฃแชแแแแแแแก แแแแ, แ แแแแแแช แแแฌแแแแแ แแ แจแแ แแแแแแฃแแแ แกแ แฃแแ แแแ แขแฃแแแแแแชแแแก แแแแแงแแแแแแ); PVH แ แแแแแ แแแแแแงแแแแแ แแแแฃแแแกแฎแแแแแ.
แแแฃแแแชแแแก แแแแแงแแแแแแกแแก (HVM แ แแแแแ), QEMU แแฎแกแแแแ แแแแแแ แแแฃแ VM-แจแ, แกแแฎแแแฌแแแแแแ stubdomain, แ แแแแช แแแชแแ แแแก แแแขแแแชแแฃแ แ แจแแชแแแแแแแก แแแแแงแแแแแแก แ แแกแแก แแแแแแแแแขแแชแแแจแ (QEMU แแ แแแฅแขแ แจแแแชแแแก แฃแแแ แแ แแแแก, แแแ แจแแ แแก แแแแกแแแแแแแแกแแแแก).
แฉแแแแก แจแแแแฎแแแแแจแ, แแก แ แแแแแ แฃแแแ แแงแแก แแแแแงแแแแแฃแแ Windows-แแกแแแแก.
แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แกแแ แแแกแ
Qubes-แแก แฃแกแแคแ แแฎแแแแแก แแ แฅแแขแแฅแขแฃแ แแจแ แฐแแแแ แแแแแ แแก แแ แ-แแ แแ แแแแแแ แ แจแแกแแซแแแแแแแ แแ แแก PCI แแแฌแงแแแแแแแแแแก แแแแแขแแแ แกแขแฃแแ แแก แแแ แแแแจแ. แขแแฅแแแแแก แแแแแ แแชแฎแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแงแแ แกแแกแขแแแแก แแแกแแแแซแแแ แแแฌแแแ แแแ แ แจแแขแแแแแแกแแแ. Xen แแฎแแ แก แฃแญแแ แก PV แแ HVM แ แแแแแแแก, แแแแ แ แจแแแแฎแแแแแจแ แแก แแแแแฎแแแก แแฎแแ แแแญแแ แแก IOMMU (Intel VT-d) - แขแแฅแแแแแก แแแฎแกแแแ แแแแก แแแ แแแ แแแ แขแฃแแแฃแ แ แแแฌแงแแแแแแแแแแกแแแแก.
แแก แฅแแแแก แ แแแแแแแแ แกแแกแขแแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแก:
- sys-net, แ แแแแแแแแแช แแแแแแแก แฅแกแแแฃแ แ แแแฌแงแแแแแแแแแ แแ แ แแแแแแช แแแแแแงแแแแแ แฎแแแแ แกแฎแแ VM-แแแแกแแแแก, แแแแแแแแแ, แแกแแแ, แ แแแแแแแช แแฎแแ แชแแแแแแแ firewall-แแก แแ VPN แแแแแแขแแก แคแฃแแฅแชแแแแก;
- sys-usb, แ แแแแแแแช แแแแแแแก USB แแ แกแฎแแ แแแ แแคแแ แแฃแแ แแแฌแงแแแแแแแแก แแแแขแ แแแแ แแแ;
- sys-firewall, แ แแแแแแช แแ แแงแแแแแก แแแฌแงแแแแแแแแแก, แแแแ แแ แแฃแจแแแแก แ แแแแ แช Firewall แแแแแแจแแ แแแฃแแ VM-แแแแกแแแแก.
USB แแแฌแงแแแแแแแแแแแ แแฃแจแแแแแกแแแแก แแแแแแงแแแแแ แแ แแฅแกแ แกแแ แแแกแแแ, แ แแแแแแแช แกแฎแแ แกแแแแแฎแแแแแ แแ แแแ แแแแแแแแแ:
- HID (แแแแแแแแแก แแแขแแ แคแแแกแแก แแแฌแงแแแแแแแ) แแแฌแงแแแแแแแแก แแแแกแแกแแแแก, แแ แซแแแแแแแแก แแแแแแแแ dom0-แแ;
- แแแกแแฎแกแแแแ แแแแแแกแแแแก, แแแฌแงแแแแแแแแก แขแแแแแแก แแแแแแแกแแแแ แแแแ แกแฎแแ VM-แแแแ (แแแ แแ dom0-แแกแ);
- แแแ แแแแแ USB แแแฌแงแแแแแแแแแ แแแแแแแกแแแแ แแแแ (USBIP แแ แแแขแแแ แแชแแแก แฎแแแกแแฌแงแแแแแก แแแแแงแแแแแแ).
แแกแแ แแแแคแแแฃแ แแชแแแจแ, แฌแแ แแแขแแแฃแแแ แจแแขแแแแ แฅแกแแแแก แกแขแแแแก แแ แแแแแแจแแ แแแฃแแ แแแฌแงแแแแแแแแแแก แแแจแแแแแแ แจแแแซแแแแ แแแแแแฌแแแแก แแฎแแแแ แแแจแแแแฃแแ VM แกแแ แแแกแแก แแแแแ แแแแกแแแแ แแ แแ แ แแแแแแแแ แกแแกแขแแแแก แแแแแแแแแแจแ. แแ แกแแ แแแกแแก VM-แแก แแแแแขแแแ แแแแก แจแแแแแ, แแก แฉแแแขแแแ แแแแ แแแแแแแแ แแแ แแแแแแแ แแแแแจแ.
VM แแแขแแแ แแชแแแก แแแกแขแ แฃแแแแขแแแ
แแแ แขแฃแแแฃแ แ แแแแ แแขแแก แกแแแฃแจแแ แแแแแแแกแแแ แฃแ แแแแ แแฅแแแแแแแก แ แแแแแแแแ แแแ แแ แกแแแแแก - แกแขแฃแแ แแแแก แกแแกแขแแแแจแ แแแแแแแชแแแแแก แแแงแแแแแ แแ แแแ แขแฃแแแแแแชแแแก แฎแแแกแแฌแงแแแแแก แแแแแงแแแแแแ แแแแแแก แแแฃแแแชแแ. แกแขแฃแแ แแก แแแแแแแชแแแแ แจแแแซแแแแ แแงแแก แกแฎแแแแแกแฎแแ แฃแแแแแ แกแแแฃแ แ แแแกแขแแแชแแฃแ แ แฌแแแแแแก แฎแแแกแแฌแงแแแแ (RDP, VNC, Spice แแ แ.แจ.) แแ แแแแแขแแ แแแฃแแ แแแแแ แแขแฃแ แฐแแแแ แแแแแ แแ (แแกแแ แแแกแขแ แฃแแแแขแแแก, แ แแแแ แช แฌแแกแ, แกแขแฃแแ แแก แแแแฃแแแแฃแ แแแก แฃแฌแแแแแแ). แจแแ แแฃแแ แแแ แแแแขแแก แแแแแงแแแแแ แแกแแแ แจแแแซแแแแ, แ แแแแกแแช แฐแแแแ แแแแแ แ แแฎแแแแก I/O-แก แแแฃแแแชแแแก แกแขแฃแแ แแก แกแแกแขแแแแกแแแแก แแ แแแ แแแแ แฃแแ แฃแแแแแงแแคแก แแ แแขแแแแแแก แแแแแงแแแแแแก แจแแกแแซแแแแแแแแก, แ แแแแแแช แแแ แแแแแแแก I/O-แก, แแแแแแแแแ, Spice-แแก แแกแแแแกแแ. แแแแแแ แแฃแแแ, แแแกแขแแแชแแฃแ แ แฌแแแแแแก แฎแแแกแแฌแงแแแแ, แ แแแแ แช แฌแแกแ, แแฎแแแแแ แแแแแกแแฎแฃแแแแแก แแแขแแแแแแชแแแก, แ แแแแแ แแกแแแ แแฃแแแกแฎแแแแแ แแฃแจแแแแแก แฅแกแแแแก แกแแจแฃแแแแแแ, แ แแช แแ แแฎแแแแก แแแแแแแ แแแแแแแแก แกแฃแ แแแแก แฎแแ แแกแฎแแ.
Qubes แแแแแแแแแ แกแแแฃแแแ แแแกแขแ แฃแแแแขแแแก VM แแแขแแแ แแชแแแกแแแแก. แฃแแแ แแแแแก แงแแแแแกแ, แแก แแ แแก แแ แแคแแแฃแแ แฅแแแกแแกแขแแแ - แคแแแฏแ แแแ แกแฎแแแแแกแฎแแ แแแ แขแฃแแแฃแ แ แแแฎแกแแแ แแแแแแ แแแแแกแแฎแฃแแแ แแ แ แกแแแฃแจแแ แแแแแแแแ แกแแแฃแแแ แ แคแแ แแก แฉแแ แฉแแแแแ. แแแแแแแ, แแแขแแแ แแชแแแก แแแกแขแ แฃแแแแขแแแ แแแคแฃแซแแแแฃแแแ แฐแแแแ แแแแแ แแก แจแแกแแซแแแแแแแแแแ - แแแแแแ แแแฃแแ แแแฎแกแแแ แแแ (Xen แกแแแ แแแขแ แชแฎแ แแแ), แจแแขแงแแแแแแแแแแก แฎแแแกแแฌแงแแแแ (Xen แแแแแแแแก แแ แฎแ), แกแแแ แแ แจแแแแฎแแแก xenstore แแ vchan แกแแแแแฃแแแแแชแแ แแ แแขแแแแแ. แแแแ แแแฎแแแ แแแแ แฎแแ แชแแแแแแแ แซแแ แแแแแ แแแแแแแแแขแแแ qrexec แแ qubes-rpc แแ แแแแแแแชแแแก แกแแ แแแกแแแ - แแฃแแแ แแ USB แแแแแแแกแแแแ แแแแ, แคแแแแแแแก แแ แแฃแคแแ แจแ แจแแแแแ แกแแก แแแแแชแแแ, แแ แซแแแแแแแแก แจแแกแ แฃแแแแ แแ แแแแแแแชแแแแแก แแแจแแแแ. แจแแกแแซแแแแแแแ แแแฌแแกแแแก แแแแแขแแแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแแชแแแ แจแแแฆแฃแแแ VM-แแ แฎแแแแแกแแฌแแแแแ แกแแ แแแกแแแ. แฅแแแแแ แแแงแแแแแแ แคแแแฃแ แ แแ แแก แแ แ VM-แแก แฃแ แแแแ แแฅแแแแแแแก แแแแชแแแแแแแชแแแก แแ แแชแแแฃแ แแก แแแแแแแแ.
แแแ แแแแ, VM-แจแ แแฃแจแแแแ แฎแแ แชแแแแแแแ แฅแกแแแแก แแแแแงแแแแแแก แแแ แแจแ, แ แแช แแซแแแแ แแแขแแแแแแฃแ แ VM-แแแแก แกแ แฃแ แแแแแงแแแแแแก แแแคแแ แแแชแแแก แแแแแแแแก แแแแแแแ แแกแแชแแแแแแแ. แแแแแแแแแ, แแกแ แฎแแ แชแแแแแแแ แแ แแแขแแแ แแคแแฃแแ แแแแ แแชแแแแแก (PGP/SSH) แแแแแฏแแแ, แ แแแแกแแช แแแ แแแ แแแกแแฆแแแแแ แแแแแแงแแแแแ แแแแแแ แแแฃแ VM-แแแจแ แแ แแ แกแชแแแแแแ แแแ.
แจแแแแแแแแ, แแแแแแแชแแ แแ แแ แแฏแแ แแแ VM-แแแ
Qubes-แจแ แแแแฎแแแ แแแแแก แงแแแแ แกแแแฃแจแแ แแแแแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแแจแ. แซแแ แแแแแ แแแกแแแแซแแแ แกแแกแขแแแ แแแแแแงแแแแแ แแแแ แแแแขแ แแแแกแ แแ แแแแฃแแแแแแชแแแกแแแแก. OS แแแแแกแขแแแแ แแแฃแแแ แจแแแแแแแแแ แแแคแฃแซแแแแฃแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แซแแ แแแแ แแแแแแแฅแขแแแ แแ แแแ (TemplateVM). แแก แจแแแแแแ แแ แแก Linux VM, แ แแแแแแช แแแคแฃแซแแแแฃแแแ Fedora แแ Debian แแแกแขแ แแแฃแชแแแแ, แแแขแแแ แแชแแแก แฎแแแกแแฌแงแแแแแ แแแแแกแขแแแแ แแแฃแแ แแ แแแแคแแแฃแ แแ แแแฃแแ, แแแแแงแแคแแแ แกแแกแขแแแแกแ แแ แแแแฎแแแ แแแแแก แแแแแงแแคแแแแ. แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแกแขแแแแชแแ แแ แแแแแฎแแแแ แฎแแ แชแแแแแแแ แกแขแแแแแ แขแฃแแ แแแแแขแแก แแแแแฏแแ แแก แแแแ (dnf แแ apt) แแแแคแแแฃแ แแ แแแฃแแ แกแแชแแแแแแแแ แกแแแแแแแแฃแแ แชแแคแ แฃแแ แฎแแแแแฌแแ แแก แแแแแแแฌแแแแแ (GnuPG). แแกแแแ VM-แแแแก แแแแแแแ แฃแแ แฃแแแแแงแแก แแแแแ แแแแแแแชแแแก VM-แแแแก แแแแแ แ, แ แแแแแแแช แแแจแแแแฃแแแ แแแ แกแแคแฃแซแแแแแ.
แฉแแขแแแ แแแแกแแก, VM แแแแแแแชแแ (AppVM) แแงแแแแแก แจแแกแแแแแแกแ VM แจแแแแแแแก แกแแกแขแแแแก แแแแแงแแคแแก แกแฃแ แแแก แแ แแแกแ แฃแแแแแก แจแแแแแ แฌแแจแแแก แแ แกแฃแ แแแก แชแแแแแแแแแแก แจแแแแฎแแแก แแแ แแจแ. แแแแฎแแแ แแแแแก แแแแ แแแแฎแแแแแแ แแแแแชแแแแแ แแแแฎแแแ แแแแฎแแแ แแแแแก แแแแแงแแคแจแ, แ แแแแแแช แฃแแแแแแฃแ แแ แแแแแแฃแแ VM แแแแแแแชแแแกแแแแก, แ แแแแแแช แแแแแแขแแแแแฃแแแ แกแแฎแแแก แแแ แแฅแขแแ แแแจแ.
แแ แแฏแแ แแแ VM-แแแแก แแแแแงแแแแแ (disposableVM) แจแแแซแแแแ แกแแกแแ แแแแแ แแงแแก แฃแกแแคแ แแฎแแแแแก แแแแแกแแแ แแกแแ. แแกแแแ VM แแฅแแแแแ แจแแแแแแแก แกแแคแฃแซแแแแแ แแแจแแแแแก แแ แแก แแ แแฎแกแแแแ แแ แแ แแแแแแ - แจแแแกแ แฃแแแก แแ แแ แแแแแแแชแแ, แแแกแ แฃแแแแก แกแแแฃแจแแแแแ แแแฎแฃแ แแแก แจแแแแแ. แแ แแฏแแ แแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแแแแงแแแแแ แจแแกแแซแแแแแแแ แกแแแญแแ แคแแแแแแแก แแแกแแฎแกแแแแแ, แ แแแแแแ แจแแแแแแกแแ แจแแแซแแแแ แแแแแแฌแแแแก แแแแแ แแขแฃแแ แแแแแแแชแแแก แแแฃแชแแแแแแแก แแแแแงแแแแแ. แแ แแฏแแ แแแ VM-แแก แแแจแแแแแก แจแแกแแซแแแแแแแ แแแขแแแ แแ แแแฃแแแ แคแแแแแแแก แแแแแฏแแ แแแ (Nautilus) แแ แแ.แคแแกแขแแก แแแแแแขแแแ (Thunderbird).
Windows VM แแกแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แจแแแแแแแกแ แแ แแ แแฏแแ แแแ VM-แแก แจแแกแแฅแแแแแแ แแแแฎแแแ แแแแแก แแ แแคแแแแก แชแแแแ แแแแงแแคแแแแแแจแ แแแแแขแแแแ. แฉแแแแก แแแ แกแแแจแ, แแกแแ แจแแแแแแก แแแแฎแแแ แแแแแ แแแแแแงแแแแแก แแแแแแแกแขแ แแชแแแก แแแแชแแแแแแกแ แแ แแแแแแแชแแแก แแแกแขแแแแชแแแกแแแแก. แจแแแแแแแ แแแงแ แแแแแแ แจแแแฅแแแแแ แ แแแแแแแแ แแแแแแแชแแแก VM - แฅแกแแแจแ แจแแแฆแฃแแฃแแ แฌแแแแแแ (แกแขแแแแแ แขแฃแแ sys-firewall แจแแกแแซแแแแแแแแแ) แแ แกแแแ แแแ แฅแกแแแจแ แฌแแแแแแก แแแ แแจแ (แแแ แขแฃแแแฃแ แ แฅแกแแแแก แแแฌแงแแแแแแแ แแ แแ แแก แจแแฅแแแแแ). แจแแแแแแจแ แแแแแกแขแแแแ แแแฃแแ แงแแแแ แชแแแแแแแ แแ แแแแแแแชแแ แฎแแแแแกแแฌแแแแแ แแฅแแแแ แแ VM-แแแจแ แกแแแฃแจแแแ แแ แกแแแแจแแแแแแก แแ แแแ แแแแแแก แแแแแ แแแแก แจแแแแฎแแแแแจแแช แแ, แแแ แแ แแฅแแแแแ แฅแกแแแจแ แฌแแแแแ แแแแแ แแแแกแแกแแแแก.
แแ แซแแแ Windows-แแกแแแแก
แแแแแ แแฆแฌแแ แแแ แคแฃแแฅแชแแแแ แแ แแก Qubes-แแก แกแแคแฃแซแแแแ แแ แแฃแจแแแแก แกแแแแแแ แกแขแแแแแฃแ แแ; แกแแ แแฃแแแแแ แแฌแงแแแ Windows-แแ. Windows-แแก แแแขแแแ แแ แแแแกแแแแก, แแฅแแแ แฃแแแ แแแแแแงแแแแ แกแขแฃแแ แแแแก แแแกแขแ แฃแแแแขแแแแก แแแแ แแแ Qubes Windows Tools (QWT), แ แแแแแแช แแแแชแแแก แแ แแแแแ แแแก Xen-แแแ แแฃแจแแแแแกแแแแก, qvideo แแ แแแแแ แก แแ แแแคแแ แแแชแแแก แแแชแแแแก แแแแฃแแแแฃแ แแ แแแ แแแแแก (แคแแแแแก แแแแแชแแแ, แแฃแคแแ แจแ). แแแกแขแแแแชแแแกแ แแ แแแแคแแแฃแ แแชแแแก แแ แแชแแกแ แแแขแแแฃแ แแ แแ แแก แแแแฃแแแแขแแ แแแฃแแ แแ แแแฅแขแแก แแแแกแแแขแแ, แแแแขแแ แฉแแแ แแแแแแแแ แแแ แแแแแแแชแแแก แแแแแชแแแแแแแก.
แแแแแแ แ แกแแ แแฃแแ แแ แกแแแแแแ แแแแแแแแ แแแฃแแ แแแกแขแ แฃแแแแขแแแแก แแฎแแ แแแญแแ แแก แแแแแแแแแแ. Key Developers (QWT), แ แแแแ แช แฉแแแก, แแแฃแฌแแแแแแแแ แแ Windows-แแก แแแขแแแ แแชแแแก แแ แแแฅแขแ แแแแแแแ แแแแแแ แแแแแแแแแ แก. แแแแขแแ, แฃแแแ แแแแแก แงแแแแแกแ, แกแแญแแ แ แแงแ แแแกแ แจแแกแ แฃแแแแแก แจแแคแแกแแแ แแ แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ แแแแแฃแแแแแแแแ แแฎแแ แแแญแแ แแก แจแแกแแซแแแแแแแแก แแแแแ แแแ. แงแแแแแแ แ แแฃแแ แจแแแฃแจแแแแแ แแ แแแแแ แแแ แแ แแก แแ แแคแแแฃแแ แแ แแแแแ แ, แ แแแแแแช แแกแแฎแแแก แแแแแ แแแแแขแแ แก แแ แแแกแแแแแก แแแแแกแแฎแฃแแแแแก แแแแแ แแ แแแแก แกแแแ แแ แแแฎแกแแแ แแแแจแ, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แแฉแแแแแ แแแแแ แกแแแฃแจแแ แแแแแแ แแ แแแแแแแชแแแก แคแแแฏแแ แ แแแ แแแแแ แแแกแแแแซแแแ แกแแกแขแแแแก แคแแแฏแแ แแจแ. แแ แแแแแ แแก แแฃแจแแแแแก แแแแแแแแก แแ แแก, แฉแแแ แแแแแฎแแแแแ แแแแแก แจแแแ แแแแก แแแแแขแแชแแ Linux-แแก แแแ แแแแจแ แแ แจแแแแแฃแจแแแแ แแแแแ แแแแก แกแฅแแแ Windows-แแก แแ แกแขแฃแแแ แกแแกแขแแแแก แจแแ แแก. Crossbuild-แแก แแขแแแแ แฉแแแ แจแแแแขแแแแ แ แแแแแแแแ แชแแแแแแแ, แ แแแแช แแแแแแ แขแแแ แงแแแแแคแแ แ แฉแแแแแแแก, แซแแ แแแแแแ แแแแฃแแแแฃแ แ แกแแจแฃแแแแแแแแก โแฉแฃแแแโ แแแกแขแแแแชแแแก แแแแแกแแแ แแกแแ แแ แแกแแแ แแฆแแแแคแฎแแ แแ แจแแกแ แฃแแแแแก แจแแแแจแคแแแแแแแ แแแแ แแแแชแแ VM-แจแ แแแแ แฎแแแก แแแแแแแแแแแจแ แแฃแจแแแแแกแแก. แกแแแฃแจแแแก แจแแแแแแแ แชแแแแ แฌแแ แแแแแแแแแแ
แกแขแฃแแ แแแแก แกแแกแขแแแแก แกแขแแแแแฃแ แแแแก แแแแแกแแแ แแกแแ แงแแแแแแ แแ แแขแแแฃแแ แแขแแแ แแ แแก Windows-แแก แแแจแแแแ, แแฅ แจแแแแซแแแแ แแแฎแแ แแแชแแแแ แแฃแ แฏแ แแแ แแแ (แแ แแ แช แแ แแแฎแแ). แแแแแแแแแแแ แจแแชแแแแแแแก แฃแแแขแแกแแแแกแแแแก แแงแ แกแฎแแแแแกแฎแแ แแแแแกแแแแแ - Xen แแแแแแก แแแฌแงแแแแแแแแก แแ แแแแแ แแแแก แแฆแแแคแฎแแ แ, VM แแแฎแกแแแ แแแแก แแแแแแแแกแแแแก แแแแแ แแแ, แฅแกแแแแก แแแ แแแแขแ แแแแก แแแคแแฅแกแแ แแแ แแ แแแ แแแแแแก แ แแแแแแแแแก แจแแแชแแ แแแ. แฉแแแแ แกแขแฃแแ แแแแก แฎแแแกแแฌแงแแแแ แแจแแแแแก แแแกแขแแแแชแแแก แแ แแฃแจแแแแก แกแ แฃแแแ แแแแแฎแแแแฃแ Windows 7-แแ แแ Windows 10-แแ (แแแ แแ qvideo).
แ แแแแฃแ แ แแแ แแแแแแ แแแ แขแฃแแแฃแ แแแ แแแแแ แแแแแกแแแแกแแก แแ แแแแแแ แฉแแแแแ Windows-แแก แแแแฅแขแแฃแ แแแแกแแแ แแแแแแจแแ แแแแ, แแฃ แแแแแแงแแแแแ แฌแแแแกแฌแแ แแแแแกแขแแแแ แแแฃแแ OEM แแแ แกแแแแ. แแกแแแ แกแแกแขแแแแแ แแงแแแแแแ แแฅแขแแแแชแแแก แแแฌแงแแแแแแแแก UEFI-แจแ แแแแแแแแฃแ แแแชแแแแแแแแ แแแงแ แแแแแแ. แแฅแขแแแแชแแแก แกแฌแแ แแ แแแกแแแฃแจแแแแแแแ, แแฃแชแแแแแแแแ แแแกแแแแซแแแ แกแแกแขแแแแก (SLIC แชแฎแ แแแ) แแแแแ ACPI แแแแงแแคแแแแแแก แแแแแแแ แแแแ แกแขแฃแแ แแก แกแแกแขแแแแจแ แแ แแแแแ แแแแ แแแแฅแขแแ แแ แกแฎแแแแ, แแแแ แแแแกแขแ แแ แแ แแฌแแ แแแแแแแ. Xen แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแคแแแฃแ แแ แแ แแแแแขแแแแแ แชแฎแ แแแแแแก ACPI แจแแแแแ แกแ, แแแแ แแ แซแแ แแแแแ แชแฎแ แแแแแแก แจแแชแแแแก แแแ แแจแ. แแกแแแแกแ OpenXT แแ แแแฅแขแแก แแแขแฉแ, แ แแแแแแช แแแแแขแแ แแแฃแแ แแงแ Qubes-แแกแแแแก, แแแแฎแแแ แ แแแแแกแแแแแก. แจแแกแฌแแ แแแแแ แกแแกแแ แแแแแ แฉแแแแ แแ แ แแฎแแแแ แฉแแแแแแแก แแ แแแแ แแแแ Qubes-แแก แแแแแแ แกแแชแแแจแ แแ Libvirt แแแแแแแแแแแจแ.
Windows แแแขแแแ แแชแแแก แฎแแแกแแฌแงแแแแแก แแจแแแ แ แแแแแแแแแแแแแ แแแแชแแแก แแฃแแแ, USB แแแฌแงแแแแแแแแแแก แแฎแแ แแแญแแ แแก แแแแแแแแแแก แแ แแแแแแกแแแ แแฃแจแแแแแก แกแแ แแฃแแแก, แ แแแแแ แแ แแ แกแแแแแก GPU-แก แแแแ แแขแฃแ แแก แแฎแแ แแแญแแ แ. แแแแ แแ แแก แแ แฃแจแแแก แฎแแแก VM-แแก แแแแแงแแแแแแก แกแแแคแแกแ แแแแฃแแแแขแแแแแ แแฃแจแแแแแกแแแแก แแ แแ แช แแแแแ แแขแฃแแ แแแ แแแ แแขแแฃแแ แแแแแแแชแแแแแก แแแจแแแแแก.
Windows VM แจแแแแแแแก แจแแฅแแแแก แจแแแแแ แแแแ แแชแแฃแ แ แแแแแจแ แแแแแกแแแแก แแแแฎแแแแ แฅแกแแแแก แแแ แแจแ แแ แจแแแฆแฃแแฃแแ แฅแกแแแแ แจแแกแ แฃแแแ แแแแแแแชแแแก VM-แแแแก แจแแกแแแแแแกแ แแแแคแแแฃแ แแชแแแแแก แจแแฅแแแแ, แฎแแแ แแแกแแฎแกแแแแ แแแแแแก แจแแ แฉแแแแแ แแแแแแจแแ แแแแก แจแแกแแซแแแแแแแ แแกแแแ แแแแแฌแงแแ แกแขแแแแแ แขแฃแแ OS แแแกแขแ แฃแแแแขแแแแ - แ แแแแกแแช แแแแแแจแแ แแแ , แแกแแแ แฎแแแแแกแแฌแแแแแแ VM sys-usb แกแแกแขแแแแจแ, แกแแแแแแแช แจแแกแแซแแแแแแแ แแแแ "แแแแแแแแแแ" แกแแญแแ แ VM-แจแ. แแแแฎแแแ แแแแแก แแแกแแขแแแ แแกแ แแแแแแงแฃแ แแแ.
แกแแกแขแแแแก แกแแแแแแ แแแ แกแแ แแแแแแแแแ (แ แแแแแแแแแช แแกแแแ แงแแแแแกแแแแชแแแแ แแแแแฌแงแแแขแ แกแแจแฃแแแแแแก แแซแแแแ) แแแแฆแแก แแแแฎแแแ แแแแแแแก แแแแ แแ แกแแกแขแแแแก แกแขแแแแแ แขแฃแแแ แแแกแขแ แฃแแแแขแแแแ แจแแกแแซแแแแแแ แแแฎแแแ แแแแแแแชแแแก แแแคแแ แแแแแ แแแแฎแแแ แแแแแก แแแแแแฃแ แกแแแฃแจแแ แกแแแแฃแ แแ VPN-แแ แฌแแแแแแ.
แแแแก แแแชแแแแ, แ แแ แแแกแแแแ
แแแแแแแ แแแ แขแฃแแแแแแชแแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแแแชแแ แแ แแฎแแ แแแญแแ แแก แแแ แแจแ แแแ แฉแแแแแ Windows แกแแกแขแแแแแแก แแแแแงแแแแแแก แ แแกแแแแ - แแก แแ แแแซแฃแแแแก แแแแกแแแแแแแแก แแฎแแ แแแแ แแขแฃแ แแกแแแ, แแก แกแแจแฃแแแแแแก แแแซแแแแ แแแแแ แแชแฎแแ แแ แแแแแขแ แแแแ แกแแกแขแแแแจแ แฌแแแแแ แฅแกแแแแก แแ แแแแแแจแแ แแแฃแแ แแแฌแงแแแแแแแแแแก แกแแจแฃแแแแแแ แแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแ แแแ แแ แแฏแแ แแแ แแแจแแแแแก แแแ แแแ.
แแแ แขแฃแแแแแแชแแแก แกแแจแฃแแแแแแ แแแแแแชแแแก แแแแแแ แแแงแ แแแแแแ, Qubes OS แแแฎแแแ แแแแ แแแแแแงแแแแ แฃแกแแคแ แแฎแแแแแก แแก แแ แกแฎแแ แแแฅแแแแแแแแ. แแแ แแแแ แแแแ แ แแแแแแแแ แฅแฃแแแกแก แฃแแแ แแแแแก แงแแแแแกแ แแแแแแแฃแ แแแแก แกแฃแ แแแแแ แฎแแแแแก, แแแแ แแ แแก แแ แแก แกแแกแแ แแแแแ แกแแกแขแแแ แ แแแแ แช แแแแแแ แแแแกแแแแก, แ แแแแแแแช แฎแจแแ แแ แฏแแแแแแ แแแแ แแ แแแฅแขแแแก, แแแคแ แแกแขแ แฃแฅแขแฃแ แแแกแ แแ แกแแแแฃแแแแแแแแก แแแแแ แฌแแแแแแกแแแแก, แแกแแแ แฃแกแแคแ แแฎแแแแแก แแแแแแแแ แแแแกแแแแก. แแแแแแแชแแแแแก แแแแแฏแแแ, แแแแแชแแแแแ แแ แแแแ แฃแ แแแแ แแฅแแแแแแแก แคแแ แแแแแแแแ แกแแคแ แแฎแแก แแแแแแแแกแ แแ แฃแกแแคแ แแฎแแแแแก แกแแกแขแแแแก แแแแแแแแก แกแแฌแงแแกแ แกแแคแแฎแฃแ แแแแ. แแก แแแแชแแแแแแแแ แฎแแแก แฃแฌแงแแแก แแแคแแ แแแชแแแก แกแขแ แฃแฅแขแฃแ แแ แแแแก แแ แแแชแแ แแแก แแแแแแแแฃแ แ แคแแฅแขแแ แแก แแแแ แจแแชแแแแแแแก แแแแแแแแแก - แแฉแฅแแ แแแแก, แแแฆแแแแแแแก แแ แ.แจ.
แแแแแแแ แแแแแแแแ แแแแจแ แแแแแแ แ แแฅแชแแแขแ แแแแแแแ Linux-แแก แแแ แแแแก แคแฃแแฅแชแแแแแ แแแแก แแแคแแ แแแแแแแ. 4.1 แแแ แกแแ แแแแแแแแ แแแแแกแแจแแแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแ แแฅแแแแ Fedora 31-แแ แแ แแแแชแแแก Xen-แแกแ แแ Libvirt-แแก แซแแ แแแแแ แแแแแแแแแขแแแแก แแแแแแแแ แ แแแ แกแแแแก. แแฆแกแแแแจแแแแแ, แ แแ Qubes แจแแฅแแแแแแ แแแคแแ แแแชแแฃแแ แฃแกแแคแ แแฎแแแแแก แแ แแคแแกแแแแแแแแแก แแแแ , แ แแแแแแแช แงแแแแแแแแก แแแ แชแแแแแแ แแแแแฎแแแแแแก แแฎแแแ แกแแคแ แแฎแแแแแก แแ แจแแชแแแแแแแก แแแแแแแแแแก แจแแแแฎแแแแแจแ.
Afterword
แแ แ-แแ แแ แแฅแกแแแ แแแแแขแฃแแ แจแแกแแซแแแแแแแ, แ แแแแแกแแช แฉแแแ แแแแแแแ แแแ, แแแแซแแแแก แกแแจแฃแแแแแแก แจแแแฅแแแแ VM-แแแ GPU-แแ แกแขแฃแแ แแก แฌแแแแแแก แแฎแแ แแแญแแ แแ Intel GVT-g แขแแฅแแแแแแแแแ, แ แแช แกแแจแฃแแแแแแก แแแแซแแแแก แแแแแแแงแแแแ แแ แแคแแแฃแแ แแแแแขแแ แแก แจแแกแแซแแแแแแแแแ แแ แแแแจแแแแแแแแแ แแแแแคแแ แแแแแ แกแแกแขแแแแก แคแแ แแแแแ. แฌแแ แแก แแ แแก, แแก แคแฃแแฅแชแแ แแฃแจแแแแก Qubes 4.1-แแก แกแแขแแกแขแ แแแแแแแแแแแ แแ แฎแแแแแกแแฌแแแแแแ
แฌแงแแ แ: www.habr.com