Segurança de marionetes e topologias de rede

Fundo:

Finalmente, estou reservando algum tempo para ingressar no século XXI e olhar para o Puppet.

Atualmente, controlamos a versão de todas as configurações de servidor em um repositório mantido internamente no escritório. Quando uma atualização precisa ser feita, as alterações são verificadas novamente nos repositórios e enviadas manualmente para a máquina em questão. Isso geralmente significa que o SFTP é transferido para a máquina remota e, em seguida, movendo os arquivos para o local, com as permissões relevantes, de um shell.

Por isso, espero que o Puppet seja uma extensão simples, mas incrível, do que já temos.

Agora, considero o processo que atualmente temos que ser razoavelmente seguro. Supondo que nossa rede interna sempre seja relativamente mais segura do que as redes públicas em nossos datacenters.

• O processo é sempre unidirecional. As mudanças passam de um ambiente seguro para inseguro e nunca o contrário.

• A loja principal está no lugar mais seguro possível. O risco de comprometimento, roubando configurações ou enviando modificações maliciosas, é bastante reduzido.

Questão:

Pelo que entendi do modelo de servidor / cliente Puppet, os clientes pesquisam e obtêm atualizações diretamente do servidor. O tráfego é envolto por SSL, portanto não pode ser interceptado ou falsificado. Mas difere do que atualmente fazemos porque os servidores Puppet precisariam ser hospedados em um local público. Centralmente ou um para cada site de data center que mantemos.

Então, eu estou pensando:

• Estou sendo desnecessariamente paranóico com a mudança de empurrar para puxar?

• Estou sendo desnecessariamente paranóico ao armazenar centralmente todas essas informações em uma rede pública?

• Como os outros mantêm várias redes - servidor separado para cada site?

Atualização 30/07/09:

Eu acho que uma das minhas outras grandes preocupações é colocar, portanto, deve confiar em uma única máquina. O mestre de marionetes seria protegido por firewall, protegido e tal. Porém, mesmo assim, qualquer máquina pública com serviços de escuta tem uma superfície de ataque de um determinado tamanho.

Presumivelmente, se o mestre tiver permissão para atualizar qualquer arquivo em qualquer um dos clientes fantoches, seu comprometimento resultará no comprometimento de todos os seus clientes. Os "reis para o reino", por assim dizer.

• Essa hipótese está correta?

• Existe alguma maneira de mitigar isso?

Como às vezes armazeno senhas em variáveis ​​em meus módulos, para poder implantar aplicativos sem ter que concluir a configuração manualmente, isso significa que não posso decentemente colocar meu repositório de fantoches em um servidor público. Fazer isso significaria que atacar o puppetmaster permitiria obter algumas senhas de aplicativos ou db de todos os nossos aplicativos diferentes em todos os nossos servidores.

Portanto, meu puppetmaster está na rede privada de nosso escritório e não executo o puppetd daemon nos servidores. Quando preciso implantar, uso o ssh da rede privada para os servidores, criando um túnel e chamando remotamente o puppetd.
O truque não é configurar o túnel remoto e o cliente fantoche para conectar-se ao puppetmaster, mas a um proxy que aceite conexão http e possa alcançar o servidor puppetmaster em rede privada. Caso contrário, o fantoche se recusará a receber por causa do conflito do nome do host com os certificados

# From a machine inside privatenet.net :
ssh -R 3128:httpconnectproxy.privatenet.net:3128 \
    -t remoteclient.publicnetwork.net \
    sudo /usr/sbin/puppetd --server puppetmaster.privatenet.net \
    --http_proxy_host localhost --http_proxy_port 3128 \
    --waitforcert 60 --test –-verbose

Funciona para mim, espero que ajude você

Temos dois sites, nosso escritório e nosso colo. Cada site tem seu próprio mestre de marionetes. Montamos um repositório svn com a seguinte estrutura:

root/office
root/office/manifests/site.pp
root/office/modules
root/colo
root/colo/manifests/site.pp
root/colo/modules
root/modules

O diretório modules em cada site é um diretório svn: externals de volta ao diretório modules de nível superior. Isso significa que eles compartilham exatamente o mesmo diretório de módulos. Depois, garantimos que a grande maioria das classes que escrevemos esteja no diretório modules e seja usada pelos dois sites. Isso tem a boa vantagem de nos forçar a pensar genericamente e não vincular uma classe a um site específico.

Quanto à segurança, hospedamos nosso puppetmaster (e o restante de nossa rede) atrás do firewall, por isso não estamos preocupados em armazenar a configuração centralmente. O puppetmaster envia apenas a configuração para os hosts em que confia. Obviamente, você precisa manter esse servidor seguro.

Não posso julgar a necessidade da sua paranóia, pois depende muito do seu ambiente. No entanto, posso dizer com confiança que os dois pontos principais da sua configuração existente ainda podem ser aplicados. Você pode garantir a mudança de um ambiente seguro (o repositório em seu escritório) para um ambiente menos seguro, onde quer que seu puppetmaster esteja localizado. Você altera o processo de SFTP'ing para vários servidores e coloca manualmente os arquivos no lugar para SFTP'ing no seu puppetmaster e permite que o Puppet distribua os arquivos e os coloque no local correto. Sua loja principal ainda é o repositório e seus riscos são atenuados.

Não acredito que empurrar ou puxar são inerentemente mais seguros que o outro modelo. O Puppet faz um ótimo trabalho ao proteger as configurações em trânsito, além de autenticar o cliente e o servidor para garantir que haja uma confiança bidirecional.

Quanto às várias redes - lidamos com isso com um mestre de marionetes "mestre" central, com mestres de marionetes por satélite em cada local, atuando como clientes do mestre central.

Uma abordagem de design é ter um puppetmaster local em cada site de sistemas e usar uma ferramenta de implantação para fazer alterações nos puppetmasters. (Usar o git com ganchos do git também pode funcionar).

Isso preservaria sua preocupação com os serviços de escuta em uma rede pública, pois o tráfego da rede fantoche seria apenas interno.

Também é possível enviar os manifestos para cada servidor e fazer com que o cliente fantoche analise os manifestos e aplique as configurações relevantes.

embora você diga "externo", duvido muito que pessoas arbitrárias precisem se conectar ao seu mestre de marionetes. você sempre pode jogar uma VPN na mistura. um amigo meu me perguntou uma vez "você precisa se preocupar com a segurança do protocolo se a conexão é segura?" embora eu não concorde com essa atitude, uma camada extra nunca dói e certamente faz maravilhas em minha paranóia pessoal. além disso, é divertido escavar túneis.

Mark Burgess, autor de cfengine e professor universitário (ao qual o boneco parece dever sua herança) escreveu muito sobre empurrar e puxar. Ele afirma que puxar é inerentemente mais seguro. Se você olhar para o site cfengine, eles tiveram apenas um incidente de segurança de rede em 17 anos. Burgess afirma que é por causa do design pull. Eu acho que um único ponto de compromisso é inevitável. Eu ficaria mais preocupado com as rotas de ataque até esse ponto.

Você pode executar fantoches sem um mestre central, se quiser. Um método que eu já vi é usar um repositório git e ter scripts que somente irão mesclar e implantar uma atualização se a tag for assinada por uma de uma lista predefinida de chaves gpg. As pessoas até descobriram como obter configurações armazenadas (usadas para, por exemplo, configurar o monitoramento do nagios em um servidor central a partir de um recurso processado em outro servidor).

Portanto, se o servidor central do git estivesse comprometido, os outros servidores não aplicariam mais atualizações. As chaves gpg estariam em laptops sys admin ou algo assim, junto com alguma maneira de revogar chaves.

Leia mais em http://current.workingdirectory.net/posts/2011/puppet-without-masters/