LUKS पर पूर्ण सिस्टम एन्क्रिप्शन और LVM के साथ Archlinux स्थापित करें

इस पोस्ट में आप मजबूर बीमार छुट्टी के दौरान मेरे अजीब शोध के बारे में थोड़ा पढ़ेंगे। यह एक ही बार में कई चीजों के बारे में होगा, जो "सर्वोत्तम अभ्यास" नहीं हैं, लेकिन यह भी संभव है! तो यहाँ एक ट्यूटोरियल है कि कैसे आर्कलिनक्स (मेरा पसंदीदा डिस्ट्रार) स्थापित किया जाए:

• एक अलग / बूट के बिना (बस / रूट में)
• / lvm पर
• luks कंटेनर के अंदर lvm
• UEFI के साथ
• एक आभासी मशीन में।
• सुरक्षित बूट के साथ (वर्चुअल मशीन में "मुश्किल" सफल होने की संभावना नहीं है)

यह उल्लेखनीय है कि सब कुछ एक ही grubx64.efi फ़ाइल के साथ EFI सिस्टम विभाजन को छोड़कर एन्क्रिप्टेड किया जाएगा - ग्रब चलाने के लिए एक EFI अनुप्रयोग।

यदि आप रुचि रखते हैं, तो बिल्ली में आपका स्वागत है!

सबसे पहले, मैंने इसे अपने लेनोवो एक्स 240 लैपटॉप पर सेट किया, फिर लेख लिखने के लिए मैंने प्रोक्समॉक्स में ओवीएमएफ के साथ एक वर्चुअल मशीन का इस्तेमाल किया।

परीक्षणित सेटअप:

सब कुछ काफी मानक तरीके से बनाया गया है। छवि मेरे पसंदीदा मेहराब का उपयोग करती है, जिसे हमेशा यैंडेक्स से डाउनलोड किया जा सकता है।

अगला, यूईएफआई के बारे में प्रॉक्समॉक्स में वर्चुअल पर कुछ बिंदु। यूईएफआई के साथ स्टैंड के संचालन का परीक्षण करने के लिए (अन्यथा यह इतना दिलचस्प नहीं होगा), आपको वर्चुअल मशीन के गुणों में सीबीआईओएस के बजाय ओवीएमएफ सेट करने की आवश्यकता है:



अगला, इस तरह से कुछ पाने के लिए, तदनुसार UEFI डिस्क जोड़ें:



अब हम वर्चुअल मशीन शुरू कर सकते हैं और इंस्टॉलेशन प्रक्रिया शुरू कर सकते हैं। वर्चुअल मशीन कंसोल में, तुरंत sshd सेवा शुरू करें, रूट पासवर्ड सेट करें और वर्चुअल मशीन का dhcp पता करें:



अगला, हम इसे और अधिक सुविधाजनक बनाने के लिए ssh पर काम करना जारी रख सकते हैं।

डिस्क लेआउट

इसलिए, पहले से ही ssh के माध्यम से कनेक्ट होने के बाद, हम पहले समय निर्धारित करते हैं ताकि बाद में यह पता न चले कि फाइल सिस्टम भविष्य में बनाया गया है:

timedatectl set-ntp true && timedatectl set-timezone Europe/Moscow 

जांचें कि सब कुछ सही है:

 root@archiso ~ # timedatectl Local time: Tue 2018-08-14 13:42:03 MSK Universal time: Tue 2018-08-14 10:42:03 UTC RTC time: Tue 2018-08-14 10:42:04 Time zone: Europe/Moscow (MSK, +0300) System clock synchronized: yes NTP service: active RTC in local TZ: no 

अब हम डिस्क को विभाजित करना शुरू कर सकते हैं। इस स्तर पर, मेरे पास / dev / vda ड्राइव है, जैसे Virtio नियंत्रक और यह विभाजन तालिका के बिना एक खाली डिस्क है:

 root@archiso ~ # fdisk -l /dev/vda Disk /dev/vda: 15 GiB, 16106127360 bytes, 31457280 sectors Units: sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes 

हम इसे 2 भागों में तोड़ेंगे:

• UEFI अनुप्रयोगों के लिए fat32 डिस्क (EFI_system_partition)
• सब कुछ के साथ LUKS कंटेनर

