Author: Markus Kohlmeyer

Letzte Aktualisierung: 12.05.2012

Veröffentlicht: 02.03.2006

Lizenz: Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

Artikel empfehlen: Flattr Twitter Facebook Google+ XING LinkedIn

Einleitung

In diesem HowTo beschreibe ich step-by-step die Remote Installation von Gentoo Linux Hardened 64Bit auf einem dedizierten Server. Weil sich meine Vorgehensweise oft nur geringfügig von einer normalen Gentoo Linux Installation unterscheidet und um eine weitere Republikation der offiziellen Gentoo Linux Dokumentation zu vermeiden, werde ich in diesem HowTo nicht alle Punkte bis ins Detail erläutern.

Vielen Dank für Dein Vertändnis.

Folgende Punkte sind in diesem HowTo zu beachten:

• Alle Dienste werden mit einem möglichst minimalen und bewährten Funktionsumfang installiert.
• Alle Dienste werden mit einer möglichst sicheren und dennoch flexiblen Konfiguration versehen.
• Alle Konfigurationen sind selbstständig auf notwendige individuelle Anpassungen zu kontrollieren.
• Alle Passworte werden als !!!SECRET!!! dargestellt und sind selbstständig durch sichere Passworte zu ersetzen.
• Die Domain der virtuellen Maschine lautet example.org und ist selbstständig durch die eigene Domain zu ersetzen.
• Die IP-Adresse der virtuellen Maschine lautet 10.0.2.15 und ist selbstständig durch die eigene IP-Adresse zu ersetzen.

Das Referenzsystem

Als Referenzsystem habe ich mich für eine virtuelle Maschine auf Basis von Oracle VM VirtualBox unter Microsoft Windows 7 SP1 Professional 64Bit entschieden, da sich so ohne grösseren Aufwand ein handelsüblicher dedizierter Server simulieren lässt. Zudem kann diese virtuelle Maschine später noch als kostengünstiges lokales Testsystem weiter genutzt werden. Leider bringt Microsoft Windows keinen eigenen SSH-Client mit, so dass ich auf das sehr empfehlenswerte Putty zurückgreife. Zur Simulation des bei nahezu allen Anbietern dedizierter Mietserver vorhandene RescueSystem wird in diesem HowTo die auf Gentoo Linux basierende SystemRescueCD eingesetzt.

VirtualBox und Putty werden jeweils mit den Standardoptionen installiert und ihre Installationspfade der Umgebungvariablen PATH des aktuellen Windows-Users hinzugefügt. Dazu öffnen wir die Eingabeaufforderung und setzen folgende drei Befehle ab:

SET OLDPATH=%PATH%
SETX PATH "%OLDPATH%;%ProgramFiles(x86)%\Putty;%VBOX_INSTALL_PATH%"
SET OLDPATH=

Da neue und geänderte Umgebungvariablen in der jeweils aktuellen Eingabeaufforderung noch nicht gültig sind, wird die Eingabeaufforderung nun wieder geschlossen.

Die Windows Registrierungsdatei bitte als putty_virtualbox.reg abspeichern und mittels Doppelklick in die Windowsregistrierung importieren. Dadurch wird PuTTY das vorkonfigurierte Profil Virtualbox hinzugefügt, welches wir für dieses HowTo verwenden werden.

Die Virtuelle Maschine

Als Erstes öffnen wir eine neue Eingabeaufforderung und legen manuell eine neue virtuelle Maschine an. Diese virtuelle Maschine bekommt den Namen Gentoo und wird mit 1024MB RAM, zwei 32GB SATA-Festplatten, einem DVD-Player, sowie einer Intel-Netzwerkkarte ausgestattet. Zudem setzen wir die RTC (Real-Time Clock) der virtuellen Maschine auf UTC (Coordinated Universal Time), schalten den HPET (High Precision Event Timer) ein und die PAE (Physical Address Extension) aus:

