Si può “ciecamente” seguire i vari passaggi per ottenere un dominio funzionante in pochi minuti, volendo invece approfondire si può leggere i due link principali che ho seguito: OpenLDAP è stato installato seguendo questa guida e configurato per l’autenticazione seguendo quest’altra guida. Al termine dell’articolo ho comunque riportato tutta una serie di link che ho visitato.

Prima di iniziare scegliete il nome del dominio. Può essere un semplice TOMMYBLUE oppure un più complesso BASE.TOMMYBLUE.IT. Non cambia molto, basta “tradurre” correttamente il tutto in ldappese, quindi TOMMYBLUE sarà dc=tommyblue mentre BASE.TOMMYBLUE.IT diventa dc=base,dc=tommyblue,dc=it. Io per semplicità ho usato soltanto DOMAIN, fate le opportune sostituzioni. Scegliete anche una password e sostituitela dove io ho messo PASSWORD.

Installazione di SLAPD

Si inizia installando i pacchetti necessari:

sudo apt-get install slapd ldap-utils

E inserendo alcuni schemi base:

sudo ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/ldap/schema/cosine.ldif
sudo ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/ldap/schema/nis.ldif
sudo ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/ldap/schema/inetorgperson.ldif

Creiamo poi un file backend.ldif con:

dn: cn=module,cn=config
objectClass: olcModuleList
cn: module
olcModulepath: /usr/lib/ldap
olcModuleload: back_hdb

dn: olcDatabase=hdb,cn=config
objectClass: olcDatabaseConfig
objectClass: olcHdbConfig
olcDatabase: {1}hdb
olcSuffix: dc=DOMAIN
olcDbDirectory: /var/lib/ldap
olcRootDN: cn=admin,dc=DOMAIN
olcRootPW: PASSWORD
olcDbConfig: set_cachesize 0 2097152 0
olcDbConfig: set_lk_max_objects 1500
olcDbConfig: set_lk_max_locks 1500
olcDbConfig: set_lk_max_lockers 1500
olcDbIndex: objectClass eq
olcLastMod: TRUE
olcDbCheckpoint: 512 30
olcAccess: to attrs=userPassword by dn="cn=admin,dc=DOMAIN" write by anonymous auth by self write by * none
olcAccess: to attrs=shadowLastChange by self write by * read
olcAccess: to dn.base="" by * read
olcAccess: to * by dn="cn=admin,dc=DOMAIN" write by * read

E inseriamolo nel db:

sudo ldapadd -Y EXTERNAL -H ldapi:/// -f backend.ldif

Creiamo frontend.ldif:

dn: dc=DOMAIN
objectClass: top
objectClass: dcObject
objectclass: organization
o: MyDomain
dc: DOMAIN
description: My Domain's LDAP

dn: cn=admin,dc=DOMAIN
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator
userPassword: PASSWORD

dn: ou=People,dc=DOMAIN
objectClass: organizationalUnit
ou: People

dn: ou=Groups,dc=DOMAIN
objectClass: organizationalUnit
ou: Groups

dn: uid=john,ou=People,dc=DOMAIN
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: shadowAccount
uid: john
sn: Doe
givenName: John
cn: John Doe
displayName: John Doe
uidNumber: 10000
gidNumber: 10000
userPassword: password
gecos: John Doe
loginShell: /bin/bash
homeDirectory: /home/john
shadowExpire: -1
shadowFlag: 0
shadowWarning: 7
shadowMin: 8
shadowMax: 999999
shadowLastChange: 10877
mail: john.doe@mymaildomain.com
postalCode: 31000
l: Toulouse
o: Example
mobile: +33 (0)6 xx xx xx xx
homePhone: +33 (0)5 xx xx xx xx
title: System Administrator
postalAddress:
initials: JD

dn: cn=example,ou=Groups,dc=DOMAIN
objectClass: posixGroup
cn: example
gidNumber: 10000

e inseriamolo nel db:

sudo ldapadd -x -D cn=admin,dc=DOMAIN -W -f frontend.ldif

Aggiungiamo degli indici per velocizzare le query, creiamo il file uid_index.ldif:

dn: olcDatabase={1}hdb,cn=config
add: olcDbIndex
olcDbIndex: uid eq,pres,sub

