Inscription rapide (en masse) de nombreux comptes utilisateurs

[ASVT]

Bonsoir,

Je suis un utilisateur d'hfs depuis plusieurs années pour accéder à mes fichiers perso d'un peu partout.

Dans une salle de classe, c'est ce que je pensa mettre en place pour permettre à environ 500 comptes d'avoir accès en lecture et/ou en écriture à quelques répertoires partagés sur un réseau local non connecté au www, composé d'une vingtaine de poste en XP pro, durant un ou deux ans a priori.

Le problème que je me pose est l'inscription de ces comptes login/motdepasse.
Dans l'idéal, je souhaiterai moi-même les fournir aux utilisateurs, en basant les login sur leurs noms de famille / prénom (que j'ai dans un fichier excel) et en générant un mot de passe aléatoire (pas forcément très fort, histoire d'être facilement mémorisable).

Voici donc mes quelques questions:
1) Quelle version d'hfs me conseillez-vous? je viens de découvrir qu'il existe des version béta ... et en plus, certaines françisées (testée très rapidement, l'interface visiteur change pas mal mais quid de la gestion des comptes utilisateurs dans la version actuelle et la béta française ou officielle?
Il me semble avoir compris que la beta actuelle a un petit bug lorsqu'il y a des espaces vides dans le noms des fichiers ?? ce cas va certainement m'arriver, bug ou pas?

2) les comptes sont-ils bien stockés uniquement dans le fichier hfs.ini (le modifier suffit-il)? peut-on éditer la ligne accounts= autant que mes besoins? peut-on la modifier en créant plusieurs lignes ?

3) si je pars dans la bonne direction, avez-vous une astuce pour réaliser cette ligne rapidement ? (dans excel, "concatener" permet de fusionner des colonnes.. mais comment fusionner plusieurs lignes en une seule?

4) avez-vous un moyen de générer des mots de passe en grande quantité et rapidement, copiés/collables facilement? (3 et 4 sont un peu hors sujet.. mais sont nécessaires pour finaliser le projet)

5) peut-on attribuer aussi "facilement"(c'est-à-dire en éditant un fichier plutôt que de cliquer 50 fois) les répertoires accessibles pour chaque compte ? (là, je n'ai pas trouvé où été cette information) et à la limite, peut-on préciser les droits en lecture et/ou écriture en même temps?

Voila, si certains se sentent partant pour me conseiller, je suis preneur!!
Dans l'idéal, je souhaiterai déployer tout cela en 2h maxi vendredi matin   la solution "serveur de fichiers" (avec samba par exemple) m'a bien traversée l'esprit, mais ça me semble tout de même un peu plus complexe vu mes connaissances de base en linux.

Merci d'avance pour tous vos messages (même d'encouragements   )

Arnaud

[ASVT]

Arf, je me suis loggué après ... et j'ai mis un "s" en trop, à la fin d'inscription (dans mon titre) , ça commence bien  

[ASVT]

Oui, cela fait un peu plus sérieux 

Merci!

J'en profite pour préciser que j'utilise Notepad++ pour coder et décoder en Base64 les "comptes" utilisateurs/motdepasse, en utilisant le plugin "MINE Tools" .

Si il y a plus simple, je suis aussi preneur du conseil 

[Mars]

les comptes sont enregistrés exclusivement dans hfs.ini , avec toutes les informations activables dans le formulaire de gestion des comptes.

le format d'enregistrement est de la forme

accounts=|login:bmV3IHVzZXI6YQ==|enabled:yes|group:no|no-limits:no;

  la partie codifiée l'est en base 64 ....

  "login:bmV3IHVzZXI6YQ=="          soit     "login:"+encode64(account+":"+password)
apres quelques heures de réflexion, j'ai créé un fichier excel pour traiter ta demande en fichier joint zipé.

Il suffit de remplir les champs des colones en vert et de cliquer sur le bouton pour créer le fichier externe accounts.ini ( dans le même répertoire que le fichier excel ) qui contient la ligne complète à remplacer dans hfs.ini.

bien conserver une copie de hfs.ini avant toute manipulation
j'ai trouvé ca sur le web qui pourra t'aider pour un fichier excel mais le codage final de la ligne complete devra etre faite dans un fichier externe

Code: [Select]

Option Explicit
 
Private Const clOneMask = 16515072          '000000 111111 111111 111111
Private Const clTwoMask = 258048            '111111 000000 111111 111111
Private Const clThreeMask = 4032            '111111 111111 000000 111111
Private Const clFourMask = 63               '111111 111111 111111 000000
 
Private Const clHighMask = 16711680         '11111111 00000000 00000000
Private Const clMidMask = 65280             '00000000 11111111 00000000
Private Const clLowMask = 255               '00000000 00000000 11111111
 
