
guide
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
LDAP consente di effettuare operazioni sui dati ma, a differenza di un generico database, è ottimizzato per effettuare operazioni di ricerca ed accesso alle informazioni. Nell’articolo vediamo il suo utilizzo con Java.
LDAP (Lightweight Directory Access Protocol) è il protocollo standard per l’interrogazione e la modifica dei servizi di directory. Un server LDAP consente di effettuare operazioni di inserzione, cancellazione ed aggiornamento dei dati ma, a differenza di un generico database, è ottimizzato per effettuare operazioni di ricerca ed accesso alle informazioni.
Lo scopo di questo articolo, non è spiegare vantaggi e svantaggi di tale protocollo ma, analizzare gli strumenti messi a disposizione da Java per interagire con un server LDAP.
Le informazioni all’interno di un server LDAP sono organizzate in modo gerarchico in elementi chiamati entry che vengono identificati in modo univoco mediante il Distinguished Name (DN) così come un file viene identificato nel file system mediante il proprio path. Ciascuna entry viene associata ad una o più classi di oggetti (objectClass) che definiscono la struttura che questa deve assumere, attributi opzionali e obbligatori, e tipologia di informazioni contenute.
OpenLDAP è un’implementazione Open Source del protocollo LDAP. È possibile scaricare i sorgenti dal sito ufficiale oppure, sul sito di Lucas Bergmans, è disponibile un pacchetto di installazione per sistemi Windows (file exe).
Dopo aver installato l’applicazione, è necessario impostare alcuni parametri nel file di configurazione slapd.conf presente nella directory d’installazione.
Includere i seguenti schemi fondamentali per l’esecuzione dei nostri esempi:
include ./schema/cosine.schema include ./schema/inetorgperson.schema include ./schema/java.schema
Settare i seguenti parametri:
suffix “dc=sportfantasy,dc=org” rootdn “cn=Manager,dc=sportfantasy,dc=org” rootpw html directory ./data
A questo punto è possibile avviare il server con il comando “slapd -d 1
“.
La SUN ha sviluppato i package javax.naming
e javax.naming.directory
che contengono delle classi utilissime per interagire con il server LDAP.
La prima operazione è la connessione al sistema. Per effettuare tale operazione, bisogna ottenere un’istanza della classe DirContext che mette a disposizione i metodi per inserire, modificare e ricercare le informazioni dal server LDAP. Per istanziare un oggetto DirContex viene utilizzata la classe InitialDirContext il cui costruttore riceve in input l’elenco delle proprietà necessarie per effettuare la connessione.
INITIAL_CONTEXT_FACTORY – driver di connessione al server PROVIDER_URL – url del servizio SECURITY_PRINCIPAL – usrname dell’utente manager corrispondente al rootdn definito nel file di configurazione SECURITY_CREDENTIALS – password dell’utente manager corrispondente al rootpw definito nel file di configurazione Properties env = new Properties(); env.put(Context.INITIAL_CONTEXT_FACTORY,”com.sun.jndi.ldap.LdapCtxFactory”); env.put(Context.PROVIDER_URL,”ldap://localhost:389″); env.put(Context.SECURITY_PRINCIPAL,”cn=Manager,dc=mycompany,dc=com”); env.put(Context.SECURITY_CREDENTIALS,”secret”); DirContext ctx = new InitialDirContext(env);
Per creare delle nuove entry nel nostro server LDAP è necessario inizializzarlo associando alla root entry gli schemi domain, dcObject e top e, aggiungendo la directory “ou=utenti,dc=sportfantasy,dc=org
” nella quale aggiungeremo gli utenti.
Creare il seguente file di testo e salvarlo con estensione ldif.
dn: dc=sportfantasy,dc=org dc: sportfantasy objectClass: domain objectClass: dcObject objectClass: top
dn: ou=utenti,dc=sportfantasy,dc=org objectClass: top objectClass: organizationalUnit ou: utenti
È possibile importare il file utilizzando un comando messo a disposizione da openLDAP oppure, utilizzando uno dei numerosi client free disponibili. Ad esempio è possibile scaricare LDAPAdmin, un tool di gestione rilasciato su licenza GPL.
ldapadd -x -D “cn=Manager,dc=sportfantasy,dc=org” -W -f init.ldif
Un utente memorizzato in un server LDAP deve obbligatoriamente essere associato a tre schemi: top, person e inetOrgPerson. Naturalmente questi schemi definiscono gli attributi opzionali e obbligatori. Per semplicità inseriamo esclusivamente quelli obbligatori.
L’utente viene creato utilizzando in questo caso il metodo createSubcontext
della classe SubContext che riceve in ingresso il DN della nuova entry e la lista degli attributi con i rispettivi valori. Nel caso in cui il DN è già presente viene sollevata un’eccezione (NameAlreadyBoundException).
Properties env = new Properties(); env.put(Context.INITIAL_CONTEXT_FACTORY, “com.sun.jndi.ldap.LdapCtxFactory”); env.put(Context.PROVIDER_URL, “ldap://localhost:389”); env.put(Context.SECURITY_PRINCIPAL, “cn=Manager,dc=sportfantasy,dc=org”); env.put(Context.SECURITY_CREDENTIALS, “html”);
try { DirContext ctx = new InitialDirContext(env);
//Creazione attributi utente: Attribute objClasses = new BasicAttribute(“objectclass”); objClasses.add(“top”); objClasses.add(“person”); objClasses.add(“inetOrgPerson”); Attribute cn = new BasicAttribute(“cn”, “pippo”); Attribute sn = new BasicAttribute(“sn”, “pippo”); Attribute uid = new BasicAttribute(“uid”, “pippo”); Attribute userPassword = new BasicAttribute(“userPassword”, “pippo”);
Attributes attributi = new BasicAttributes(); attributi.put(objClasses); attributi.put(cn); attributi.put(sn); attributi.put(uid); attributi.put(userPassword);
//creazione dell’utente ctx.createSubcontext(“cn=pippo,ou=utenti,dc=sportfantasy,dc=org”, attributi);
System.out.println(“L’utente è stato creato <<cn=pippo,ou=utenti,dc=sportfantasy,dc=org>>”); } catch (NameAlreadyBoundException nabe){ System.err.println(“Il DN immesso è già esistente!”); nabe.printStackTrace(); } catch (Exception e){ e.printStackTrace(); }
Mediante il metodo getAttributes
, della classe DirContext, leggiamo gli attributi di una entry. Il metodo riceve in ingresso il DN della directory e l’elenco degli attributi da estrarre. Ciascun attributo può avere n valori quindi occorre un ciclo for
per stamparli.
Properties env = new Properties(); env.put(Context.INITIAL_CONTEXT_FACTORY, “com.sun.jndi.ldap.LdapCtxFactory”); env.put(Context.PROVIDER_URL, “ldap://localhost:389”); env.put(Context.SECURITY_PRINCIPAL, “cn=Manager,dc=sportfantasy,dc=org”); env.put(Context.SECURITY_CREDENTIALS, “html”);
try{ DirContext ctx = new InitialDirContext(env);
String[] attrs = new String[4]; attrs[0] = “cn”; attrs[1] = “sn”; attrs[2] = “uid”; attrs[3] = “userPassword”;
Attributes result = ctx.getAttributes(“cn=pippo,ou=utenti,dc=sportfantasy,dc=org”, attrs);
if (result == null){ System.out.print(“Attributi non presenti”); }else{ Attribute attr = result.get(“cn”); if (attr != null){ System.out.println(“cn:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); }
attr = result.get(“sn”); if (attr != null){ System.out.println(“sn:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); }
attr = result.get(“uid”); if (attr != null){ System.out.println(“uid:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); }
attr = result.get(“userPassword”); if (attr != null){ System.out.println(“userPassword:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); } } } catch(NamingException ne){ ne.printStackTrace(); }
È possibile ricercare le entry all’interno del server LDAP semplicemente specificando il punto di partenza per la ricerca ed, eventualmente, lo scope (soltanto nel livello corrente oppure in tutti i sottolivelli rispetto a quello corrente). Inoltre è possibile specificare un filtro di ricerca in modo analogo a come avviene per le query SQL, come se fosse una where condition. Un utente è contraddistinto dai seguenti valori del suo attributo objectClass: person e inetOrgPerson quindi, utilizziamo come filtro di ricerca (&(objectClass=inetOrgPerson)(objectClass=person))
.
La ricerca viene effettuata con il metodo search della classe DirContext che riceve in ingresso il punto di partenza per la ricerca, il filtro e gli attributi settabili mediante la classe SearchControls. Nel nostro caso abbiamo semplicemente settato lo scope ma, è possibile impostare anche altri attributi, come ad esempio il numero massimo di elementi (ctls.setCountLimit(100)
) e gli attributi da restituire (ctls.setReturningAttributes(new String[] {"cn", "uid"})
).
Properties env = new Properties(); env.put(Context.INITIAL_CONTEXT_FACTORY, “com.sun.jndi.ldap.LdapCtxFactory”); env.put(Context.PROVIDER_URL, “ldap://localhost:389”); env.put(Context.SECURITY_PRINCIPAL, “cn=Manager,dc=sportfantasy,dc=org”); env.put(Context.SECURITY_CREDENTIALS, “html”);
try{ DirContext ctx = new InitialDirContext(env);
SearchControls ctls = new SearchControls(); ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);
String filter = “(&(objectClass=inetOrgPerson)(objectClass=person))”;
NamingEnumeration<SearchResult> answer = ctx.search(“dc=sportfantasy,dc=org”, filter, ctls);
while (answer.hasMoreElements()){ SearchResult a = answer.nextElement(); System.out.println(a.getNameInNamespace());
Attributes result = a.getAttributes();
if (result == null){ System.out.print(“Attributi non presenti”); }else{ Attribute attr = result.get(“cn”); if (attr != null){ System.out.println(“cn:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); }
attr = result.get(“sn”); if (attr != null){ System.out.println(“sn:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); }
attr = result.get(“uid”); if (attr != null){ System.out.println(“uid:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); }
attr = result.get(“userPassword”); if (attr != null){ System.out.println(“userPassword:”); for (NamingEnumeration vals = attr.getAll(); vals.hasMoreElements(); System.out.println(“t” + vals.nextElement())); } } } } catch(NamingException ne){ ne.printStackTrace(); }
Naturalmente gli esempi proposti sono validi per qualsiasi server LDAP e non soltanto per OpenLDAP.
Se vuoi aggiornamenti su Usare LDAP con Java inserisci la tua email nel box qui sotto:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La tua iscrizione è andata a buon fine. Se vuoi ricevere informazioni personalizzate compila anche i seguenti campi opzionali:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
WirelessKeyView è uno strumento indispensabili per gli appassionati di reti wireless e sicurezza informatica: il programma riesce ad individuare le […]
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Come creare applicazioni per il Web con PHP e MySQL per il DBMS.
Tutte le principali tecnologie per diventare uno sviluppatore mobile per iOS.
I fondamentali per lo sviluppo di applicazioni multi piattaforma con Java.
Diventare degli esperti in tema di sicurezza delle applicazioni Java.
Usare Raspberry Pi e Arduino per avvicinarsi al mondo dei Maker e dell’IoT.
Le principali guide di HTML.it per diventare un esperto dei database NoSQL.
Ecco come i professionisti creano applicazioni per il Cloud con PHP.
Lo sviluppo professionale di applicazioni in PHP alla portata di tutti.
Come sviluppare applicazioni Web dinamiche con PHP e JavaScript.
Fare gli e-commerce developer con Magento, Prestashop e WooCommerce.
Realizzare applicazioni per il Web utilizzando i framework PHP.
Creare applicazioni PHP e gestire l’ambiente di sviluppo come un pro.
Percorso base per avvicinarsi al web design con un occhio al mobile.
Realizzare siti Web e Web application con WordPress a livello professionale.
Come creare database e collection, inserire, estrarre, aggiornare e rimuovere dati da una base di dati MongoDB con Python
Impariamo ad utilizzare Takamaka, una blockchain Java Full Stack, per scrivere codice Java installabile ed eseguibile su una blockchain
Breve analisi dei due principali linguaggi di interrogazione di database
Guida a Red Hat Quarkus, uno stack Java Kubernetes nativo pensato per applicazioni serverless e per la realizzazione di microservizi rapidi ed ottimizzati. Una piattaforma concepita per accedere in ambiente Cloud mettendo a disposizione un framework orientato ai microservizi, come ad esempio Spring Boot o Micronaut