E inseriamoli:

sudo ldapmodify -Y EXTERNAL -H ldapi:/// -f uid_index.ldif

È necessario anche convertire gli schema al nuovo formato, creiamo quindi il file schema_convert.conf:

include /etc/ldap/schema/core.schema
include /etc/ldap/schema/collective.schema
include /etc/ldap/schema/corba.schema
include /etc/ldap/schema/cosine.schema
include /etc/ldap/schema/duaconf.schema
include /etc/ldap/schema/dyngroup.schema
include /etc/ldap/schema/inetorgperson.schema
include /etc/ldap/schema/java.schema
include /etc/ldap/schema/misc.schema
include /etc/ldap/schema/nis.schema
include /etc/ldap/schema/openldap.schema
include /etc/ldap/schema/ppolicy.schema

Creiamo una directory temporanea in cui salvare l’output:

mkdir -p ./tmp/ldif_output

E convertiamo il file schema in LDIF:

slapcat -f schema_convert.conf -F ./tmp/ldif_output -n0 -s "cn={5}dyngroup,cn=schema,cn=config" > ./tmp/cn=dyngroup.ldif

Il file ./tmp/cn\=dyngroup.ldif va modificato in questo modo:

dn: cn=dyngroup,cn=schema,cn=config
...
cn: dyngroup

E rimosse le seguenti righe dalla fine del file:

structuralObjectClass: olcSchemaConfig
entryUUID: 10dae0ea-0760-102d-80d3-f9366b7f7757
creatorsName: cn=config
createTimestamp: 20080826021140Z
entryCSN: 20080826021140.791425Z#000000#000#000000
modifiersName: cn=config
modifyTimestamp: 20080826021140Z

Infine inseriamo gli schema nel db:

sudo ldapadd -Y EXTERNAL -H ldapi:/// -f ./tmp/cn\=dyngroup.ldif

Con questo comando possiamo verificare il tutto:

sudo ldapsearch -LLL -Y EXTERNAL -H ldapi:/// -b cn=config dn

Autenticazione LDAP

Come sempre installiamo il necessario:

sudo apt-get install libnss-ldap

In fase di configurazione dobbiamo rispondere:

ldap://127.0.0.1:389/
dc=DOMAIN
3
yes
no
cn=admin,dc=DOMAIN
PASSWORD

Configuriamo anche le autenticazioni NSS e PAM:

sudo auth-client-config -t nss -p lac_ldap
sudo pam-auth-update

Con getent possiamo verificare il funzionamento dell’autenticazione. Il sistema infatti adesso ha unito i gruppi e gli utenti su ldap a quelli in /etc/passwd e /etc/group:

~$ getent passwd

...
john:x:10000:10000:John Doe:/home/john:/bin/bash

~$ getent group

...
example:*:10000:

Se non vedete l’utente john o il gruppo example, avete sbagliato qualcosa :)

Samba

Installiamo i pacchetti:

sudo apt-get install samba samba-doc smbldap-tools

Inseriamo lo schema samba:

sudo cp /usr/share/doc/samba-doc/examples/LDAP/samba.schema.gz /etc/ldap/schema/
sudo gzip -d /etc/ldap/schema/samba.schema.gz

Creiamo il file samba_schema_convert.conf:

include /etc/ldap/schema/core.schema
include /etc/ldap/schema/collective.schema
include /etc/ldap/schema/corba.schema
include /etc/ldap/schema/cosine.schema
include /etc/ldap/schema/duaconf.schema
include /etc/ldap/schema/dyngroup.schema
include /etc/ldap/schema/inetorgperson.schema
include /etc/ldap/schema/java.schema
include /etc/ldap/schema/misc.schema
include /etc/ldap/schema/nis.schema
include /etc/ldap/schema/openldap.schema
include /etc/ldap/schema/ppolicy.schema
include /etc/ldap/schema/samba.schema

E convertiamo gli schema:

slapcat -f samba_schema_convert.conf -F ./tmp/ldif_output -n0 -s "cn={12}samba,cn=schema,cn=config" > ./tmp/cn=samba.ldif

Modifichiamo il file ./tmp/cn\=samba.ldif sistemando i seguenti attributi:

dn: cn=samba,cn=schema,cn=config
...
cn: samba

