Como se deve depurar um aplicativo da Web PHP com segurança sem expor segredos aos concorrentes?

Recentemente eu fiz um programa. Eu esqueço de excluir 2 linhas de códigos. Esse erro me custou US $ 800 por dia todos os dias.

Eu estava programando com PHP. Se um visitante usa proxy, ele redireciona para outro lugar. O uso do depurador era impossível porque algum código contém ioncube. Como o programa simplesmente redireciona para outro lugar, não importa o quê, é difícil ver qual parte do código é executada.

Então eu coloquei um monte de informações de depuração em todos os lugares. Eu pensei que vou excluí-los mais tarde de qualquer maneira.

A maneira mais natural de depurar é, naturalmente, colocar as informações de depuração em um arquivo. O problema é que geralmente uso proxy. Então, depois de alterar o programa, geralmente tenho que baixar o arquivo de texto com o filezilla. Muitas vezes, o arquivo de texto não mostra o que acho que deveria mostrar. Finalmente, decidi apenas exibir o erro na web.

Eu considerei ter o modo de depuração. No entanto, tenho medo de esquecer as informações de depuração.

Considerei ter o modo de depuração se o usuário fizer? Debuggingmode = 1 por exemplo. No entanto, fiquei paranóico de que, de alguma forma, meu concorrente possa adivinhar a palavra-chave secreta.

Eu apaguei a maioria das informações de depuração. Esqueço de excluir um e esse só aparece se os usuários usarem proxy do país certo. Acontece que eu não tenho procuração do país certo e não percebi isso. Depois que o programa funciona por 24 horas, enviei o arquivo para o meu domínio principal.

Meu concorrente, usando proxy, vê o código de depuração. Ele copiou a ideia e foi assim que eu perdi US $ 800 por dia.

Em retrospecto, eu realmente tenho dificuldade em ver onde errei. Eu tenho super cuidado. No entanto, aconteceu.

Como se deve depurar um aplicativo da Web PHP com segurança sem expor segredos aos concorrentes?

Eu realmente tenho dificuldade em ver onde errei

O grande erro foi que você reinventou a roda. Em vez de usar mecanismos padrão para o log, você inventou o seu próprio , que exibia as informações na página. Uma estrutura de log prefere armazenar logs em arquivos de log, permitindo que você consulte esses logs posteriormente por SSHing no servidor.

Quanto aos bugs, produzir código sem bugs implica usar técnicas específicas, como prova formal . Dadas as dispendiosas, essas técnicas são apropriadas para aplicações críticas à vida, como aplicações que controlam o tráfego de aeronaves ou ônibus espaciais, mas são um exagero para quase todas as aplicações de negócios.

■ Consulte Eles escrevem as coisas certas na revista Fast Company.
_{O artigo descreve a metodologia usada na NASA, bem como o custo de produção de software dessa maneira.}

■ Consulte Prova de mecanização (Mackenzie 2004).
_{O livro resume o histórico da prova automatizada de software, explicando os prós e os contras dessa prova, bem como os motivos pelos quais não são comumente usados ​​pelas empresas para escrever software confiável.}

Dito isto, existem várias técnicas usadas para aplicativos de negócios para garantir a qualidade do software. Isso inclui, mas não se limita a:

• Revisões de códigos informais,
• Inspeções formais de código,
• Teste,
• Verificação pessoal de código,
• etc.

■ Consulte Código completo (McConnell 2004), Produtividade em programação (Jones 1986a), Eficiência de remoção de defeitos de software (Jones 1996) e O que aprendemos sobre o combate a defeitos (Shull et al. 2002).

Além disso, não esqueça a integração contínua e a entrega contínua. Isso ajuda a reverter automaticamente o aplicativo em produção para uma versão funcional quando um revisado parece ter um problema que foi esquecido durante as revisões de código e os testes de unidade, mas detectado quando o aplicativo foi implantado.

■ Consulte O segredo para a implantação contínua segura (vídeo)
_{Explica quais técnicas foram configuradas no Google para impedir que erros que não pudessem ser encontrados antes da implantação permanecessem por muito tempo na produção. Também descreve pdiffe como foi usado para capturar bugs, incluindo aqueles que não estavam relacionados à camada de apresentação.}