VBoxManage createhd --filename "Gentoo1.vdi" --size 32768 --remember
VBoxManage createhd --filename "Gentoo2.vdi" --size 32768 --remember
VBoxManage createvm --name "Gentoo" --ostype Gentoo_64 --register
VBoxManage modifyvm "Gentoo" --memory 1024 --rtcuseutc on --pae off --hpet on --nic1 nat --nictype1 82540EM
VBoxManage modifyvm "Gentoo" --boot1 dvd --boot2 disk --boot3 none --boot4 none
VBoxManage storagectl "Gentoo" --name "IDE Controller" --add ide --controller ICH6
VBoxManage storagectl "Gentoo" --name "SATA Controller" --add sata --controller IntelAHCI --sataportcount 4
VBoxManage storageattach "Gentoo" --storagectl "SATA Controller" --port 0 --device 0 --type hdd --medium "Gentoo1.vdi"
VBoxManage storageattach "Gentoo" --storagectl "SATA Controller" --port 1 --device 0 --type hdd --medium "Gentoo2.vdi"

Die virtuelle Maschine, genauer die virtuelle Netzwerkkarte, kann dank NAT zwar problemlos mit der Aussenwelt, aber leider nicht direkt mit dem Hostsystem kommunizieren. Aus diesem Grund richten wir nun für den SSH-Zugang noch ein Portforwarding ein, welches den Port 2222 des Hostsystems auf den Port 22 der virtuellen Maschine weiterleitet. Das Gleiche machen wir für HTTP (8080->80) und HTTPS (8443->443):

VBoxManage modifyvm "Gentoo" --natpf1 ,tcp,,2222,,22
VBoxManage modifyvm "Gentoo" --natpf1 ,tcp,,8080,,80
VBoxManage modifyvm "Gentoo" --natpf1 ,tcp,,8443,,443

RescueSystem booten

Um unser Gentoo Linux Hardened installieren zu können, müssen wir unsere virtuelle Maschine mit einem RescueSystem booten. Hierzu eignet sich die auf Gentoo Linux basierende SystemRescueCD am Besten. Wir laden uns die SystemRescueCD nun mit Windows-Bordmitteln per FTP auf unseren Windows Host herunter und weisen sie unserer virtuellen Maschine als Bootmedium zu:

cd "%USERPROFILE%\.VirtualBox"

ftp -A ftp.mirrorservice.org
cd sites/download.sourceforge.net/pub/sourceforge/s/project/sy/systemrescuecd/sysresccd-x86/1.6.4
get systemrescuecd-x86-1.6.4.iso
quit

VBoxManage storageattach "Gentoo" --storagectl "IDE Controller" --port 0 --device 0 --type dvddrive --medium "%USERPROFILE%\.VirtualBox\systemrescuecd-x86-1.6.4.iso"

Nachdem die virtuelle Maschine nun konfiguriert ist, wird es Zeit das RescueSystem zu booten:

VBoxManage startvm "Gentoo"

Im Bootscreen wählen wir die Option "64Bit Kernel with default options"

Wer mit dem amerikanischen Tastaturlayout nicht zurechtkommt, sollte während des Bootens die Frage nach der Keymap mit de beantworten.

Ist der Bootvorgang abgeschlossen, wird als Erstes das root-Passwort für das RescueSystem gesetzt:

passwd root

Jetzt sollten wir uns mittels Putty als root in das RescueSystem einloggen und mit der Installation unseres Gentoo Linux Hardened beginnen können.

putty -load Virtualbox -l root

Partitionieren der Festplatte

Da jeder Administrator andere Präferenzen an sein Partitionslayout stellt und wir andernfalls mit diesem HowTo nicht weiterkommen, verwenden wir im Folgenden ein minimales Partitionslayout. Fortgeschrittenere Administratoren können dieses Partitionslayout selbstverständlich an ihre eigenen Bedürfnisse anpassen.