e rimuovendo le seguenti righe dalla fine del file:

structuralObjectClass: olcSchemaConfig
entryUUID: b53b75ca-083f-102d-9fff-2f64fd123c95
creatorsName: cn=config
createTimestamp: 20080827045234Z
entryCSN: 20080827045234.341425Z#000000#000#000000
modifiersName: cn=config
modifyTimestamp: 20080827045234Z

Inseriamo il tutto nel db:

sudo ldapadd -Y EXTERNAL -H ldapi:/// -f ./tmp/cn\=samba.ldif

Aggiungiamo gli indici, creiamo samba_indexes.ldif:

dn: olcDatabase={1}hdb,cn=config
add: olcDbIndex
olcDbIndex: uidNumber eq
olcDbIndex: gidNumber eq
olcDbIndex: loginShell eq
olcDbIndex: memberUid eq,pres,sub
olcDbIndex: uniqueMember eq,pres
olcDbIndex: sambaSID eq
olcDbIndex: sambaPrimaryGroupSID eq
olcDbIndex: sambaGroupType eq
olcDbIndex: sambaSIDList eq
olcDbIndex: sambaDomainName eq
olcDbIndex: default sub

Inseriamoli:

sudo ldapmodify -Y EXTERNAL -H ldapi:/// -f samba_indexes.ldif

smbldap-tools

Gli smbldap-tools sono degli ottimi script per gestire il tutto, io comunque per la gestione del dominio consiglio l’utilizzo di LAM ma con smbldap-tools si può popolare velocemente LDAP con i dati necessari e Samba li utilizzerà per aggiungere le macchine che si uniscono al dominio.
Iniziamo quindi configurandoli:

sudo gzip -d /usr/share/doc/smbldap-tools/configure.pl.gz
sudo perl /usr/share/doc/smbldap-tools/configure.pl

Dopo l’ultimo comando vi verranno fatte varie domande che servono a configurare i file che riporto qui di seguito, quindi dategli uno sguardo per capire cosa dovete rispondere.

/etc/smbldap-tools/smbldap_bind.conf:

slaveDN="cn=admin,dc=DOMAIN"
slavePw="PASSWORD"
masterDN="cn=admin,dc=DOMAIN"
masterPw="PASSWORD"

/etc/smbldap-tools/smbldap.conf:

SID="S-1-5-21-395106984-1667043562-2069293566" (il SID è unico del vostro server, questo è il mio!)
sambaDomain="DOMAIN"
slaveLDAP="127.0.0.1"
slavePort="389"
masterLDAP="127.0.0.1"
masterPort="389"
ldapTLS="0"
verify=""
cafile=""
clientcert=""
clientkey=""
suffix="dc=DOMAIN"
usersdn="ou=People,${suffix}"
computersdn="ou=Computers,${suffix}"
groupsdn="ou=Groups,${suffix}"
idmapdn="ou=Idmap,${suffix}"
sambaUnixIdPooldn="sambaDomainName=DOMAIN,${suffix}"
scope="sub"
hash_encrypt="SSHA"
crypt_salt_format=""
userLoginShell="/bin/bash"
userHome="/home/%U"
userHomeDirectoryMode="700"
userGecos="System User"
defaultUserGid="513"
defaultComputerGid="515"
skeletonDir="/etc/skel"
defaultMaxPasswordAge="120"
userSmbHome=""
userProfile=""
userHomeDrive="H:"
userScript="logon.cmd"
mailDomain="mymaildomain.com"
with_smbpasswd="0"
smbpasswd="/usr/bin/smbpasswd"
with_slappasswd="0"
slappasswd="/usr/sbin/slappasswd"

A questo punto configuriamo anche samba con il suo file /etc/samba/smb.conf. Riporto direttamente l’output del comando testparm che verifica il ruolo del server Samba e poi stampa il dump del file smb.conf:

Load smb config files from /etc/samba/smb.conf
rlimit_max: rlimit_max (1024) below minimum Windows limit (16384)
Processing section "[netlogon]"
WARNING: The "share modes" option is deprecated
Processing section "[profiles]"
Loaded services file OK.
Server role: ROLE_DOMAIN_PDC
Press enter to see a dump of your service definitions

