All perguntas(server)

O Openvpn3 parou de funcionar depois que atualizei meu laptop Ubuntu 20.04 de python3.8 para python 3.11

Recebo este erro:

openvpn3-systemd[9972]: ModuleNotFoundError: No module named '_dbus_bindings'

Descobri que import dbusfunciona bem com python3.8, mas não funciona com python3.11

Tentei fazer o openvpn3 funcionar alterando o sistema padrão python de volta para 3.8 usando

sudo update-alternatives --config python

E também verifiquei que quando uso python na linha de comando, ele encontra dbus,

python -c 'import dbus'

Reiniciar o serviço ainda falha com o mesmo erro. Editei o arquivo /usr/libexec/openvpn3-linux/openvpn3-systemdpara que ele imprima a versão python antes de tentar importar o dbus usando estas 2 linhas no topo do arquivo:

import sys
print ('openvpn3-python-version-used: ' + sys.version)

E vejo que está usando python3.11

Como posso alterar o arquivo de serviço para forçá-lo a usar a versão mais antiga do python3.8?/lib/systemd/system/[email protected]

Arquivo de serviço atual:

[Unit]
Description=OpenVPN 3 Linux - VPN session for %I
After=dbus.service network-online.target
Wants=dbus.service network-online.target
Documentation=man:openvpn3-linux(7)
Documentation=man:openvpn3-systemd(7)

[Service]
Type=notify
PrivateTmp=true
ProtectSystem=true
ProtectHome=true
Environment="PYTHONUNBUFFERED=on"
ExecStart=/usr/libexec/openvpn3-linux/openvpn3-systemd --start %i
ExecReload=/usr/libexec/openvpn3-linux/openvpn3-systemd --restart %i
ExecStop=/usr/libexec/openvpn3-linux/openvpn3-systemd --stop %i

[Install]
WantedBy=multi-user.target

Tenho os seguintes ClusterRoles definidos:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: deployer-system
rules:
- apiGroups:
  - '*'
  resources:
  - '*'
  verbs:
  - list
- nonResourceURLs:
  - '*'
  verbs:
  - list

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: deployer-nonsystem
rules:
- apiGroups:
  - '*'
  resources:
  - secrets
  - PersistentVolumes
  - Role
  - RoleBinding
  verbs:
  - list
- apiGroups:
  - '*'
  resources:
  - deployments
  - pods
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - patch
- nonResourceURLs:
  - '*'
  verbs:
  - list

Eu uso os seguintes RoleBindings para atribuir a um usuário o ClusterRole acima:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: theuser-nonsystem-role-binding
  namespace: nonsystem-namespace
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: deployer-nonsystem
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: User
  name: theuser

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: theuser-kube-system-role-binding
  namespace: system-namespace
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: deployer-system
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: User
  name: theuser

No entanto, eles conseguem executar um kubectl -n [NAMESPACE] get secrets -o yamle ver todos os segredos. Eu esperaria que essa chamada fosse proibida com base nas especificações ClusterRole acima.

Estou esquecendo ou entendendo mal alguma coisa aqui? Por que o usuário pode "pegar" segredos?

ATUALIZAÇÃO: Observe: meu problema NÃO é que eles podem listar segredos. Meu problema aqui é que o usuário pode "obter" segredos (verbos diferentes!)

Tenho uma situação (acho) muito particular no meu Linux embarcado que não consigo resolver corretamente...

Devido a verificações específicas (personalizadas) a serem executadas em sistemas de arquivos na inicialização antes de montá-los, eu uso um ramdisk inicial para verificar e montar todos os sistemas de arquivos solicitados e, então, os transfiro para o sistema de arquivos raiz quando o init é concluído (então nenhum /etc/fstabdispositivo é usado para montar, mas eles são montados por meio de um script que reside dentro do ramdisk inicial).

Para ser mais específico, a /bootpartição ( mmcblk1p1) é montada primeiro (no modo SOMENTE LEITURA); dentro dessa partição, tenho um arquivo ( rootfs.squashfs) correspondente a uma imagem squashfs do sistema de arquivos raiz de destino... então, após algumas outras operações (não relevantes para o propósito deste post), o script ramdisk inicial acaba montando a imagem squashfs /rootfse, no final do script init, a raiz do sistema é alternada /rootfs(via switch-rootcomando);