Você nunca deve depurar na produção.

Você sempre deve ter um ambiente de teste idêntico ao ambiente de produção e depurar lá.

Quando você precisar alterar o código no ambiente de teste (como adicionar instruções de depuração), verifique se elas não entram em produção.

Uma configuração profissional geralmente se parece com isso:

Production
   ^
Staging
   ^
Development

As instâncias "Production", "Staging" e "Development" do seu aplicativo devem ser tão idênticas quanto possível, para que um erro que ocorre em "Production" possa ser reproduzido em "Staging" e "Development", mas ainda seja completamente separado de um ao outro para que o que quer que aconteça em um dos casos não afete os outros.

Quando você precisar analisar um problema, faça isso em "Desenvolvimento". Mexa com as instruções de depuração e experimente tudo o que quiser. Quando você encontrou uma solução, aplica essa correção à base de código inalterada em "Armazenamento temporário" e verifica se a correção funciona. Então você promove a correção para "Produção".

Um controle de versão adequado e um sistema de gerenciamento de build podem ajudá-lo com isso.

Isso raramente é feito porque o esforço não vale a pena. Mesmo se você perder US $ 800 por dia, o esforço de provar um programa correto rapidamente se torna maior do que isso, o que implica que não há nenhum argumento comercial para fazê-lo.

Se sendo certo é pena que muito (por exemplo, para software Space Shuttle ou controle de mísseis), então você executar a verificação formal, testes exaustivos de todas as entradas possíveis, etc. Concedido, é também extremamente difícil , assim como lento e caro. Mas projetos com orçamentos de bilhões de dólares também tendem a ter pessoas extremamente brilhantes neles. (Ou talvez eles apenas costumavam - as manchetes atuais parecem contradizer essa regra.)

Às vezes, você precisa depurar um sistema ativo. Sim, você deve ter uma cópia de desenvolvimento ou de teste. Mas sempre haverá diferenças. Isso é especialmente verdade se o código estiver acabando no hardware do cliente. Ou, potencialmente, muitas instalações de clientes diferentes.

Eu usei a técnica & debugging = 1 no passado. Eu suspeito que a maioria dos desenvolvedores de PHP tem. Isso ativou uma opção no código que habilitou a depuração mais detalhada no aplicativo. Essas informações geralmente são despejadas em um arquivo de log - geralmente no log do apache (usando error_log ()). Mas você também pode produzi-lo. Nosso criador de perfil, por exemplo, reunia informações e depois apresentava os vários benchmarks na parte inferior da página. Você também pode enviar as informações de depuração como um comentário HTML ou em um elemento oculto que só pode ser visualizado se você visualizar a fonte da página.

Se o seu site tiver 'usuários', você poderá limitar a depuração apenas a um usuário específico. Dessa forma, se alguém tentar ativar a depuração, ele ainda não funcionará, a menos que esteja conectado como usuário.

Agora, você mencionou que estava usando o FileZilla para se conectar ao servidor. Um desenvolvedor realmente deve ter acesso SSH ao servidor. Isso tornará a depuração muito mais fácil para você. Por exemplo, se você produzir suas instruções de depuração no log de erros do Apache, por exemplo, poderá facilmente saudar esse arquivo pelo seu endereço IP e ver as informações de depuração geradas pela sua última solicitação de página.

Todo mundo já cobriu o caso geral:

Validação formal (/ Código comprovado): Não é viável para programas do mundo real, embora exista um kernal do sistema operacional de 4000 linhas, formalmente comprovado.

Teste de CI << Teste automatizado << Teste : certifique-se de usar uma ferramenta de cobertura para verificar se seus casos de teste têm 100% de cobertura.

Para o seu caso específico de deixar o código de depuração em produção, tenho duas opções, ambas as quais exigem que o código-fonte seja recomplicado como parte da implantação em um novo ambiente (teste de teste / teste final).

1. Remova-o em tempo de compilação. Embrulhe o código de depuração em estruturas como C # e C #ifdef DEBUGpara verificar o destino da compilação (depuração ou versão) e removê-los automaticamente em tempo de compilação.

