A Apple introduziu medidas de proteção de privacidade no macOS Monterey e iOS 15, que usam uma rede de IPs atribuídos aleatoriamente para atuar como proxies ao carregar (entre outras coisas) conteúdo de e-mail. Alguém sabe, ou sabe como posso saber, quais são os alcances de rede desses serviços?
Eu quero servir miniaturas para imagens, e essas miniaturas são geradas sob demanda, gravadas em disco, então eu quero entregá-las ao nginx para servir.
Minha pasta raiz para miniaturas é /var/www/images. Quando recebo uma solicitação para /thumb/post1/image1.jpg, quero processá-la assim:
- Se a imagem estiver presente em
/var/www/images/thumb/post1/image1.jpg, veicule-a diretamente. - Se a imagem não estiver lá, ela precisa ser gerada, então passe a solicitação para a API em
@backend. - A API gera a imagem e a grava na pasta de miniaturas, depois entrega o caminho para ela de volta ao nginx usando um
X-Accel-Redirectcabeçalho. - O nginx reinicia o processamento na etapa 1, que será bem-sucedida porque o arquivo agora está presente.
- Se o item para o qual a miniatura foi solicitada não existir, a API retornará um 404 e o nginx deverá veicular uma imagem de espaço reservado localizada em
/var/www/images/missing.png.
Minha configuração do nginx está assim:
upstream api {
server localhost:7440 fail_timeout=0;
}
server {
root /var/www/www.example.com/public;
location / {
try_files $uri @backend;
}
location /thumb {
root /var/www/images;
try_files $uri @backend /missing.png;
}
location @backend {
root /var/www/api.example.com/public;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header Host $http_host;
proxy_set_header X-NginX-Proxy true;
proxy_redirect off;
proxy_pass http://api;
#For websocket compatibility
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
}
Minhas miniaturas são mantidas fora da pasta do projeto, então preciso de uma rootdiretiva no /thumblocal para fazê-la procurar a imagem. O /local lida com solicitações de API e outros ativos estáticos e o /thumblocal faz o mesmo, mas também tem o fallback para missing.png.
Uma peculiaridade: por razões históricas, minha rootpasta geral não é a mesma usada pelo meu @backendlocal nomeado, no entanto, estou substituindo isso em ambas as locationdiretivas e não há arquivos try_files.
No entanto, isso não funciona. As solicitações de imagens ausentes não são enviadas para a API, mas um substituto para uma imagem ausente sim! Se eu remover o fallback, as solicitações são enviadas para a API, mas o handoff para x-accel-redirectfalha, mesmo que o arquivo já exista; quando a imagem do polegar existe, o nginx não a serve – apenas atinge a API novamente.
Como isso deve ser configurado?
Preciso fazer muitos testes de e-mail local (no macOS 10.14), então uso um servidor SMTP falso na porta 2500 para a maioria das coisas, no entanto, também preciso interceptar mensagens enviadas diretamente por meio de um sendmailbinário local, e isso realmente significa usar um servidor de correio real que pode retransmiti-los para o meu servidor de correio falso. Estou tentando usar o postfix para isso, mas realmente não está indo bem. Meu objetivo é fazer com que ele transmita todas as mensagens para todos os usuários em todos os domínios, sem filtragem, criptografia ou autenticação. Não quero que ele preste atenção às contas de usuários locais, e isso parece exigir a desativação do agente de entrega local do postfix, e não encontrei como fazer isso.
Minha configuração se resume principalmente a isso:
local_transport = local:$myhostname
mydestination = $myhostname, localhost.$mydomain, localhost
local_recipient_maps =
relayhost = localhost:2500
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/local_passwd
smtp_use_tls = no
smtp_tls_security_level = none
compatibility_level = 2
fallback_transport = localhost:2500
Meu servidor de e-mail falso requer autenticação, embora não verifique nada e qualquer nome de usuário ou senha funcione, então há uma entrada fictícia nesse local_passwdarquivo.
Ver logs no macOS é extremamente doloroso; a melhor abordagem que encontrei até agora é:
sudo log stream --predicate '(process == "cleanup") || (process == "pickup") || (process == "qmgr") || (process == "error")' --info
Quando eu envio mensagens diretamente para ele usando o sendmail, posso ver que ele aceita mensagens para contas locais, mas não as retransmite. Ele também rejeita mensagens enviadas para contas inexistentes, como [email protected]essa que eu quero aceitar e retransmitir.
As mensagens acabam em uma caixa de correio em algum lugar que eu possa acessar se eu executar mail.
O que eu perdi?
Este é um seguimento a esta pergunta .
Eu tenho um jogo que provisiona várias instâncias do EC2. Por necessidade, o hostsvalor é localhost(porque quando é executado não há hosts), e o play monta uma nova lista de hosts chamada ec2hosts, e gera um host ip to hostname map porque esta é a primeira e única vez que a informação é disponibilizada , e salva usando set_fact. Esta lista de anfitriões é então o assunto de uma peça de acompanhamento. O problema é que eu preciso usar o hostname_mapdict criado durante o jogo de provisionamento no segundo jogo, e não consigo ver como fazer isso.
Aqui está a primeira jogada:
- hosts: localhost
connection: local
gather_facts: False
tasks:
- name: Provision a set of instances
ec2:
key_name: marcus
instance_type: t2.micro
image: "{{ ami_id }}"
wait: true
exact_count: "{{ server_count }}"
count_tag:
Tutorial: "{{ tutorial_name }}"
instance_tags:
Tutorial: "{{ tutorial_name }}"
groups: ['SSH', 'Web']
register: ec2
- name: Add all instance public IPs to host group
add_host:
hostname: "{{ item.public_ip }}"
groups: ec2hosts
loop: "{{ ec2.instances }}"
- name: Build an IP to hostname map
set_fact:
hostname_map: "{{ hostname_map | combine({item.0.public_ip: (item.1 + '.' + tutorial_domain)}) }}"
loop: "{{ ec2.instances|zip(hostnames)|list }}"
- name: Debug hostname_map
debug:
msg: "{{ hostname_map }}"
No final deste, hostname_mapcontém um mapa como:
{
"18.184.109.70": "host1.example.com",
"18.196.135.59": "host2.example.com"
}
Ao ler os documentos do ansible no escopo da variável, ele diz que as variáveis definidas em um jogo não estão disponíveis fora desse jogo, a menos que estejam sendo aplicadas ao mesmo conjunto de hosts. Isso não é possível neste caso, então preciso usar um var com escopo global e, pelo que li, set_facté a maneira apropriada de fazer isso. Então criei uma variável vazia em /group_vars/all, para que a variável fique acessível a todas as jogadas:
hostname_map: {}
A próxima jogada se conecta a cada instância recém-criada (usando a lista de hosts que criamos dinamicamente) e define seu nome de host por dentro:
- hosts: ec2hosts
gather_facts: yes
tasks:
- name: Debug hostname_map
debug:
msg: "{{ hostname_map }}"
- name: Set hostnames
hostname:
name: "{{ hostname_map[ansible_host] }}"
No entanto, isso falha porque hostname_mapestá vazio
TASK [Debug hostname_map]
ok: [18.184.109.70] => {
"msg": {}
}
ok: [18.196.135.59] => {
"msg": {}
}
então recebo este erro:
fatal: [18.184.109.70]: FALHOU! => {"msg": "A tarefa inclui uma opção com uma variável indefinida. O erro foi: 'dict object' não tem atributo u'18.184.109.70'
Curiosamente, recebo a mesma saída e erro de depuração, mesmo quando não defino a variável globalmente .
Outros artigos que li sugerem que os valores devem ser enumerados explicitamente em vars, mas não posso fazer isso porque os dados são dinâmicos e desconhecidos até o tempo de execução. Da mesma forma, não posso fornecê-lo usando extra_varsuma linha de comando pelo mesmo motivo.
Como posso disponibilizar essa variável na segunda jogada? Eu gostaria de evitar soluções desajeitadas, como escrever um arquivo local e depois lê-lo novamente!
Também estou aberto a sugestões para fazer isso de uma maneira completamente diferente, onde "isto" é: crie um número arbitrário de instâncias do EC2 e atribua a elas nomes de host retirados de uma lista estática.
Estou configurando um monte de até 150 servidores EC2 temporários para uma sessão de tutorial prático.
Estou criando com êxito o inventário do EC2 dinamicamente e executando funções nas instâncias criadas para configurar tudo, mas preciso definir um nome de host direto para cada uma. Para esse fim, tenho um arquivo que contém uma lista simples de nomes que quero usar para os nomes de host. Isso está no meu manual:
---
- hosts: localhost
connection: local
gather_facts: false
tasks:
- name: Provision a set of instances
ec2:
key_name: ubuntu
instance_type: t2.micro
image: "{{ ami_id }}"
wait: true
exact_count: {{ server_count }}
count_tag:
Name: Tutorial
instance_tags:
Name: Tutorial
groups: ['SSH', 'Web']
register: ec2
- name: Add all instance public IPs to host group
add_host: hostname={{ item.public_ip }} groups=ec2hosts
loop: "{{ ec2.instances }}"
- name: Set a host name for each instance in DNS
route53:
zone: {{ tutorial_domain }}
record: "name.{{ tutorial_domain }}"
state: present
type: A
ttl: 120
value: {{ item.public_ip }}
wait: yes
loop: "{{ ec2.instances }}"
Realmente se resume a essa record: "name.{{ tutorial_domain }}"linha - como posso procurar um nome na minha lista de nomes e usá-lo como um nome de host, transformando -se nameem {{ some_dynamic_name }}?
Eu vi os plugins de pesquisa, mas todos eles parecem estar focados em fazer um loop sobre todo o conteúdo de algum arquivo externo - mas eu já estou fazendo um loop na lista de servidores, e essa lista pode ser menor que a lista de nomes (por exemplo, Eu posso ter apenas 10 servidores). Idealmente, eu quero ler a lista de nomes em uma matriz uma vez e usar o índice do loop do servidor para escolher o nome (ou seja, para que o 3º servidor obtenha o 3º nome). Como faço isso no ansible? Ou existe uma abordagem melhor?
O tipo de registro DNS de autorização de autoridade de certificação (CAA) inclui um issueparâmetro (também issuewild) que designa um identificador para uma autoridade de certificação com permissão para emitir certificados para seu domínio. Tudo bem, mas é um pouco vago.
Ao definir o valor em seus próprios registros de CAA, como você deve descobrir qual deve ser o valor exato para sua(s) CA(s)? No caso de letsencrypt, eles fornecem um documento aqui que menciona que seu identificador de problema é letsencrypt.org, e que também está documentado na seção 4.2.1 da Declaração de Prática de Certificação . Se eu inspecionar o certificado, posso ver vários campos nele, no entanto, nenhum corresponde exatamente a essa string, embora existam alguns que a contenham . Isso não parece ser uma maneira rigorosa ou confiável de garantir que o CA corresponda ao que está no registro do CAA - por exemplo, o que impede que ele seja correspondido letsencrypt.org.evilcorp.com?
Tudo isso é viável de uma perspectiva humana, mas não é muito legível por máquina e é exclusivo desta CA.
Eu também tenho certificados da Comodo, e encontrei várias fontes não autorizadas dizendo que o ID do problema do CAA é comodoca.com(e outros dizendo que é comodo.com), mas não encontrei um documento oficial como o letsencrypt para isso. A comodoca.comstring aparece em alguns campos do meu certificado, mas não em um contexto que eu esperaria que fosse encontrada de forma confiável - por exemplo, o nome do emissor é COMODO ECC Domain Validation Secure Server CA (COMODO CA Limited from GB), a CRL é http://crl.comodoca.com/COMODOECCDomainValidationSecureServerCA.crle o OCSP URI é http://ocsp.comodoca.com.
SSLMate tem um gerador de registro CAA e inclui uma lista de CAs e seus IDs de emissor - mas de onde essas informações foram obtidas?
Agora considere o caso de validação - dado um certificado e um ou mais IDs de emissor de CAA, quais elementos no certificado devemos esperar que correspondam exatamente ao emissor de CAA? Ou essa informação é obtida de algum outro serviço, como um log de CT?
Então, em suma, de onde os IDs do emissor da CAA devem ser obtidos e como eles devem ser validados de forma confiável?
Eu tenho uma configuração nginx que inclui um cabeçalho CSP que é servido para todas as solicitações. Agora preciso substituí-lo em um local específico (que também é reescrito). Estou pensando algo assim:
server {
listen 80;
listen [::]:80;
server_name example.com;
root /var/www;
index index.php;
try_files $uri @rewrites;
add_header Content-Security-Policy "default-src 'self' ; script-src 'self' ; style-src 'self' 'unsafe-inline' ; img-src * 'self' data: ; font-src 'self' ; media-src * 'self' ; form-action 'self'";
location @rewrites {
rewrite ^/special/([0-9]*) /special.php?id=$1 last;
rewrite ^/foo/([a-z]+) /foo.php?method=$1 last;
}
location /special {
add_header Content-Security-Policy "default-src 'self' ; script-src 'self' 'unsafe-inline' ; style-src 'self' 'unsafe-inline' ; img-src * 'self' data: ; font-src 'self' ; media-src * 'self' ; form-action 'self'";
}
location ~ \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+?\.php)(/.*)$;
include fastcgi_params;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_pass php;
}
}
No entanto, embora isso defina o cabeçalho em qualquer solicitação que comece com /special, isso resulta em um 404 porque não continua no local a seguir que mapeia arquivos PHP. Como devo fazer isso?
Estou tentando obter algumas coisas muito básicas trabalhando com Ansible 2.1.1.0 no OS X.
Meus alvos são todos Ubuntu 16.04, então a primeira coisa que tenho que fazer é instalar o python2.7, pois sem isso nem o 'ping' funcionará.
Eu tenho um inventário configurado assim em servers:
[dbservers]
192.168.x.x set_hostname=db
[webservers]
[servers:children]
dbservers
webservers
E esta é a minha peça em init.yml:
---
- hosts: servers
gather_facts: False
become: yes
tasks:
- name: apt-get update
raw: /usr/bin/apt-get update -qq
- name: Install python 2.7
raw: test -e /usr/bin/python || /usr/bin/apt-get install -q -y python2.7 python-simplejson
Eu verifico se está selecionando os hosts corretos especificando o dbserversgrupo, que é um subconjunto de servers(existe apenas 1 de qualquer maneira), que parece certo para mim:
# ansible dbservers -i servers --list-hosts
hosts (1):
192.168.x.x
O comando que estou executando é este:
# ansible dbservers -i servers init.yml
e é aí que recebo o erro ERROR! Missing target hosts. Não entendo como pode ter hosts e nenhum host ao mesmo tempo! O que estou fazendo errado?
O Perfect Forward Secrecy é um aprimoramento importante para as comunicações SSL/TLS, ajudando a impedir que o tráfego SSL capturado seja descriptografado, mesmo que o invasor tenha a chave privada. É bastante fácil de suportar em servidores web, mas também é aplicável a qualquer outro contexto SSL, como em servidores de e-mail para SMTP, POP3 e IMAP.
Isso recentemente (setembro de 2014) veio à tona na Alemanha, onde órgãos de proteção de dados começaram a inspecionar e multar organizações que não suportam PFS em seus servidores de correio, juntamente com vulnerabilidades heartbleed e poodle. O suporte a PFS em navegadores da Web é um tanto irregular, embora todos os principais o suportem - mas estou procurando informações de compatibilidade de PFS em servidores de e-mail e clientes, idealmente algo como os testes de handshake do SSL Labs , mas para servidores de e-mail.
Alguém pode fornecer ou me indicar boas fontes para compatibilidade com PFS do servidor de email?
Para esclarecer, não pretendo interrogar um servidor específico, mas ver os resultados de tais testes em uma ampla gama de servidores diferentes, por exemplo, seria útil saber que o Outlook 2003 não oferece suporte a ECDHE ou que o Android 2 não permite parâmetros DH maiores que 2048 bits (não sei se são verdadeiros, são apenas exemplos). O benefício disso é saber que, se eu optar por desabilitar alguma cifra específica, quais clientes provavelmente afetarão, assim como os testes de laboratórios SSL mostram para clientes da web.
Eu tenho uma definição de servidor nginx com uma correspondência regex, assim:
server_name ~^(?<vhost>[a-z0-9-]+)\.example\.com$;
root /var/www/example/$vhost;
access_log /var/log/nginx/$vhost.example-access.log;
Isso tudo funciona bem, no entanto, este domínio hospeda vários projetos PHP usando fastcgi e PHP-FPM, que recebem valores como este em $_SERVER:
SERVER_NAME => "~^(?<vhost>[a-z0-9-]+)\.example\.com$"
HTTP_HOST => "myhost.example.com"
Como você pode ver, o padrão regex é colocado em SERVER_NAMEvez da string que correspondeu. Isso parece um pouco complicado para mim e também representa um risco de segurança, pois revela detalhes desnecessários (em outras configurações, estou correspondendo a um conjunto específico de nomes em vez de um curinga).
Você pode dizer "use HTTP_HOST em vez de SERVER_NAME" - se fosse tão simples - existem bibliotecas que esperam que SERVER_NAME (sem surpresa) contenha o nome do servidor. Não consigo ver um bom caso de uso para esse comportamento.
Eu vi vários exemplos de configuração para lidar com hosts virtuais IPv4 e IPv6 de pilha dupla no nginx. Muitos sugerem este padrão:
listen 80;
listen [::]:80 ipv6only=on;
Tanto quanto eu posso ver, isso atinge exatamente a mesma coisa que:
listen [::]:80 ipv6only=off;
Por que você usaria o primeiro? A única razão que posso pensar é se você precisar de parâmetros adicionais específicos para cada protocolo, por exemplo, se você quiser apenas definir deferredIPv4.