Existe um servidor webdav multiusuário disponível para linux?

Estou procurando descomissionar completamente meu serviço SMBA e substituí-lo por um serviço WebDav.

Todas as pesquisas do Google até agora me indicaram o uso do Apache / Webdav. Isso está próximo do que eu preciso, mas, tanto quanto li, o Apache precisa ter acesso aos arquivos do meu usuário e algo pior; se ele criar um arquivo, o novo arquivo será de propriedade do Apache (não do usuário). Observe que ter arquivos com a propriedade e permissões corretas do Unix é um requisito, pois alguns usuários têm acesso SSH direto.

Portanto, estou simplesmente procurando uma maneira de fazer o Apache / Webdav funcionar "corretamente" com vários usuários (que é mudar o usuário unix para o usuário conectado antes de tentar servir o arquivo ) ou encontrar uma alternativa completa ao Apache / Webdav.

Até agora, as pesquisas não revelaram nada.

Se você tiver o nome de usuário e / ou o uid, poderá fazê-lo com nginx + lua + luarocks ljsyscall

Em um sistema debian, configurado como:

apt-get -y install nginx libnginx-mod-http-dav-ext libnginx-mod-http-lua luarocks
luarocks install ljsyscall

E o nginx configurou da seguinte maneira:

user  root;
worker_processes  1;

load_module modules/ngx_http_dav_ext_module.so;
load_module modules/ndk_http_module.so;
load_module modules/ngx_http_lua_module.so;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    sendfile        on;
    keepalive_timeout  65;
    gzip  on;

    server {
        listen      80;
        listen [::]:80;

        location / {
            rewrite ^ http://$host$request_uri?; # permanent;
        }
    }

    server {
        listen      443           ssl http2;
        listen [::]:443           ssl http2;

        ssl                       on;    
        # [ SSL Sections Omitted ]

        # Set the maximum size of uploads
        client_max_body_size 200m;

        # Default is 60, May need to be increased for very large uploads
        client_body_timeout 120s; 

        # other configs
        location /webdav/ {
            autoindex              on;
            alias                  /data/www/;
            client_body_temp_path  /data/client_temp;

            dav_methods PUT DELETE MKCOL COPY MOVE;
            dav_ext_methods PROPFIND OPTIONS;

            create_full_put_path   on;
            # Not sure if you want to tweak this
            # dav_access             group:rw  all:r;

            # Let's assume you have an auth subrequest that can set X-UID
            auth_request  /auth
            auth_request_set $auth_status $upstream_status;
            auth_request_set $saved_remote_user $upstream_http_REMOTE_USER;
            auth_request_set $saved_remote_uid $upstream_http_X_UID;

            # Per-Request Impersonation
            access_by_lua_block {
                # Boilerplate because ljsyscall doesn't have setfsuid implemented directly
                local syscall_api = require 'syscall'
                local ffi = require "ffi"
                local nr = require("syscall.linux.nr")
                local sys = nr.SYS
                local uint = ffi.typeof("unsigned int")
                local syscall_long = ffi.C.syscall -- returns long
                local function syscall(...) return tonumber(syscall_long(...)) end 
                local function setfsuid(id) return syscall(sys.setfsuid, uint(id)) end
                -- If you only have ngx.var.saved_remote_user, install luaposix and do this ...
                -- local pwd = require 'posix.pwd'
                -- local new_uid = pwd.getpwnam(ngx.saved_remote_user).pw_uid
                local new_uid = tonumber(ngx.var.saved_remote_uid)
                ngx.log(ngx.NOTICE, "[Impersonating User #" .. new_uid .. "]")
                local previous = setfsuid(new_uid)
                local actual = setfsuid(new_uid)
                if actual ~= new_uid then
                    ngx.log(ngx.CRIT, "Unable to impersonate users")
                    ngx.exit(ngx.HTTP_INTERNAL_SERVER_ERROR)
                end
            }
        }

        location = /auth {
            internal;
            proxy_pass              http://localhost:8080/auth;
            proxy_pass_request_body off;
            proxy_set_header        Content-Length "";
            proxy_set_header        X-Original-URI $request_uri;
            proxy_set_header        X-Original-Method $request_method;
        }
    }
}