Die Partitionen legen wir nun mittels sfdisk an:

dd if=/dev/zero of=/dev/sda count=1 bs=512
sfdisk -uM /dev/sda <<"EOF"
0,512,FD,*
,2048,FD
,,FD
EOF

dd if=/dev/zero of=/dev/sdb count=1 bs=512
sfdisk -uM /dev/sdb <<"EOF"
0,512,FD,*
,2048,FD
,,FD
EOF

Für eine leicht erhöhte Datensicherheit legen wir nun noch mittels mdadm ein Software-RAID1 an:

cat > /etc/mdadm.conf <<"EOF"
MAILADDR root@localhost
DEVICE /dev/sd[ab]1
DEVICE /dev/sd[ab]2
DEVICE /dev/sd[ab]3
ARRAY /dev/md1 level=raid1 num-devices=2 metadata=00.90 devices=/dev/sda1,/dev/sdb1
ARRAY /dev/md2 level=raid1 num-devices=2 metadata=00.90 devices=/dev/sda2,/dev/sdb2
ARRAY /dev/md3 level=raid1 num-devices=2 metadata=00.90 devices=/dev/sda3,/dev/sdb3
EOF

mdadm --create /dev/md1 --level=1 --raid-devices=2 --metadata=0.90 /dev/sd[ab]1
mdadm --create /dev/md2 --level=1 --raid-devices=2 --metadata=0.90 /dev/sd[ab]2
mdadm --create /dev/md3 --level=1 --raid-devices=2 --metadata=0.90 /dev/sd[ab]3

Formatieren der Partitionen

Die frisch angelegten Partitionen müssen selbstverständlich noch formatiert werden. Normalerweise formatiere ich die Rootpartition mit XFS, da allerdings nicht jeder Administrator XFS für seine Rootpartition verwenden möchte, werden wir ein manuell optimiertes EXT3 anlegen. Dieses ist nötig, da die e2fsprogs bei einigen Distributionen und somit auch RescueSystemen oft veraltet oder suboptimal konfiguriert sind und daher nicht immer ein für Server optimiertes EXT3 erzeugen.

Die Bootpartition sollte grundsätzlich mit EXT2 formatiert weren, da dieses Filesystem als Einziges von allen gängigen Linux-Bootloadern fehlerfrei unterstützt wird.

mke2fs -c /dev/md1
tune2fs -c 0 -i 0 /dev/md1

mke2fs -c -j /dev/md3
tune2fs -c 0 -i 0 /dev/md3
tune2fs -O dir_index /dev/md3
tune2fs -o journal_data /dev/md3
e2fsck -D /dev/md3

mkswap /dev/md2

Mounten der Partitionen

Nun werden die Partitionen für unsere zur Installation benötigten Chroot-Umgebung gemountet und der Swapspace aktiviert:

swapon /dev/md2

mkdir -p /mnt/gentoo
mount -t ext3 /dev/md3 /mnt/gentoo
mkdir -p /mnt/gentoo/boot
mount -t ext2 /dev/md1 /mnt/gentoo/boot

Entpacken des Stage-Tarballs

Der Stage3-Tarball enthält ein minimalistisches Gentoo Linux Hardened, welches alle zur Installation notwendigen Tools enthält und uns als Chroot-Umgebung dient. Wir müssen nun den aktuellen Stage3-Tarball ermitteln, wozu wir per Webbrowser den Gentoo Linux Master Mirror aufsuchen und das Datum im folgenden wget-Aufruf entsprechend ersetzen. Den Stage3-Tarball werden wir bereits während des Download direkt nach /mnt/gentoo entpacken:

wget -q -O - http://gentoo.osuosl.org/releases/amd64/autobuilds/current-stage3-amd64-hardened+nomultilib/stage3-amd64-hardened+nomultilib-20100923.tar.bz2 | tar xpjvf - -C /mnt/gentoo/