GPT बनाने के लिए gdisk का उपयोग करें:

 root@archiso ~ # gdisk /dev/vda GPT fdisk (gdisk) version 1.0.4 Command (? for help): o This option deletes all partitions and creates a new protective MBR. Proceed? (Y/N): y 

अगला, EF के साथ EF00 (EFI सिस्टम विभाजन) के लिए पहला विभाजन बनाएँ:

 Command (? for help): n Partition number (1-128, default 1): First sector (34-31457246, default = 2048) or {+-}size{KMGTP}: Last sector (2048-31457246, default = 31457246) or {+-}size{KMGTP}: +512M Current type is 'Linux filesystem' Hex code or GUID (L to show codes, Enter = 8300): <b>EF00</b> Changed type of partition to 'EFI System' 

अब LUKS के लिए एक विभाजन बनाएँ, जहाँ हम टाइप के साथ भी परेशान नहीं होते और इसे छोड़ देते हैं:

 Command (? for help): n Partition number (2-128, default 2): First sector (34-31457246, default = 1050624) or {+-}size{KMGTP}: Last sector (1050624-31457246, default = 31457246) or {+-}size{KMGTP}: <b>Current type is 'Linux filesystem' Hex code or GUID (L to show codes, Enter = 8300): Changed type of partition to 'Linux filesystem'</b> 

हम परिवर्तनों को लिखेंगे और विभाजन मार्कअप के साथ समाप्त करेंगे:

 Command (? for help): w Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING PARTITIONS!! Do you want to proceed? (Y/N): y OK; writing new GUID partition table (GPT) to /dev/vda. The operation has completed successfully. 

एक LUKS कंटेनर और फ़ाइल सिस्टम बनाना

पहले खंड (vda1) के साथ, सब कुछ काफी सरल है। हमें बस इसे प्रारूपित करने की आवश्यकता है और अभी के लिए यह है:

 root@archiso ~ # mkfs.vfat /dev/vda1 mkfs.fat 4.1 (2017-01-24) 

दूसरा विभाजन कंटेनर है जिसे आपको पहले तैयार करना होगा। हम विभाजन को cryptsetup के माध्यम से प्रारूपित करते हैं और पासफ़्रेज़ सेट करते हैं:

 root@archiso ~ # cryptsetup -v luksFormat /dev/vda2 WARNING! ======== This will overwrite data on /dev/vda2 irrevocably. Are you sure? (Type uppercase yes): YES Enter passphrase for /dev/vda2: Verify passphrase: Command successful. 

*** मैं सिफर की पसंद से परेशान नहीं था, जिसमें रैंडमाइजेशन के साथ यादृच्छिक और अन्य लोगों के साथ ओवरराइट किया गया था, लेकिन सिर्फ एक डिफ़ॉल्ट कंटेनर बनाया गया था।

अगला, उसी पासफ़्रेज़ को निर्दिष्ट करके कंटेनर खोलें:

 root@archiso ~ # cryptsetup luksOpen /dev/vda2 container Enter passphrase for /dev/vda2: 

अब हमारे पास डिवाइस मैपर के माध्यम से एक खुला कंटेनर सुलभ है:

 root@archiso ~ # ls -l /dev/mapper | grep container lrwxrwxrwx 1 root root 7 Aug 14 14:01 container -> ../dm-0 

अब हम lvm के साथ जारी रख सकते हैं (मैं एक त्वरित तरीके से लिखूंगा, क्योंकि यह एक विषय नहीं है):

 root@archiso ~ # pvcreate /dev/mapper/container Physical volume "/dev/mapper/container" successfully created. root@archiso ~ # vgcreate rootvg /dev/mapper/container Volume group "rootvg" successfully created root@archiso ~ # lvcreate -L1G -n swap rootvg Logical volume "swap" created. root@archiso ~ # lvcreate -L5G -n root rootvg Logical volume "root" created. root@archiso ~ # lvcreate -L2G -n home rootvg Logical volume "home" created. root@archiso ~ # lvs LV VG Attr LSize Pool Origin Data% Meta% Move Log Cpy%Sync Convert home rootvg -wi-a----- 2.00g root rootvg -wi-a----- 5.00g swap rootvg -wi-a----- 1.00g 

