From 1fc571e228fd4d483fa82c74c6ea059c7adbfde7 Mon Sep 17 00:00:00 2001 From: Manuel Traut Date: Sat, 21 Nov 2009 19:13:19 +0100 Subject: Auth: fixed Authentication handling - on server side, iterate through registrated auth plugins for any request - auth pg sql plugin, moved parts of old rmi based code, to new corba layout - remove of plugins not implemented yet - changing user details not implemented yet Signed-off-by: Manuel Traut --- src/YalpAuth/YalpPGSqlAuth/PGSqlAuth.java | 118 ++++++++++++ src/YalpAuth/YalpPGSqlAuth/YalpAuthPluginImpl.java | 209 +++++++++++++++++++++ src/YalpAuth/YalpPGSqlAuth/YalpPGSqlAuth.java | 1 + src/YalpServer/AuthPlugin.java | 30 +++ src/YalpServer/AuthPluginHandler.java | 58 ++++++ src/YalpServer/InitServer.java | 1 + src/YalpServer/ServerControlImpl.java | 138 ++++++++------ src/yalp.idl | 2 +- 8 files changed, 499 insertions(+), 58 deletions(-) create mode 100644 src/YalpAuth/YalpPGSqlAuth/PGSqlAuth.java create mode 100644 src/YalpAuth/YalpPGSqlAuth/YalpAuthPluginImpl.java create mode 100644 src/YalpServer/AuthPlugin.java create mode 100644 src/YalpServer/AuthPluginHandler.java diff --git a/src/YalpAuth/YalpPGSqlAuth/PGSqlAuth.java b/src/YalpAuth/YalpPGSqlAuth/PGSqlAuth.java new file mode 100644 index 0000000..ba88ad4 --- /dev/null +++ b/src/YalpAuth/YalpPGSqlAuth/PGSqlAuth.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2009 Manuel Traut and Volker Dahnke + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Common Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/cpl-v10.html + * + * Contributors: Manuel Traut and Volker Dahnke + */ + +package YalpAuth.YalpPGSqlAuth; + +import YalpInterfaces.*; + +import org.omg.CosNaming.*; +import org.omg.CosNaming.NamingContextPackage.*; +import org.omg.CORBA.*; +import org.omg.PortableServer.*; +import org.omg.PortableServer.POA; + +/* + * Class PGSqlAuth + * + * Postgre SQL database connection + * + * @author Volker Dahnke / Manuel Traut + * + * @version 2.1 2009-11-21
+ */ +public class PGSqlAuth { + + private static ORB orb; + private static POA poa; + private static YalpAuthPluginImpl psql; + private static AuthPluginInterface authPlugin; + private static ServerControlInterface srvCon; + private static PluginInfo pluginInfo; + + public PGSqlAuth(String[] argv) { + + pluginInfo = new PluginInfo(); + pluginInfo.name = "Postgre SQL Auth Plugin"; + pluginInfo.description = "provides Postgre SQL database based user authentification"; + pluginInfo.type = PluginType.AUTH_PLUGIN; + // pluginInfo.supportedTypes = new MediaType[]; + + try { + this.orb = ORB.init(argv, null); + org.omg.CORBA.Object objRef = + orb.resolve_initial_references("NameService"); + NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef); + poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); + } catch(Exception e) { + /* t.b.d. error handling */ + System.out.println("couldn't host plugin implementation"); + } + + try { + poa.the_POAManager().activate(); + } catch(org.omg.PortableServer.POAManagerPackage.AdapterInactive e) { + /* t.b.d. error handling */ + System.out.println("poa inactive"); + } + + YalpErrorHolder err = new YalpErrorHolder(); + + try { + org.omg.CORBA.Object objRef = + orb.resolve_initial_references("NameService"); + + NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef); + String name = "YALP_Server"; + srvCon = ServerControlInterfaceHelper.narrow(ncRef.resolve_str(name)); + } catch (Exception e) { + System.out.println("Couldn't connect to YALP Server"); + System.exit(0); + } + + psql = new YalpAuthPluginImpl(); + psql.setORB(orb); + + try { + poa.activate_object(psql); + org.omg.CORBA.Object ref = poa.servant_to_reference(psql); + authPlugin = AuthPluginInterfaceHelper.narrow(ref); + + org.omg.CORBA.Object objRef = + orb.resolve_initial_references("NameService"); + + NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef); + String name = "YALP_Postgre_SQL_Auth"; + NameComponent path[] = ncRef.to_name(name); + ncRef.rebind(path, authPlugin); + + PluginInfoHolder tmp = new PluginInfoHolder(pluginInfo); + srvCon.ping(err); + System.out.println(err.value.descr); + srvCon.registerAuthPlugin(authPlugin, tmp, err ); + pluginInfo = tmp.value; + + if(err.value.code != YalpErrorCode.OK) + { + System.out.println("registring authplugin failed"); + return; + } + + psql.setInfo(pluginInfo); + System.out.println("auth plugin registered"); + + orb.run(); + + } catch (Exception e) { + System.out.println("binding plugin failed 1"); + e.printStackTrace(); + System.exit(0); + } + } +} diff --git a/src/YalpAuth/YalpPGSqlAuth/YalpAuthPluginImpl.java b/src/YalpAuth/YalpPGSqlAuth/YalpAuthPluginImpl.java new file mode 100644 index 0000000..9412f2c --- /dev/null +++ b/src/YalpAuth/YalpPGSqlAuth/YalpAuthPluginImpl.java @@ -0,0 +1,209 @@ +package YalpAuth.YalpPGSqlAuth; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.*; +import java.sql.*; + +import org.omg.CosNaming.*; +import org.omg.CosNaming.NamingContextPackage.*; +import org.omg.CORBA.*; + +import org.apache.log4j.Logger; +import org.apache.log4j.PropertyConfigurator; + +import YalpInterfaces.*; + +public class YalpAuthPluginImpl extends AuthPluginInterfacePOA{ + private String db; + private String dbuser; + private String dbpasswd; + private Statement stat; + private Connection con; + + private PluginInfo pluginInfo; + + private String log4jFile = "log4j_auth_plugin.conf"; + + private static Logger logger = + Logger.getLogger("Yalp.AuthPlugins.PGSqlAuth.YalpAuthPluginImpl"); + + private ORB orb; + +/* + * Constructor establishes connection to Database Server + * + * @param db + * jdbc Connection to database + * @param dbYalpUser + * userName for database + * @param dbPasswd + * password for database + */ + public YalpAuthPluginImpl() + { + PropertyConfigurator.configureAndWatch(log4jFile); + logger.debug("YalpAuthPluginImpl()"); + } + + public void setORB(ORB _orb) + { + orb = _orb; + + /* t.b.d. read from config xml */ + String db = "jdbc:postgresql://localhost:5433/yalp"; + String dbYalpUser = "yalp"; + String dbPasswd = "yalp"; + + try{ + dbuser = dbYalpUser; + dbpasswd = dbPasswd; + Class.forName("org.postgresql.Driver"); + con = DriverManager.getConnection(db,dbuser,dbpasswd); + System.out.println("YalpPGSqlInput: db connection established"); + stat= con.createStatement(); + } catch (SQLException e) { + System.out.println("Exception in PGSqlInput Constructor: "+e); + } catch (ClassNotFoundException e) { + System.out.println("Exception in PGSqlInput Constructor: "+e); + } + } + + public void setInfo(PluginInfo info) + { + logger.debug("interfaceImpl - setInfo(): "+info.id); + pluginInfo = info; + } + +/* + * checks if user exists in yalpYalpUser Database and what rights he has + * + * @param username + * username to check + * @param passwd + * password to check + * + * @return enum privilege level + */ + public void userVerify(String username, String passwd, YalpErrorHolder err, + YalpUserHolder user) + { + + YalpError error = new YalpError ("auth ok", YalpErrorCode.OK, + YalpErrorLevel.ERROR_LEVEL_INFO, "authentication module working"); + + try{ + ResultSet result=stat.executeQuery("select * from \"user\" where \"username\" = '"+username+"' and \"passwd\" = '"+passwd+"';"); + + if (result.next()){ + if (result.getBoolean(5)==true) + { + user.value.level = AccessRights.ADMIN; + err.value = error; + return; + } + else + { + user.value.level = AccessRights.USER; + err.value = error; + return; + } + } + else + { + user.value.level = AccessRights.DENY; + err.value = error; + return; + } + }catch (SQLException e){ + user.value.level = AccessRights.DENY; + error.code = YalpErrorCode.ERROR_SQL; + error.msg = "failed to send auth request to pgsql db"; + error.level = YalpErrorLevel.ERROR_LEVEL_ERROR; + error.descr = e.toString(); + err.value = error; + return; + } + } + +/* + * returns an ArrayList with all yalpYalpUsers and Admins + * + * @return ArrayList + * list with all YalpYalpUsers and Admins + */ + public void getUser(UsersHolder list, YalpErrorHolder err) { + try { + ArrayList resultList =new ArrayList(); + YalpUser actUser = new YalpUser(); + String query = "select * from \"user\"order by \"id\";"; + Statement stat= con.createStatement(); + ResultSet result=stat.executeQuery(query); + + while(result.next()) + { + /* t.b.d. - create YalpUser according to new database design */ + // result.getInt(1),result.getString(2),result.getString(3),result.getString(4),result.getBoolean(5))) + resultList.add( actUser ); + } + YalpUser[] u = new YalpUser[1]; + list = new UsersHolder(resultList.toArray(u)); + } catch (SQLException e) { + YalpError error = new YalpError(); + error.code = YalpErrorCode.ERROR_SQL; + error.descr = e.toString(); + error.level = YalpErrorLevel.ERROR_LEVEL_ERROR; + err = new YalpErrorHolder(error); + } + } + +/* + * submits changes to yalpYalpUserDatabase + * + * @param change + * describes the change to commit + * @return int + * -1 if failed + */ + public void changeUser(YalpUser usr, String passwd, Action todo, + YalpErrorHolder err) { + + /* t.b.d. alter to new db design + try{ + String sql; + switch (todo.type){ + // if updateType is UPDATE + case Action._UPDATE: + sql="update \"user\" set \"username\"='"+usr.name+"', \"passwd\"='"+change.passwd+"', \"realname\"='"+change.realname+"', \"admin\"="+change.admin+" where \"id\"= "+change.id+" ;"; + break; + // if updateType is INSERT INTO + case Action._INSERT: + sql="insert into \"user\" values(nextval('userId'), '"+usr+"','"+change.passwd+"','"+change.realname+"',"+change.admin+");"; + break; + // if updateType is DELETE + case Action._DELETE: + sql="delete from \"user\" where \"id\"= "+change.id+" ;"; + break; + default: + //errorhandling + } + // perform operation on table an return number of updated rows + System.out.println(sql); + return stat.executeUpdate(sql); + }catch(SQLException e){ + System.out.println("Exception in DbConnection.changeYalpUser: "+e); + } + */ + } + + /* + * returns plugin information + * @param PluginInfoHolder info holder for PluginInformation + * @param YalpErrorHolder err holder for error information + */ + public void getInfo(PluginInfoHolder info, YalpErrorHolder err) + { + info = new PluginInfoHolder(pluginInfo); + } +} diff --git a/src/YalpAuth/YalpPGSqlAuth/YalpPGSqlAuth.java b/src/YalpAuth/YalpPGSqlAuth/YalpPGSqlAuth.java index bf9077f..676fe3c 100644 --- a/src/YalpAuth/YalpPGSqlAuth/YalpPGSqlAuth.java +++ b/src/YalpAuth/YalpPGSqlAuth/YalpPGSqlAuth.java @@ -28,5 +28,6 @@ public class YalpPGSqlAuth { public static void main(String[] args) { System.out.println("YalpPGSqlAuth\n"); + PGSqlAuth auth = new PGSqlAuth(args); } } diff --git a/src/YalpServer/AuthPlugin.java b/src/YalpServer/AuthPlugin.java new file mode 100644 index 0000000..4c505e3 --- /dev/null +++ b/src/YalpServer/AuthPlugin.java @@ -0,0 +1,30 @@ +package YalpServer; + +import org.apache.log4j.Logger; +import org.apache.log4j.PropertyConfigurator; + +import YalpInterfaces.*; + +public class AuthPlugin { + + private String log4jFile = "log4j_server.conf"; + + public AuthPluginInterface itf; + public PluginInfo info; + + private static Logger logger = + Logger.getLogger("Yalp.Server.AuthPlugin"); + + public AuthPlugin() { + PropertyConfigurator.configureAndWatch(log4jFile); + logger.debug("AuthPlugin()"); + } + + public AuthPlugin(AuthPluginInterface _itf, PluginInfo _info) { + PropertyConfigurator.configureAndWatch(log4jFile); + logger.debug("AuthPlugin("+_info.name+")"); + info = _info; + itf = _itf; + } + +} diff --git a/src/YalpServer/AuthPluginHandler.java b/src/YalpServer/AuthPluginHandler.java new file mode 100644 index 0000000..1011b69 --- /dev/null +++ b/src/YalpServer/AuthPluginHandler.java @@ -0,0 +1,58 @@ +package YalpServer; + +import java.util.ArrayList; + +import org.apache.log4j.Logger; +import org.apache.log4j.PropertyConfigurator; + +import YalpInterfaces.*; + +public class AuthPluginHandler { + + private ArrayList plugins; + private static int auth_ids = 0; + + private String log4jFile = "log4j_server.conf"; + + private static Logger logger = + Logger.getLogger("Yalp.Server.AuthPluginHandler"); + + public AuthPluginHandler() { + PropertyConfigurator.configureAndWatch(log4jFile); + logger.debug("AuthPluginHandler()"); + plugins = new ArrayList(); + } + + public PluginInfo addPlugin(AuthPlugin plugin) + { + logger.debug("addPlugin("+plugin.info.name+")"); + plugin.info.id = auth_ids++; + plugins.add(plugin); + return plugin.info; + } + + Session logon( String userName, + String password, + String ipAddress, + SessionHolder session, + YalpErrorHolder err ) + { + YalpUserHolder user = new YalpUserHolder(); + PluginInfo[] p = {}; + + for (AuthPlugin plugin : plugins) + { + plugin.itf.userVerify(userName, password, err, user); + if (err.value.code == YalpErrorCode.OK) + { + session.value = new Session (auth_ids++, user.value, ipAddress, p); + return session.value; + } + } + + /* user not accepted return dummy objects (null causes segfault in corba) */ + YalpUser no_user = new YalpUser(-1, "", "", AccessRights.DENY); + Session s = new Session (-1, no_user, "0.0.0.0", p); + return s; + } +} diff --git a/src/YalpServer/InitServer.java b/src/YalpServer/InitServer.java index 387d23a..850c5bc 100755 --- a/src/YalpServer/InitServer.java +++ b/src/YalpServer/InitServer.java @@ -54,6 +54,7 @@ public class InitServer { private static ServerSettings settings = new ServerSettings(); public static InputPluginHandler inputHandler = new InputPluginHandler(); public static OutputPluginHandler outputHandler = new OutputPluginHandler(); + public static AuthPluginHandler authHandler = new AuthPluginHandler(); private ServerControlImpl srvCon; private ServerControlInterface srv; diff --git a/src/YalpServer/ServerControlImpl.java b/src/YalpServer/ServerControlImpl.java index 2470175..f8e4579 100755 --- a/src/YalpServer/ServerControlImpl.java +++ b/src/YalpServer/ServerControlImpl.java @@ -35,34 +35,45 @@ import org.apache.log4j.PropertyConfigurator; * @version 0.6 14-12-2005
* @see client */ -public class ServerControlImpl extends ServerControlInterfacePOA { - +public class ServerControlImpl extends ServerControlInterfacePOA +{ private ORB orb; private InitServer srv; private InputPluginHandler inputHandler; private OutputPluginHandler outputHandler; + private AuthPluginHandler authHandler; + + private ArrayList sessions; + private ArrayList plugin_infos; private String log4jFile = "log4j_server.conf"; private static Logger logger = Logger.getLogger("Yalp.Server.ServerControlImpl"); -public ServerControlImpl() { +public ServerControlImpl() +{ + this.sessions = new ArrayList (); + this.plugin_infos = new ArrayList (); + PropertyConfigurator.configureAndWatch(log4jFile); logger.debug("ServerControlImpl()"); } - public void setORB(ORB _orb) { + public void setORB(ORB _orb) + { logger.debug("setOrb()"); orb = _orb; } - public void init(InitServer _srv) { + public void init(InitServer _srv) + { logger.debug("init()"); srv = _srv; inputHandler = srv.inputHandler; outputHandler = srv.outputHandler; + authHandler = srv.authHandler; } /* @@ -74,40 +85,28 @@ public ServerControlImpl() { * @param session (out) * @param error (out) */ - public void clientLogon( String userName, + public void clientLogon( String name, String password, - String ipAdress, + String ipAddress, SessionHolder session, YalpErrorHolder err ) { logger.debug("clientLogon()"); - /* t.b.d. session managmnet */ - try { - - - System.out.println("logon: "+userName+" - "+ipAdress); - - session.value = new Session(); - session.value.id = 666; - session.value.me = new YalpUser(); - session.value.me.id = 333; - session.value.me.name = userName; - session.value.me.realName = "huhu"; - session.value.me.level = AccessRights.ADMIN; - session.value.ip = "127.0.0.1"; - session.value.availablePlugins = new PluginInfo[0]; - - YalpError error = new YalpError(); - error.code = YalpErrorCode.OK; - error.descr = "no error"; - error.level = YalpErrorLevel.ERROR_LEVEL_DEBUG; - error.msg = ""; - err.value = error; - - } catch (Exception e) { - System.out.println(e.toString()); - } - System.out.println("t.b.d. clientLogon nothing implemented at the moment"); + + YalpError error = new YalpError(); + error.code = YalpErrorCode.OK; + error.descr = "authentication successfull"; + error.msg = "nice isn't it"; + error.level = YalpErrorLevel.ERROR_LEVEL_INFO; + err.value = error; + + session.value = authHandler.logon(name, password, ipAddress, session, err); + + ArrayList all_plugins = new ArrayList(); + + PluginInfo[] t = {}; + session.value.availablePlugins = plugin_infos.toArray(t); + sessions.add(session.value); } /* @@ -116,12 +115,18 @@ public ServerControlImpl() { * @param session * @param error (out) */ - public void clientLogoff( Session bye, YalpErrorHolder err) { + public void clientLogoff( Session bye, YalpErrorHolder err) + { logger.debug("clientLogoff"); - // srv.remClient( bye.ip, bye.me.name ); + YalpError error = new YalpError(); error.code = YalpErrorCode.OK; - err = new YalpErrorHolder(error); + error.descr = "logged out"; + error.msg = "sad isn't it"; + error.level = YalpErrorLevel.ERROR_LEVEL_INFO; + err.value = error; + + sessions.remove(bye); } /* @@ -221,9 +226,8 @@ public ServerControlImpl() { public void registerOutputPlugin( OutputPluginInterface itf, PluginInfoHolder info, YalpErrorHolder err ) { - logger.debug("registerOutputPlugin()"); - /* t.b.d. itf handling */ logger.info("registering output plugin: " + info.value.name ); + OutputPluginInterface outputItf; try { @@ -241,6 +245,7 @@ public ServerControlImpl() { inf = outputHandler.addPlugin( newPlugin ); info.value = inf; + plugin_infos.add( inf ); YalpError error = new YalpError(); error.msg = "plugin registered"; @@ -291,35 +296,32 @@ public ServerControlImpl() { PluginInfoHolder info, YalpErrorHolder err ) { logger.info("registering input plugin: " + info.value.name ); + InputPluginInterface inputItf; + try { inputItf = InputPluginInterfaceHelper.narrow(itf); } catch( Exception e ) { e.printStackTrace(); return; } - logger.debug("create new InputPlugin"); + InputPlugin newPlugin = new InputPlugin(inputItf, info.value); - logger.debug("add new InputPlugin to Handler"); + + PluginInfo inf = new PluginInfo(); + if( newPlugin != null ) - inputHandler.addPlugin( newPlugin ); - logger.debug("error handling"); + inf = inputHandler.addPlugin( newPlugin ); + + info.value = inf; + plugin_infos.add( inf ); + YalpError error = new YalpError(); error.msg = "plugin registered"; error.descr = ""; error.code = YalpErrorCode.OK; error.level = YalpErrorLevel.ERROR_LEVEL_INFO; err.value = error; - PluginInfo inf = new PluginInfo(); - inf.id = 666; - inf.name = info.value.name; - inf.description = info.value.description; - inf.type = info.value.type; - inf.supportedTypes= info.value.supportedTypes; - inf.access = info.value.access; - inf.maxClients = info.value.maxClients; - inf.actClients = info.value.actClients; - info.value = inf; } /* @@ -362,15 +364,37 @@ public ServerControlImpl() { public void registerAuthPlugin( org.omg.CORBA.Object itf, PluginInfoHolder info, YalpErrorHolder err ) { - logger.debug("registerAuthPlugin()"); - /* t.b.d. itf handling */ + logger.info("registering auth plugin: " + info.value.name ); + + AuthPluginInterface authItf; + + try { + authItf = AuthPluginInterfaceHelper.narrow(itf); + } catch( Exception e ) { + e.printStackTrace(); + return; + } + + AuthPlugin newPlugin = new AuthPlugin(authItf, info.value); + + PluginInfo inf = new PluginInfo(); + + if( newPlugin != null ) + inf = authHandler.addPlugin( newPlugin ); + + info.value = inf; + plugin_infos.add (inf); + YalpError error = new YalpError(); + error.msg = "plugin registered"; + error.descr = ""; error.code = YalpErrorCode.OK; - err = new YalpErrorHolder(error); + error.level = YalpErrorLevel.ERROR_LEVEL_INFO; + err.value = error; } /* - * remove input plugin + * remove auth plugin * * @param plugin which should be registered * @param error diff --git a/src/yalp.idl b/src/yalp.idl index 9d87fc2..4c56fbb 100644 --- a/src/yalp.idl +++ b/src/yalp.idl @@ -192,7 +192,7 @@ interface InputPluginInterface { }; /* implemented by UserIdentificationPlugin */ -interface UserIdentificationInterface { +interface AuthPluginInterface { void getInfo(out PluginInfo info, out YalpError err); void userVerify(in string user, in string passwd, out YalpError err, out YalpUser acc); -- cgit v1.2.3