O problema surge na reinicialização do sistema (ou desligamento): quando o sistema tenta desmontar todos os sistemas de arquivos montados, a desmontagem /bootfalha (porque o dispositivo está ocupado, como é óbvio, já que o sistema de arquivos raiz é montado a partir de um arquivo squashfs que reside em /boot).

Existe uma maneira de evitar desmontar /bootna reinicialização/desligamento/desligamento, evitando assim a falha de umount? Como ele é montado somente para leitura, não deve ser arriscado, não é? Ou estou esquecendo de algo?

PS: Não sei se pode ser útil e/ou relevante: a inicialização do meu sistema operacional é gerenciada via systemd.

Estamos usando o Exchange Server 2013 CU23. Eu uso "delegação de caixa de correio" para outras caixas de correio da minha organização para controlar e-mails quando outros funcionários estão de férias.

Agora tenho muitos links que não são necessários para mim. Eu removi a delegação, mas os links não desapareceram. Eu reconectei o Outlook, mas todos os links foram restaurados, sem acesso. Eu posso vê-lo, mas sem mostrar o que está dentro dele.

Pelo que me lembro, tudo isso era fácil de usar, mas agora tenho esse problema estranho.

Alguém pode me ajudar?

PC + Wifi + servidor doméstico

-> roteador (Fritzbox)
-> caixa de cabo UPC

Tenho 2 NAT um após o outro.

Tenho um problema estranho de DNS. Configurei o DuckDns para apontar para um endereço IP interno. A resolução funciona em todos os lugares, mas não nos dispositivos conectados ao Fritzbox. Aqui há um tempo limite quando a entrada do DuckDns aponta para um IP interno como 192.168.xy

Se a entrada do Duckdns apontar para um IP "real", a resolução funcionará corretamente.

Então troquei o DNS no Fritzbox (menu de configuração -> servidor dns) para 9.9.9.9, porém obtive o mesmo resultado. Algo não funciona como esperado, porque:

nslookup xx.duckdns.org: tempo limite nslookup xx.duckdns.org 9.9.9.9: pode resolver

Parece que o Fritzbox suprime as pesquisas de DNS quando elas retornam um IP que está dentro do NAT.

Isso é plausível?

Como posso descobrir qual DNS é realmente usado quando o Fritzbox está fazendo a resolução?

Saudações, exae

consiste em Apache2 vinculado com Django como backend (WSGI), e React como frontend. Mas ele retorna apenas '403 Forbidden' com símbolo AH01630no log de erros. A versão do Apache2 também é 2.4.58 .

Uma parte da configuração do apache sites-available/default-ssl.conf:

WSGIDaemonProcess serve python-home=/venv/vee python-path=/venv/pub/proj/serve/serve
WSGIScriptAlias /api /venv/pub/proj/serve/serve/wsgi.py

<Directory /venv/pub/proj/serve/serve>
        <Files wsgi.py>
                Require all granted
        </Files>
</Directory>

<Directory /venv/pub/proj/serve/front/build>
        Options Indexes FollowSymLinks
        Require all granted
</Directory>

'sites-available/react.conf`:

DocumentRoot /venv/pub/proj/serve/front/build

<Directory /venv/pub/proj/serve/front/build>
        Options Indexes FollowSymlinks
        AllowOverride None
        Require all granted
</Directory>

O projeto Django é colocado em /venv/pub/proj/serve, e o projeto React é /venv/pub/proj/serve/front.

Anteriormente, o servidor era configurado Apache2 e Django, não React, então as configurações do Django WSGI não são problema. Quero saber por que parece haver conflito nas configurações do Apache2 entre default-ssl.confe react.conf. Se o WSGI estiver desabilitado, o aplicativo React é exibido.

Tenho 2 instâncias do AWS EC2, uma das quais reside em uma sub-rede pública e está configurada para atuar como uma instância NAT , e executa Nginx. A outra instância reside em uma sub-rede privada, mas pode se comunicar com a pública. Os respectivos endereços IP das instâncias são, por exemplo:

• 172.25.48.14 - Instância Nginx em uma sub-rede pública (172.25.48.0/28), tem um IP elástico atribuído
• 172.25.48.140 - instância executando php-fpm em uma sub-rede privada (172.25.48.128/28)

A questão é que eu quero que este site seja acessível por uma certa URL - eu supus que o Nginx agisse como um servidor proxy reverso que mapeia solicitações para certos subdomínios ou URLs para recursos respectivos. Então, aqui está minha configuração do Nginx:

http {
    sendfile on;
    tcp_nopush on;
    types_hash_max_size 2048;
    server_names_hash_bucket_size 128;

    include /etc/nginx/mime.types;
    default_type text/html;

    proxy_headers_hash_bucket_size;
    access_log /var/log/nginx/access.log
    error_log /var/log/nginx/error.log

    server {
        listen 80;

        location ~ ^/site1(.*)$ {
            # These are commented out because no matter if specified or not the result is the same
            # index index.php;
            # try_files $uri $uri/ /site1/index.php?$request_uri;
            location ~ \.php$ {
                include fastcgi.conf;
                try $uri =404;

                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_pass 172.25.48.140:9000;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                include fastcgi_params;
            }
        }
    }
}

E aqui está, respectivamente, a configuração do pool php-fpm para o site na instância privada:

[site1]
user = www-data
group = www-data
listen = 172.25.48.140:9000
listen.allowed_clients = 172.25.48.14, 172.25.48.140, 127.0.0.1
php_admin_value[disable_functions] = exec, passthru, shell_exec, system
php_admin_flag[allow_url_fopen] = off
pm = dynamic
pm.max_children = 10
pm.start_servers = 1
pm.min_spare_servers = 1
pm.max_spare_servers = 8
pm.process_idle_timeout = 30s
pm.status_path = /php_status
ping.path = /ping
ping.response = wrrrrrrrrryyyyyyyyyyy
access.log = /var/log/php/8.3/$pool.access.log
access.format = "%R - %u %t \"%m %r%Q%q\" %s %f %{milli}d %{kilo}M %C%%"

Para simplificar, vamos supor que eu tenha apenas um único index.phparquivo, que também reside na instância privada em /apps/site1/, que tem um link simbólico em /var/www/html/site1.

O problema é que não importa o que eu tente, recebo 404, e a julgar pelos logs no lado da instância privada, a solicitação nem chega lá - mesmo sabendo que tenho os grupos de segurança da instância configurados corretamente e nas portas certas, porque, de outra forma, posso conectar da instância privada para a pública e vice-versa sem problemas. A única vez que recebi uma solicitação para o php-fpm (embora um 404 também) foi quando movi a pesquisa de "localização" mais profunda (aquela que corresponde aos scripts .php) para o nível superior do servidor - então, basicamente, a solicitação foi direto para 172.25.48.14, e não para 172.25.48.14/site1como eu pretendia.

Estou esquecendo de algo? O problema pode ser que os arquivos de origem estão localizados na mesma instância que o php-fpm, e não no lado do Nginx? Estou entendendo errado o conceito de como ele funciona? Por favor, se você tiver alguma ideia sobre isso, ficarei extremamente grato pela sua ajuda. Obrigado antecipadamente!

De tempos em tempos e por vários motivos, o PyTTY perde a conexão com sessões SSH no meu servidor CentOS 7 (o PuTTY está com bugs, o servidor SSH está com bugs, o roteador foi reinicializado, a conexão caiu, o cabo foi desconectado etc.). Essas sessões abandonadas são um fardo para o servidor e consomem recursos. O servidor SSH CentOS 7 pode ser configurado para encerrar automaticamente qualquer sessão SSH após 24 horas, independentemente do propósito e do estado da sessão?

Por que independentemente do propósito e status da sessão? Porque, na minha opinião, às vezes pode ser difícil distinguir entre uma sessão normal e uma sessão abandonada.

Configurei com sucesso Postfix + Dovecot + IMAP. E também instalei spamassassin, spamc, spamass-milter, e configurei imap_sieveo plugin para combater spam.

Saída de doveconf -n:

