Hannes's questions

Fail2ban é usado para bloquear usuários em certos padrões via rejectcomando. Às vezes, especialmente quando os usuários estão atrás de um NAT com muitos usuários, eles são bloqueados involuntariamente. O usuário então escreve um E-Mail e então eu peço que seu endereço IP seja desbloqueado (muitas vezes o E-mail é encaminhado para mim, então eu não tenho o cabeçalho do Mail com seu endereço IP).

Para facilitar esta etapa, gostaria de redirecioná-lo para uma página dinâmica especial que exibe seu endereço IP e entre em contato por e-mail. Um exemplo está aqui:

Eu gostaria de ter uma página semelhante. Uma solução fácil seria o php, mas isso requer a instalação do php e alguma configuração do servidor web. A solução mais simples seria um pequeno servidor web que serve apenas um pequeno texto para um endereço IP.

Eu considerei usar python, porque o Python já está instalado. Encontrei este artigo https://www.anycodings.com/1questions/2464569/how-do-i-get-the-client-ip-address-on-a-python-server mas que imprime o endereço IP apenas em stdout e serve arquivos.

Para usar python tão simples quanto com php, seria necessário Flask ou Django, tanto quanto eu descobri. No entanto, esses são frameworks grandes e muito superdimensionados para este caso de uso simples. Também eles provavelmente podem significar algum problema de segurança. Esta página de informações também deve ser segura por design, para não criar possíveis problemas de segurança em comparação com o rejectmétodo. Eu sei que o DOS é mais provável por causa de mais dados transmitidos do que usando reject, mas o tamanho desta página é muito pequeno, então isso seria bom.

Então, qual é uma solução fácil para essa tarefa? Pitão? Em caso afirmativo, você poderia sugerir algumas palavras-chave que eu possa pesquisar para realizar essa tarefa? Existem outras soluções? Talvez estes se encaixem ainda melhor do que a ideia do python.

Eu tenho um software bastante antigo que não suporta TLS 1.2. No entanto, o servidor SMTP suporta apenas TLS 1.2.

Agora eu queria usar o stunnel para conectar ao servidor SMTP e também ouvir o acesso smtp. Já tenho um certificado válido para este servidor. Antes de configurar diferentes versões do TLS, eu só queria testar se esse "proxy stunnel" funciona em geral. Eu uso o Thunderbird para conectar a :587 Em [TLS_proxy_connector] e [TLS_proxy_listener] eu tenho protocol = smtp. Eu tentei comentá-los em uma ou ambas as seções. No entanto, recebo um erro imediato ou algum tipo de tempo limite e o Thunderbird não pode enviar o e-mail.

Aqui está a configuração do stunnel:

setuid = stunnel4
setgid = stunnel4

foreground = yes
;don't write pid
pid =


[TLS_proxy_connector]
client = yes
accept = 127.0.0.1:53681
protocol = smtp
connect = <mailserver>:587
verify = 2
CApath = /etc/ssl/certs/
checkHost = <mailserver>
;OCSPaia = yes

[TLS_proxy_listener]
accept = 587
protocol = smtp
key = /etc/ssl/private/key.pem
cert = /etc/ssl/certs/cert_.pem
CAfile = /etc/ssl/certs/chain_.pem
connect = 53681

O que estou fazendo errado? Existe outra ferramenta que se encaixa melhor aqui? Eu sei que poderia configurar um servidor de e-mail próprio que aceita TLS 1.0 e 1.1 e usa como smarthost, mas isso seria demais, porque aí eu tenho que me preocupar com segurança. Atualmente verifica a segurança porque você só tem permissão para enviar com credenciais válidas. Obrigado pela ajuda.

Atualização: Funciona com a configuração acima quando ambas as entradas possuem protocol = smtp. Adicionarei mais informações quando mais testes forem feitos em relação às versões do TLS.

Aqui https://security.stackexchange.com/a/52564 você pode ler que as versões mais recentes do OpenSSH usam bcrypt para proteger o arquivo de chave. A segurança do bcrypt depende do fator de custo, consulte https://security.stackexchange.com/questions/139721/estimate-the-time-to-crack-passwords-using-bcrypt/201965#201965

De acordo com https://crypto.stackexchange.com/questions/58536/how-does-openssh-use-bcrypt-to-set-ivs/58543#58543 o número padrão da rodada bcrypt seria 16. Esta seria uma boa segurança . Mas como obter a contagem de rodadas/fator de custo?

O que eu fiz até agora: Parece que a chave (para torná-la mais curta aqui, apenas uma chave fraca de 1024 bits)

