Arcticooling's questions

Desejo um comando que crie/altere algum arquivo e, em seguida, crie esse arquivo, tudo em uma linha, no Bash.

É importante para mim saber se é possível (ou por que não), pois isso pode ajudar a economizar algumas linhas em alguns scripts longos, evitando a necessidade de arquivos sourceou ./.

Por exemplo, tenho este modelo de código para adicionar aliases em /etc/bash.bashrc:

cat <<-"APPENDIX" >> /etc/bash.bashrc
    alias shortcut="command"
    alias shortcut="command"
APPENDIX
source /etc/bash.bashrc

Como é possível salvar essa source /etc/bash.bashrclinha fazendo com que o arquivo seja originado no momento em que é alterado?

Nota: Eu tenho permissões totais em relação ao /etc/bash.bashrc.

Este é meu padrão de crontab que armazeno em minha conta do Github:

source ~/.profile
0 0 * * *
# More cron commands

Como exercício, tentei canalizar os dados stdout curlpara o meu crontab (mudei o caminho do Github para o padrão geral).

1) Tentei usar um pipe simples:

curl https://raw.githubusercontent.com/user/repo/master/cronjobs | crontab

Isso falhou com o erro:

"-":0: minuto ruim

erros no arquivo crontab, não é possível instalar.

2) Eu tentei usar um heredoc:

curl https://raw.githubusercontent.com/user/repo/master/cronjobs | cat > crontab

Isso falhou com o erro:

Nenhuma modificação feita

3) Tentei ecoar a curlsaída em crontab.

echo "curl $(https://raw.githubusercontent.com/user/repo/master/cronjobs)" | crontab

Isso falhou com o erro:

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0...: command not found
100   505  100   505    0     0    804      0 --:--:-- --:--:-- --:--:--   804
(23) Failed writing body

Você pode ver que tentei três maneiras diferentes de enviar os dados de stdout para crontab e ainda nada funciona. O que mais me resta se quiser passar diretamente para o crontab e não para os cron.darquivos?

É assim que crio um MySQL autorizado, todos os usuários de banco de dados privilegiados e uma instância de banco de dados correspondente com o mesmo nome, diretamente do Bash:

echo "CREATE USER "${domain}"@"localhost" IDENTIFIED BY \"${dbup}\";" | mysql -u root -p"${dbrp}"
echo "CREATE DATABASE ${domain};" | mysql -u root -p"${dbrp}"
echo "GRANT ALL PRIVILEGES ON ${domain}.* TO ${domain}@localhost;" | mysql -u root -p"${dbrp}"

Os dois primeiros comandos poderiam ser mesclados em um comando de alguma forma?

Esta é a minha readoperação atual que funciona bem, mas gostaria de encurtar:

echo "Please save your DB root password:" && read -s dbrp
echo "Please save your DB user password:" && read -s dbup

Foi assim que tentei encurtá-lo e falhei (o prompt é importante para mim):

echo "Please save your DB passwords (root, then non-root):" && read -s dbrp && echo "\n" && read -s dbup

Já está em uma linha como eu desejava, mas não me sinto confortável com isso porque:

1. Existem dois read -scomandos em vez de apenas um.
2. Devo usar echo /npara quebrar a linha enquanto gostaria de quebrar sem isso.

Algo poderia ser feito para melhorar isso?

Atualizar