Vorbereiten der Chroot-Umgebung

Vor dem Wechsel in die Chroot-Umgebung müssen wir noch die resolv.conf und mdadm.conf in die Chroot-Umgebung kopieren und die für eine erfolgreiche Installation noch fehlenden Filesysteme mounten:

cp -L /etc/mdadm.conf /mnt/gentoo/etc/mdadm.conf
cp -L /etc/resolv.conf /mnt/gentoo/etc/resolv.conf

mount -t proc none /mnt/gentoo/proc
mount -o bind /dev /mnt/gentoo/dev

Betreten der Chroot-Umgebung

Beim Betreten der Chroot-Umgebung setzen wir mittels /bin/env -i erstmal alle Environment-Variablen zurück. Andererseits benötigen wir aber die Environment-Variablen HOME, TERM, PS1 und PATH, welche wir manuell auf sinnvolle Defaults setzen.

chroot /mnt/gentoo /bin/env -i HOME=/root TERM=$TERM PS1='\u:\w\$ ' PATH=/sbin:/bin:/usr/sbin:/usr/bin /bin/bash +h

Setup der Chroot-Umgebung

Wir setzen die Timezone, legen die mtab an und aktualisieren das Environment:

cp /usr/share/zoneinfo/Europe/Berlin /etc/localtime

grep -v rootfs /proc/mounts > /etc/mtab

env-update
source /etc/profile

Portage konfigurieren

Mittels der /etc/make.conf wird Portage konfiguriert:

cat > /etc/make.conf <<"EOF"
ACCEPT_KEYWORDS="amd64"
CHOST="x86_64-pc-linux-gnu"
CFLAGS="-O2 -pipe -mtune=native -fomit-frame-pointer"
CXXFLAGS="-O2 -pipe -mtune=native -fomit-frame-pointer"
GENTOO_MIRRORS="http://de-mirror.org/distro/gentoo http://distfiles.gentoo.org"
USE="-* acl bcmath berkdb bzip2 caps cgi cli crypt cxx exif expat fam \
   fastcgi ftp gd gdbm gmp graphviz hardened iconv idn imap ipv6 ithreads \
   jpeg libssh2 libwww lzma mime mmx modules mudflap mysql mysqli ncurses \
   nls nocxx nptl nptlonly openmp pcre perl pic png posix python readline \
   reflection session sha512 sharedmem sockets spl sse sse2 ssl symlink \
   sysfs tcl tcpd threads tiff tokenizer truetype unicode urandom xattr \
   xml xmlrpc xsl zlib"
EOF

Mittels /etc/portage/package.use werden einzelnen Paketen von der /etc/make.conf abweichende USE-Flags zugewiesen:

mkdir -p /etc/portage

cat > /etc/portage/package.use <<"EOF"
sys-apps/busybox  static
sys-apps/pciutils  -zlib
sys-devel/gcc  -nocxx
EOF

Als Nächstes legen wir mittels emerge den Portage-Tree an:

emerge --sync

Locales setzen

Da das System später weltweit erreichbar sein wird und die Standardsystemsprache amerikanisch ist, werden die Locales auf en_US.utf8 gesetzt und neu erzeugt:

cat > /etc/env.d/02locale <<"EOF"
LC_ALL="en_US.utf8"
LANG="en_US.utf8"
EOF

cat > /etc/locale.gen <<"EOF"
en_US ISO-8859-1
en_US.UTF-8 UTF-8
de_DE ISO-8859-1
de_DE@euro ISO-8859-15
de_DE.UTF-8 UTF-8
EOF

locale-gen -c /etc/locale.gen

env-update
source /etc/profile

Basissystem kompilieren

Nun muss das komplette Basissystem neu kompiliert werden. Dieser Vorgang ist zwar zeitaufwendig, aber für diese Installationsvariante zwingend notwendig. Auch die Reihenfolge ist sehr wichtig, da das System ansonsten unbrauchbar beziehungsweise instabil wird. Während dieses Vorgangs werden nur wenige Konfigurationsdateien automatisch aktualisiert, alle anderen müssen manuell mittels etc-update aktualisiert werden.