# 2.3.13 (89f716dc2): /etc/dovecot/dovecot.conf
# Pigeonhole version 0.5.13 (cdd19fe3)
# OS: Linux 5.10.0-33-amd64 x86_64 Debian 11.11 
# Hostname: mail.example.com
mail_debug = yes
mail_location = maildir:~/Maildir
mail_privileged_group = mail
managesieve_notify_capability = mailto
managesieve_sieve_capability = fileinto reject envelope encoded-character vacation subaddress comparator-i;ascii-numeric relational regex imap4flags copy include variables body enotify environment mailbox date index ihave duplicate mime foreverypart extracttext imapsieve vnd.dovecot.imapsieve
namespace inbox {
  inbox = yes
  location = 
  mailbox Drafts {
    auto = no
    special_use = \Drafts
  }
  mailbox Sent {
    auto = subscribe
    special_use = \Sent
  }
  mailbox Spam {
    auto = subscribe
    special_use = \Junk
  }
  mailbox Trash {
    auto = subscribe
    special_use = \Trash
  }
  prefix = 
}
passdb {
  args = %s
  driver = pam
}
plugin {
  imapsieve_mailbox1_before = file:/var/lib/dovecot/sieve.d/default.sieve
  imapsieve_mailbox1_name = INBOX
  sieve_plugins = sieve_imapsieve
}
protocols = imap sieve
service auth {
  unix_listener /var/spool/postfix/private/auth {
    group = postfix
    mode = 0660
    user = postfix
  }
}
service imap-login {
  inet_listener imap {
    port = 143
  }
  inet_listener imaps {
    port = 993
    ssl = yes
  }
}
ssl = required
ssl_cert = </etc/ssl/mail/domain.crt
ssl_key = # hidden, use -P to show it
userdb {
  driver = passwd
}
protocol imap {
  mail_max_userip_connections = 20
  mail_plugins = " imap_sieve"
}

Conteúdo de /var/lib/dovecot/sieve.d/default.sieve:

require "fileinto";

if header :contains "X-Spam-Flag" "YES" {
    fileinto "Spam";
    stop;
}

E testei minha configuração com:

# Executed from outside my network
wget https://spamassassin.apache.org/gtube/gtube.txt
swaks --to [email protected] --body gtube.txt

E funciona. O e-mail é marcado com sucesso como spam (evidente X-Spam-Flag: YESnos cabeçalhos). Mas o filtro Sieve não funciona como esperado. Ele deveria mover a mensagem para minha pasta "Spam", mas em vez disso ele copia a mensagem para a pasta "Spam", mas somente depois que eu abro a mensagem. A mensagem permanece dentro da CAIXA DE ENTRADA.

Como posso fazer para que a mensagem seja movida para a pasta "Spam" (não copiada)? E por que o filtro Sieve só funciona depois que eu abro a mensagem no meu cliente de e-mail?

Eu uso o AlmaLinux 9 e entendo que há um novo serviço de backend nftables que pode ser gerenciado pelo comando iptables-nft, então eu defini algumas regras e meu conjunto de regras se parece com:

# Warning: table ip nat is managed by iptables-nft, do not touch!
table ip nat {
    chain DOCKER {
        iifname "docker0" counter packets 0 bytes 0 return
        iifname != "docker0" tcp dport 8080 counter packets 3 bytes 180 dnat to 172.17.0.2:80
        iifname != "docker0" tcp dport 9001 counter packets 4 bytes 240 dnat to 172.17.0.3:9001
    }

    chain POSTROUTING {
        type nat hook postrouting priority srcnat; policy accept;
        ip saddr 172.17.0.0/16 oifname != "docker0" counter packets 0 bytes 0 masquerade
        ip saddr 172.17.0.0/16 oifname != "docker0" counter packets 0 bytes 0 masquerade
        ip saddr 172.17.0.0/16 oifname != "docker0" counter packets 0 bytes 0 masquerade
        ip saddr 172.17.0.2 ip daddr 172.17.0.2 tcp dport 9001 counter packets 0 bytes 0 masquerade
        ip saddr 172.17.0.2 ip daddr 172.17.0.2 tcp dport 9001 counter packets 0 bytes 0 masquerade
        ip saddr 172.17.0.2 ip daddr 172.17.0.2 tcp dport 80 counter packets 0 bytes 0 masquerade
        ip saddr 172.17.0.3 ip daddr 172.17.0.3 tcp dport 9001 counter packets 0 bytes 0 masquerade
    }

    chain PREROUTING {
        type nat hook prerouting priority dstnat; policy accept;
        fib daddr type local counter packets 236 bytes 12653 jump DOCKER
        fib daddr type local counter packets 39 bytes 1732 jump DOCKER
        fib daddr type local counter packets 39 bytes 1732 jump DOCKER
        fib daddr type local counter packets 23 bytes 1056 jump DOCKER
        fib daddr type local counter packets 23 bytes 1056 jump DOCKER
    }

    chain OUTPUT {
        type nat hook output priority dstnat; policy accept;
        ip daddr != 127.0.0.0/8 fib daddr type local counter packets 0 bytes 0 jump DOCKER
        ip daddr != 127.0.0.0/8 fib daddr type local counter packets 0 bytes 0 jump DOCKER
        ip daddr != 127.0.0.0/8 fib daddr type local counter packets 0 bytes 0 jump DOCKER
    }
}
# Warning: table ip filter is managed by iptables-nft, do not touch!
table ip filter {
    chain FORWARD {
        type filter hook forward priority filter; policy drop;
        counter packets 178 bytes 55546 jump DOCKER-USER
        counter packets 178 bytes 55546 jump DOCKER-ISOLATION-STAGE-1
        oifname "docker0" ct state related,established counter packets 84 bytes 11338 accept
        oifname "docker0" counter packets 7 bytes 420 jump DOCKER
        iifname "docker0" oifname != "docker0" counter packets 87 bytes 43788 accept
        iifname "docker0" oifname "docker0" counter packets 0 bytes 0 accept
    }

    chain DOCKER-USER {
        counter packets 178 bytes 55546 return
    }

    chain INPUT {
        type filter hook input priority filter; policy drop;
        ct state established,related counter packets 195 bytes 18089 accept
        tcp dport 22 counter packets 2 bytes 120 accept
        tcp dport 443 counter packets 0 bytes 0 accept
    }

    chain DOCKER {
        ip daddr 172.17.0.2 iifname != "docker0" oifname "docker0" tcp dport 80 counter packets 3 bytes 180 accept
        ip daddr 172.17.0.3 iifname != "docker0" oifname "docker0" tcp dport 9001 counter packets 4 bytes 240 accept
    }

    chain DOCKER-ISOLATION-STAGE-1 {
        iifname "docker0" oifname != "docker0" counter packets 87 bytes 43788 jump DOCKER-ISOLATION-STAGE-2
        counter packets 178 bytes 55546 return
    }

    chain DOCKER-ISOLATION-STAGE-2 {
        oifname "docker0" counter packets 0 bytes 0 drop
        counter packets 87 bytes 43788 return
    }
}