-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAACmFlczI1Ni1jdHIAAAAGYmNyeXB0AAAAGAAAABBLF8sO2Q
hcLXI43z96e1hiAAAAEAAAAAEAAACXAAAAB3NzaC1yc2EAAAADAQABAAAAgQC0gBWeZpej
9ILT/59bEb0/lSvXx0WfZqP2lXRDbuY+gluuWyT+REQcVTR2BxSx9F/P20mLTnupzY+XE3
xEu+SIJlwKIAH3fed62+QBzDrPsl9kyfoIGIvi/28ZftqVN/kg0GSOaAqu4Px+vNVX1VKn
PNV5VVCZWL4ZPlGQZ48UJwAAAhCwDkueKT9oq8E0qtD92/4DSAD2eTI7bd6jBGUxugEw85
6xWbRYnFQZdwO2ZCNV0aTHViD1FRKlC9cBHDoSORKcM/9dY9Msy6lZj7Tp5s8r7x2pOrJi
TVRbv5/cI732I+l/vYvssJEhZpeSw4JKh9tyPpifVmzBxqtqwkBrTuLCMqkwLmrcxReFUq
aA/RIZy3L616CJsAvx2ezEc49D6SbJ9i9OlKuv73a1baS4RpMvFzWGLE2NBvvtQpEnJFoL
Kyjz+two4doT6SZ7UtiVGyCtO5WQEoeAgjhkbZzOPtM2AvoV+hNLRIX2/52jOB5A1bNQ0v
qW64aj2YNe8vWfj5xtA/8BlyEG7gwhu+0HgbgMDxw7o/0qVkHM/Hv3YgBTRygsH+8h4wsR
kxA292NOKKaD18tv1j3atR80q0XQVcQH20uX8tSqXtKfDtkUc/EPbFCNp3xQJG/F81USKh
YAmjxEeDkZZ/LkEOEJKvFRCL3gFlH4rqF5/pRk6HmB99xceD4irbazm+BWfPAf5Q0zdB5L
/yei3sqA4G48yRXIkaELtYNEeTYHMp3PGz1b3CP3l+ZGZp6XNaM+sMfdICbI3Zae5bnxKg
VXEE2UMdi7DEXbqEzSlfcIf5QzXHMQJm0ZL+iLoaEmakamAxCKk6jJ+QzHzGADZEIRXrj3
5Nhhd0jsToEMsXmmawt2qxy0cIHET1M=
-----END OPENSSH PRIVATE KEY-----

PW étest

Então vamos decodificar a base64. Portanto, a primeira e a última linha começando com '-----' devem ser removidas

cat key | tail -n +2 | head -n -1 | base64 -d > text.txt

Agora abra text.txt por exemplo no Notepad++ Isso mostra

mas agora não tenho ideia de como ler a contagem de rodadas a partir daí. Você pode ajudar?

Configuração: SSD criptografado com luks aes-xts 512 bits (chave AES de 256 bits), sistema de arquivos ext4

dd desempenho de gravação de 138 MB/s , uso da CPU 97-100%

dd if=/dev/zero of=testfile status=progress bs=32M count=128
4294967296 bytes (4,3 GB, 4,0 GiB) copied, 31 s, 138 MB/s
128+0 Datensätze ein
128+0 Datensätze aus
4294967296 bytes (4,3 GB, 4,0 GiB) copied, 31,0463 s, 138 MB/s

dd desempenho de leitura de 110 MB/s , o uso da CPU começa com > 90 %, depois cai para cerca de 50-60 % e, no final da leitura do arquivo, sobe para > 90 % novamente.

#crop cache before
sudo sh -c "echo 1 > /proc/sys/vm/drop_caches"

Agora faça o teste:

dd if=testfile of=/dev/null status=progress bs=32M
4261412864 bytes (4,3 GB, 4,0 GiB) copied, 39 s, 109 MB/s
128+0 Datensätze ein
128+0 Datensätze aus
4294967296 bytes (4,3 GB, 4,0 GiB) copied, 39,1345 s, 110 MB/s

Agora vamos dar uma olhada no samba:

Gravar um arquivo de 1 GB em um compartilhamento de samba no disco comparado acima fornece cerca de 73 MB/s , o uso da CPU é de apenas cerca de 70%.

Ler um arquivo de 1 GB do compartilhamento do samba fornece apenas cerca de 64 MB/s , o uso da CPU é de cerca de 55%. Observe também este gráfico: Ele começa devagar e depois a velocidade sobe e desce, gerando algum tipo de forma de onda.

Copiando este arquivo imediatamente novamente, quando ele estiver em cache , então ele será copiado com 112 MB/s , portanto, velocidade GigabitEthernet completa como deveria.

Compare com a unidade não criptografada :

dd velocidade de gravação 133 MB/s

dd velocidade de leitura 207 MB/s

Gravação do Samba: 112 MB/s

Leitura do Samba: 112 MB/s

Portanto, a criptografia LUKS por si só fornece velocidade suficiente, o Samba sozinho também tem velocidade suficiente. Em combinação, há uma grande queda de desempenho, enquanto ainda há muitos recursos de CPU disponíveis que são usados ​​quando apenas o dd é usado.

O que está errado aqui? Por que a CPU não é totalmente usada ao fazer operações para o samba enquanto está com o dd? O que pode ser feito para ter também desempenho total / uso da CPU com criptografia smb e luks?

