From 459b03ae291c83ac79881046f2a2969fde7f9655 Mon Sep 17 00:00:00 2001
From: ManifoldFR <wilson.jallet@gmail.com>
Date: Thu, 30 Aug 2018 16:28:45 +0200
Subject: [PATCH] refactor remaining ldap config imports
---
src/config_passport.js | 8 +-
src/ldap/config.js | 12 ++-
src/ldap/ldap_data.js | 170 ++++++++++++++++++++---------------------
src/server.ts | 9 +--
4 files changed, 101 insertions(+), 98 deletions(-)
diff --git a/src/config_passport.js b/src/config_passport.js
index f07fa2f..07bc463 100644
--- a/src/config_passport.js
+++ b/src/config_passport.js
@@ -19,16 +19,16 @@ import passport from 'passport';
import LdapStrategy from 'passport-ldapauth';
import fs from 'fs';
import path from 'path';
-import { config } from './ldap/config';
+import { ldapConfig } from './ldap/config';
// specifies options for 'ldapauth' strategy, to customize the behaviour of subsequent passport.authenticate('ldapauth') calls
passport.use(new LdapStrategy({
server: {
- url: config.ldap.server,
+ url: ldapConfig.ldap.server,
//bindDn: '.............',
//bindCredentials: '..........',
- searchBase: config.ldap.searchBase,
- searchFilter: config.ldap.searchFilter,
+ searchBase: ldapConfig.ldap.searchBase,
+ searchFilter: ldapConfig.ldap.searchFilter,
//searchAttributes: ['givenName', 'sn'],
//tlsOptions: '..........',
},
diff --git a/src/ldap/config.js b/src/ldap/config.js
index 1c4793a..d482f1d 100644
--- a/src/ldap/config.js
+++ b/src/ldap/config.js
@@ -6,14 +6,18 @@ var fs = require('fs');
var path = require('path');
// Point central ; tous les champs de la BDD sont 'cachés' dans config.json et pas visibles directement
-var configPath = path.resolve('./', 'ldap_config.json');
-const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+const configPath = path.resolve('./', 'ldap_config.json');
+const ldapConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+const credentialsPath = path.resolve('./', 'ldap_connexion_config.json');
+const credentialsConfig = JSON.parse(fs.readFileSync(credentialsPath));
// Override config server from environment
if (process.env.LDAP_URI != null) {
- config.ldap.server = process.env.LDAP_URI;
+ ldapConfig.ldap.server = process.env.LDAP_URI;
}
module.exports = {
- config
+ "ldapConfig": ldapConfig,
+ "credentialsConfig": credentialsConfig
};
diff --git a/src/ldap/ldap_data.js b/src/ldap/ldap_data.js
index c7c298a..24407ef 100644
--- a/src/ldap/ldap_data.js
+++ b/src/ldap/ldap_data.js
@@ -22,10 +22,10 @@ var path = require('path');
// Important ; permet de vérifier que l'utilisateur reste connecté.
var ensureLoggedin = require('connect-ensure-login').ensureLoggedIn;
-const config = require('./config').config;
+const { ldapConfig, credentialsConfig } = require('./config');
// Connection au serveur LDAP avec des temps de timeout arbitraires
-var client = ldap.createClient({url: config.ldap.server});
-console.log(`Connecting to LDAP at ${config.ldap.server}.`);
+var client = ldap.createClient({url: ldapConfig.ldap.server});
+console.log(`Connecting to LDAP at ${ldapConfig.ldap.server}.`);
//------------------------------------------------------------------------------------------------------------------------
// Fonctions de base
@@ -138,7 +138,7 @@ function ajouterLDAP(user, dn, vals) {
return new Promise((resolve, reject) => {
connecterLDAP(user);
// Ajout LDAP selon la configuration en argument
- client.add(config.key_id+"="+vals[config.key_id]+","+dn, vals, function(err) {
+ client.add(ldapConfig.key_id+"="+vals[ldapConfig.key_id]+","+dn, vals, function(err) {
reject(err);
});
client.bind("", "", (err, res) => {});
@@ -192,13 +192,13 @@ function trouverGroupesModulable(input, return_attributes) {
let str=ldapEscape.filter("${txt}", { txt: input});
// Construction du filtre custom
- let filter= "(|("+config.key_id+"="+str+")"+ // On cherche la valeur exacte
- "(|("+config.key_id+"=*"+str+")"+ // La valeur finale avec des trucs avant ; wildcard *
- "(|("+config.key_id+"=*"+str+"*)"+ // La valeur du milieu avec des trucs avant et après
- "("+config.key_id+"="+str+"*))))"; // La valeur du début avec des trucs après
+ let filter= "(|("+ldapConfig.key_id+"="+str+")"+ // On cherche la valeur exacte
+ "(|("+ldapConfig.key_id+"=*"+str+")"+ // La valeur finale avec des trucs avant ; wildcard *
+ "(|("+ldapConfig.key_id+"=*"+str+"*)"+ // La valeur du milieu avec des trucs avant et après
+ "("+ldapConfig.key_id+"="+str+"*))))"; // La valeur du début avec des trucs après
// Appel rechercheLDAP avec filtre de l'espace
- rechercherLDAP(config.dn_groups, return_attributes, filter).then(res => resolve(res));
+ rechercherLDAP(ldapConfig.dn_groups, return_attributes, filter).then(res => resolve(res));
});
}
@@ -237,7 +237,7 @@ function repliquerTOLModulable(data, return_attributes) {
// Escape de l'input utilisateur
let str=ldapEscape.filter("${input}", { input: val});
// Traduction en language LDAP
- let attribute = config.user[key];
+ let attribute = ldapConfig.user[key];
// Creation du filtre étape par étape
filter="(&"+filter+ "(|("+attribute+"="+str+")"+ // On cherche la valeur exacte
"(|("+attribute+"=*"+str+")"+ // La valeur finale avec des trucs avant ; wildcard * (MEF la wildcart ne marche pas pour tous les attributs)
@@ -247,7 +247,7 @@ function repliquerTOLModulable(data, return_attributes) {
}
}
// Appel rechercheLDAP avec filtre de l'espace
- rechercherLDAP(config.dn_users, return_attributes, filter).then(res => resolve(res));
+ rechercherLDAP(ldapConfig.dn_users, return_attributes, filter).then(res => resolve(res));
});
}
@@ -260,7 +260,7 @@ function repliquerTOLModulable(data, return_attributes) {
* @return {Promise(Object[])} Liste de dictionnaires de profils en cohérence avec l'input avec pour clés tous les attributs disponibles ou presque (voir config).
*/
function repliquerTOL(data) {
- return repliquerTOLModulable(data, config.user.profil);
+ return repliquerTOLModulable(data, ldapConfig.user.profil);
}
/**
@@ -279,7 +279,7 @@ function repliquerTOL(data) {
function assurerUnicite(valeur, attribut, dn, evoluerValeur, n=0) {
return new Promise((resolve, reject) => {
// Recherche d'autres occurences de l'id
- rechercherLDAP(dn, config.key_id, "("+attribut+"="+valeur+")").then(matches => {
+ rechercherLDAP(dn, ldapConfig.key_id, "("+attribut+"="+valeur+")").then(matches => {
// On renvoit la valeur si elle est bien unique
if (matches.length==0) { resolve(valeur); }
// Sinon, on tente de nouveau notre chance avec la valeur suivante
@@ -299,7 +299,7 @@ function assurerUnicite(valeur, attribut, dn, evoluerValeur, n=0) {
function genererUid(givenName, lastName, promotion) {
// Le filtrage évite l'injection de code dans le LDAP, le normalize et lowerCase standardisent le format
return new Promise((resolve, reject) => {
- assurerUnicite(ldapEscape.filter("${uid}",{uid: givenName+'.'+lastName}).toLowerCase().normalize('UFD'), config.key_id, config.dn_users, (id,n) => {
+ assurerUnicite(ldapEscape.filter("${uid}",{uid: givenName+'.'+lastName}).toLowerCase().normalize('UFD'), ldapConfig.key_id, ldapConfig.dn_users, (id,n) => {
if (n==1) { id+='.'+ldapEscape.filter("${pr}",{pr: promotion}); } // Si prénom.nom existe déjà , on rajoute la promo
else if (n==2) { id+='.'+n-1; } // Puis si prénom.nom.promo existe déjà on passe à nom.prenom.promo .1
else if (n>2) { id+=+n; } // Ensuite on continue .23, .234, etc...
@@ -317,7 +317,7 @@ function genererUid(givenName, lastName, promotion) {
function genererGid(name) {
// Le filtrage évite l'injection de code dans le LDAP, le normalize et lowerCase standardisent le format
return new Promise((resolve, reject) => {
- assurerUnicite(ldapEscape.filter("${id}",{id: name}).toLowerCase().normalize('UFD'), config.key_id, config.dn_groups, (id,n) => {
+ assurerUnicite(ldapEscape.filter("${id}",{id: name}).toLowerCase().normalize('UFD'), ldapConfig.key_id, ldapConfig.dn_groups, (id,n) => {
if (n==1) { id+='.'+n; } // Si nom existe déjà , on essaie nom.1
else if (n>1) { id+=+n; } // Ensuite on continue .12, .123, etc...
return id;
@@ -395,9 +395,9 @@ class UtilisateurAnonyme {
* @return {Promise(string[])} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
*/
listGroups(uid) {
- let filtered_request = ldapEscape.filter(config.key_id + "=${id}," + config.dn_users, { id: uid });
+ let filtered_request = ldapEscape.filter(ldapConfig.key_id + "=${id}," + ldapConfig.dn_users, { id: uid });
// console.log(filtered_request);
- return rechercherLDAP(filtered_request, config.user.groups)
+ return rechercherLDAP(filtered_request, ldapConfig.user.groups)
.then(res => res[0]);
}
@@ -408,9 +408,9 @@ class UtilisateurAnonyme {
* @return {Promise(String[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
*/
listMembers(uid) {
- let filtered_request = ldapEscape.filter(config.key_id + "=${id}," + config.dn_groups, { id: uid });
+ let filtered_request = ldapEscape.filter(ldapConfig.key_id + "=${id}," + ldapConfig.dn_groups, { id: uid });
// console.log(filtered_request);
- return rechercherLDAP(filtered_request, config.group.member)
+ return rechercherLDAP(filtered_request, ldapConfig.group.member)
.then(res => res);
}
@@ -423,7 +423,7 @@ class UtilisateurAnonyme {
listAdmins(gid) {
return new Promise((resolve, reject) => {
rechercherLDAP(ldapEscape.filter(
- config.key_id+"=${id},"+config.dn_users, {id : gid}), config.group.admin).then(res => resolve(res[0])
+ ldapConfig.key_id+"=${id},"+ldapConfig.dn_users, {id : gid}), ldapConfig.group.admin).then(res => resolve(res[0])
);
});
}
@@ -436,7 +436,7 @@ class UtilisateurAnonyme {
* voir `ldap_config.json`(..\..\ldap_config.json) pour les clés exactes.
*/
getUser(uid) {
- return rechercherLDAP(ldapEscape.filter(config.key_id+"=${id},"+config.dn_users, {id : uid}), config.user.profil);
+ return rechercherLDAP(ldapEscape.filter(ldapConfig.key_id+"=${id},"+ldapConfig.dn_users, {id : uid}), ldapConfig.user.profil);
}
/**
@@ -447,9 +447,9 @@ class UtilisateurAnonyme {
* voir `ldap_config.json`(../../ldap_config.json) pour les clés exactes.
*/
getGroup(gid) {
- let filtered_request = ldapEscape.filter(config.key_id + "=${id}," + config.dn_groups, { id: gid });
+ let filtered_request = ldapEscape.filter(ldapConfig.key_id + "=${id}," + ldapConfig.dn_groups, { id: gid });
// console.log(filtered_request);
- return rechercherLDAP(filtered_request, config.group.profil);
+ return rechercherLDAP(filtered_request, ldapConfig.group.profil);
}
//------------------------------------------------------------------------------------------------------------------------
@@ -466,11 +466,11 @@ class UtilisateurAnonyme {
trouverGroupesParTypes(input, type) {
return new Promise((resolve, reject) => {
// Simple appel à la fonction précédente
- trouverGroupesModulable(input, [config.key_id, config.group.type]).then(gList => {
+ trouverGroupesModulable(input, [ldapConfig.key_id, ldapConfig.group.type]).then(gList => {
let gidtyList = [];
gList.forEach(g => {
// Si le groupe est du bon type on rajoute son gid
- if (g[config.group.type]==type) { gidtyList.push(g[config.key_id]); }
+ if (g[ldapConfig.group.type]==type) { gidtyList.push(g[ldapConfig.key_id]); }
});
resolve(gidtyList);
});
@@ -486,7 +486,7 @@ class UtilisateurAnonyme {
*/
repliquerTOLdesIds(data) {
return new Promise((resolve, reject) => {
- repliquerTOLModulable(data, config.key_id).then(res => {
+ repliquerTOLModulable(data, ldapConfig.key_id).then(res => {
resolve(res);
});
});
@@ -529,56 +529,56 @@ class UtilisateurConnecte extends UtilisateurAnonyme {
let vals = {};
// uid de base généré à partir du nom standardisé
- genererGid(user, data['name']).then(id => { vals[config.group['name']]=id; });
+ genererGid(user, data['name']).then(id => { vals[ldapConfig.group['name']]=id; });
// Ecriture de toutes les valeurs directement inscrites dans le LDAP (in pour input)
- config.group.direct_input.forEach(key_att => vals[config.group[key_att]]=data[key_att]);
+ ldapConfig.group.direct_input.forEach(key_att => vals[ldapConfig.group[key_att]]=data[key_att]);
// Appel à la fonction de base
- ajouterLDAP(user, config.key_id+"="+vals[config.group['name']]+","+config.dn_groups, vals).then( res => {
+ ajouterLDAP(user, ldapConfig.key_id+"="+vals[ldapConfig.group['name']]+","+ldapConfig.dn_groups, vals).then( res => {
// Certains champs nécessitent de petits calculs
let vals2={};
// Sauvegarde du nom (pour le cas où gid != data['name'])
- vals2[config.group["name"]]=data['name'];
+ vals2[ldapConfig.group["name"]]=data['name'];
// ?!
- vals2[config.user['password']] = '';
+ vals2[ldapConfig.user['password']] = '';
// Génération id aléatoire et test contre le LDAP
- genererIdNum(user, config.groups["idNumber"], config.dn_groups).then(id => { vals2[config.group['idNumber']]=id; });
+ genererIdNum(user, ldapConfig.groups["idNumber"], ldapConfig.dn_groups).then(id => { vals2[ldapConfig.group['idNumber']]=id; });
// FOIREUX : Hypothèse sur la structure du reste des données mais évite un assurerUnicite à deux variables
- vals2[config.group['idNumber2']]=vals2[config.group['idNumber']];
+ vals2[ldapConfig.group['idNumber2']]=vals2[ldapConfig.group['idNumber']];
// Stockage machine ; dépend du prénom
- vals2[config.group['directory']] = '/hosting/groups/'+vals[config.key_id];
+ vals2[ldapConfig.group['directory']] = '/hosting/groups/'+vals[ldapConfig.key_id];
// Code root
- vals2[config.group['cleanFullName']]=data['name'].replace(':', ';').toLowerCase().normalize('UFD');
+ vals2[ldapConfig.group['cleanFullName']]=data['name'].replace(':', ';').toLowerCase().normalize('UFD');
// Adressage root
- vals2[config.group['login']] = "/sbin/nologin";
+ vals2[ldapConfig.group['login']] = "/sbin/nologin";
// Permissions BR
- vals2[config.group['readPerm']] = '!*';
- vals2[config.group['writePerm']] = '!*';
+ vals2[ldapConfig.group['readPerm']] = '!*';
+ vals2[ldapConfig.group['writePerm']] = '!*';
// Inscription des valeurs calculées
- modifierLDAP(user, config.key_id+"="+vals[config.key_id]+","+config.dn_groups, "add", vals2).then(res => {
+ modifierLDAP(user, ldapConfig.key_id+"="+vals[ldapConfig.key_id]+","+ldapConfig.dn_groups, "add", vals2).then(res => {
if (!res) { reject(false); }
});
["posixAccount", "posixGroup", "brAccount"].forEach(cst => {
let vals3={};
- vals3[config.group['class']]=cst;
- modifierLDAP(user, config.key_id+"="+vals[config.key_id]+","+config.dn_groups, "add", vals3).then(res => {
+ vals3[ldapConfig.group['class']]=cst;
+ modifierLDAP(user, ldapConfig.key_id+"="+vals[ldapConfig.key_id]+","+ldapConfig.dn_groups, "add", vals3).then(res => {
if (!res) { reject(false); }
});
});
// Utilisation des fonctions adaptées pour assurer la cohérence de l'ensemble
- data['members'].forEach(uid => { this.ajouterMembreGroupe(user, uid, vals[config.key_att]); });
- data['admins'].forEach(uid => { this.ajouterAdministrateurGroupe(user, uid, vals[config.key_att]); });
+ data['members'].forEach(uid => { this.ajouterMembreGroupe(user, uid, vals[ldapConfig.key_att]); });
+ data['admins'].forEach(uid => { this.ajouterAdministrateurGroupe(user, uid, vals[ldapConfig.key_att]); });
resolve(true);
});
@@ -607,8 +607,8 @@ class UtilisateurConnecte extends UtilisateurAnonyme {
this.getUser(user, uid).then(profil => {
// Reecriture de profil avec les bons champs
Object.keys(profil).forEach(keyLDAP => {
- Object.keys(config.user).forEach(keyAlias => {
- config.user[keyAlias]=keyLDAP;
+ Object.keys(ldapConfig.user).forEach(keyAlias => {
+ ldapConfig.user[keyAlias]=keyLDAP;
profil[keyAlias]=profil[keyLDAP];
});
});
@@ -669,8 +669,8 @@ class AdministrateurConnecte extends UtilisateurConnecte {
this.listMembers(user,gid).then(lm => {
if (!lm.includes(uid)) {
let vals = {};
- vals[config.groups.member] = uid;
- modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_groups, { id: gid }), "add", vals).then(res => {
+ vals[ldapConfig.groups.member] = uid;
+ modifierLDAP(user, ldapEscape(ldapConfig.key_id+"=${id},"+ldapConfig.dn_groups, { id: gid }), "add", vals).then(res => {
// Erreur si pb lors de la modification
if (!res) { reject(false); }
});
@@ -679,8 +679,8 @@ class AdministrateurConnecte extends UtilisateurConnecte {
}).then(res => this.listGroups(user,uid)).then( lg => {
if (!lg.includes(gid)) {
let vals2 = {};
- vals2[config.users.groups] = gid;
- modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_users, { id: uid }), "add", vals2).then(res => {
+ vals2[ldapConfig.users.groups] = gid;
+ modifierLDAP(user, ldapEscape(ldapConfig.key_id+"=${id},"+ldapConfig.dn_users, { id: uid }), "add", vals2).then(res => {
// Erreur si pb lors de la modification
if (!res) { reject(false); }
});
@@ -704,7 +704,7 @@ class AdministrateurConnecte extends UtilisateurConnecte {
this.listMembers(user,gid).then(lm => {
if (lm.includes(uid)) {
// Supprime tous les utilisateurs
- modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_groups, { id: gid }), "del", config.group.member).then(res => {
+ modifierLDAP(user, ldapEscape(ldapConfig.key_id+"=${id},"+ldapConfig.dn_groups, { id: gid }), "del", ldapConfig.group.member).then(res => {
// Les rajoute un par un, sauf pour le supprimé
lm.forEach(id => {
if (id!=uid) { this.ajouterMembreGroupe(user,id, gid); }
@@ -715,7 +715,7 @@ class AdministrateurConnecte extends UtilisateurConnecte {
// Vérifie que l'utilisateur est pas déjà viré pour users
if (lg.includes(gid)) {
// Supprime tous les groupes
- modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_users, { id: uid }), "del", config.group.admin).then(res => {
+ modifierLDAP(user, ldapEscape(ldapConfig.key_id+"=${id},"+ldapConfig.dn_users, { id: uid }), "del", ldapConfig.group.admin).then(res => {
// Les rajoute un par un, sauf pour le supprimé
lg.forEach(id => {
if (id!=gid) { this.ajouterMembreGroupe(user,uid, id); }
@@ -744,8 +744,8 @@ class AdministrateurConnecte extends UtilisateurConnecte {
if (!la.includes(uid)) {
// Finalement modification, uniquement dans groups
let vals = {};
- vals[config.groups.admin] = uid;
- modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_groups, { id: gid }), "add", vals).then(res => {
+ vals[ldapConfig.groups.admin] = uid;
+ modifierLDAP(user, ldapEscape(ldapConfig.key_id+"=${id},"+ldapConfig.dn_groups, { id: gid }), "add", vals).then(res => {
// Gestion d'erreur
if (!res) { reject(false); }
});
@@ -772,7 +772,7 @@ class AdministrateurConnecte extends UtilisateurConnecte {
this.listAdmins(user,gid).then(la => {
if (la.includes(uid)) {
// Supprime tous les administrateurs
- modifierLDAP(user, ldapEscape(config.key_id+"=${id},"+config.dn_groups, { id: gid }), "del", config.group.admin).then(res => {
+ modifierLDAP(user, ldapEscape(ldapConfig.key_id+"=${id},"+ldapConfig.dn_groups, { id: gid }), "del", ldapConfig.group.admin).then(res => {
// Les rajoute un par un, sauf pour le supprimé
la.forEach(id => {
if (id!=uid) { this.ajouterAdministrateurGroupe(user, id, gid); }
@@ -801,8 +801,8 @@ class AdministrateurConnecte extends UtilisateurConnecte {
this.getGroup(user, gid).then(profil => {
// Reecriture de profil avec les bons champs
Object.keys(profil).forEach(keyLDAP => {
- Object.keys(config.group).forEach(keyAlias => {
- config.group[keyAlias]=keyLDAP;
+ Object.keys(ldapConfig.group).forEach(keyAlias => {
+ ldapConfig.group[keyAlias]=keyLDAP;
profil[keyAlias]=profil[keyLDAP];
});
});
@@ -835,11 +835,11 @@ class AdministrateurConnecte extends UtilisateurConnecte {
// Gestion des membres et administrateurs d'abord
this.getGroup(user, gid).then(profil => {
// Ordre important
- profil[config.group['admin']].forEach(id => { this.removeGroupAdmin(user, id, gid); });
- profil[config.group['member']].forEach(id => { this.removeGroupMember(user, id, gid); });
+ profil[ldapConfig.group['admin']].forEach(id => { this.removeGroupAdmin(user, id, gid); });
+ profil[ldapConfig.group['member']].forEach(id => { this.removeGroupMember(user, id, gid); });
// Elimination
}).then(res => {
- supprimerLDAP(user, config.key_id+"="+gid+","+config.dn_groups);
+ supprimerLDAP(user, ldapConfig.key_id+"="+gid+","+ldapConfig.dn_groups);
}).then(res => { if (res) {resolve(true); }});
});
}
@@ -886,21 +886,21 @@ class SuperAdministrateurConnecte extends AdministrateurConnecte {
// uid de base généré à partir de nom et prénom, plus potentiellement promo et un offset
// MEF mélange de Promise et de fonction standard
- genererUid(user, data['givenName'],data['lastName'],data['promotion']).then(id => { vals[config.key_id]=id; } );
+ genererUid(user, data['givenName'],data['lastName'],data['promotion']).then(id => { vals[ldapConfig.key_id]=id; } );
// Ecriture de toutes les valeurs directement inscrites dans le LDAP (in pour input)
// Génère une erreur si un champ n'est pas rempli
- config.user.direct_input.forEach(key_att => vals[config.user[key_att]]=data[key_att]);
+ ldapConfig.user.direct_input.forEach(key_att => vals[ldapConfig.user[key_att]]=data[key_att]);
// Appel à la fonction de base
- ajouterLDAP(user, config.key_id+"="+vals[config.key_id]+","+config.dn_users, vals).then( res => {
+ ajouterLDAP(user, ldapConfig.key_id+"="+vals[ldapConfig.key_id]+","+ldapConfig.dn_users, vals).then( res => {
// Modifications multiples pour avoir plusieurs champs de même type ; boucle sur les attributs multiples (d'où mul)
- config.user.muliple_input.forEach(key_att => {
+ ldapConfig.user.muliple_input.forEach(key_att => {
// On rajoute chaque valeur en entrée
data[key_att].forEach(val => {
let vals2 = {};
- vals2[config.user[key_att]]=val;
- modifierLDAP(user, config.key_id+"="+vals[config.key_id]+","+config.dn_users, "add", vals2).then(res => {
+ vals2[ldapConfig.user[key_att]]=val;
+ modifierLDAP(user, ldapConfig.key_id+"="+vals[ldapConfig.key_id]+","+ldapConfig.dn_users, "add", vals2).then(res => {
if (!res) { reject(false); }
});
});
@@ -910,51 +910,51 @@ class SuperAdministrateurConnecte extends AdministrateurConnecte {
let vals3={};
// Création d'un nom complet lisible
- vals3[config.user['fullName']]=data['givenName']+' '+data['lastName'].toUpperCase();
+ vals3[ldapConfig.user['fullName']]=data['givenName']+' '+data['lastName'].toUpperCase();
// ?!
- vals3[config.user['password']] = '{CRYPT}' + data['password'];
+ vals3[ldapConfig.user['password']] = '{CRYPT}' + data['password'];
// Ecriture d'un surnom s'il y a lieu
if ((data['nickname']!=undefined)&(data['nickname']!='')) {
- vals3[config.user['nickname']]=data['nickname'];
+ vals3[ldapConfig.user['nickname']]=data['nickname'];
}
// Génération id aléatoire unique
- genererIdNum(user, config.user['id'], config.dn_users).then(id => { vals3[config.user['id']]=id; });
+ genererIdNum(user, ldapConfig.user['id'], ldapConfig.dn_users).then(id => { vals3[ldapConfig.user['id']]=id; });
// Stockage machine ; dépend du prénom
- vals3[config.user['directory']] = '/hosting/users/' + data['givenName'][0];
+ vals3[ldapConfig.user['directory']] = '/hosting/users/' + data['givenName'][0];
// Code root
- vals3[config.user['cleanFullName']]=data['fullName'].replace(':', ';').toLowerCase().normalize('UFD');
+ vals3[ldapConfig.user['cleanFullName']]=data['fullName'].replace(':', ';').toLowerCase().normalize('UFD');
// Adressage root
- if (data['groups'].includes("on_platal")) { vals3[config.user['login']] = "/bin/bash"; }
- else { vals3[config.user['login']] = "/sbin/nologin"; }
+ if (data['groups'].includes("on_platal")) { vals3[ldapConfig.user['login']] = "/bin/bash"; }
+ else { vals3[ldapConfig.user['login']] = "/sbin/nologin"; }
// Permissions BR
- vals3[config.user['readPerm']] = 'br.*,public.*';
- if (data['readPerm'].length>0) { vals3[config.user['readPerm']] += ',' + data['readPerm']; }
- vals3[config.user['writePerm']] = 'br.*,!br.blague-du-jour,public.*,!br.campagnekes';
- if (data['writePerm'].length>0) { vals3[config.user['readPerm']] += ',' + data['writePerm']; }
+ vals3[ldapConfig.user['readPerm']] = 'br.*,public.*';
+ if (data['readPerm'].length>0) { vals3[ldapConfig.user['readPerm']] += ',' + data['readPerm']; }
+ vals3[ldapConfig.user['writePerm']] = 'br.*,!br.blague-du-jour,public.*,!br.campagnekes';
+ if (data['writePerm'].length>0) { vals3[ldapConfig.user['readPerm']] += ',' + data['writePerm']; }
// Valeur nécessaire mais inutile
- vals3[config.user['idNum']] ='5000';
+ vals3[ldapConfig.user['idNum']] ='5000';
// Inscription des valeurs calculées
- modifierLDAP(user, config.key_id+"="+vals[config.user['hruid']]+","+config.dn_users, "add", vals3).then(res => {
+ modifierLDAP(user, ldapConfig.key_id+"="+vals[ldapConfig.user['hruid']]+","+ldapConfig.dn_users, "add", vals3).then(res => {
if (!res) { reject(false); }
});
["posixAccount", "shadowAccount", "inetOrgPerson", "brAccount"].forEach(cst => {
let val3={};
- vals3[config.user['class']]=cst;
- modifierLDAP(user, config.key_id+"="+vals[config.user['hruid']]+","+config.dn_users, "add", vals3).then(res => {
+ vals3[ldapConfig.user['class']]=cst;
+ modifierLDAP(user, ldapConfig.key_id+"="+vals[ldapConfig.user['hruid']]+","+ldapConfig.dn_users, "add", vals3).then(res => {
if (!res) { reject(false); }
});
});
// Utilisation des fonctions adaptées pour assurer la cohérence de l'ensemble
- data['groupsIsMember'].forEach(gid => { this.ajouterMembreGroupe(user, vals[config.key_id], gid); });
- data['groupsIsAdmin'].forEach(gid => { this.ajouterAdministrateurGroupe(user, vals[config.key_id], gid); });
+ data['groupsIsMember'].forEach(gid => { this.ajouterMembreGroupe(user, vals[ldapConfig.key_id], gid); });
+ data['groupsIsAdmin'].forEach(gid => { this.ajouterAdministrateurGroupe(user, vals[ldapConfig.key_id], gid); });
resolve(true);
});
@@ -978,13 +978,13 @@ class SuperAdministrateurConnecte extends AdministrateurConnecte {
return new Promise((resolve, reject) => {
// Gestion des groupes d'abord
this.getUser(user, uid).then(profil => {
- profil[config.user['groups']].forEach(gid => {
+ profil[ldapConfig.user['groups']].forEach(gid => {
this.isGroupAdmin(user, uid, gid).then(res => {
if (this.la.includes(res)) { this.supprimerAdministrateurGroupe(user, uid, gid); }
}).then(res => { this.removeGroupMember(user, uid, gid); });
});
// Elimination
- }).then(res => { supprimerLDAP(user, config.key_id+"="+uid+","+config.dn_users); });
+ }).then(res => { supprimerLDAP(user, ldapConfig.key_id+"="+uid+","+ldapConfig.dn_users); });
});
}
}
diff --git a/src/server.ts b/src/server.ts
index 842bec3..42dc86a 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -32,6 +32,9 @@ import morgan from 'morgan';
import path from 'path';
import fs from 'fs';
+import { ldapConfig, credentialsConfig } from './ldap/config';
+
+const { dn, passwd } = credentialsConfig;
const app = express(); // "The app object conventionally denotes the Express application" (https://expressjs.com/en/4x/api.html#app)
@@ -74,15 +77,13 @@ app.use('/assets', express.static(path.resolve('./', 'assets')));
* Remarque: introduit aussi les middlewares session et passport, qui sont aussi utiles pour l'authentification dans les autres cas.
*/
-const configPath = path.resolve('./', 'ldap_config.json');
-const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
// WTF??? why is sessionSecret in ldap_config.json? it has nothing to do with ldap. TODO
// defines parameters for *session store*. (adds field req.session and do some magic stuff)
// basically, searches for a session matching the received cookie and, if found, adds field req.blasomethingbla containing serialized object representing user (i.e. similar to what passport.serializeUser() could produce)
// TODO: it is important to configure this right!!! please check out https://www.npmjs.com/package/express-session and make sure you understand the way session is stored. (en vrai c'est vraiment important...)
app.use(session({
- secret: config.sessionSecret,
+ secret: ldapConfig.sessionSecret,
resave: true,
saveUninitialized: false,
//store: // TODO: change this. express-session doc warns that default value is ok to use for development only
@@ -203,8 +204,6 @@ app.post('/login',
/**
* @desc API GRAPHQL
*/
-
-import { dn, passwd } from "../ldap_connexion_config.json"; // default bind user
const environment = process.env.NODE_ENV || 'development';
app.use('/graphql',
--
GitLab