[global]
        dos charset = 850
        unix charset = ISO8859-1
        workgroup = DOMAIN
        server string = %h server (Samba, Ubuntu)
        map to guest = Bad User
        obey pam restrictions = Yes
        passdb backend = ldapsam:ldap://127.0.0.1
        pam password change = Yes
        passwd program = /usr/bin/passwd %u
        passwd chat = *Enter\snew\s*\spassword:* %n\n *Retype\snew\s*\spassword:* %n\n *password\supdated\ssuccessfully* .
        unix password sync = Yes
        log level = 3 passdb:5 auth:10 winbind:2
        syslog = 0
        log file = /var/log/samba/log.%m
        max log size = 1000
        smb ports = 139 445
        name resolve order = wins host dns bcast
        time server = Yes
        deadtime = 10
        socket options = TCP_NODELAY IPTOS_LOWDELAY SO_SNDBUF=8192 SO_RCVBUF=8192
        load printers = No
        show add printer wizard = No
        add machine script = sudo /usr/sbin/smbldap-useradd -t 0 -w "%u"
        logon script = logon.cmd
        logon path =
        logon drive = H:
        logon home =
        domain logons = Yes
        os level = 65
        preferred master = Yes
        domain master = Yes
        dns proxy = No
        wins support = Yes
        ldap admin dn = cn=admin,dc=DOMAIN
        ldap group suffix = ou=Groups
        ldap idmap suffix = ou=Idmap
        ldap machine suffix = ou=Computers
        ldap passwd sync = yes
        ldap suffix = dc=DOMAIN
        ldap ssl = no
        ldap user suffix = ou=People
        usershare allow guests = Yes
        panic action = /usr/share/samba/panic-action %d
        idmap backend = ldap:ldap://127.0.0.1
        idmap uid = 10000-20000
        idmap gid = 10000-20000
        template shell = /bin/bash
        winbind enum users = Yes
        winbind enum groups = Yes
        nt acl support = No
        case sensitive = No
        dont descend = /proc,/dev,/etc,/lib,/lost+found,/initrd

[netlogon]
        comment = Network Logon Service
        path = /srv/samba/netlogon
        guest ok = Yes
        share modes = No

[profiles]
        comment = Users profiles
        path = /srv/samba/profiles
        create mask = 0600
        directory mask = 0700
        profile acls = Yes
        browseable = No
        browsable = No

A questo punto popoliamo LDAP:

sudo smbldap-populate

Se tutto è andato bene il vostro albero LDAP dovrebbe esser più o meno così:

Prima di terminare creiamo la cartella netlogon:

sudo mkdir -p /srv/samba/netlogon
sudo touch /srv/samba/netlogon/logon.cmd

Il file logon.cmd può contenere le istruzioni che volete che i pc Windows eseguano all’accesso dell’utente, ad esempio per montare delle condivisioni o settare qualche paramentro.

Riavviamo Samba e impostiamo la password di root:

sudo stop smbd
sudo start smbd
sudo smbpasswd -w PASSWORD

Verifichiamo il mappaggio dei gruppi Samba nei gruppi LDAP con il comando net:

~$ sudo net groupmap list

Domain Admins (S-1-5-21-395106984-1667043562-2069293566-512) -> Domain Admins
Domain Users (S-1-5-21-395106984-1667043562-2069293566-513) -> Domain Users
Domain Guests (S-1-5-21-395106984-1667043562-2069293566-514) -> Domain Guests
Domain Computers (S-1-5-21-395106984-1667043562-2069293566-515) -> Domain Computers
Administrators (S-1-5-32-544) -> Administrators
Account Operators (S-1-5-32-548) -> Account Operators
Print Operators (S-1-5-32-550) -> Print Operators
Backup Operators (S-1-5-32-551) -> Backup Operators
Replicators (S-1-5-32-552) -> Replicators

Attualmente l’utente Domain Admin è root, è comodo avere l’alias in Administrator:

echo "root = Administrator" > /etc/samba/smbusers

Abbiamo terminato, possiamo adesso aggiungere il primo pc al dominio!

Aggiungere un pc Windows al dominio

In generale si può seguire la guida ufficiale Microsoft

