Changeset 32369

Show
Ignore:
Timestamp:
23.08.2018 13:57:26 (14 months ago)
Author:
kjdon
Message:

lots of changes. moved to version 2 of recaptcha. moved all the error strings into the servicerack.properties file. fixed up the bug whereby a user changes his own account details, then was being shown the full user list.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/service/Authentication.java

    r28966 r32369  
    1111import java.util.regex.Pattern; 
    1212 
    13 import net.tanesha.recaptcha.ReCaptchaImpl; 
    14 import net.tanesha.recaptcha.ReCaptchaResponse; 
     13// for verifying recaptcha 
     14import java.io.BufferedReader; 
     15import java.io.DataOutputStream; 
     16import java.io.IOException; 
     17import java.io.InputStreamReader; 
     18import java.io.StringReader; 
     19import java.net.URL; 
     20import javax.net.ssl.HttpsURLConnection; 
     21// https://developer.android.com/reference/org/json/JSONObject.html 
     22// https://developer.android.com/reference/org/json/JSONArray.html 
     23import org.json.JSONArray; 
     24import org.json.JSONException; 
     25import org.json.JSONObject; 
    1526 
    1627import org.apache.commons.codec.digest.DigestUtils; 
     
    3647    //Error codes 
    3748    protected static final int NO_ERROR = 0; 
    38     protected static final int ERROR_REQUEST_HAS_NO_PARAM_LIST = -1; 
    3949    protected static final int ERROR_NOT_LOGGED_IN = -2; 
    4050    protected static final int ERROR_ADMIN_NOT_LOGGED_IN = -3; 
    4151    protected static final int ERROR_COULD_NOT_GET_USER_INFO = -4; 
    4252    protected static final int ERROR_USERNAME_NOT_SPECIFIED = -5; 
    43     protected static final int ERROR_REQUESTED_USER_NOT_FOUND = -6; 
     53    protected static final int ERROR_USER_NOT_FOUND = -6; 
    4454    protected static final int ERROR_SQL_EXCEPTION = -7; 
    4555    protected static final int ERROR_INVALID_USERNAME = -8; 
     
    5262    protected static final int ERROR_ADDING_USER = -15; 
    5363    protected static final int ERROR_REMOVING_USER = -16; 
    54     protected static final int ERROR_CAPTCHA_DOES_NOT_MATCH = -17; 
     64    protected static final int ERROR_CAPTCHA_FAILED = -17; 
    5565    protected static final int ERROR_CAPTCHA_MISSING = -18; 
    5666    protected static final int ERROR_NOT_AUTHORISED = -19; 
    57  
    58     protected static final HashMap<Integer, String> _errorMessageMap; 
     67    protected static final int ERROR_MISSING_PARAMS = -20; 
     68   
     69    protected static final HashMap<Integer, String> _errorKeyMap; 
    5970    static 
    6071    { 
    61         //Corresponding error messages 
    62         HashMap<Integer, String> errorMessageMap = new HashMap<Integer, String>(); 
    63         errorMessageMap.put(ERROR_REQUEST_HAS_NO_PARAM_LIST, "The list of parameters for this request was empty."); 
    64         errorMessageMap.put(ERROR_NOT_LOGGED_IN, "You must be logged in to access this page."); 
    65         errorMessageMap.put(ERROR_ADMIN_NOT_LOGGED_IN, "You must be logged in as an administrator to access this page."); 
    66         errorMessageMap.put(ERROR_COULD_NOT_GET_USER_INFO, "There was a error getting the user information."); 
    67         errorMessageMap.put(ERROR_USERNAME_NOT_SPECIFIED, "No username was specified."); 
    68         errorMessageMap.put(ERROR_REQUESTED_USER_NOT_FOUND, "The requested user was not found in the database."); 
    69         errorMessageMap.put(ERROR_SQL_EXCEPTION, "There was an SQL exception while accessing the database."); 
    70         errorMessageMap.put(ERROR_INVALID_USERNAME, "The username specified was invalid."); 
    71         errorMessageMap.put(ERROR_PASSWORD_NOT_ENTERED, "No password was entered."); 
    72         errorMessageMap.put(ERROR_PASSWORD_TOO_SHORT, "The password you entered was too short (minimum of 3 characters)."); 
    73         errorMessageMap.put(ERROR_PASSWORD_TOO_LONG, "The password you entered was too long (maximum of 64 characters)."); 
    74         errorMessageMap.put(ERROR_PASSWORD_USES_ILLEGAL_CHARACTERS, "The password you entered contains illegal characters."); 
    75         errorMessageMap.put(ERROR_INCORRECT_PASSWORD, "The password specified was incorrect."); 
    76         errorMessageMap.put(ERROR_USER_ALREADY_EXISTS, "This user already exists and therefore cannot be added."); 
    77         errorMessageMap.put(ERROR_ADDING_USER, "There was an error adding this user to the database."); 
    78         errorMessageMap.put(ERROR_REMOVING_USER, "There was an error removing this user from the database."); 
    79         errorMessageMap.put(ERROR_CAPTCHA_DOES_NOT_MATCH, "The words you entered did not match the image, please try again."); 
    80         errorMessageMap.put(ERROR_CAPTCHA_MISSING, "The information from the captcha is missing."); 
    81         errorMessageMap.put(ERROR_NOT_AUTHORISED, "You are not authorised to access this page."); 
    82  
    83         _errorMessageMap = errorMessageMap; 
     72        //Corresponding error message keys for looking up in ServiceRack dictionary 
     73        HashMap<Integer, String> errorKeyMap = new HashMap<Integer, String>(); 
     74        errorKeyMap.put(ERROR_NOT_LOGGED_IN, "auth.error.not_logged_in"); 
     75        errorKeyMap.put(ERROR_ADMIN_NOT_LOGGED_IN, "auth.error.admin_not_logged_in"); 
     76        errorKeyMap.put(ERROR_COULD_NOT_GET_USER_INFO, "auth.error.could_not_get_user_info"); 
     77        errorKeyMap.put(ERROR_USERNAME_NOT_SPECIFIED, "auth.error.username_not_specified"); 
     78        errorKeyMap.put(ERROR_USER_NOT_FOUND, "auth.error.user_not_found"); 
     79        errorKeyMap.put(ERROR_SQL_EXCEPTION, "auth.error.sql_exception"); 
     80        errorKeyMap.put(ERROR_INVALID_USERNAME, "auth.error.invalid_username"); 
     81        errorKeyMap.put(ERROR_PASSWORD_NOT_ENTERED, "auth.error.no_password"); 
     82        errorKeyMap.put(ERROR_PASSWORD_TOO_SHORT, "auth.error.password_too_short"); 
     83        errorKeyMap.put(ERROR_PASSWORD_TOO_LONG, "auth.error.password_too_long"); 
     84        errorKeyMap.put(ERROR_PASSWORD_USES_ILLEGAL_CHARACTERS, "auth.error.password_illegal_chars"); 
     85        errorKeyMap.put(ERROR_INCORRECT_PASSWORD, "auth.error.incorrect_password"); 
     86        errorKeyMap.put(ERROR_USER_ALREADY_EXISTS, "auth.error.user_already_exists"); 
     87        errorKeyMap.put(ERROR_ADDING_USER, "auth.error.add_user_error"); 
     88        errorKeyMap.put(ERROR_REMOVING_USER, "auth.error.remove_user_error"); 
     89        errorKeyMap.put(ERROR_CAPTCHA_FAILED, "auth.error.captcha_failed"); 
     90        errorKeyMap.put(ERROR_CAPTCHA_MISSING, "auth.error.captcha_missing"); 
     91        errorKeyMap.put(ERROR_NOT_AUTHORISED, "auth.error.not_authorised"); 
     92        errorKeyMap.put(ERROR_MISSING_PARAMS, "auth.error.missing_params"); // ??? 
     93        _errorKeyMap = errorKeyMap; 
    8494    } 
    8595 
     
    123133 
    124134    //Other operations 
    125     protected static final String REGISTER = "Register"; 
    126     protected static final String PERFORM_REGISTER = "PerformRegister"; 
     135  protected static final String REGISTER = "Register"; // displays the register page 
     136  protected static final String PERFORM_REGISTER = "PerformRegister"; // performs the registration action 
    127137    protected static final String LOGIN = "Login"; 
    128  
     138  protected static final String BLANK = "Info"; // a dummy page just for showing an error message 
    129139    //the services on offer 
    130140    protected static final String AUTHENTICATION_SERVICE = "Authentication"; 
     
    135145    protected static boolean _derbyWrapperDoneForcedShutdown = false; 
    136146 
    137     protected String _recaptchaPrivateKey = null; 
    138     protected String _recaptchaPublicKey = null; 
     147    protected String _recaptchaSiteKey = null; 
     148    protected String _recaptchaSecretKey = null; 
    139149 
    140150    /** constructor */ 
     
    198208        { 
    199209            Element currentElem = (Element) recaptchaElems.item(i); 
    200             if (currentElem.getAttribute(GSXML.NAME_ATT) != null && currentElem.getAttribute(GSXML.NAME_ATT).equals("public_key")) 
     210            if (currentElem.getAttribute(GSXML.NAME_ATT) != null && currentElem.getAttribute(GSXML.NAME_ATT).equals("site_key")) 
    201211            { 
    202212                if (currentElem.getAttribute(GSXML.VALUE_ATT) != null) 
    203213                { 
    204                     _recaptchaPublicKey = currentElem.getAttribute(GSXML.VALUE_ATT); 
    205                 } 
    206             } 
    207             else if (currentElem.getAttribute(GSXML.NAME_ATT) != null && currentElem.getAttribute(GSXML.NAME_ATT).equals("private_key")) 
     214                    _recaptchaSiteKey = currentElem.getAttribute(GSXML.VALUE_ATT); 
     215                } 
     216            } 
     217            else if (currentElem.getAttribute(GSXML.NAME_ATT) != null && currentElem.getAttribute(GSXML.NAME_ATT).equals("secret_key")) 
    208218            { 
    209219                if (currentElem.getAttribute(GSXML.VALUE_ATT) != null) 
    210220                { 
    211                     _recaptchaPrivateKey = currentElem.getAttribute(GSXML.VALUE_ATT); 
     221                    _recaptchaSecretKey = currentElem.getAttribute(GSXML.VALUE_ATT); 
    212222                } 
    213223            } 
     
    269279        return getTextString(service_id + ".description", lang); 
    270280    } 
    271  
     281    protected String getErrorTextString(int error_code, String lang) { 
     282      return getTextString(_errorKeyMap.get(error_code), lang); 
     283       
     284    } 
    272285    protected Element processChangeUserEditMode(Element request) 
    273286    { 
     
    282295        if (paramList == null) 
    283296        { 
    284             GSXML.addError(result, _errorMessageMap.get(ERROR_REQUEST_HAS_NO_PARAM_LIST)); 
    285             return result; 
     297          logger.error("ChangeUserEditMode request has no param list!!"); 
     298          return result; 
    286299        } 
    287300 
     
    384397        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS); 
    385398 
     399        String lang = request.getAttribute(GSXML.LANG_ATT); 
    386400        Element paramList = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER); 
    387401        if (paramList == null) 
    388402        { 
    389             GSXML.addError(result, _errorMessageMap.get(ERROR_REQUEST_HAS_NO_PARAM_LIST)); 
    390             return result; 
     403          logger.error("GetUserInformation request has no param list"); 
     404          return result; 
    391405        } 
    392406 
     
    397411        if (username == null) 
    398412        { 
    399             GSXML.addError(result, _errorMessageMap.get(ERROR_USERNAME_NOT_SPECIFIED)); 
     413            GSXML.addError(result, getErrorTextString(ERROR_USERNAME_NOT_SPECIFIED, lang)); 
    400414            return result; 
    401415        } 
     
    410424        if (terms.size() == 0) 
    411425        { 
    412             GSXML.addError(result, _errorMessageMap.get(ERROR_REQUESTED_USER_NOT_FOUND)); 
     426            GSXML.addError(result, getErrorTextString(ERROR_USER_NOT_FOUND, lang)); 
    413427            return result; 
    414428        } 
     
    461475 
    462476        // Get the parameters of the request 
     477        String lang = request.getAttribute(GSXML.LANG_ATT); 
    463478        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER); 
    464479        if (param_list == null) 
    465480        { 
    466481            serviceNode.setAttribute("operation", LOGIN); 
    467             GSXML.addError(result, _errorMessageMap.get(ERROR_REQUEST_HAS_NO_PARAM_LIST)); 
     482            logger.error("Authentication request has no param list"); 
    468483            return result; // Return the empty result 
    469484        } 
     
    476491 
    477492        Element userInformation = (Element) GSXML.getChildByTagName(request, GSXML.USER_INFORMATION_ELEM); 
    478         if (userInformation == null && _userOpList.contains(op)) 
    479         { 
    480             serviceNode.setAttribute("operation", LOGIN); 
    481             GSXML.addError(result, _errorMessageMap.get(ERROR_NOT_LOGGED_IN)); 
    482             return result; 
    483         } 
    484  
    485493        if (userInformation != null) 
    486494        { 
     
    489497        } 
    490498 
    491         if (username == null && _userOpList.contains(op)) 
    492         { 
     499        if ((userInformation == null || username == null) && _userOpList.contains(op)) 
     500        { 
     501          // its an operation that requires the user to be logged on - direct them to login page 
    493502            serviceNode.setAttribute("operation", LOGIN); 
    494             GSXML.addError(result, _errorMessageMap.get(ERROR_NOT_LOGGED_IN)); 
     503            GSXML.addError(result, getErrorTextString(ERROR_NOT_LOGGED_IN, lang)); 
    495504            return result; 
    496505        } 
     
    498507        if (_adminOpList.contains(op) && (groups == null || !groups.matches(".*\\badministrator\\b.*"))) 
    499508        { 
     509          // actually, the user needs to be an admin user and they are not 
    500510            serviceNode.setAttribute("operation", LOGIN); 
    501             GSXML.addError(result, _errorMessageMap.get(ERROR_ADMIN_NOT_LOGGED_IN)); 
     511            GSXML.addError(result, getErrorTextString(ERROR_ADMIN_NOT_LOGGED_IN, lang)); 
    502512            return result; 
    503513        } 
     
    505515        if (op.equals(LIST_USERS)) 
    506516        { 
    507             int error = addUserInformationToNode(null, serviceNode); 
    508             if (error != NO_ERROR) 
    509             { 
    510                 GSXML.addError(result, _errorMessageMap.get(error)); 
    511             } 
    512         } 
    513         else if (op.equals(PERFORM_ADD)) 
     517          int error = addUserInformationToNode(null, serviceNode); 
     518          if (error != NO_ERROR) 
     519            { 
     520              serviceNode.setAttribute("operation", BLANK); 
     521              GSXML.addError(result, getErrorTextString(error, lang)); 
     522            } 
     523          return result; 
     524           
     525        } 
     526         
     527        if (op.equals(PERFORM_ADD)) 
    514528        { 
    515529            String newUsername = (String) paramMap.get("username"); 
     
    524538            if ((error = checkUsername(newUsername)) != NO_ERROR) 
    525539            { 
    526                 GSXML.addError(result, _errorMessageMap.get(error)); 
     540                GSXML.addError(result, getErrorTextString(error, lang)); 
    527541                return result; 
    528542            } 
     
    531545            if ((error = checkPassword(newPassword)) != NO_ERROR) 
    532546            { 
    533                 GSXML.addError(result, _errorMessageMap.get(error)); 
     547                GSXML.addError(result, getErrorTextString(error, lang)); 
    534548                return result; 
    535549            } 
     
    541555            { 
    542556                serviceNode.setAttribute("operation", ADD_USER); 
    543                 GSXML.addError(result, _errorMessageMap.get(error)); 
     557                GSXML.addError(result, getErrorTextString(error, lang)); 
    544558            } 
    545559            else 
     
    548562                serviceNode.setAttribute("operation", LIST_USERS); 
    549563            } 
    550         } 
    551         else if (op.equals(PERFORM_REGISTER)) 
     564            return result; 
     565        } 
     566         
     567        if (op.equals(PERFORM_REGISTER)) 
    552568        { 
    553569            String newUsername = (String) paramMap.get("username"); 
     
    559575            if ((error = checkUsername(newUsername)) != NO_ERROR) 
    560576            { 
    561                 GSXML.addError(result, _errorMessageMap.get(error)); 
     577                GSXML.addError(result, getErrorTextString(error, lang)); 
    562578                return result; 
    563579            } 
     
    566582            if ((error = checkPassword(newPassword)) != NO_ERROR) 
    567583            { 
    568                 GSXML.addError(result, _errorMessageMap.get(error)); 
     584                GSXML.addError(result, getErrorTextString(error, lang)); 
    569585                return result; 
    570586            } 
     
    572588            newPassword = hashPassword(newPassword); 
    573589 
    574             if (_recaptchaPrivateKey != null && _recaptchaPrivateKey.length() > 0) 
    575             { 
    576                 ReCaptchaImpl reCaptcha = new ReCaptchaImpl(); 
    577                 reCaptcha.setPrivateKey(_recaptchaPrivateKey); 
    578  
    579                 try 
    580                 { 
    581                     //If this line throws an exception then we'll assume the user has a firewall that is too restrictive 
    582                     //(or that they're not connected to the Internet) to allow access to google services. 
    583                     //In this situation we won't use the recaptcha test. 
    584                     reCaptcha.checkAnswer(request.getAttribute("remoteAddress"), "", ""); 
    585  
    586                     String challenge = (String) paramMap.get("recaptcha_challenge_field"); 
    587                     String uResponse = (String) paramMap.get("recaptcha_response_field"); 
    588  
    589                     if (challenge == null || uResponse == null) 
    590                     { 
    591                         serviceNode.setAttribute("operation", REGISTER); 
    592                         GSXML.addError(result, _errorMessageMap.get(ERROR_CAPTCHA_MISSING)); 
    593                         return result; 
    594                     } 
    595  
    596                     ReCaptchaResponse reCaptchaResponse = reCaptcha.checkAnswer(request.getAttribute("remoteAddress"), challenge, uResponse); 
    597  
    598                     if (!reCaptchaResponse.isValid()) 
    599                     { 
    600                         serviceNode.setAttribute("operation", REGISTER); 
    601                         GSXML.addError(result, _errorMessageMap.get(ERROR_CAPTCHA_DOES_NOT_MATCH)); 
    602                         return result; 
    603                     } 
    604                 } 
    605                 catch (Exception ex) 
    606                 { 
    607                 } 
     590            // check the recaptcha 
     591            if (_recaptchaSiteKey != null && _recaptchaSecretKey.length() > 0) { 
     592 
     593              String user_response = (String) paramMap.get("g-recaptcha-response"); 
     594              int recaptcha_error = verifyRecaptcha(_recaptchaSecretKey, user_response); 
     595              if (recaptcha_error != NO_ERROR) { 
     596                serviceNode.setAttribute("operation", REGISTER); 
     597                GSXML.addError(result, getErrorTextString(recaptcha_error, lang)); 
     598                return result; 
     599              } 
    608600            } 
    609601 
     
    612604            { 
    613605                serviceNode.setAttribute("operation", REGISTER); 
    614                 GSXML.addError(result, _errorMessageMap.get(error)); 
    615             } 
    616         } 
     606                GSXML.addError(result, getErrorTextString(error, lang)); 
     607            } 
     608            return result; 
     609        } 
     610         
    617611        else if (op.equals(PERFORM_EDIT)) 
    618612        { 
     
    629623            if ((error = checkUsername(newUsername)) != NO_ERROR) 
    630624            { 
    631                 GSXML.addError(result, _errorMessageMap.get(error)); 
     625                GSXML.addError(result, getErrorTextString(error, lang)); 
    632626                return result; 
    633627            } 
     
    642636                if ((error = checkPassword(newPassword)) != NO_ERROR) 
    643637                { 
    644                     GSXML.addError(result, _errorMessageMap.get(error)); 
     638                    GSXML.addError(result, getErrorTextString(error, lang)); 
    645639                    return result; 
    646640                } 
     
    660654                { 
    661655                    serviceNode.setAttribute("operation", EDIT_USER); 
    662                     GSXML.addError(result, _errorMessageMap.get(error)); 
     656                    GSXML.addError(result, getErrorTextString(error, lang)); 
    663657                } 
    664658                return result; 
     
    669663            { 
    670664                serviceNode.setAttribute("operation", EDIT_USER); 
    671                 GSXML.addError(result, _errorMessageMap.get(error)); 
     665                GSXML.addError(result, getErrorTextString(error, lang)); 
    672666            } 
    673667            else 
     
    677671            } 
    678672        } 
     673        // this operation is done by a user when editing their own details. Should not return userNode info. 
    679674        else if (op.equals(PERFORM_ACCOUNT_EDIT)) 
    680675        { 
     
    690685                addUserInformationToNode(previousUsername, serviceNode); 
    691686                serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
    692                 GSXML.addError(result, _errorMessageMap.get(ERROR_USER_ALREADY_EXISTS)); 
     687                GSXML.addError(result, getErrorTextString(ERROR_USER_ALREADY_EXISTS, lang)); 
    693688                return result; 
    694689            } 
     
    704699                    addUserInformationToNode(previousUsername, serviceNode); 
    705700                    serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
    706                     GSXML.addError(result, _errorMessageMap.get(ERROR_INCORRECT_PASSWORD), "Incorrect Password"); 
     701                    GSXML.addError(result, getErrorTextString(ERROR_INCORRECT_PASSWORD, lang), "INCORRECT_PASSWORD"); 
    707702                    return result; 
    708703                } 
     
    712707                if ((error = checkPassword(newPassword)) != NO_ERROR) 
    713708                { 
    714                     GSXML.addError(result, _errorMessageMap.get(error)); 
     709                  addUserInformationToNode(previousUsername, serviceNode); 
     710                  serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     711                    GSXML.addError(result, getErrorTextString(error, lang)); 
    715712                    return result; 
    716713                } 
     
    727724            if ((error = checkUsername(newUsername)) != NO_ERROR) 
    728725            { 
    729                 GSXML.addError(result, _errorMessageMap.get(error)); 
     726              addUserInformationToNode(previousUsername, serviceNode); 
     727                  serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     728                GSXML.addError(result, getErrorTextString(error, lang)); 
    730729                return result; 
    731730            } 
     
    738737            if (error != NO_ERROR) 
    739738            { 
    740                 if (error == ERROR_USERNAME_NOT_SPECIFIED) 
    741                 { 
    742                     addUserInformationToNode(null, serviceNode); 
    743                     serviceNode.setAttribute("operation", LIST_USERS); 
    744                 } 
    745                 else 
    746                 { 
    747                     addUserInformationToNode(previousUsername, serviceNode); 
    748                     serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
    749                     GSXML.addError(result, _errorMessageMap.get(error)); 
    750                 } 
    751                 return result; 
     739              addUserInformationToNode(previousUsername, serviceNode); 
     740              serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     741              GSXML.addError(result, getErrorTextString(error, lang)); 
     742              return result; 
    752743            } 
    753744 
     
    755746            if (error != NO_ERROR) 
    756747            { 
    757                 GSXML.addError(result, _errorMessageMap.get(error)); 
    758             } 
    759  
    760             addUserInformationToNode(null, serviceNode); 
    761             serviceNode.setAttribute("operation", LIST_USERS); 
     748              serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     749                GSXML.addError(result, getErrorTextString(error, lang)); 
     750            } 
     751 
     752            addUserInformationToNode(newUsername, serviceNode); 
     753            serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     754            GSXML.addError(result, getTextString("auth.success.account_settings", lang)); 
     755             
    762756        } 
    763757        else if (op.equals(PERFORM_RETRIEVE_PASSWORD)) 
     
    773767            if (user_name == null || oldPassword == null || newPassword == null) 
    774768            { 
    775                 GSXML.addError(result, _errorMessageMap.get("missing compulsory parameters: username, oldPassword, or newPassword")); 
     769                GSXML.addError(result, getErrorTextString(ERROR_MISSING_PARAMS, lang)); 
    776770                return result; 
    777771            } 
     
    781775            { 
    782776                addUserInformationToNode(user_name, serviceNode); 
    783                 GSXML.addError(result, _errorMessageMap.get(ERROR_INCORRECT_PASSWORD), "Incorrect Password"); 
     777                GSXML.addError(result, getErrorTextString(ERROR_INCORRECT_PASSWORD, lang), "INCORRECT_PASSWORD"); 
    784778                return result; 
    785779            } 
     
    789783            if ((error = checkPassword(newPassword)) != NO_ERROR) 
    790784            { 
    791                 GSXML.addError(result, _errorMessageMap.get(error)); 
     785                GSXML.addError(result, getErrorTextString(error, lang)); 
    792786                return result; 
    793787            } 
     
    800794            if (info != "succeed") 
    801795            {//see DerbyWrapper.modifyUserInfo 
    802                 GSXML.addError(result, _errorMessageMap.get(info)); 
     796              GSXML.addError(result, info);  
    803797                return result; 
    804798            } 
     
    810804            if (error != NO_ERROR) 
    811805            { 
    812                 GSXML.addError(result, _errorMessageMap.get(error)); 
     806              GSXML.addError(result, getErrorTextString(error, lang)); 
    813807            } 
    814808        } 
     
    820814            { 
    821815                serviceNode.setAttribute("operation", ""); 
    822                 GSXML.addError(result, _errorMessageMap.get(ERROR_USERNAME_NOT_SPECIFIED)); 
     816                GSXML.addError(result, getErrorTextString(ERROR_USERNAME_NOT_SPECIFIED, lang)); 
    823817                return result; 
    824818            } 
     
    827821            { 
    828822                serviceNode.setAttribute("operation", LOGIN); 
    829                 GSXML.addError(result, _errorMessageMap.get(ERROR_NOT_AUTHORISED)); 
     823                GSXML.addError(result, getErrorTextString(ERROR_NOT_AUTHORISED, lang)); 
    830824                return result; 
    831825            } 
     
    833827            if (error != NO_ERROR) 
    834828            { 
    835                 GSXML.addError(result, _errorMessageMap.get(error)); 
     829              GSXML.addError(result, getErrorTextString(error, lang)); 
    836830            } 
    837831        } 
     
    851845        else if (op.equals(REGISTER)) 
    852846        { 
    853             if (_recaptchaPrivateKey != null && _recaptchaPrivateKey.length() > 0) 
    854             { 
    855                 try 
    856                 { 
    857                     ReCaptchaImpl reCaptcha = new ReCaptchaImpl(); 
    858                     reCaptcha.setPrivateKey(_recaptchaPrivateKey); 
    859                     reCaptcha.checkAnswer(request.getAttribute("remoteAddress"), "", ""); 
    860                 } 
    861                 catch (Exception ex) 
    862                 { 
    863                     return result; 
    864                 } 
    865             } 
    866  
    867             if (_recaptchaPublicKey != null && _recaptchaPrivateKey != null) 
    868             { 
    869                 Element recaptchaElem = result_doc.createElement("recaptcha"); 
    870                 recaptchaElem.setAttribute("publicKey", _recaptchaPublicKey); 
    871                 recaptchaElem.setAttribute("privateKey", _recaptchaPrivateKey); 
    872                 result.appendChild(recaptchaElem); 
    873             } 
    874847        } 
    875848        else if (op.equals(PERFORM_DELETE_USER)) 
     
    879852            if (error != NO_ERROR) 
    880853            { 
    881                 GSXML.addError(result, _errorMessageMap.get(error)); 
     854              GSXML.addError(result, getErrorTextString(error, lang)); 
    882855            } 
    883856            addUserInformationToNode(null, serviceNode); 
     
    933906    } 
    934907 
     908  public int verifyRecaptcha(String secret_key, String user_response) { 
     909 
     910    if (user_response == null || user_response.length() == 0) { 
     911      return ERROR_CAPTCHA_MISSING; 
     912    } 
     913 
     914    try{ 
     915       
     916      URL obj = new URL("https://www.google.com/recaptcha/api/siteverify"); 
     917      HttpsURLConnection con = (HttpsURLConnection) obj.openConnection(); 
     918 
     919      // add reuqest header 
     920      con.setRequestMethod("POST"); 
     921      con.setRequestProperty("User-Agent", "Mozilla/5.0"); 
     922      con.setRequestProperty("Accept-Language", "en-US,en;q=0.5"); 
     923 
     924      String postParams = "secret=" + secret_key + "&response=" 
     925    + user_response; 
     926 
     927      // Send post request 
     928      con.setDoOutput(true); 
     929      DataOutputStream wr = new DataOutputStream(con.getOutputStream()); 
     930      wr.writeBytes(postParams); 
     931      wr.flush(); 
     932      wr.close(); 
     933 
     934      int responseCode = con.getResponseCode(); 
     935      //System.out.println("\nSending 'POST' request to URL : https://www.google.com/recaptcha/api/siteverify");// + url); 
     936      //System.out.println("Post parameters : " + postParams); 
     937      //System.out.println("Response Code : " + responseCode); 
     938       
     939      BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream())); 
     940      String inputLine; 
     941      StringBuffer response = new StringBuffer(); 
     942       
     943      while ((inputLine = in.readLine()) != null) { 
     944    response.append(inputLine); 
     945      } 
     946      in.close(); 
     947       
     948      // print result 
     949      //System.out.println(response.toString()); 
     950 
     951      JSONObject json_obj = new JSONObject(response.toString()); 
     952      boolean res = json_obj.getBoolean("success"); 
     953      if (res) { 
     954    return NO_ERROR; 
     955      } else { 
     956    return ERROR_CAPTCHA_FAILED; 
     957      } 
     958    }catch(Exception e){ 
     959      e.printStackTrace(); 
     960      return ERROR_CAPTCHA_FAILED; 
     961    } 
     962 
     963  } 
    935964    // This method can also be used for printing out the password in hex (in case 
    936965    // the password used the UTF-8 Charset), or the hex values in any unicode string. 
     
    11641193    } 
    11651194 
     1195 
    11661196    // main() method - calls hashPassword() on any String argument, printing this to stdout 
    11671197    // This main() is invoked by gliserver.pl perl code to encrypt passwords identically to Java code.