Private Const cl2Exp18 = 262144             '2 to the 18th power
Private Const cl2Exp12 = 4096               '2 to the 12th
Private Const cl2Exp6 = 64                  '2 to the 6th
Private Const cl2Exp8 = 256                 '2 to the 8th
Private Const cl2Exp16 = 65536              '2 to the 16th
 
Public Function Encode64(sString As String) As String
 
    Dim bTrans(63) As Byte, lPowers8(255) As Long, lPowers16(255) As Long, bOut() As Byte, bIn() As Byte
    Dim lChar As Long, lTrip As Long, iPad As Integer, lLen As Long, lTemp As Long, lPos As Long, lOutSize As Long
 
    For lTemp = 0 To 63                                 'Fill the translation table.
        Select Case lTemp
            Case 0 To 25
                bTrans(lTemp) = 65 + lTemp              'A - Z
            Case 26 To 51
                bTrans(lTemp) = 71 + lTemp              'a - z
            Case 52 To 61
                bTrans(lTemp) = lTemp - 4               '1 - 0
            Case 62
                bTrans(lTemp) = 43                      'Chr(43) = "+"
            Case 63
                bTrans(lTemp) = 47                      'Chr(47) = "/"
        End Select
    Next lTemp
 
    For lTemp = 0 To 255                                'Fill the 2^8 and 2^16 lookup tables.
        lPowers8(lTemp) = lTemp * cl2Exp8
        lPowers16(lTemp) = lTemp * cl2Exp16
    Next lTemp
 
    iPad = Len(sString) Mod 3                           'See if the length is divisible by 3
    If iPad Then                                        'If not, figure out the end pad and resize the input.
        iPad = 3 - iPad
        sString = sString & String(iPad, Chr(0))
    End If
 
    bIn = StrConv(sString, vbFromUnicode)               'Load the input string.
    lLen = ((UBound(bIn) + 1) \ 3) * 4                  'Length of resulting string.
    lTemp = lLen \ 72                                   'Added space for vbCrLfs.
    lOutSize = ((lTemp * 2) + lLen) - 1                 'Calculate the size of the output buffer.
    ReDim bOut(lOutSize)                                'Make the output buffer.
 
    lLen = 0                                            'Reusing this one, so reset it.
 
    For lChar = LBound(bIn) To UBound(bIn) Step 3
        lTrip = lPowers16(bIn(lChar)) + lPowers8(bIn(lChar + 1)) + bIn(lChar + 2)    'Combine the 3 bytes
        lTemp = lTrip And clOneMask                     'Mask for the first 6 bits
        bOut(lPos) = bTrans(lTemp \ cl2Exp18)           'Shift it down to the low 6 bits and get the value
        lTemp = lTrip And clTwoMask                     'Mask for the second set.
        bOut(lPos + 1) = bTrans(lTemp \ cl2Exp12)       'Shift it down and translate.
        lTemp = lTrip And clThreeMask                   'Mask for the third set.
        bOut(lPos + 2) = bTrans(lTemp \ cl2Exp6)        'Shift it down and translate.
        bOut(lPos + 3) = bTrans(lTrip And clFourMask)   'Mask for the low set.
        If lLen = 68 Then                               'Ready for a newline
            bOut(lPos + 4) = 13                         'Chr(13) = vbCr
            bOut(lPos + 5) = 10                         'Chr(10) = vbLf
            lLen = 0                                    'Reset the counter
            lPos = lPos + 6
        Else
            lLen = lLen + 4
            lPos = lPos + 4
        End If
    Next lChar
 
    If bOut(lOutSize) = 10 Then lOutSize = lOutSize - 2 'Shift the padding chars down if it ends with CrLf.
 
    If iPad = 1 Then                                    'Add the padding chars if any.
        bOut(lOutSize) = 61                             'Chr(61) = "="
    ElseIf iPad = 2 Then
        bOut(lOutSize) = 61
        bOut(lOutSize - 1) = 61
    End If
 
    Encode64 = StrConv(bOut, vbUnicode)                 'Convert back to a string and return it.
 
End Function
 