Accedere al pc, cliccare col tasto destro del mouse su Risorse del computer e poi su Proprietà. Selezionare la scheda Nome computer e premere su Cambia.
Spuntare Membro di Dominio e inserire il nome del dominio DOMAIN.
Alla richiesta inserire username root (o Administrator) e la relativa password.

Risoluzione dei problemi

In caso di errore nell’unione al dominio:

• Aprire l’editor delle policy di Sicurezza Locale Start->Pannello di controllo->Strumenti di Aministrazione->Criteri di protezione locali->Criteri locali->opzioni di protezione
• Disabilitare la voce Domain member: Digitally encrypt or sign secure channel (always) (_Membro di dominio: aggiunta crittografia of irma digitale ai dati del canale protetto (sempre))
• Disabilitare la voce Domain member: Disable machine account password changes (Controller di dominio: rifiuta cambio password account computer)
• Disabilitare la voce Domain member: Require strong (Windows 2000 or later) session key (Membro di dominio: richiesta chiave di sessione avanzata (Windows 2000 o versioni successive))
• Scaricare il file WinXP_SignOrSeal.reg (qui di seguito) ed eseguirlo per modificare il registro di sistema:

Windows Registry Editor Version 5.00

;
; This registry key is needed for a Windows XP Client to join
; and logon to a Samba domain. Note: Samba 2.2.3a contained
; this key in a broken format which did nothing to the registry -
; however XP reported "registry key imported". If in doubt
; check the key by hand with regedit.

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters]
"requiresignorseal"=dword:00000000

Funzioni di base

Qui di seguito riporto alcuni comandi di base per la gestione del dominio, consiglio comunque l’utilizzo di LAM (ldap-account-manager) che semplifica il tutto.. e parecchio :)

• Per aggiungere un nuovo utente a LDAP con attributi Samba, digitare quanto segue, sostituendo “NOME_UTENTE” con un nome utente reale:

sudo smbldap-useradd -a -P NOME_UTENTE

L’opzione -a aggiunge gli attributi Samba, -P chiama l’utilità smbldap-passwd dopo aver creato l’utente consentendo di inserire la password per l’utente.

• Per rimuovere un utente dalla directory:

sudo smbldap-userdel NOME_UTENTE

L’utilità smbldap-userdel è dotata anche di un’opzione -r per rimuovere la directory home dell’utente.

• Per aggiungere un gruppo, usare smbldap-groupadd, sostituendo “NOME_GRUPPO” con il nome di un gruppo esistente:

sudo smbldap-groupadd -a NOME_GRUPPO

Come per smbldap-useradd, l’opzione -a aggiunge gli attributi Samba.

• Per aggiungere un utente a un gruppo, usare smbldap-groupmod:

sudo smbldap-groupmod -m NOME_UTENTE NOME_GRUPPO

Assicurarsi di sostituire NOME_UTENTE con un utente reale. Inoltre, con l’opzione -m è possibile aggiungere più di un utente alla volta, elencandoli come valori separati da virgola.

• smbldap-groupmod può essere usato anche per rimuovere un utente da un gruppo:

sudo smbldap-groupmod -x NOME_UTENTE NOME_GRPPO

• L’utilità smbldap-useradd può anche aggiungere degli account macchina:

sudo smbldap-useradd -t 0 -w NOME_MACCHINA

Sostituire NOME_MACCHINA con il nome della workstation. L’opzione -t 0 crea un account macchina immediatamente, -w indica di creare l’utente come account macchina. Notare che l’opzione add machine script in /etc/samba/smb.conf è stata modificata per usare smbldap-useradd.

Webografia

• http://help.ubuntu-it.org/10.04/ubuntu/serverguide/it/samba-ldap.html
• http://help.ubuntu-it.org/10.04/ubuntu/serverguide/it/samba-dc.html
• https://help.ubuntu.com/10.04/serverguide/C/samba-dc.html
• https://help.ubuntu.com/10.04/serverguide/C/samba-ldap.html
• http://it.fon.wikia.com/wiki/Samba_pdc
• http://www.areanetworking.it/installazione-di-samba-come-pdc-con-ldap-backend.html
• http://www.finex.org/configurare-samba-su-ubuntu-come-pdc.html
• http://www.pluto.it/files/journal/pj0605/samba3pdc.html
• http://www.openskill.info/infobox.php?ID=552
• http://wiki.novell.com/index.php/OES_as_PDC
• http://www.pascal-hacker.de/info/it/sw/ubuntu/pdc.htm
• http://tuxnetworks.blogspot.com/2010/07/howto-samba-ldap-on-1004-lucid-short.html