अगला, हमारे lv पर फ़ाइल सिस्टम बनाएँ:

 root@archiso ~ # mkfs.ext4 -L root /dev/mapper/rootvg-root mke2fs 1.44.3 (10-July-2018) ... Writing superblocks and filesystem accounting information: done [root@archiso ~]# mkfs.ext4 -L home /dev/mapper/rootvg-home mke2fs 1.44.3 (10-July-2018) Creating filesystem with 524288 4k blocks and 131072 inodes ... Writing superblocks and filesystem accounting information: done [root@archiso ~]# mkswap -L swap /dev/mapper/rootvg-swap ... LABEL=swap, UUID=98b0bc31-1c62-4fec-bb97-e1913d1e8cb4 

अब यह सब आधार प्रणाली को स्थापित करने के लिए रखा जा सकता है। स्थापना बिंदु होगा / mnt, जहां हमारे भविष्य की प्रणाली की जड़ शुरू होगी:

 [root@archiso ~]# mount /dev/mapper/rootvg-root /mnt/ [root@archiso ~]# mkdir -p /mnt/{home,boot/efi} 

*** / boot / efi मैं बनाता हूं ताकि / बूट स्वयं / dev / mapper / rootvg- रूट पर बना रहे, और efi फ़ोल्डर पहले से ही / dev / vda1 (fat32 efi पार्टीशन) पर आरोहित हो:

 [root@archiso ~]# mount /dev/vda1 /mnt/boot/efi/ [root@archiso ~]# mount /dev/mapper/rootvg-home /mnt/home/ [root@archiso ~]# swapon /dev/mapper/rootvg-swap 

वर्तमान माउंट पॉइंट (हमेशा उपयोगी) की जाँच करें:

 [root@archiso ~]# lsblk NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT loop0 7:0 0 462.5M 1 loop /run/archiso/sfs/airootfs sr0 11:0 1 573M 0 rom /run/archiso/bootmnt vda 254:0 0 15G 0 disk ├─vda1 254:1 0 512M 0 part /mnt/boot/efi └─vda2 254:2 0 14.5G 0 part └─container 253:0 0 14.5G 0 crypt ├─rootvg-swap 253:1 0 1G 0 lvm [SWAP] ├─rootvg-root 253:2 0 5G 0 lvm /mnt └─rootvg-home 253:3 0 2G 0 lvm /mnt/home 

जैसा कि हम देखते हैं, सब कुछ ईमानदार है और अब यह आर्च को डालने का समय है।

आधार प्रणाली की स्थापना

बेस पैकेज से बेस पैकेज और बेस-डेवेल सेट का उपयोग करके स्थापित करें (आप जो कुछ भी उन्हें और इसके अलावा चाहते हैं वह सब कुछ डाल सकते हैं):

 pacstrap /mnt base base-devel 

सब कुछ पूरी तरह से बूट हो गया है, आधार प्रणाली तैयार है। स्वाभाविक रूप से, मैंने निष्कर्ष निकाला। अब हम बूट और काम करने के लिए इस सिस्टम को कॉन्फ़िगर कर सकते हैं।

बुनियादी चीजों से, हम तुरंत fstab उत्पन्न करते हैं:

 genfstab -pU /mnt >> /mnt/etc/fstab 

इसके बाद, इस नए सिस्टम में आर्क-चेरोट बनाएं:

 [root@archiso ~]# arch-chroot /mnt 

*** आर्च-चेरोट एक बहुत ही उपयोगी उपयोगिता है, क्योंकि यह सब कुछ अपने आप करता है। यद्यपि आप हमेशा मानक चरोट का उपयोग कर सकते हैं, ऐसा करने से पहले, gentoo-handbook wiki.gentoo.org/wiki/Handbook में निर्देशों का पालन करें: AMD64 / स्थापना / बेस अनुभाग "आवश्यक फाइल सिस्टम को माउंट करना"

सिस्टम समय और hostname को तुरंत कॉन्फ़िगर करें:

 ln -s /usr/share/zoneinfo/Europe/Moscow /etc/localtime && \ hwclock --systohc && \ echo luks-test > /etc/hostname 