Isso executará o setfsuid em cada solicitação atendida pelo trabalhador nginx. Infelizmente, parece que você deve estar executando o nginx como root para que isso funcione corretamente no momento. Eu acredito que é possível que isso funcione com um usuário diferente, desde que o processo tenha sido iniciado como root, transferido para um usuário diferente, com CAP_SETUID preservado (consulte a documentação para capsh) e a userdiretiva está ausente no arquivo de configuração nginx.

Você também pode precisar definir os IDs do grupo, potencialmente.

Consulte "Efeito das alterações de ID do usuário nos recursos" em http://man7.org/linux/man-pages/man7/capabilities.7.html

Vale a pena ler: Outra entrada: várias pastas de usuários e uma pasta compartilhada http://hexeract.wordpress.com/2011/02/25/configure-a-webdav-enabled-webserver-for-multiple-user-folders -e-uma-pasta-compartilhada /

Usei este como guia para configurar o webdav: http://bernaerts.dyndns.org/linux/75-debian/62-debian-webdav-share

Sim, o Apache é o grupo (www-data no Debian), mas você pode adicionar usuários a esse grupo, então eu adicionei um usuário. Não testou por que você não pode adicionar outros usuários .... O servidor webdav que usa, em princípio, essa configuração é executado agora por 3 anos no meu e no de meus filhos (portanto, 2 servidores idênticos para o trabalho do meu filho). O Debian 6 é desde alguns meses a versão LTS (até fevereiro de 2016).

Comparado com Bernaerts, adaptei no arquivo Apache: / etc / apache2 / sites-available / default essa parte da configuração.

Alias /webdav1 /data/webdav1

<Location /webdav1>
DAV on
Authtype Basic
Authname "webdav1"
AuthUserFile /var/www/web1/passwd1.dav
Require valid-user
</location>

Portanto, meus arquivos não estão mais em www, mas em / data / webdav1 (por meio do apelido webdav1 para mantê-lo curto). Para cada disco rígido que criei essa seção, o webdav1 se torna webdav2 para o segundo disco rígido dessa seção. Podemos criar no máximo 10 discos rígidos nesses servidores, portanto 10 dessas seções nesse arquivo de configuração. Eu adicionei o usuário a www-data, davfs2 e davfs, para que o usuário possa acessar as pastas do webdav. Portanto, o usuário precisa fazer login e será solicitado o nome de usuário e a senha. No fstab, todos os discos de dados do webdav são listados para que a montagem continue automaticamente. Essa parte do fstab:

/ dev / sda3 / data / webdav1 ext3, usuário, automático 0 0

Você já tentou o OwnCloud ? Ainda estou testando sozinho, mas parece que preenche seus requisitos: o webdav funciona imediatamente.

Tendo procurado por um longo tempo, simplesmente não consegui encontrar um. Existem muitos servidores multiusuário, mas não consegui encontrar um que seja executado como usuário do sistema.

Então eu mesmo escrevi um. Isso é testado apenas na medida em que eu mesmo possa testá-lo. Mas, para o que vale, o código fonte está aqui:

https://github.com/couling/WebDAV-Daemon

Hy,

Eu estava procurando a mesma coisa e finalmente reuni uma solução usando o apache2. Tentei a solução do nó usando o npm webdav-server e descobri que nem todos funcionavam tão bem quanto o módulo apache. Então tentei um servidor npm dav baseado em jsDAV que poderia fazer melhor e ser uma solução, mas como tive que lidar com uma péssima conexão 3G, preferi o apache e descobri vários scripts de instância.

Então, aqui eu compartilho minha experiência.