English version

L’idea è semplice: utilizzare una base sicura (e meglio “aggeggiabile”) come Debian Etch con cui virtualizzare Windows Server 2003 (per alcuni servizi che non si possono far girare altrimenti) utilizzando VirtualBox.
Tutto sommato non è stato così difficile, ecco qua cosa ho fatto.

Installazione

Ho effettuato l’installazione del “sistema standard” aggiungendo poi ai repository quello di virtualbox come descritto nella pagina ufficiale di download.
Il pacchetto da installare è virtualbox che si porta dietro un bel po’ di dipendenze:

I seguenti pacchetti NUOVI (NEW) saranno installati:
cpp cpp-4.1 defoma fontconfig fontconfig-config libasound2 libaudio2 libdirectfb-0.9-25 libexpat1 libfontconfig1
libfreetype6 libglib2.0-0 libice6 libicu36 libidl0 libjpeg62 liblcms1 libmng1 libpng12-0 libqt3-mt libsdl1.2debian
libsdl1.2debian-alsa libsm6 libsvga1 libsysfs2 libx11-6 libx11-data libxalan110 libxau6 libxcursor1 libxdmcp6
libxerces27 libxext6 libxfixes3 libxft2 libxi6 libxinerama1 libxrandr2 libxrender1 libxt6 psmisc svgalibg1
ttf-dejavu virtualbox x11-common

Quindi aggiungete al gruppo vboxusers l’utente che poi lancerà la macchina virtuale (eventualmente createlo prima, io ho usato winserver2003).

Se volete lanciare la GUI VirtualBox per la configurazione della macchina virtuale o per utilizzarla in locale e’ necessario installare anche i pacchetti xorg (o quelli che ritenete più opportuni per poter lanciare X e xterm) e libxalan110. Questi pacchetti non sono invece necessari se la macchina sara’ configurata da console (o su un’altra macchina) e se sara’ necessario solo l’accesso remoto.

ATTENZIONE
Puo’ capitare che la compilazione del modulo vboxdrv fallisca, in questo caso verificate di aver installato il pacchetto linux-headers-vostrokernel ed, eventualmente, build-essential, dopodiche’ rilanciate

 ~# /etc/init.d/vboxdrv setup

Creazione e configurazione della macchina virtuale con la GUI

A questo punto si può lanciare X con startx (dall’utente appena aggiunto al gruppo vboxusers) e da xterm si lancia virtualbox col comando VirtualBox. Creare una macchina virtuale è molto semplice e potete far riferimento alle tantissime risorse già presenti su internet. L’unica nota è non attivare il server RDP presente in VirtualBox (funziona malissimo!), se necessario meglio usare quello di Windows.

La macchina virtuale puo’ essere creata su un pc e poi spostata nel server finale (dove, magari, non e’ installato l’ambiente grafico) semplicemente spostando (e impostando poi i giusti permessi) la cartella ~/.VirtualBox.

Configurare la rete

La procedura consiste nel creare una scheda di rete virtuale vbox0 e un bridge tra essa e la scheda fisica su cui, per comodità, ho creato un ip alias per gestire meglio le richieste.

Ecco quindi il file /etc/network/interfaces col quale imposto l’ip primario e un alias che assocerò alla macchina virtuale:

# Interfaccia fisica
auto eth0
iface eth0 inet static
        address 192.168.2.60
        netmask 255.255.255.0
        gateway 192.168.2.254
        dns-nameservers 208.67.222.222 208.67.220.220

# Interfaccia virtuale
auto eth0:1
iface eth0:1 inet static
        address 192.168.2.61
        netmask 255.255.255.0

Poi, dopo aver installato bridge-utils, bisogna creare il bridge br0 tra eth0:1 e vbox0, io ho creato uno script che faccio avviare all’inizio, ovvero /etc/init.d/bridge linkato in /etc/rc.2/S20bridge.
ATTENZIONE: è fondamentale che parta PRIMA che virtualbox abbia creato vbox0, altrimenti br0 non viene trovato, ovvero prima dei files S20vboxdrv e S20vboxnet.

