@Override
public void checkAccess(ThreadGroup g) {
if (!isSecutityOn) {
return;
}
Thread c = Thread.currentThread();
if (isSafeThread(c)) {
return;
}
super.checkAccess(g);
final ThreadGroup cg = c.getThreadGroup();
if (cg == null) {
// What the heck is going on here? JDK 1.3 is sending me a dead thread.
// This crashes the entire jvm if I don't return here.
return;
}
IHostedThread robotProxy = threadManager.getLoadedOrLoadingRobotProxy(c);
if (robotProxy == null) {
throw new AccessControlException(
"Preventing " + c.getName() + " from access to " + g.getName());
}
if (cg.activeCount() > 5) {
String message = "Robots are only allowed to create up to 5 threads!";
robotProxy.punishSecurityViolation(message);
throw new AccessControlException(message);
}
}
@Override
public void checkAccess(Thread t) {
if (!isSecutityOn) {
return;
}
Thread c = Thread.currentThread();
if (isSafeThread(c)) {
return;
}
super.checkAccess(t);
// Threads belonging to other thread groups is not allowed to access threads belonging to other
// thread groups
// Bug fix [3021140] Possible for robot to kill other robot threads.
// In the following the thread group of the current thread must be in the thread group hierarchy
// of the
// attacker thread; otherwise an AccessControlException must be thrown.
boolean found = false;
ThreadGroup cg = c.getThreadGroup();
ThreadGroup tg = t.getThreadGroup();
while (tg != null) {
if (tg == cg) {
found = true;
break;
}
try {
tg = tg.getParent();
} catch (AccessControlException e) {
// We expect an AccessControlException due to missing RuntimePermission modifyThreadGroup
break;
}
}
if (!found) {
String message = "Preventing " + c.getName() + " from access to " + t.getName();
IHostedThread robotProxy = threadManager.getLoadedOrLoadingRobotProxy(c);
if (robotProxy != null) {
robotProxy.punishSecurityViolation(message);
}
throw new AccessControlException(message);
}
}
@Override
public void checkAccess(final ThreadGroup pG) {
if (finalSecurityManager != null) finalSecurityManager.checkAccess(pG);
}
@Override
public void checkAccess(final ThreadGroup g) {
if (securityManager != null) securityManager.checkAccess(g);
}
@Override
public void checkAccess(final Thread t) {
// it's still possible to kill us with Thread.currentThread().interrupt()
// but I don't know how to restrict thread access to this kind of operations only
if (securityManager != null) securityManager.checkAccess(t);
}
/**
* Determines if the currently running thread has permission to modify this thread group.
*
* <p>If there is a security manager, its <code>checkAccess</code> method is called with this
* thread group as its argument. This may result in throwing a <code>SecurityException</code>.
*
* @exception SecurityException if the current thread is not allowed to access this thread group.
* @see java.lang.SecurityManager#checkAccess(java.lang.ThreadGroup)
* @since JDK1.0
*/
public final void checkAccess() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkAccess(this);
}
}