http://helpcenter.epages.com/Doc/doc/apache2/README.multiple-instances

Eu corro uma instância por usuário webdav ... não muito escalável, mas trabalhar em uma equipe pequena é bom o suficiente.

Substitua myUser pelo seu usuário.

No Ubuntu 14.04

sh /usr/share/doc/apache2/examples/setup-instance myUser

Então, eu executo um processo apache como o usuário myUser definido em / etc / apache2-myUser / envars

export APACHE_RUN_USER=myUser
export APACHE_RUN_GROUP=myUser

Edite ports.conf

# If you proxy with nginx as I did better to limit to local interface
listen localhost:8080
# listen 8080

Não consegui fazer com que a autenticação PAM no ubuntu 14.04 funcionasse, por isso preciso enganar com a autenticação básica, pois depois a envolvo em https com nginx

htpasswd -c /etc/apache2/htpasswd myUser

Em seguida, /etc/apache2-myUser/sites-available/000-default.conf

<VirtualHost *:8080>

DocumentRoot /var/www/html

Alias /${APACHE_RUN_USER} /home/${APACHE_RUN_USER}
<Directory /home/${APACHE_RUN_USER}>
    Require all granted
    Options +Indexes
</Directory>

<Location /${APACHE_RUN_USER}>
      DAV On
      AuthType Basic
      AuthName "Restricted Area"
      AuthUserFile /etc/apache2/htpasswd
      Require valid-user
</Location>

DavLockDB /home/${APACHE_RUN_USER}/.DavLock
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

então o nginx proxy tem um truque com o cabeçalho Destination passando a pasta de ícones, permitindo que o webdav faça um downgrade agradável nos navegadores

server {
listen 443 ssl http2;
server_name exemple.com;

location ~ ^/(myUser|icons)/ {

    proxy_pass http://dav-myUser;

#         auth_basic "Restricted Content";
#         auth_basic_user_file /etc/nginx/htpasswd;

#         proxy_set_header Authorization $http_authorization;

    proxy_pass_header  Authorization;
    proxy_pass_request_headers on;

    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Host $http_host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto $scheme;

    port_in_redirect off;

    # to avoid 502 Bad Gateway:
    # http://vanderwijk.info/Members/ivo/articles/ComplexSVNSetupFix
    set $destination $http_destination;

    if ($destination ~* ^https(.+)$) {
        set $destination http$1;
    }

    proxy_set_header Destination $destination;

    proxy_read_timeout     300;
    proxy_connect_timeout  5;

    # Default is HTTP/1, keepalive is only enabled in HTTP/1.1
    proxy_http_version 1.1;

    # Remove the Connection header if the client sends it,
    # it could be "close" to close a keepalive connection
    proxy_set_header Connection "";
}

ssl on;
ssl_certificate /etc/letsencrypt/live/exemple.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/exemple.com/privkey.pem;

include /etc/letsencrypt/options-ssl-nginx.conf;

}

Não há nenhuma obrigação de usar o nginx como proxy, o apache pode muito bem fazer o https, mas, ao entrar no problema de destino do proxy, senti que valia a pena mencioná-lo.

Também estou procurando uma solução semelhante.

Solução 1: O ambiente da área de trabalho (Gnome, KDE) pode ter widgets para expor uma determinada pasta pelo WebDAV. Isso funcionará enquanto o ambiente da área de trabalho estiver em execução e não for uma solução daemon.

Solução 2: Nada impede você de executar o Apache com sua própria vinculação de usuário em portas não privilegiadas acima de 1024. Basta escrever um arquivo de configuração ou copiar os que estão incluídos na sua distribuição em seu $ HOME / etc / httpd (apenas um exemplo), adicione DAV- configuração relacionada e execute-a como seu próprio usuário não root, como:

$ httpd -f $ HOME / etc / httpd

A execução como seus usuários garante que o Apache criará arquivos como você.