apenas para obter alguma experiência com mdadm eu coloquei alguns HDD juntos e tentei um pouco. Eu tenho 2 250 GB e um HD de 500 GB. Eu sei que isso não é ideal para RAID5 e só terei 500 GB de capacidade no total. 250 GB de HDD de 500 GB são desperdiçados. Mas como eu disse, estou apenas brincando um pouco.

Primeiro vamos ver os tamanhos dos discos:

lsblk /dev/sdb /dev/sdc /dev/sdd
NAME MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sdb    8:16   0 232.9G  0 disk
sdc    8:32   0 465.8G  0 disk
sdd    8:48   0 232.9G  0 disk

Crie o RAID5:

sudo mdadm --create --verbose /dev/md0 --level=5 --raid-devices=3 /dev/sdb /dev/sdc /dev/sdd -c 4 --auto md

Mostrar informações para o Raid5 criado:

cat /proc/mdstat                                     Personalities : [raid6] [raid5] [raid4]
md0 : active raid5 sdd[3] sdc[1] sdb[0]
      488132976 blocks super 1.2 level 5, 4k chunk, algorithm 2 [3/2] [UU_]
      [>....................]  recovery =  0.5% (1354384/244066488) finish=59.7min speed=67719K/sec
      bitmap: 0/2 pages [0KB], 65536KB chunk

unused devices: <none>

Mostre um pouco mais de detalhes:

 sudo mdadm --detail /dev/md0
/dev/md0:
           Version : 1.2
     Creation Time : Wed Feb 26 14:52:54 2020
        Raid Level : raid5
        Array Size : 488132976 (465.52 GiB 499.85 GB)
     Used Dev Size : 244066488 (232.76 GiB 249.92 GB)
      Raid Devices : 3
     Total Devices : 3
       Persistence : Superblock is persistent

     Intent Bitmap : Internal

       Update Time : Wed Feb 26 14:57:43 2020
             State : clean, degraded, recovering
    Active Devices : 2
   Working Devices : 3
    Failed Devices : 0
     Spare Devices : 1

            Layout : left-symmetric
        Chunk Size : 4K

Consistency Policy : bitmap

    Rebuild Status : 7% complete

              Name : raspberrypi:0  (local to host raspberrypi)
              UUID : 3291b54e:fad8f43b:cc398574:a1845ff9
            Events : 57

    Number   Major   Minor   RaidDevice State
       0       8       16        0      active sync   /dev/sdb
       1       8       32        1      active sync   /dev/sdc
       3       8       48        2      spare rebuilding   /dev/sdd

Dmesg mostra

[ 2462.122882] md/raid:md0: device sdc operational as raid disk 1
[ 2462.122892] md/raid:md0: device sdb operational as raid disk 0
[ 2462.126278] md/raid:md0: raid level 5 active with 2 out of 3 devices, algorithm 2
[ 2462.142439] md0: detected capacity change from 0 to 499848167424
[ 2462.222689] md: recovery of RAID array md0

Então, o que estou fazendo de errado com a criação do RAID5? Também estou confuso na saída mdadm --detail /dev/md0com disknumber 0, 1 e 3 e não 0, 1, 2

Eu tento escrever um pequeno script que substitui o endereço do nullmailer. Nullmailer tem uma opção "allmailfrom" você pode colocar um endereço de e-mail em /etc/nullmailer/allmailfrom e todos os e-mails enviados têm este endereço como "Return-Path", mas From ainda é o valor de enviar programa como pi@raspberrypi

Então eu tentei criar um pequeno script para reescrever o endereço do remetente. Basicamente você move o sendmail para sendmail-bin e nomeia o script criado como sendmail. Funciona com o comando "mail", o endereço é reescrito como deveria. No entanto, com o cron, não funciona. STDIN está vazio e, portanto, a saída do cron não é recebida por e-mail. Gravações de syslogs

 /usr/sbin/sendmail: line 11: /dev/stdin: permission denied

Aqui o roteiro.

#!/bin/bash
#########################################
#Beginn change here
export NULLMAILER_USER=user
export NULLMAILER_HOST=somedomain.com
#Ende change here
#############################################

export NULLMAILER_FLAGS=ft

stdin=$(</dev/stdin)

optPosition=0 #defaultvalue when not found

while getopts ":f:" from; do
    case $from in
        f) optPosition=$OPTIND
           break
           ;;
    esac
done


arguments=($@)

if (($optPosition != 0)); then #-f Option was used
 arguments[(($optPosition-2))]=$NULLMAILER_USER@$NULLMAILER_HOST
 set -- "${arguments[@]}"
fi



echo "$stdin" | /usr/sbin/sendmail-bin "$@"   

O NULLMAILER_USER com NULLMAILER_HOST e NULLMAILER_FLAGS=f dizem ao nullmailer para usar isso como o endereço de origem. Essa parte funciona, veja http://manpages.ubuntu.com/manpages/trusty/man1/nullmailer-inject.1.html

No crontab é apenas

*/1 * * * * echo test 

Quando o sendmail original de nullmailer está presente, então "teste" está no corpo do e-mail, como deveria. Então, por que não pode ler esse script bash do stdin?