MongoDb 3.0 Security

Su MongoDb di default le impostazioni di sicurezza sono disabilitate, per abilitarle occorre far partire il server con l'opzione --auth.
Tutti i dati degli utenti sono salvati nella collection db.system.users nel db admin.
Obiettivo del post è creare un utente root in grado di creare utenti e che abbia un ruolo da amministratore generale su ogni db.
Quindi creare un db di prova e abilitare due utenti uno in sola lettura e uno in lettura e scrittura al db.

RUOLI BUILT-IN

Mongodb fornisce la possibilità di inserire i ruoli scegliendo in un ventaglio di ruoli predefiniti.

A livello di singolo database abbiamo:

• read, può leggere su tutte le collection non di tipo system , eccezion fatta per system.indexes,system.js e system.namespaces
• readWrite legge e modifica tutte le collection non system più la system.js

A livello di amministrazione di singolo database abbiamo:

• dbAdmin consente di effettuare operazione amministrative, indicizzazione e raccolta di statistiche, non consente di gestire le utenze;
• dbOwner consente di effettuare tutto sul singolo db, unisce i privilegi di readWrite a quelli di userAdmin e di dbOwner
• userAdmin crea e modifica ruoli sul db

 A livello di amministrazione globale dei database abbiamo invece:

• readAnyDatabase
• readWriteAnyDatabase
• userAdminAnyDatabase
• dbAdminAnyDatabase

A livello di amministrazione di cluster abbiamo invece:

• clusterAdmin
• clusterManager
• clusterMonitor
• hostManager 

A livello di superuser abbiamo root che combina le abilitazioni di:

• readWriteAnyDatabase
• dbAdminAnyDatabase
• userAdminAnyDatabase
• clusterAdmin

ESEMPIO CREAZIONE SUPER USER


Facciamo partire il server senza impostazioni di sicurezza

sudo mongod --dbpath /data/dbTest --port 27018 --logpath /data/dbTest/dbInfo.log  --fork

Ora colleghiamoci al db:

mongo --port 27018

Quindi scegliamo il db admin e creaiamo l'utente con role root

> use admin
switched to db admin
> db.createUser({user:"superAdmin",pwd:"root",roles:["root"]})
Successfully added user: { "user" : "superAdmin", "roles" : [ "root" ] }

Quindi possiamo vedere interrogando la collection db.system.users l'utente attualmente inserito:

> db.system.users.find().pretty()
{
 "_id" : "admin.superAdmin",
 "user" : "superAdmin",
 "db" : "admin",
 "credentials" : {
  "SCRAM-SHA-1" : {
   "iterationCount" : 10000,
   "salt" : "HL4Hdem/yHeYZdPzC/1rFA==",
   "storedKey" : "3XGxaW4FtZEc+O+Xk+D/Zq7w3K0=",
   "serverKey" : "cOFlFork/KU//07ZZeNTp/vQ6AM="
  }
 },
 "roles" : [
  {
   "role" : "root",
   "db" : "admin"
  }
 ]
}

Quindi buttiamo giù il servizio di mongod e facciamo ripartire il server con lo stesso script di prima + l'opzione --auth. Con l'utenza appena creata possiamo riloggarci al db admin:

mongo 127.0.0.1:27018/admin -u superAdmin -p

Verrà chiesta al prompt la password.

Iniziamo a creare 4 utenti su un db denominato provaUser, uno con profilo read, uno write e uno dbOwner. Infine creiamo un utente denominato utentepowerdb con ruolo dbAdminAnyDatabase.

Per fare questa operazione dobbiamo specificare prima il db su cui opereremo , quindi dobbiamo digitare il comando use provaUser.

Prima di creare invece l'utente con ruolo dbAdminAnyDatabase

> db.createUser({user:"utentebase",pwd:"utentebase",roles:[{role:"read",db:"provaUser"}]})
Successfully added user: {
 "user" : "utentebase",
 "roles" : [
  {
   "role" : "read",
   "db" : "provaUser"
  }
 ]
}
> db.createUser({user:"utentewrite",pwd:"utentewrite",roles:[{role:"readWrite",db:"provaUser"}]})
Successfully added user: {
 "user" : "utentewrite",
 "roles" : [
  {
   "role" : "readWrite",
   "db" : "provaUser"
  }
 ]
}
> db.createUser({user:"utenteowner",pwd:"utenteowner",roles:[{role:"dbOwner",db:"provaUser"}]})
Successfully added user: {
 "user" : "utenteowner",
 "roles" : [
  {
   "role" : "dbOwner",
   "db" : "provaUser"
  }
 ]
}

db.createUser({user:"utentepowerdb",pwd:"utentepowerdb",roles:["dbAdminAnyDatabase"]}) 

Quindi proviamo a riloggarci con utentebase e verifichiamo che possiamo leggere dalla collection presente sul db provaUser ma non scrivere:

mongo 127.0.0.1:27018/provaUser -u utentebase -p 
MongoDB shell version: 3.0.9
Enter password: 
connecting to: 127.0.0.1:27018/provaUser
> show collections
randomData
system.indexes
> db.randomData.find()
{ "_id" : ObjectId("56cb814e7c51ef2d6cf2fdd1"), "a" : 60 }
> db.randomData.insert({a:Math.floor(Math.random()*100)})
WriteResult({
 "writeError" : {
  "code" : 13,
  "errmsg" : "not authorized on provaUser to execute command { insert: \"randomData\", documents: [ { _id: ObjectId('56cb8c0928a311bd5a49faa5'), a: 18.0 } ], ordered: true }"
 }
})

Con l'utentewrite invece l'inserimento sarà possibile ma non si potranno ad esempio creare nuovi utenti; tale operazione sarà invece consentita al nostro utente con ruolo dbOwner.

mongo 127.0.0.1:27018/provaUser -u utentewrite -p 
MongoDB shell version: 3.0.9
Enter password: 
connecting to: 127.0.0.1:27018/provaUser
> db.randomData.insert({a:Math.floor(Math.random()*100)})
WriteResult({ "nInserted" : 1 })
> db.randomData.createIndex({a:1})
{
 "createdCollectionAutomatically" : false,
 "numIndexesBefore" : 1,
 "numIndexesAfter" : 2,
 "ok" : 1
}
> db.createUser({user:"test",pwd:"test",roles:[{role:"read",db:"provaUser"}]})
2016-02-22T23:36:39.962+0100 E QUERY    Error: couldn't add user: not authorized on provaUser to execute command { createUser: "test", pwd: "xxx", roles: [ { role: "read", db: "provaUser" } ], digestPassword: false, writeConcern: { w: "majority", wtimeout: 30000.0 } }
    at Error ()
    at DB.createUser (src/mongo/shell/db.js:1101:11)
    at (shell):1:4 at src/mongo/shell/db.js:1101
> ^C
bye
xxxxxx@xxxxxx-HP-Pavilion-Notebook:/data$ mongo 127.0.0.1:27018/provaUser -u utenteowner -p 
MongoDB shell version: 3.0.9
Enter password: 
connecting to: 127.0.0.1:27018/provaUser
> db.createUser({user:"test",pwd:"test",roles:[{role:"read",db:"provaUser"}]})
Successfully added user: {
 "user" : "test",
 "roles" : [
  {
   "role" : "read",
   "db" : "provaUser"
  }
 ]
}