Hinweis: Die folgenden Schritte sind nötig, da dieses HowTo eine angepasste Portage-Konfiguration verwendet und zudem seit dem Release des Stage3-Tarballs eventuell ein paar für diese Installationvariante wichtige Basispakete im Portage-Tree aktualisiert wurden:

emerge -1 portage baselayout

etc-update
# -5

emerge -C cracklib pam pambase
emerge -1 shadow openssh busybox

etc-update
# -5

emerge -1 linux-headers glibc

etc-update
# -9

emerge -1 binutils gcc

env-update
source /etc/profile

emerge -1 python-updater python
python-updater

Kompilieren und Aufräumen des Basissystems:

emerge -De system

grpconv

etc-update
# -5

rm -r /usr/lib64/perl5{,/*}/5.8.8/x86_64-linux

Basissystem rekompilieren

Um sicherzustellen, dass das Basissystem ab diesem Punkt keine veraltete Konfiguration oder (speicheresistente) Software nutzt, wird sicherheitshalber kurz die Chroot-Umgebung verlassen und gleich wieder betreten. Im Anschluss wird das Basissystem ein zweites Mal vollständig rekompiliert, damit sichergestellt ist, dass auch wirklich jedes Paket nur noch gegen die aktuell vorhanden Libraries gelinkt ist und somit keine veralteten und/oder nicht mehr vorhandenen Funktionen nutzt:

exit

chroot /mnt/gentoo /bin/env -i HOME=/root TERM=$TERM PS1='\u:\w\$ ' PATH=/sbin:/bin:/usr/sbin:/usr/bin /bin/bash +h

env-update
source /etc/profile

emerge -De system

etc-update

Systemzeit konfigurieren

sed 's@^CLOCK=.*@CLOCK="UTC"@' -i /etc/conf.d/clock
sed 's@^#TIMEZONE=.*@TIMEZONE="Europe/Berlin"@' -i /etc/conf.d/clock

fstab erstellen

Ohne fstab wird das System später nicht booten ;-)

cat > /etc/fstab <<"EOF"
/dev/md1   /boot      ext2    defaults              1 2
/dev/md2   none       swap    sw                    0 0
/dev/md3   /          ext3    defaults              1 1
shm        /dev/shm   tmpfs   nodev,nosuid,noexec   0 0
EOF

Netzwerk konfigurieren

Das Netzwerk konfigurieren wir statisch, wobei wir sicherheithalber auf DHCP als Fallback zurückgreifen:

sed 's@^HOSTNAME=.*@HOSTNAME="devnull"@' -i /etc/conf.d/hostname

cat > /etc/conf.d/net <<"EOF"
modules=( "iproute2" )
config_eth0=( "10.0.2.15/24 brd 10.0.2.255" )
routes_eth0=( "default via 10.0.2.2" )
fallback_eth0=( "dhcp" )
EOF

rc-update add net.eth0 boot

OpenSSL konfigurieren

Folgende Optionen müssen in der /etc/ssl/openssl.cnf im Abschnitt [ req_distinguished_name ] angepasst werden:

[ req_distinguished_name ]
countryName_default             = DE
stateOrProvinceName_default     = Bundesland
localityName_default            = Stadt
0.organizationName_default      = Example Organization
organizationalUnitName_default  = Administration
commonName_default              = example.org
emailAddress_default            = admin@example.org

OpenSSL CA

Als nächstes wird ein eigenes CA Zertifikat erstellt und selbst signiert. Hierzu werden jeweils die Default-Werte übernommen und sehr sichere Passworte gewählt. Die Option A challenge password sollte jedoch leer gelassen werden, andernfalls kann es zu Problemen mit einigen Diensten kommen:

cd /etc/ssl
mkdir -p demoCA
mkdir -p demoCA/certs
mkdir -p demoCA/crl
mkdir -p demoCA/newcerts
mkdir -p demoCA/private
touch demoCA/index.txt

openssl req -new -keyout demoCA/private/cakey.pem -out demoCA/careq.pem
openssl ca -create_serial -out demoCA/cacert.pem -batch -keyfile demoCA/private/cakey.pem -selfsign -extensions v3_ca -infiles demoCA/careq.pem
cd

OpenSSH konfigurieren

OpenSSH wird sehr restriktiv konfiguriert, das heisst, dass das Einloggen nur Systemusern, die der Systemgruppe wheel angehören und einen gültigen Public-Key in ihrer ~/.ssh/authorized_keys hinterlegt haben, gestattet ist:

cat >> /etc/ssh/sshd_config <<"EOF"
Port 22
Protocol 2
PermitRootLogin no
PasswordAuthentication no
ChallengeResponseAuthentication no
AllowGroups wheel
EOF

rc-update add sshd default

Systemprogramme installieren

Jetzt werden wichtige Systemprogramme installiert:

emerge syslog-ng logrotate vixie-cron iproute2 dhcpcd mdadm

etc-update
# -5

rc-update add syslog-ng default
rc-update add vixie-cron default

cat >> /etc/mdadm.conf <<"EOF"
MAILADDR root@localhost
DEVICE /dev/sd[ab]1
DEVICE /dev/sd[ab]2
DEVICE /dev/sd[ab]3
ARRAY /dev/md1 level=raid1 num-devices=2 metadata=00.90 devices=/dev/sda1,/dev/sdb1
ARRAY /dev/md2 level=raid1 num-devices=2 metadata=00.90 devices=/dev/sda2,/dev/sdb2
ARRAY /dev/md3 level=raid1 num-devices=2 metadata=00.90 devices=/dev/sda3,/dev/sdb3
EOF

Bootloader installieren

Als Bootloader kommt grub zum Einsatz:

emerge grub-static

grub --no-floppy <<"EOF"
root (hd1,0)
setup (hd1)
quit
EOF
grub --no-floppy <<"EOF"

root (hd0,0)
setup (hd0)
quit
EOF

Bootloader konfigurieren

Grub muss noch konfiguriert werden:

cat > /boot/grub/grub.conf <<"EOF"
default 0
timeout 5
title=Gentoo Linux
  root (hd0,0)
  kernel /boot/kernel root=/dev/ram0 init=/sbin/init real_root=/dev/md3
  initrd /boot/initramfs
EOF

Kernelsourcen installieren

Wir installieren nun die Gentoo Linux Hardened Kernelsourcen und das Gentoo Linux Tool genkernel zum automatisierten Erstellen des Kernel und des zugehörigen Initramfs.

emerge hardened-sources genkernel

sed 's/^# SYMLINK=.*$/SYMLINK="yes"/g' -i /etc/genkernel.conf
sed 's/^# MDADM=.*$/MDADM="yes"/g' -i /etc/genkernel.conf

Kernelsourcen konfigurieren

Die Gentoo Hardened Kernel Config bitte als /usr/src/linux/.config abspeichern. Zusätzlich kopieren wir die Kernelkonfiguration zur leichteren späteren Verwendung nach /root/kernels/DEVNULL:

mkdir -p /root/kernels
cp /usr/src/linux/.config /root/kernels/DEVNULL

Kernelsourcen kompilieren

Die Kernelkonfiguration, insbesondere die Hardware-Optionen, muss Abseits der virtuellen Maschine an das eigene System angepasst werden. Dies ermöglicht uns die Angabe der Option --menuconfig beim genkernel-Aufruf. Für die Verwendung des Kernels in der virtuelle Maschine ist allerdings kein weiteres Anpassen der Kernelkonfiguration notwendig.

genkernel --menuconfig --kernel-config=/root/kernels/DEVNULL all

Systemtools installieren

Als Nächstes installieren wir noch ein paar notwendige beziehungsweise nützliche Systemtools.

emerge gradm gnupg re2c expect bind-tools ntp ed pciutils libutempter lsof lynx mailx smartmontools

Systemtools konfigurieren

Wir sorgen nun dafür, dass unsere Systemzeit mittels cron stündlich mit dem Timeserver der PTB in Braunschweig, dem Betreiber der deutschen Atomuhr, synchronisiert wird. Zudem aktivieren die regelmässige Überwachung der SMART-Werte unserer Festplatten.

cat > /etc/cron.hourly/ntpdate <<"EOF"
#!/bin/sh
/usr/sbin/ntpdate -b -s -p 4 -t 0.1 ptbtime1.ptb.de
EOF
chmod 0755 /etc/cron.hourly/ntpdate

rc-update add ntp-client default

echo '/dev/sda -a -o on -S on -s (S/../.././02|L/../../6/03)' >> /etc/smartd.conf
echo '/dev/sdb -a -o on -S on -s (S/../.././02|L/../../6/03)' >> /etc/smartd.conf

gradm -P

sysctl.conf einrichten

Mit diesem sed werden ein paar Kernelparameter für die Netzwersicherheit gesetzt:

sed 's@^#net.ipv4@net.ipv4@' -i /etc/sysctl.conf

Root-Passwort setzen

Das Passwort für root sollte mindestens 8 Zeichen lang sein und neben Gross/Klein-Schreibung auch Ziffern und/oder Sonderzeichen enthalten:

passwd root

Arbeitsuser anlegen

Wir legen uns nun einen Arbeitsuser für administrative Aufgaben an. Diesen Arbeitsuser stecken wir in die Systemgruppen users, cron und wheel und schützen sein Home-Verzeichnis mittels chmod 0700 vor neugierigen Blicken anderer User. Das Passwort für den Arbeitsuser sollte wie das root-Passwort aufgebaut sein, sich von diesem aber deutlich unterscheiden.

useradd admin -m -g users -G cron,wheel

chmod 0700 /home/admin

passwd admin

SSH-Keys installieren

Für den eben angelegten Arbeitsuser müssen nun noch die SSH-Keys erzeugt werden:

su - admin
ssh-keygen -q -b 2048 -t rsa -N "" -f ~/.ssh/id_rsa
install -m 0600 ~/.ssh/id_rsa.pub ~/.ssh/authorized_keys
exit

Abschliessend müssen die SSH-Keys per Putty auf den Client (PC) kopiert und der Private-Key mittels <code>puttygen ins Putty-Format konvertiert und gespeichert werden:

mkdir "%USERPROFILE%\Putty"
pscp -load Virtualbox root@127.0.0.1:/mnt/gentoo/home/admin/.ssh/id_rsa "%USERPROFILE%\Putty\id_rsa"
pscp -load Virtualbox root@127.0.0.1:/mnt/gentoo/home/admin/.ssh/id_rsa.pub "%USERPROFILE%\Putty\id_rsa.pub"

puttygen "%USERPROFILE%\Putty\id_rsa"

Künftig können wir uns dann folgendermassen per Putty als Arbeitsuser einloggen:

putty -load Virtualbox -l admin -i "%USERPROFILE%\Putty\id_rsa.ppk"

Reboot ins neue System

Die Basisinstallation ist nun endlich abgeschlossen und wir können das neue System zum ersten Mal booten:

exit

umount /mnt/gentoo/dev
umount /mnt/gentoo/proc
umount /mnt/gentoo/boot
umount /mnt/gentoo

shutdown -r now

Wie geht es weiter?

Natürlich mit den Gentoo Tips und Tricks und/oder mit dem Gentoo Web Hosting System.

Viel Spass mit dem neuen Gentoo Basissystem.