रूट पासवर्ड सेट करें:

 [root@archiso /]# passwd root New password: Retype new password: passwd: password updated successfully 

/Etc/locale.gen में आवश्यक स्थानों को रद्द करें:

 [root@archiso /]# vi /etc/locale.gen [root@archiso /]# grep -v '^#' /etc/locale.gen en_US ISO-8859-1 en_US.UTF-8 UTF-8 ru_RU.UTF-8 UTF-8 ru_RU ISO-8859-5 

हम उन्हें उत्पन्न करेंगे:

 [root@archiso /]# locale-gen Generating locales... en_US.ISO-8859-1... done en_US.UTF-8... done ru_RU.UTF-8... done ru_RU.ISO-8859-5... done Generation complete 

सिस्टम और कंसोल के लिए उन्हें तुरंत कॉन्फ़िगर करें:

 [root@archiso /]# echo LANG=en_US.UTF-8 > /etc/locale.conf [root@archiso /]# echo KEYMAP=ru > /etc/vconsole.conf [root@archiso /]# echo FONT=cyr-sun16 >> /etc/vconsole.conf 

अब /etc/mkinitcpio.conf फ़ाइल को कॉन्फ़िगर करें, जो initramfs उत्पन्न करते समय विकल्पों, हुक आदि के लिए ज़िम्मेदार है:

 vi /etc/mkinitcpio.conf 

सबसे महत्वपूर्ण बात हुक और उनका क्रम है:

 HOOKS=(base udev autodetect modconf block keymap encrypt lvm2 resume filesystems keyboard fsck) 

*** स्वैप से हाइबरनेट करने के बाद सिस्टम को बूट करने के लिए फिर से शुरू करें। वर्चुअल मशीन पर इसकी आवश्यकता नहीं है। मैंने उसे बीच से कॉपी किया।

अब हम initramfs उत्पन्न कर सकते हैं:

 [root@archiso /]# mkinitcpio -p linux ==> Building image from preset: /etc/mkinitcpio.d/linux.preset: 'default' -> -k /boot/vmlinuz-linux -c /etc/mkinitcpio.conf -g /boot/initramfs-linux.img ==> Starting build: 4.17.14-arch1-1-ARCH -> Running build hook: [base] -> Running build hook: [udev] -> Running build hook: [autodetect] -> Running build hook: [modconf] -> Running build hook: [block] -> Running build hook: [keymap] -> Running build hook: [encrypt] -> Running build hook: [lvm2] -> Running build hook: [resume] -> Running build hook: [filesystems] -> Running build hook: [keyboard] -> Running build hook: [fsck] ==> Generating module dependencies ==> Creating gzip-compressed initcpio image: /boot/initramfs-linux.img ==> Image generation successful 

अब जब हमारे पास सिस्टम है, तो हमें बूटलोडर को स्वयं इंस्टॉल करना होगा। मेरी पसंद ग्रब (2) पर गिर गई, क्योंकि यह किसी तरह अधिक परिचित है और आसानी से एक एन्क्रिप्टेड विभाजन से कर्नेल को लोड करने में सक्षम है (अच्छी तरह से, या मैं वास्तव में दूसरों की तलाश नहीं करता हूं)।

ग्रब पैकेज स्थापित करें:

 [root@archiso /]# pacman -S grub dosfstools efibootmgr mtools 

कॉन्फ़िगर करने से पहले, डिफ़ॉल्ट ग्रब विकल्पों को संपादित करें:

 vim /etc/default/grub 

यहाँ आपको एक महत्वपूर्ण पंक्ति को अनसुना करने की आवश्यकता है (कोई टिप्पणी नहीं, अवश्य):

 # Uncomment to enable booting from LUKS encrypted devices GRUB_ENABLE_CRYPTODISK=y 

और GRUB_CMDLINE_LINUX में जोड़ें (डिफ़ॉल्ट रूप से खाली है):

 GRUB_CMDLINE_LINUX="cryptdevice=UUID=5ad7c9ad-fb17-4839-925e-479432516c07:container" 

