Segurança na execução dos Metodos

Olá pessoal,
meu primeiro post aqui, espero não falar besteira!!! :lol: kkkk

É o seguinte, estou desenvolvendo uma aplicação (Desktop) para 'gerenciar coisas'...
Na verdade é um mini gerenciador de projetos, mas gostaria de desenvolvê-lo de forma bem genérica, servindo para gerenciar
qualquer coisa, com suporte a plugins e tudo mais...

Devido à natureza genérica estou preocupado com a segurança do sistema... Pois de repente algum plugin poderia tentar executar
algum método indesejado e a confusão estaria gerada...

Exemplo: A classe 'Persistense' oferece métodos para persistir um Objeto qualquer (que um plugin poderia querer persistir)...
Porem esta mesma classe tem metodos 'init', 'load', 'save', etc... que deveriam ser de uso exclusivo da classe principal, e não de plugins...
Por isso gostaria de limitar o acesso às mesmas...

Dito isso, surgem algumas dúvidas:
[list]Eu sou paranóico/ tô viajando? :( [/list]
[list]O mais correto seria criar uma política de acesso (como estou fazendo), ou criar métodos de forma que possam ser usados por
qualquer um, sem provocar problemas[/list]
[list]Se for melhor criar a política de acesso, o que acham da forma escolhida (explicada abaixo)[/list]
[list]Ninguém vai querer criar plugins para meu programa, logo, não devo me preocupar?[/list]

//Base para as Classes que desejam segurança
public abstract class Secure {
	private SecureAccess	owner;
	private boolean			granted;

	public Secure(SecureAccess owner) {
		... //inicia
	}

	//O objeto que quer acessar um metodo, passa a si proprio e o metodo que deseja (q eh executado via Reflection)
	public void exec(Object requestor, String method, Object... args) {

		//owner decide se o acesso esta liberado
		if (owner.getAccess(requestor)) {
			this.granted = true;
			//Executa via reflection
		}
		this.granted = false;
	}

	/* Verifica se o acesso está consedido (usado pelos metodos da subclasse)*/
	protected void accessGranted() {
		if (!granted) {
			throw new AccessDeniedException();
		}
	}
}

//Classes 'owner' devem implementar, para decidir sobre o acesso
public interface SecureAccess {
	public boolean getAccess(Object obj);
}

public class Persistense extends Secure {
	public Persistense(SecureAccess owner) {
		super(owner);
		//inicia...
	}

	// Metodo Desprotegido (pode ser acessado por qualquer classe)
	public String getParam(String key) {
		return this.params.get(key);
	}
	// Metodo Desprotegido
	public <P> P getObject(String key) {
	}


	// Metodo Protegido, acessado somente via método 'exec' da super-classe 'Secure' (owner decide quem pode acessar)
	public void init() {
		accessGranted();
		//...
	}
	// Metodo Protegido
	public void reset() {
		accessGranted();
		//...
	}
	// Metodo Protegido
	public void halt() {
		accessGranted();
		//...
	}
}

Bom... Gostaria de saber o que acham... [color=green]Boa solução[/color], [color=red]má solução[/color], [color=orange]furos na logica/ideia/arquitetura...[/color]

Mesmo que não seja necessária tannnnnnnta segurança para um programa 'não crítico', acho que é sempre importante
tentar desenvolver códigos melhores, mais seguros e tudo mais... Para o bem da Programação né... hehe...

Pelo menos foi isso que me levou a criar o tópico, pois achei a idéia/solução interessante
(sem falar que demorou um tempão pra pensar nisso :twisted: )

É isso... Espero ter sido claro... Obrigado desde já galera :P