esse conjunto de regras é salvo para /etc/sysconfig/nftables.confser carregado toda vez que o servidor é reiniciado, como você pode ver na cadeia INPUT, tudo deve ser descartado, exceto as portas 22 e 443, então tentei executar o teste do servidor nginx na porta 8080 e ainda consigo acessá-lo, meu firewall não está bloqueando nada... por quê? mesmo quando a política INPUT está definida para ser descartada.

EDITAR2:

então eu li que o docker usa a cadeia DOCKER-USER para regras definidas pelo usuário, então eu fiz:

table ip filter {
    chain FORWARD {
        type filter hook forward priority filter; policy drop;
        counter packets 0 bytes 0 jump DOCKER-USER
        counter packets 0 bytes 0 jump DOCKER-ISOLATION-STAGE-1
        oifname "docker0" ct state related,established counter packets 0 bytes 0 accept
        oifname "docker0" counter packets 0 bytes 0 jump DOCKER
        iifname "docker0" oifname != "docker0" counter packets 0 bytes 0 accept
        iifname "docker0" oifname "docker0" counter packets 0 bytes 0 accept
        oifname "docker0" ct state established,related counter packets 184 bytes 27570 accept
        oifname "docker0" ct state established,related counter packets 85 bytes 28483 accept
    }

    chain DOCKER-USER {
        counter packets 534 bytes 178277 return
        tcp dport 8080 drop
        tcp dport 9001 drop
    }

    chain INPUT {
        type filter hook input priority filter; policy drop;
        ct state established,related counter packets 584 bytes 54071 accept
        tcp dport 22 counter packets 8 bytes 460 accept
    }

    chain DOCKER {
        ip daddr 172.17.0.2 iifname != "docker0" oifname "docker0" tcp dport 80 counter packets 0 bytes 0 accept
        ip daddr 172.17.0.3 iifname != "docker0" oifname "docker0" tcp dport 9001 counter packets 0 bytes 0 accept
    }

    chain DOCKER-ISOLATION-STAGE-1 {
        iifname "docker0" oifname != "docker0" counter packets 0 bytes 0 jump DOCKER-ISOLATION-STAGE-2
        counter packets 0 bytes 0 return
    }

    chain DOCKER-ISOLATION-STAGE-2 {
        oifname "docker0" counter packets 0 bytes 0 drop
        counter packets 0 bytes 0 return
    }
}

e ainda não funciona, consigo acessar as portas 8080 e 9001, tentei até reiniciar o servidor.

EDIÇÃO 3:

mudei minha corrente para isso:

chain DOCKER-USER {
    tcp dport 8080 drop
    tcp dport 9001 drop
    return
}

servidor reiniciado e a porta 8080 ainda está acessível