Forked from an inaccessible project.
-
Olivér FACKLAM authoredOlivér FACKLAM authored
basics.ts 15.20 KiB
/**
* @file Ce fichier regroupe les fonctions fondamentales aux interactions avec le LDAP.
* C'est ici que tout le filtrage est opéré, au plus bas niveau.
* Toutes les fonctions écrites ici sont asynchrones et renvoient des Promises ce qui nécessite de les appeler avec la synthaxe
* un peu particulière `f(args).then(res => ...)` pour exploiter leur résultat.
* @author hawkspar
* @memberof LDAP
*/
// Import moche à cause mauvais typage ldapjs
var ldap : any = require('ldapjs');
// Toutes les entrées utilisateur sont escapées par sécurité
import ldapEscape from 'ldap-escape';
// Fichier de ldapConfig du ldap
import { ldapConfig } from './config';
// Connection au serveur LDAP avec des temps de timeout arbitraires
var client = ldap.createClient({ url: ldapConfig.server, tlsOptions: ldapConfig.tlsOptions });
// Interface pratique pour que Typescript comprenne ce qu'est un dictionnaire simple
interface dic { [Key: string]: string | string[]; }
//------------------------------------------------------------------------------------------------------------------------
// Fonctions de base agissant sur le LDAP
//------------------------------------------------------------------------------------------------------------------------
export class Basics {
/**
* @memberof LDAP
* @class Basics
* @classdesc Cette classe est la brique de base du fichier tout entier puisqu'elle contient les functions qui agissent directement sur le LDAP.
* @summary Constructeur vide.
*/
constructor() {}
/**
* @memberof LDAP
* @summary Fonction qui sert à se déconnecter du LDAP, puis s'identifier sur le LDAP avec pleins pouvoirs.
* @desc Assez important en terme de sécurité, de gestion de conflit, et de droit d'accès.
* Fait appel à une méthode ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode bind).
* @returns {Promise(boolean)} `true` si l'opération s'est bien déroulée, `false` sinon.
* @static
*/
static bind() : Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
// Se déconnecter dans le doute
client.unbind();
// Escape DN as everywhere in this file, but password is taken as is
client.bind(process.env.LDAP_DN, process.env.LDAP_PASSWD, err => {
// Gestion erreur
if (err instanceof ldap.LDAPError) {
console.log("Erreur lors de la connection au LDAP : "+err.message);
resolve(false);
}
resolve(true);
});
});
}
/**
* @memberof LDAP
* @callback entryHandler
* @arg entry {*} - Convoluted ldap.js search result object
*/
/**
* @memberof LDAP
* @summary Fonction qui interroge le LDAP selon un protocole spécifié en argument et modifie une liste pour y insérer les valeurs trouvées.
* @desc Cette fonction utilise ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Cette fonction fait une demande au LDAP
* qu'elle filtre selon un schéma prédéfini dans `filter` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). * @arg {'gr'|'us'} domain - Emplacement de la requête (groupe ou utilisateur)
* @arg {string[]} attributes - Attributs à renvoyer
* @arg {string} id [null] - Identifiant facultatif pour une recherche triviale en o(1)
* @arg {string} filter ["(objectClass=*)"] - Filtre logique de la recherche (format [`RFC2254`](https://tools.ietf.org/search/rfc2254)) déjà passé au ldapEscape
* @arg {entryHandler} handler - Wrapper pour gérer les requêtes simples ou multiples
* @return {void} Utilise handler pour gérer ses résultats au fur et à mesure
* @static
*/
static search(domain: 'group'|'user', attributes: string[], id: string, filter: string, handler : (entry: any) => void) : Promise<boolean> {
let dn = "";
if (id != null) {
if (domain == "group") dn += ldapConfig.group.gid;
else dn += ldapConfig.user.uid;
dn += '=' + ldapEscape.dn("${txt}", { txt: id }) + ',';
}
dn += ldapConfig.dn[domain];
console.log("Searching dn= " + dn + ", filter : " + filter);
// Interrogation LDAP selon filter
return new Promise<boolean>(function(resolve, reject) {
client.search(dn, { // Must be escaped in case of a malignious false id
"scope": "sub",
"filter": filter, // Must be escaped in case of a malignious search arg
"attributes": attributes
}, (err, res) => {
// Gestion erreur ; pb car pas simple true / autre en sortie
if (Basics.catch(err)) {
console.log("Erreur lors de la recherche sur le LDAP.");
resolve(false);
} else {
// Dès que la recherche renvoit une entrée, on stocke les attributs qui nous intéresse
res.on('searchEntry', entry => handler(entry));
// Si la recherche renvoie une erreur (client ou TCP seulement), on renvoit
res.on('error', err2 => {
console.log(err2);
resolve(false);
});
// Quand la recherche est finie on se déconnecte
res.on('end', res2 => {
// Si la co avec le LDAP est tombée on relance
if (res2.status != 0) Basics.bind();
resolve(true);
});
}
});
});
}
/**
* @memberof LDAP
* @summary Fonction qui interroge le LDAP selon un protocole spécifié en argument et renvoit une liste de valeurs trouvées.
* @desc Cette fonction utilise {@link LDAP.search} directement.
* @arg {'gr'|'us'} domain - Emplacement de la requête (groupe ou utilisateur)
* @arg {string} attribute - Attribut unique à renvoyer
* @arg {string} id [null] - Identifiant facultatif pour une recherche triviale en o(1)
* @arg {string} filter ["(objectClass=*)"] - Filtre logique de la recherche (format [`RFC2254`](https://tools.ietf.org/search/rfc2254)) déjà passé au ldapEscape
* @return {Promise(string[])} Résultats de la recherche ; soit une liste de valeurs d'attributs,
* soit une liste de dictionnaires si on veut plus d'un attribut (les clés du dictionnaire sont celles du LDAP)
* @static
* @async
*/
static async searchSingle(domain: 'group'|'user', attribute: string, id: string=null, filter: string="(objectClass=*)") : Promise<string[]> {
let vals=[];
await Basics.search(domain, [attribute], id, filter, entry => {
// Cas un seul attribut où le résultat est une liste directement
console.log("searchSingle found " + entry.object[(domain == 'group' ? ldapConfig['group']['gid'] : ldapConfig['user']['uid'])]);
vals.push(entry.object[attribute]);
});
return vals;
}
/**
* @memberof LDAP
* @summary Fonction qui interroge le LDAP selon un protocole spécifié en argument et renvoit les valeurs trouvées.
* @desc Cette fonction utilise ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Cette fonction fait une demande au LDAP
* qu'elle filtre selon un schéma prédéfini dans `filter` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
* @arg {'gr'|'us'} domain - Emplacement de la requête (groupe ou utilisateur)
* @arg {string[]} attributes - Liste des attributs qui figureront dans le résultat final ; peut aussi être un seul élément
* @arg {string} id [null] - Identifiant facultatif pour une recherche triviale en o(1)
* @arg {string} filter ["(objectClass=*)"] - Filtre logique de la recherche (format [`RFC2254`](https://tools.ietf.org/search/rfc2254)) déjà passé au ldapEscape
* @return {Promise(Array<dic>)} Résultats de la recherche ; soit une liste de valeurs d'attributs,
* soit une liste de dictionnaires si on veut plus d'un attribut (les clés du dictionnaire sont celles du LDAP)
* @static
* @async
*/
static async searchMultiple(domain: 'group'|'user', attributes: string[], id: string=null, filter: string="(objectClass=*)") : Promise<Array<dic>> {
let vals=[];
await Basics.search(domain, attributes, id, filter, entry => {
// Cas plusieurs attributs donc résultat dictionnaire
vals.push({});
console.log("searchMultiple found " + entry.object[domain == 'group' ? ldapConfig.group['gid'] : ldapConfig.user['uid']]);
// Suppose que tous les champs du LDAP sont définis pour les atttributs demandés
attributes.forEach(attribute => vals.slice(-1)[0][attribute]=entry.object[attribute]);
});
return vals;
}
/**
* @memberof LDAP
* @summary Fonction intermédiaire qui factorise la gestion d'erreur pour toute la classe.
* @desc Permet de définir un comportement par défaut pour les méthodes de base add, change et clear pour différents types d'erreur.
* @arg {ldap.LDAPError} err - Erreur renvoyée
* @returns {Promise(boolean)} `true` si l'opération s'est bien déroulée, `false` sinon.
* @static
*/
static catch(err) : boolean {
if (err instanceof ldap.LDAPError) {
console.log("L'erreur suivante est survenue : " +err.message);
// TBC
if (err instanceof ldap.TimeLimitExceededError) {
Basics.bind();
}
else if (err instanceof ldap.ProtocolError) {
Basics.bind();
}
else if (err instanceof ldap.SizeLimitExceededError) {
Basics.bind();
}
else if (err instanceof ldap.InsufficientAccessRightsError) {
Basics.bind();
}
return true;
}
return false;
}
/**
* @memberof LDAP
* @summary Fonction qui permet de modifier un élément sur le LDAP. Gestion intelligente de l'appartenance à un binet.
* @desc Cette fonction traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode modify).
* @arg {'gr'|'us'} domain - Emplacement de la requête (groupe ou utilisateur)
* @arg {string} id - Identifiant unique de la feuille à modifier ; passé par ldapEscape dans cette fonction
* @arg {"add"|"del"|"replace"} op - Operation à réaliser sur le LDAP. Trois opération sont possibles ; "add", qui rajoute des attributs et qui peut créer des doublons,
* "del" qui en supprime, et "replace" qui remplace du contenu par un autre.
* @arg {dic} mod - Dictionnaire contenant les attributs à modifier et les nouvelles valeurs des attributs.
* @arg {string} mod[key] - Nouvelle valeur de l'attribut key. Une nouvelle valeur vide ("") est équivalent à la suppression de cet attribut.
* @return {Promise(boolean)} `true` si la modification s'est bien déroulée, `false` sinon.
* @static
*/
static change(domain: 'group'|'user', id: string, op: "add"|"del"|"replace", mod: dic) : Promise<boolean> {
return new Promise<boolean>((resolve, reject) => { let dn = "";
if (domain == 'group') dn += ldapConfig.group.gid;
else dn += ldapConfig.user.uid;
dn += '='+ldapEscape.dn("${txt}", { txt: id })+','+ldapConfig.dn[domain];
// Modification LDAP selon dn fourni en argument (pourrait prendre une liste de Changes)
client.modify(ldapEscape.dn("${txt}", {txt: dn}), new ldap.Change({
operation: op,
modification: mod,
// Gestion erreur
}), err => {
if (Basics.catch(err)) {
console.log("Erreur lors d'une opération élémentaire de modification dans le LDAP (Basics.change)");
resolve(false);
}
resolve(true);
});
});
}
/**
* @memberof LDAP
* @summary Fonction qui permet de rajouter un élément sur le LDAP.
* @desc Cette fonction traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode add).
* On notera le rôle particulier de vals[uid/gid] qui sert à identifier la feuille à changer ; passé par ldapEscape dans cette fonction.
* @arg {'gr'|'us'} domain - Emplacement de la requête (groupe ou utilisateur)
* @arg {Object.<string, string>} vals - Dictionnaire contenant les valeurs à créer (contient un champ en ldapConfig)
* @arg {Object} vals[key] - Nouvelle valeur pour le champ key
* @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon.
* @static
*/
static add(domain: 'group'|'user', vals) : Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
let dn = "";
if (domain == "group") dn += ldapConfig.group.gid+"="+ldapEscape.dn("${txt}", { txt: vals[ldapConfig.group.gid] });
else dn += ldapConfig.user.uid+"="+ldapEscape.dn("${txt}", { txt: vals[ldapConfig.user.uid] });
dn += ldapConfig.dn[domain];
// Ajout LDAP selon la ldapConfiguration en argument
client.add(dn, vals, err => {
if (Basics.catch(err)) {
console.log("Erreur lors d'une opération élémentaire d'ajout dans le LDAP (Basics.add)");
resolve(false);
}
resolve(true);
});
});
}
/**
* @memberof LDAP
* @summary Fonction qui permet de supprimer une feuille du LDAP.
* @desc Cette fonction traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode del).
* Elle est différente de modify avec "del" car elle affecte directement une feuille et pas un attribut.
* @arg {'gr'|'us'} domain - Emplacement de la requête (groupe ou utilisateur)
* @arg {string} id - Identifiant unique de la cible, passé par ldapEscape dans cette fonction
* @return {Promise(boolean)} `true` si la modification s'est bien déroulée, false sinon
* @static
*/
static clear(domain: 'group'|'user', id: string) : Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
let dn = "";
if (domain == "group") dn += ldapConfig.group.gid+"="+ldapEscape.dn("${txt}", { txt: id });
else dn += ldapConfig.user.uid+"="+ldapEscape.dn("${txt}", { txt: id });
dn += ldapConfig.dn[domain];
// Suppression LDAP
client.del(dn, err => {
if (Basics.catch(err)) {
console.log("Erreur lors d'une opération élémentaire de suppression dans le LDAP (Basics.clear)");
resolve(false);
}
resolve(true); });
});
}
}
// Bind
Basics.bind();
console.info("Binding with LDAP client completed successfully, looking good !");