nginx group http auth

Question

procedente de apache2 la única característica que no puedo archivar: tener usuarios en una base de datos de contraseñas (htpasswd) y permitir el acceso a diferentes archivos/carpetas/servidores virtuales.

autenticación HTTP básico que permitió a las obras:

location ~ ^/a/ { 
    # should allow access for user1, user2 
    auth_basic   "Restricted"; 
    auth_basic_user_file /etc/nginx/auth/file_a; 
} 
location ~ ^/b/ { 
    # should allow access for user2, user3 
    auth_basic   "Restricted"; 
    auth_basic_user_file /etc/nginx/auth/file_b; 
} 

si tengo usuario1, usuario2 en file_a y usuario2, User3 en file_b, esto funciona, pero tengo que actualizar ambos archivos cuando cambio la contraseña para user2 (la contraseña debe ser la misma para todas las ubicaciones). Como tendré> 15 ubicaciones diferentes con diferentes derechos de acceso y> 10 usuarios, esto no es realmente fácil de manejar. (¡Me encantan los derechos de acceso detallados!)

Con Apache definí diferentes grupos para cada ubicación y requirió el grupo correcto. Cambiar el acceso fue tan fácil como agregar/eliminar usuarios a grupos.

¿Hay algo así o cómo se puede manejar este escenario fácilmente con nginx?

Answer 1

finalmente lo manejan como este con autenticación básica http:

• Para cada grupo tengo un archivo de contraseña por separado, por ejemplo, group_a.auth, group_b.auth, ...
• Además, tengo un archivo en el que se escribe cada usuario y contraseña, por ejemplo passwords.txt
• passwords.txt tiene el mismo formato como los archivos de autenticación, así que algo como user1:password_hash
• tengo un script ruby ​​update.rb para sincronizar contraseñas de los usuarios de password.txt a todos .auth archivos (así más de una envoltura de sed):

guión Rubí update.rb:

#!/usr/bin/env ruby 

passwords = File.new("./passwords.txt","r") 

while pwline = passwords.gets 
    pwline.strip! 
    next if pwline.empty? 

    user, _ = pwline.split(':') 
    %x(sed -i 's/#{user}:.*/#{pwline.gsub('/','\/')}/g' *.auth) 
end 

• Para actualizar la contraseña de un usuario: contraseña de actualización en passwords.txt y ejecutar update.rb
• Para añadir un usuario a un grupo (por ejemplo new_user a group_a): abierta group_a.auth y agregue la línea new_user:.A continuación, añadir new_user:password_hash-passwords.txt si el usuario no está ya presente y, finalmente, ejecutar update.rb

Answer 2

Puede hacerlo funcionar usando el módulo AuthDigest y los reinos como grupos: tendrá múltiples entradas para un usuario, pero puede tenerlas línea por línea en un solo archivo. No es perfecto, pero es mejor que la pesadilla que tienes ahora.

Pequeño cambio en la configuración (ver auth_digest y user_file para la segunda ubicación):

location ~ ^/a/ { 
    # should allow access for user1, user2 
    auth_digest   "Restricted"; 
    auth_digest_user_file /etc/nginx/auth/file_a; 
} 
location ~ ^/b/ { 
    # should allow access for user2, user3 
    auth_digest   "Restricted2"; 
    auth_digest_user_file /etc/nginx/auth/file_a; 
} 

y file_a:

user1:Restricted1:password_hash 
user2:Restricted1:password_hash 
user2:Restricted2:password_hash 
user3:Restricted2:password_hash 

Answer 3

estoy usando un script nginx-groups.pl que analiza los archivos de contraseñas estilo apache y grupos y genera archivos de contraseñas individuales para cada grupo. Por lo tanto, básicamente hace lo mismo que la secuencia de comandos de Ruby en la respuesta de Markus, pero utiliza un solo archivo para todos los grupos y el archivo de grupo está en el mismo formato que para apache.

La versión actual de la secuencia de comandos es:

#! /usr/bin/env perl 

use strict; 

die "Usage: $0 USERSFILE GROUPSFILE\n" unless @ARGV == 2; 
my ($users_file, $groups_file) = @ARGV; 

my %users; 
open my $fh, "<$users_file" or die "cannot open '$users_file': $!\n"; 
while (my $line = <$fh>) { 
    chomp $line; 
    my ($name, $password) = split /:/, $line, 2; 
    next if !defined $password; 
    $users{$name} = $line; 
} 

open my $fh, "<$groups_file" or die "cannot open '$groups_file': $!\n"; 
while (my $line = <$fh>) { 
    my ($name, $members) = split /:/, $line, 2 or next; 
    next if !defined $members; 
    $name =~ s/[ \t]//g; 
    next if $name eq ''; 
    my @members = grep { length $_ && exists $users{$_} } 
        split /[ \t\r\n]+/, $members; 

    my $groups_users_file = $name . '.users'; 

    print "Writing users file '$groups_users_file'.\n"; 

    open my $wh, ">$groups_users_file" 
     or die "Cannot open '$groups_users_file' for writing: $!\n"; 

    foreach my $user (@members) { 
     print $wh "$users{$user}\n" 
      or die "Cannot write to '$groups_users_file': $!\n"; 
    } 

    close $wh or die "Cannot close '$groups_users_file': $!\n"; 
} 

guardarlo con el nombre que quiera y que sea ejecutable. Invocarlo sin argumentos imprimirá una breve información de uso.

Ver http://www.guido-flohr.net/group-authentication-for-nginx/ para más detalles!