Ecco quindi /etc/init.d/bridge:

#!/bin/bash
brctl addbr br0
ifconfig br0 10.1.1.1 netmask 255.255.255.0 up

# Regole per far funzionare PASV mode in FTP
/sbin/modprobe ip_conntrack_ftp
/sbin/modprobe ip_nat_ftp

echo 1 > /proc/sys/net/ipv4/ip_forward

# Giro tutte le richieste su .61 alla macchina virtuale
iptables -t nat -A PREROUTING -p tcp -d 192.168.2.61 -j DNAT --to 10.1.1.2

# Con queste regole si possono girare singole porte
# HTTP
#iptables -t nat -A PREROUTING -p tcp -d 192.168.2.61 --dport 80 -j DNAT --to 10.1.1.2:80
# HTTPS
#iptables -t nat -A PREROUTING -p tcp -d 192.168.2.61 --dport 443 -j DNAT --to 10.1.1.2:443
# Desktop Remoto
#iptables -t nat -A PREROUTING -p tcp -d 192.168.2.61 --dport 3389 -j DNAT --to 10.1.1.2:3389

# Permetto alla macchina virtuale di navigare
iptables -t nat -A POSTROUTING -o eth0 -s 10.1.1.2 -j MASQUERADE

Infine creo l’interfaccio vbox0, prima però è meglio riavviare la rete per aggiornare gli indirizzi ip (attenzione se cambiate l’ip e siete connessi via SSH) ed eseguire lo script /etc/init.d/bridge per creare il bridge (altrimenti verrà mostrato un errore che si risolverà al riavvio del pc).

/etc/init.d/netrworking restart
chmod +x /etc/init.d/bridge
/etc/init.d/bridge

Il comando qui di seguito crea vbox0 e salva la cui configurazione nel file /etc/vbox/interfaces):

VBoxAddIF vbox0 nomeutente br0

Al posto di nomeutente ho usato winserver2003.
Ricordatevi di impostare su Windows l’ip a 10.1.1.2/24 e il gateway a 10.1.1.1

Avvio automatico all’accensione del pc

Per avviare con l’interfaccia grafica ho usato gdm con login automatico dell’utente con cui lancio la macchina virtuale e nel file .bashrc ho inserito il comando necessario a lanciare la macchina da console:

VBoxSDL -fullscreen -vm WinServer2003

Se invece volete soltanto l’accesso remoto alla macchina il comando e’:

VBoxVRDP -startvm WinServer2003

Per l’avvio automatico ho creato il file /etc/init.d/VBoxAutostart linkato in /etc/rc.2/S99VBoxAutostart come questo qui sotto:

#!/bin/bash

echo -e ""
echo -e "### AVVIO DELLA MACCHINA VIRTUALE ###"
echo -e ""
su winserver2003 -c 'VBoxVRDP -startvm WinServer2003 &'
sleep 5
echo -e ""

In alternativa e’ possibile creare uno script contenente

VBoxVRDP -startvm WinServer2003 &

da lanciare poi con start-stop-daemon sempre nel file /etc/init.d/VBoxAutostart

#!/bin/bash
start-stop-daemon --start -c winserver2003 --exec /path/script.sh

Cose che capitano…
Ho avuto modo di provare più volte la procedura descritta qui sopra e di correggerla altrettante volte a causa di qualche “svista”. Alcuni fallimenti nella creazione/avvio della macchina virtuale però non sono relativi alla procedura da me descritta ed ho quindi deciso di elencarli per cercare di esservi d’aiuto.

Se, ad esempio, la macchina da linea di comando non si avvia con l’errore Invalid machine name! non è proprio detto che sia sbagliato il nome della macchina. Nel mio caso infatti mi ero scordato di creare la cartella /home/winserver2003/scambio che avevo impostato come cartella di scambio tra il sistema host e quello virtuale.

Altri errori sui permessi, ad esempio, dell’uso del cdrom o altre periferiche li ho risolti aggiungendo l’utente ai gruppi relativi (audio, cdrom, floppy, plugdev, ecc.)

continua… :D