Public Function Decode64(sString As String) As String
 
    Dim bOut() As Byte, bIn() As Byte, bTrans(255) As Byte, lPowers6(63) As Long, lPowers12(63) As Long
    Dim lPowers18(63) As Long, lQuad As Long, iPad As Integer, lChar As Long, lPos As Long, sOut As String
    Dim lTemp As Long
 
    sString = Replace(sString, vbCr, vbNullString)      'Get rid of the vbCrLfs.  These could be in...
    sString = Replace(sString, vbLf, vbNullString)      'either order.
 
    lTemp = Len(sString) Mod 4                          'Test for valid input.
    If lTemp Then
        Call Err.Raise(vbObjectError, "MyDecode", "Input string is not valid Base64.")
    End If
 
    If InStrRev(sString, "==") Then                     'InStrRev is faster when you know it's at the end.
        iPad = 2                                        'Note:  These translate to 0, so you can leave them...
    ElseIf InStrRev(sString, "=") Then                  'in the string and just resize the output.
        iPad = 1
    End If
 
    For lTemp = 0 To 255                                'Fill the translation table.
        Select Case lTemp
            Case 65 To 90
                bTrans(lTemp) = lTemp - 65              'A - Z
            Case 97 To 122
                bTrans(lTemp) = lTemp - 71              'a - z
            Case 48 To 57
                bTrans(lTemp) = lTemp + 4               '1 - 0
            Case 43
                bTrans(lTemp) = 62                      'Chr(43) = "+"
            Case 47
                bTrans(lTemp) = 63                      'Chr(47) = "/"
        End Select
    Next lTemp
 
    For lTemp = 0 To 63                                 'Fill the 2^6, 2^12, and 2^18 lookup tables.
        lPowers6(lTemp) = lTemp * cl2Exp6
        lPowers12(lTemp) = lTemp * cl2Exp12
        lPowers18(lTemp) = lTemp * cl2Exp18
    Next lTemp
 
    bIn = StrConv(sString, vbFromUnicode)               'Load the input byte array.
    ReDim bOut((((UBound(bIn) + 1) \ 4) * 3) - 1)       'Prepare the output buffer.
 
    For lChar = 0 To UBound(bIn) Step 4
        lQuad = lPowers18(bTrans(bIn(lChar))) + lPowers12(bTrans(bIn(lChar + 1))) + _
                lPowers6(bTrans(bIn(lChar + 2))) + bTrans(bIn(lChar + 3))           'Rebuild the bits.
        lTemp = lQuad And clHighMask                    'Mask for the first byte
        bOut(lPos) = lTemp \ cl2Exp16                   'Shift it down
        lTemp = lQuad And clMidMask                     'Mask for the second byte
        bOut(lPos + 1) = lTemp \ cl2Exp8                'Shift it down
        bOut(lPos + 2) = lQuad And clLowMask            'Mask for the third byte
        lPos = lPos + 3
    Next lChar
 
    sOut = StrConv(bOut, vbUnicode)                     'Convert back to a string.
    If iPad Then sOut = Left$(sOut, Len(sOut) - iPad)   'Chop off any extra bytes.
    Decode64 = sOut
 
End Function


[TCube]

salut ASVT !

Très intéressant ton poste ! nous sommes loin du P2P et dans un contexte d'utilisation enfin "semi-pro" et utile 

Une facilité devrait pouvoir accélérer la mise en place : notamment dans la gestion Groupe/Utilisateur (cf. point N°5).
Sauf erreur de ma part : l'inclusion d'utilisateurs dans un groupe permet de définir les accès (répertoires virtuels/réels) en une seule fois

T3

[ASVT]

@TCube: effectivement, hfs a toutes les qualités pour être utilisé à des fins honorables .

@Mars: WOUAH!!! je ne pensais pas que ma demande allait être traitée aussi ... parfaitement!!! Bon, c'est que je me rends compte que j'ai bien des lacunes en réalisation de macros (je n'ai jamais vraiment essayé, le temps me manque un peu, mais quand on voit le résultat, ça donne envie!!).

Un seul mot : MERCI !

Bon, je vois que mon utilisation "de base" d'hfs ne m'a pas tout dévoilé.
Aussi, je vais essayé de comprendre comment bien utilisé les groups, redir et link .

Je pense prendre la dernière version officielle stable, avec une traduction simple, le retrait des informations peu utiles du point de vue des utilisateurs. Je vous tiens au courant 

[ASVT]

Testé très rapidement, je regarde plus finement ce soir.

Apparemment, si j'utilise l'exemple fourni, en mettant créant 2 répertoires réels (exemple1 et welcome), hfs modifie la ligne accounts (dans le fichier hfs.ini):
1) il retire un "|" au début
2) il  retire "group:yes|" ou "group:no| pour tous les comptes

En fait, apparemment la ligne générée est
accounts=|login:Z3JvdXAxOg==|enabled:yes|group:yes|no-limits:no;|login:Z3JvdXAyOg==|enabled:yes|group:yes|no-limits:no;|login:dXNlciAxOmE=|enabled:yes|group:no|no-limits:no|redir:/exemple1|link:group1:group2;|login:dXNlciAyOmI=|enabled:yes|group:no|no-limits:no|link:group3;|login:dXNlciAzOmM=|enabled:yes|group:no|no-limits:no;|login:dXNlciA0OmQ=|enabled:yes|group:no|no-limits:no|redir:/welcome|link:group1:group2:group3;

