Por que precisamos de segurança no nível do método?

No mundo real, por que precisamos implementar a segurança no nível do método?

Temos um aplicativo da Web ou um aplicativo de desktop, onde o usuário acessa a interface do usuário (e, portanto, diretamente não pode acessar o método).

Então, onde os métodos de acesso entram diretamente em cena aqui?

edit: faço essa pergunta porque estou experimentando a segurança da primavera e vejo autorizar os usuários a acessar métodos.

algo como :

 @ROLE_ADMIN
public void update() {
      //update
}

Em um aplicativo projetado corretamente, o back-end e o front-end são desconectados. O sistema de segurança de back-end não pode assumir que nenhum front-end específico lide com segurança corretamente, portanto, ele tem que lidar com ele próprio.

Presumo que você esteja falando sobre o acesso baseado em função a ações em um controlador. Ou seja, em uma arquitetura MVC, cada método em uma Controllerclasse é uma ação separada. A maioria das estruturas MVC que usei me permitem atribuir privilégios no nível do método e no nível da classe. Isso significaria que eu posso aplicar um atributo / anotação no nível da classe e a função correspondente seria necessária para cada ação nesse controlador.

Em relação ao controle mais refinado para acesso baseado em função, considere o seguinte:

• É conveniente agrupar todas as ações em torno de um recurso. Ou seja, suas ações Criar / Ler / Atualizar / Excluir (CRUD) para artigos, contas etc. Isso facilita a gravação e a manutenção de APIs no estilo REST.
• Muitos sistemas têm credenciais / funções diferentes necessárias para as ações Criar / Atualizar / Excluir do que para as ações de Leitura.
• Se todas as ações da conta do usuário estiverem em um controlador, você deseja permitir que qualquer pessoa efetue login, mas apenas certas pessoas criam novas contas ou atribuem funções.

Goste ou não, quando o Ruby on Rails chegou ao ar alguns anos atrás, praticamente todas as estruturas MVC copiaram sua abordagem de design fundamental. Costumava ser que as ações eram classes separadas, mas a lógica da ação tende a ser pequena e focada, de modo que uma sobrecarga total da classe é um exagero. Mapear um método em um controlador para a ação de uma página realmente fazia muito sentido. Saiba apenas que muitas pessoas precisam de um controle refinado sobre quais funções podem desempenhar quais funções.

A segurança no nível do método é útil por dois motivos principais:

• como outra camada de segurança (além de outras camadas)

• nos casos em que é mais conveniente ou lógico ter permissões no nível do método, considere um caso em que diferentes usuários possam executar as mesmas ações "diretas" (para que a segurança do cliente não seja relevante). mas, em alguns casos, a ação deles pode desencadear um comportamento que você deseja limitar - nesse caso, a segurança no nível do método pode ser uma solução relevante.

Mike Wiesner lembrou nesta apresentação do SpringSource, Introduction to Spring Security 3 / 3.1 , que trouxe o exemplo de que o Tomcat e muitos outros contêineres de Servlets tinham um bug que falha ao reconhecer corretamente "../", quando codificado em unicode, de uma maneira que um teste simples de igual falharia em Java, mas seria traduzido para o diretório superior do sistema de arquivos.

A segurança é difícil, vários níveis de segurança aumentam as chances de bloquear tentativas de evasão. Como a segurança no nível do método é codificada diretamente dentro da classe, após o aumento da AOP, quando você chama o método, sempre chama a verificação de segurança antes.

Presumo que você esteja falando de métodos públicos, privados e protegidos aqui?

Nesse caso, eles não existem para fins de segurança. Eles existem com o objetivo de facilitar a garantia de que o software seja modularizado adequadamente. (Se eles terão sucesso nesse debate, deixarei para os outros. Essa é, no entanto, a visão do que eles servem.)

Suponha que eu forneça uma biblioteca e, em seguida, esteja livre para entregar uma versão diferente da biblioteca e alterar as coisas marcadas como privadas, tanto quanto eu quiser. Por outro lado, se eu não tivesse marcado essas coisas como privadas, seria incapaz de alterar quaisquer componentes internos do meu software porque alguém, em algum lugar, provavelmente está acessando diretamente. Claro, em teoria, a culpa é deles por não usar a API documentada. Mas o cliente perceberá como minha culpa que minha atualização de software quebrou o software deles. Eles não querem desculpas, querem consertar. Mas se eu não permitir que eles tenham acesso, minha API é exatamente o método público que eu pretendia ser minha API e o problema é evitado.

A segunda coisa mais provável sobre a qual você poderia estar falando é o modelo de segurança do Java. Se você está falando sobre isso, o motivo é que a visão original para Java envolvia pessoas enviando applets possivelmente não confiáveis ​​para trabalhar interativamente dentro de programas de terceiros (por exemplo, navegadores). Portanto, o modelo de segurança foi criado para oferecer aos usuários alguma proteção contra miniaplicativos maliciosos. Portanto, a ameaça de segurança com a qual se preocupar e se proteger são applets não confiáveis ​​que tentam interagir com outro software que pode ser carregado.