UUID मैंने ब्लकिड से लिया:

 [root@archiso /]# blkid | grep vda2 /dev/vda2: UUID="5ad7c9ad-fb17-4839-925e-479432516c07" TYPE="crypto_LUKS" PARTLABEL="Linux filesystem" PARTUUID="667a1243-17ff-4f03-952c-5afd5e3415cc" 

हम ग्रब के लिए एक कॉन्फिगरेशन उत्पन्न करते हैं:

 [root@archiso /]# grub-mkconfig -o /boot/grub/grub.cfg Generating grub configuration file ... WARNING: Failed to connect to lvmetad. Falling back to device scanning. Found linux image: /boot/vmlinuz-linux Found initrd image: /boot/initramfs-linux.img Found fallback initrd image(s) in /boot: initramfs-linux-fallback.img WARNING: Failed to connect to lvmetad. Falling back to device scanning. done 

इसके बाद, डिस्क पर ही ग्रब स्थापित करें:

 [root@archiso /]# grub-install /dev/vda Installing for x86_64-efi platform. ... Installation finished. No error reported. 

*** आप --recheck --debug जोड़ सकते हैं, वास्तुकला निर्दिष्ट कर सकते हैं ... लेकिन ... यह वास्तव में अपने आप काम करता है)

अब हम / etc / crypttab को संपादित करेंगे, ताकि सिस्टम को स्वयं पता चल जाए कि लोड करते समय LUKS अनुभाग को डिक्रिप्ट करना आवश्यक है। लाइन जोड़ें:

 echo "container /dev/vda2 none" >> /etc/crypttab 

जिसका अर्थ है कि आपको / dev / vda2 विभाजन के लिए एक पासवर्ड (कोई नहीं) का अनुरोध करने की आवश्यकता है और इसे डिवाइस मैपर के माध्यम से पहले से ही कंटेनर के रूप में प्रस्तुत करना होगा।

अब हम चेरोट से बाहर निकलने और सिस्टम को रिबूट करने के लिए तैयार हैं:

 [root@archiso /]# exit exit [root@archiso ~]# reboot Welcome back! 

अब परिणाम देखने के लिए वर्चुअल मशीन कंसोल की ओर मुड़ते हैं:



इस स्तर पर, हमने EFI एप्लिकेशन /boot/efi/EFI/arch/grubx64.efi के साथ / dev / vda1 शुरू किया, जो हमसे हमारे कंटेनर को डिक्रिप्ट करने के लिए पासवर्ड मांगता है।

पासवर्ड दर्ज करने के बाद अगला:



यहाँ हमारे बूट विकल्प /boot/grub/grub.cfg से परिचित ग्रब विंडो है।
इस बिंदु पर, ग्रब ने हमारे कंटेनर को डिक्रिप्ट किया और इस फ़ाइल (/boot/grub/grub.cfg), कर्नेल, और इनट्रामाफ़्स तक स्वयं पहुंच प्राप्त की। विकल्प चुनने के बाद, कर्नेल डिफ़ॉल्ट रूप से बूट होगा, initramfs:



सक्रिय रूप से, कर्नेल एन्क्रिप्टेड हुक के साथ आया, जो फिर से कंटेनर को डिक्रिप्ट करने के लिए हमसे पासवर्ड पूछता है (सामान्य तौर पर, आपको पासवर्ड को 2 बार दर्ज करने की आवश्यकता होती है, लेकिन ऐसा हो सकता है कि आप बूट के लिए 2 कंटेनर बनाते हैं और अतिरिक्त लंबन से रूट करते हैं :)

और फिर सिस्टम पूरी तरह से लोड होने के बाद:



पुनश्च: स्किज़ोफ्रेनिया के स्तर को बढ़ाने के लिए, केवल सुरक्षित बूट हमारे grubx64.efi बूस्टर पर हस्ताक्षर करने के लिए पर्याप्त नहीं है।

मैंने पाया कि यह केवल / कर्ण / vda1 पर कर्नेल और इनट्रामेफ़्स डालने के लिए अनिच्छुक था, जैसा कि मैंने पहले ही 100 बार किया था। अन्य बूट लोडर जैसे SHIM, बूटक्टल आदि को यह नहीं पता कि यह कैसे करना है (ठीक है, अगर मुझे नहीं पता है, तो हमें टिप्पणियों में बताएं)