hfs la modifie pour en faire :
accounts=login:Z3JvdXAxOg==|enabled:yes|no-limits:no;login:Z3JvdXAyOg==|enabled:yes|no-limits:no;login:dXNlciAxOmE=|enabled:yes|no-limits:no;login:dXNlciAyOmI=|enabled:yes|no-limits:no;login:dXNlciAzOmM=|enabled:yes|no-limits:no;login:dXNlciA0OmQ=|enabled:yes|no-limits:no;

Je regarderai ce soir de plus près... mais LA solution est très proche

[SilentPliz]

Bienvenue ASVT

Je n'ai pas testé moi même le script que Mars te propose; il est possible qu'une petite erreur s'y soit glissée. Mais je t'invite tout de même à refaire tes tests avec une version bêta récente de HFS. Je suis quasiment sûr que c'est à partir d'une bêta que Mars a fait ses tests.

En effet, tu remarqueras, sur ce forum, que la version officielle dite "stable" est très peu utilisée pour les utilisations "pointues".

Je ne vais pas te faire une liste exhaustive des améliorations qu'apportent les versions bêta, mais en revanche, je peux te dire ce que tu ne pourras pas faire avec la version stable.

La version stable ne gère pas (entre autre) les "macros"; donc tu ne pourras pas utiliser de templates récents, qui permettent des fonctions avancées comme la création / suppression de répertoires, la suppression de fichiers, la création de scripts personnalisée te sera aussi impossible ...etc

La version stable ne donne pas la possibilité de créer des groupes.
Avec la bêta française, par exemple, il est possible de gérer simplement l'ajout d'utilisateurs à un groupe en plus de la gestion habituelle des groupes permise par la bêta "officielle".
Je cite cette option car c'est une nouvelle "exclusivité" de la bêta française.

Le bug des "espaces dans les noms" est résolu avec la version française (et il le sera sur la version anglaise dès la prochaine "release"). Ce bug permettait virtuellement de mettre des espaces avant et après un nom de répertoire... rien de dramatique en somme, il est rare d'avoir envie de créer des répertoires ayant cette forme.

Enfin, les "bêta" récentes n'ont rien à envier à la version stable au niveau... stabilité
Il s'agit plus de développer de nouvelles fonctions additionnelles, que de corriger des bugs.
Il semblerait même que les échanges soient plus rapides et efficaces avec les versions bêta.

Voila. Je ne sais pas si cela fait avancer le "Shmilblik", mais cela te permettras peut-être de te situer dans "l'offre" existante et ainsi choisir plus clairement, au plus proche de tes besoins d'utilisateur.

A bientôt

[Mars]

il n'y a pas d'erreurs, je peux facilement en déduire que tu utilises la version officielle 2.2f, le fichier excel est aussi utilisable pour les version beta 2.3 build xxx naturellement.

toute information  dans hfs.ini est toujours épurée quand on utilise une version antérieure de hfs après l'utilisation d'une version plus récente (en terme de build)

 

de par mon expérience , à long terme, je te conseillerais de mettre en place un serveur linux et d'y implanter une surcouche samba, cela t' offrira une securité accrue et une gestion des comptes utilisateurs bien plus simple et plus puissante. ainsi tes machines pourront se connecter comme sur un serveur windows, sans avoir à redonner un couple identifiant et mot de passe  obligatoires si tu utilises HFS car ce dernier est beaucoup moins sécurisé qu'un serveur samba.

[ASVT]

Bon je vais donc tester ce soir avec une beta française. Ma question portait effectivement sur la stabilité.

Une mise en place d'un serveur linux avec samba est prévu à terme (un ou deux ans), lorsqu'il sera à généraliser à un parc d'une centaine de machines.

[Mars]

j'ai indirectement participé, et j'ai assisté à la mise en place d'un tel serveur et il peut même servir de seveur suffisament sécurisé pour être utilisé à partir du web, avec tout ce que la société linux peut fournir.

ce n'est pas de la contre pub pour hfs, mais dans un domaine d'utilisation comme le tien, samba est plus adéquate. Il est dommage que la personne qui s'occupait de cela ne soit plus de ce monde sinon , j'aurai pu te mettre en relation car vous étiez de la même région ( mait chut sur le sujet)

[ASVT]

Bon, tout fonctionne! c'est vraiment super!

Y'a plus qu'à ... reprendre ses esprits et quelques forces car je commence à m'embrouiller entre le concept de group et d'user . Là, par exemple, je n'arrive pas à obliger de s'identifier avant d'accéder à une ressource: soit la ressource est cachée malgré l'identification, soit l'accès à la ressource est interdite sans pour autant proposer un moyen de se logguer.

Bref, je tente de résoudre cela demain, après une bonne nuit de sommeil!!

Merci 1000 fois pour l'aide que vous m'avez apportée!