2. Sinalize no momento da implantação. Coloque um comentário próximo ao código que não deve ser executado no ambiente real. Por exemplo //TODO: Remove This Before Deployment, quando for migrado (implantado) para o armazenamento temporário, antes de compilar o código, execute-o através de um script simples que verifique se não há comentários de sinalizador (por exemplo //TODO:) deixados no código-fonte.

Sugiro o primeiro para se for de longo prazo e você o desejará novamente (por exemplo, modo de registro detalhado), e o posterior se for um hack rápido enquanto você estava depurando (por exemplo, vários printfs espalhados pelo seu código)

Como outros já disseram antes de mim, muitos testes (unitários e funcionais), se possível automatizados e com boa cobertura de código, são a chave para ter um software livre de erros.

Se eu entender bem a descrição do seu problema, as informações de depuração serão mostradas na página veiculada pelo seu servidor. Se for esse o caso, considere colocar essas informações em logs adequados no seu servidor. Dessa forma, nunca será mostrado ao usuário final, mesmo se você implantar uma versão 'detalhada' na produção. Isso é bom para fazer qualquer que seja o projeto no qual você esteja trabalhando, a menos que você tenha boas razões para fazer o contrário.

O que os outros dizem sobre a depuração na produção é correto. Mas eu já fiz algumas vezes de qualquer maneira. E acho que existem maneiras mais seguras de fazer isso do que a sua, embora nada seja infalível.

Eu não preciso de tanta segurança, apenas não quero que os usuários vejam um monte de bobagens em suas telas.

$debug = true;
$allowed_ips = array('192.168.0.220','173.46.89.255'); // limit to your own ip's. If your competitor knows them, though, he can spoof it! But if your stuff is not top secret, it's ok. 

if(!in_array($_SERVER['REMOTE_ADDR'],$allowed_ips) ) {
  $debug = false;
}

if($debug) {
  echo '<pre>' . print_r($some_variable) . '</pre>';
}

Agora, os usuários não verão sua depuração, a menos que realmente desejem. Se seus US $ 800 / dia dependerem de manter essas informações em sigilo, não use o código acima . Mas se as informações não forem tão sensíveis, as opções acima serão muito melhores do que depender de uma variável GET ou revelar seus segredos para um país inteiro.

Como alternativa, você pode criar uma debugclasse ou função que verifique se a impressão é permitida ou não com base em seus critérios. Isto é o que eu faço.

Algo assim:

class debug {
  public $on = false;
  public static function print($variable) {
    if($on) {
      echo '<pre>' . print_r($some_variable) . '</pre>';
    }
  }
}

debug::print($some_variable); // class checks if printing is allowed. If not, no printing occurs.

Para o meu programa que me custará US $ 800 / dia (em desenvolvimento), uso o apache mod auth para exigir uma senha para acessar qualquer parte do site, além de restringir as informações de depuração para determinados IPs. Sua pergunta me faz pensar que eu deveria procurar uma segurança melhor.

Na verdade, eu teria duas validações extras aqui. Um é o &debug=1parâmetro na solicitação. Você também pode usar alguma variável de sessão especial ou configuração de cookie que somente você pode ativar através de uma chamada para uma página "secreta" (de preferência com autenticação).

A segunda validação seria ter no arquivo de configuração, uma matriz com um intervalo de IPs e apenas chamadas de um IP nessa matriz podem acionar a funcionalidade de depuração. algo como

Na configuração:

$debugAllowedIPs = array('127.0.0.1', '192.168.0.1', /* add more IPs here */);

Tenha o seguinte método em algum lugar onde ele possa ser acessado globalmente:

function getClientIp() {
    if (!empty($_SERVER['HTTP_CLIENT_IP']))  return $_SERVER['HTTP_CLIENT_IP'];
    if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) return $_SERVER['HTTP_X_FORWARDED_FOR'];
    return $_SERVER['REMOTE_ADDR'];
}

E no seu código chame algo como:

if (in_array(getClientIp(), $debugAllowedIPs)) { /* show debug info here */ }

Lembre-se de que o código no getClientIp()método não é seguro, pois o valor de $_SERVER['HTTP_X_FORWARDED_FOR']é facilmente falsificado; no entanto, ele deve servir ao propósito de esclarecer a questão.