Eu cometi um erro ao usar echolá (além de adicionar \n. Como readtem sua própria opção de adição de prompt:

read -sp "What's your DB root password?" dbrp
read -sp "What's your DB user password?" dbup

Como eu poderia encurtar ainda mais o script a seguir, cujo objetivo é criar um banco de dados && instância do WordPress e, em seguida, alterar as permissões de acordo com o domínio fornecido e reiniciar o servidor?

${domain}representa o domínio que passo como argumento na execução do script. ${drt}significa raiz do documento ( /var/www/html).

#!/bin/sh
domain="$1"
echo "What's your DB root password?" && read -s dbrp
echo "What's your DB user password?" && read -s dbup

echo "CREATE USER "${domain}"@"localhost" IDENTIFIED BY \"${dbup}\";" | mysql -u root -p"${dbrp}"
echo "CREATE DATABASE ${domain};" | mysql -u root -p"${dbrp}"
echo "GRANT ALL PRIVILEGES ON ${domain}.* TO ${domain}@localhost;" | mysql -u root -p"${dbrp}"

cd ${drt}
curl -L http://wordpress.org/latest.tar.gz | tar -zxv -C ${domain}/
cp ${domain}/wp-config-sample.php ${domain}/wp-config.php
sed -i "s/database_name_here/${domain}"/g ${domain}/wp-config.php
sed -i "s/username_here/${domain}/g" ${domain}/wp-config.php
sed -i "s/password_here/${dbup}/g" ${domain}/wp-config.php

chown -R ${domain}:${domain} ${domain}/* && chmod -R a-x,a=rX,u+w ${domain}/* && systemctl restart nginx.service

Meu objetivo é encurtá-lo em 2 a 3 linhas, mas acho que provavelmente é impossível.

Eu pensei sobre:

1) Removendo a cd ${drt}sintaxe e começando a adicionar ${drt}onde eu precisar.

2) Una os 2 primeiros seds desta forma:

sed -i "s/_name_here/${domain}"/g ${domain}/wp-config.php

Gostaria de saber se há algo mais que possa ser encurtado (unido) que você reconheça.

Qual é a principal diferença entre o diretório cron.d (como em /etc/cron.d/) e crontab?

Tanto quanto eu entendo, pode-se criar um arquivo como /etc/cron.d/my_non_crontab_cronjobse colocar o que quiser dentro dele, assim como você os colocaria crontabvia crontab -e.

Então, qual é a principal diferença entre os dois?

Eu tenho um ambiente de servidor Ubuntu 16.04 Nginx com vários sites CMS (WordPress) na raiz do documento.

Todos os diretórios do site têm www-datacomo dono e grupo, recursivamente.

De acordo com algumas consultas de segurança que recebi, isso é problemático porque os dados de um site podem alterar qualquer outro site adjacente (por exemplo, um módulo malicioso instalado em um dos CMSs de um dos sites).

Presumo que a solução seria alterar este comando que sempre executo após adicionar um novo site (e também no cron após atualizações que alteram proprietário e grupo):

chown -R www-data:www-data /var/www/html/*

Para algum comando condicional que altera essas características não apenas para, www-datamas para o nome real do diretório do site.

Para esclarecer, o proprietário de cada diretório do site deve ser domain.tlde o grupo também deve ser domain.tld(eu sempre nomeio os diretórios do site de acordo com o domínio.tld do site).

O que poderia ser tal comando condicional?

Observação: tanto o usuário do Nginx quanto o diretório /var/www/html/permanecerão com www-data:www-data.

Atualização para o G-Man:

Ainda não testei mas acho que fica bom se você passar ${domain}como primeiro argumento para uma variável ( $1):

chown -R ${domain}:${domain} ${domain}/*

Embora eu o mantivesse:

chown -R ${domain}:www-data ${domain}/*

Claro, adduser ${domain} --disabled-password --disabled-loginé necessário antes, se não foi feito.

No Ubuntu 16.04 Bash 4.3.46(1) no final de /etc/bash.bashrcdeclarei a seguinte variável:

drt="/var/www/html"

Eu criei o arquivo ( source /etc/bash.bashrc)

Eu executei crontab -ee adicionei apenas para teste * * * * * touch /var/www/html/myFile.sh. Isso funcionou, enquanto * * * * * touch ${drt}/myFile.shnão funcionou.

Se uma variável declarada em bash.bashrcfor global, por que ela não é processada por crontab?

Atualização1

Não quero duplicar o fluxo drt="/var/www/html"em crontab(ou cron.d) para evitar redundância por princípio.

Atualização2

Acompanhei esta sessão e parece que a resposta marcada como correta não resolveu meu problema.

A segunda resposta não ficou clara para mim - por que colocar essa declaração condicional em (alguns?) bashrcArquivo.

Eu também tentei a terceira solução em relação a bash.bashrc(adicionado SHELL=/bin/bashno início de crontab, salvei o arquivo e originei, bash.bashrcmas não alterei em um * * * * * touch ~/myfiileteste.

Peço assim reabrir esta questão, ou pelo menos, esclarecer uma das respostas aí existentes.

Existem arquivos criados e/ou ampliados pelo sistema além de correio e logs?

AFAIK, os únicos arquivos que são criados e/ou ampliados pelo sistema por padrão são /var/mail/arquivos e /var/log/arquivos (ampliados por meio do tamanho do arquivo).

Para lidar com isso, redirecionei `/dev/null nos arquivos desses diretórios.

Mas existem mais arquivos além de mail e logs que eu deveria me preocupar que sejam criados e ampliados pelo próprio sistema Linux, ao longo do tempo?

Qual será uma maneira "elegante" de uma linha para anexar uma única linha de dados no final de um arquivo, com herestring, se esses dados exatos ainda não estiverem nesse arquivo?

Este é o meu padrão de acréscimo de herestring:

cat >> /var/www/html/myFile <<< "myOutput"

Eu tenho o seguinte script que uso para criar arquivos conf webapp (em /etc/nginx/sites-available/).

Este é o roteiro:

#!/bin/sh

for domain; do
    cat <<-WEBAPPCONF > /etc/nginx/sites-available/${domain}.conf
        server {
            root var/www/html/${domain};
            server_name ${domain} www.${domain};
            location / {
                index index.php index.html index.htm fastcgi_index;
                try_files $uri $uri =404 $uri/ /index.php?$args;
            }
            location ~ \.php$ {
                fastcgi_pass unix:/var/run/php/php*-fpm.sock;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                include fastcgi_params;
            }
        }
    WEBAPPCONF
    ln -s /etc/nginx/sites-available/${domain}.conf /etc/nginx/sites-enabled/
done

systemctl restart nginx.service

Dado que tem um forloop para uma domainvariável, posso executá-lo para vários domínios passando esses domínios como argumentos para domain:

bash ~/nwsm domain_1.tld domain_2.tld

Minha pergunta

Assuma que, por qualquer motivo, prefiro não usar um forloop e trabalhar apenas com um domínio de cada vez:

Se eu remover a for domain; do ... donesintaxe, presumo que não seria capaz de passar um domínio como argumento porque não há uma domainvariável para mantê-lo como um valor. Por isso pergunto qual é a maneira correta de alterar o script para que ele processe apenas um argumento de domínio, sem forloop?

Não tenho certeza se apenas adicionar domainno início do script é a maneira correta de fazer isso.

Apêndice

Alguns argumentos fracos de por que alguém iria querer fazer isso (porque for loopfunciona muito bem para ser honesto):

1) Reduzir a quantidade de linhas ao aspirar ao minimalismo.

2) Definir-se mentalmente para trabalhar com um domínio de cada vez reduzirá a chance de digitação extra e erros de digitação e facilitará a validação do que já está escrito.

3) Usar um forloop é redundante em alguns ambientes pequenos quando você trabalha com um número esparso de domínios (<=5 domínios).

Digamos que eu crie um arquivo ~/myScript.sh:

#!/bin/sh

for myVar; do
    echo "Hi"
done

Se eu executar bash myScriptsem argumentos, não obterei nada, mas se executar com um ou mais argumentos, obterei a saída pelo número dessas variáveis _{​​(a variável parece tornar o script dependente dos argumentos passados)} :

bash ~/myScript.sh arg0 arg1

O loop for, que é baseado na variável indefinida myVar, aplicaria arg0e arg1a si mesmo (desculpe se esta frase é ruim) e obterei esta saída:

Oi

Oi

(um "Hi" por argumento).

Originalmente, presumi que um forloop funciona com um argumento, portanto, se eu tivesse myVar_0e myVar_1com arg0e arg1, myVar_0trabalharia com arg_0e myVar_1funcionaria com arg1, mas testei mais e estava errado --- todos os forloops funcionaram com todos os argumentos:

#!/bin/sh

for myVar_0; do
    echo "Hi"
done

for myVar_1; do
    echo "Hello"
done

retornará em bash myScript arg0 arg1:

Oi

olá

Oi

olá

Observação: presumo que, se quiser "1 argumento por 1 loop for", só preciso usar uma função Bash para escopo local.

Minha pergunta

Qual é o nome dessa correspondência "todos os argumentos por todos os loops for" que o Bash faz?

Considere estes wgetcódigos:

wget -P ~/ https://raw.githubusercontent.com/user/repo/branch/papj.sh
wget -P ~/ https://raw.githubusercontent.com/user/repo/branch/nixta.sh

Existe alguma maneira elegante de unir diferentes terminais do mesmo URL básico acima, em uma linha em vez de 2 ou mais?

Pseudo-código:

wget -P ~/ https://raw.githubusercontent.com/user/repo/branch/papj.sh||nixta.sh

Eu sei o que é ugoa (proprietário, grupo, outros, todos) ou rwx (ler/direita/executar) ou 4,2,1 ou -, f, d, l, e tentei ler man chmodpara entender o que é uma maiúscula X, chmodmas não havia uma entrada para ele. Eu então li neste artigo em posix/chmod mas fiquei preso nesta passagem:

Defina o bit executável somente se o destino a) for um diretório b) já tiver pelo menos um bit executável definido para qualquer usuário, grupo ou outros.

Eu também li neste artigo que dá este exemplo de código:

chmod -R u=rwX,g=rX,o=rX testdir/

Entendo que há uma permissão recursiva no testdir/, em relação ao dono (u), grupo (g) e outros (o), mas admito que ainda sinto falta da intenção do X maiúsculo.

Talvez uma frase didática aqui possa lançar alguma luz sobre isso (o principal motivo de eu publicar isso aqui é porque não encontrei uma sessão de SE sobre isso).

_Atualizar

_{Desculpe a todos, eu perdi isso no homem. Não imaginei que o X apareceria antes da lista de argumentos e pensei que a busca retornasse x ao invés de X, que pena.}

Como anexar várias linhas a um arquivo, se essas linhas não existirem nesse arquivo?

Por exemplo, para adicionar vários aliases globais /etc/bash.bashrc, uso um heredocument :

cat <<-"BASHRC" >> /etc/bash.bashrc
    alias rss="/etc/init.d/php*-fpm restart && systemctl restart nginx.service"
    alias brc="nano /etc/bash.bashrc"
BASHRC

Fui criticado que esta operação não inclui uma maneira de verificar se as linhas já estão lá, e se reexecutar o heredocument por engano, poderia causar redundância, bem como conflito.

Existe uma maneira de validar ou confirmar que o usuário escreveu o que significava escrever read?

• Por exemplo, o usuário pretendia escrever "Hello world!" mas erroneamente escreveu "Hello world@".

• Isso é muito semelhante à validação do formulário de contato de um campo de e-mail/telefone.

Existe uma maneira de solicitar ao usuário algo como "Por favor, redigite a entrada", em leitura?

Não encontrei essa opção em man read.

Nota: A entrada é uma senha, então não quero imprimi-la ou compará-la com uma string já existente.

Não estou em um ambiente de teste agora, mas desejo fazer o download de um script Bash curle carregar seu conteúdo no crontab.

O conteúdo que aparece no documento bruto do Github é, por exemplo:

0 0 * * * ... 
0 0 * * 0 ...

Este modelo de código parece bom para você?

curl -O https://raw.githubusercontent.com/user/repo/master/file.sh | crontab

É possível imprimir crontabcom um heredocument?

Eu tentei estes, mas falhei:

cat <<-"CRONTAB" > crontab
    0 0 * * * cat /dev/null > /var/mail/root
    0 1 * * 0 certbot renew -q
CRONTAB

e:

bash <<-"CRONTAB" > crontab
    0 0 * * * cat /dev/null > /var/mail/root
    0 1 * * 0 certbot renew -q
CRONTAB

Por outro lado, não é um documento aqui, mas funcionou:

# CRONTAB
echo "
    0 0 * * * cat /dev/null > /var/mail/root
    0 1 * * 0 certbot renew -q
" | crontab

Eu me pergunto se isso é possível com heredocument.

Eu tenho esses comandos:

find /var/www/html/* -type d -exec chmod 755 {} \;
find /var/www/html/* -type f -exec chmod 644 {} \;

Eu entendi pela resposta de Stephen Kitt aqui que eu poderia combiná-los desta maneira:

find /var/www/html/* -exec chmod a-x,a=rX,u+w {} \+

Esses chmodargumentos são menos confortáveis ​​para eu ler, especialmente na findsintaxe (ainda não me familiarizei com o significado nix dos combos como a-x, a=rX, e u+we não tenho tempo e tranquilidade de espírito para aprender em um gravemente nos próximos dias).

É possível usar números lá? Caso contrário, pode haver uma maneira um pouco mais confortável de unir os dois comandos, mesmo que um pouco mais longo do que o proposto em particular?

Minhas formas atuais de proteger o PHPmyadmin (PMA), particularmente contra ataques de força bruta (BFAs) em meu ubuntu-nginx-httpsambiente, são uma ou mais destas:

1) Alterar a localização do diretório PMA para algo com fio e difícil de adivinhar.

2) Faça login a partir de um IP permanente.

3) Faça login por meio de uma VPN reconhecida ( _{esta é uma edição devido aos comentários abaixo} ).

4) Executar o PMA temporariamente em uma tmuxsessão separada:

cat <<-"PHPMYADMIN" > /opt/pma.sh
    #!/bin/bash
    find /var/www/html -iname '*phpmyadmin*' -exec rm -rf {} \;
    cd /var/www/html && wget https://www.phpmyadmin.net/downloads/phpMyAdmin-latest-all-languages.zip
    find /var/www/html -type f -iname '*phpmyadmin*.zip' -exec unzip {} \;
    find /var/www/html -type d -iname 'phpmyadmin-*' -exec mv {} phpmyadmin \;

    sleep 2h

    find /var/www/html -iname '*phpmyadmin*' -exec rm -rf {} \;
    tmux kill-session
PHPMYADMIN
chmod +x /opt/pma.sh

cat <<-"BASHRC" >> /etc/bash.bashrc
    alias pma="tmux new-session -d 'bash /opt/pma.sh'"
BASHRC
source /etc/bash.bashrc

então:

pma # execute script and use pma for 2 hours.

Por que não me sinto confortável usando essas formas

1. E se alguém encontrar o caminho PMA não intuitivo com fio, ele ainda pode tentar forçar isso.

2. Eu não posso pagar isso. Às vezes, posso mudar de apartamento.

3. Esta pode ser uma boa opção, embora possa ser esmagadora para esse propósito (não tenho outros usos de VPN nesta época).

4. Este script é bastante pesado e alonga o já muito longo script Nginx Server Environment Setup (NSES) que eu uso.

Minha pergunta

O que mais me resta para proteger o PMA do ataque de força bruta em meu ubuntu-nginx-httpsambiente?