/src/my/com/upass/gemalto/GemaltoTokenControllerImpl.java - Annotate - M2U UPASS Project - Penril Support System

m2u-upass-core / src / my / com / upass / gemalto / GemaltoTokenControllerImpl.java @ 5:f608e6319b70

History | View | Annotate | Download (16 KB)

-:02300db8682b
+/*
  * Copyright (c) 2012 Penril Datability (M) Sdn Bhd All rights reserved.
+ *
  * This software is copyrighted. Under the copyright laws, this software
  * may not be copied, in whole or in part, without prior written consent
  * of Penril Datability (M) Sdn Bhd or its assignees. This software is
  * provided under the terms of a license between Penril Datability (M)
  * Sdn Bhd and the recipient, and its use is subject to the terms of that
  * license.
  */
 package my.com.upass.gemalto;
 import java.util.Date;
 import java.util.HashMap;
 import ocra.Ocra;
 import my.com.upass.Constants;
 import my.com.upass.TokenBean;
 import my.com.upass.vasco.TokenController;
 /*
  * <pre>
  * PROGRAMMER: Enson Yeoh
  * CHANGE-NO:
  * TASK-NO:
  * DATE CREATED: Oct 5, 2012
  * TAG AS:
  * REASON(S):
  * MODIFICATION:
  * </pre>
+ *
+ *
  * Requirements:
  * 1) Retrieve the tokenBean and override the existing tokenBean object.
  * 2) Override the existing serial number with the given tokenBean.
  * 3) Override the existing authentication mode with the given tokenBean.
  * 4) Override the existing blob with the given tokenBean.
  * 5) Update useCount (total number of usage of the given token)
  * 6) Update errorCount (total number of errors attempted by the given token)
  * 7) Update last first time (the first usage date of the given token)
  * 8) Update last used time (the last usage date of the given token)
  * 9) Update the tokenBean object whenever there is changes.
  * 10) Verify token with the given password (OTP)
  * 11) Blob synchronization.
  * 12) Check last authentication
+ *
+ *
  */
 public class GemaltoTokenControllerImpl implements TokenController
+{
         private Ocra myocra = new Ocra();
         private TokenBean tb;
         private int retCode;
         private String serialNumber;
         private String authMode;
         private byte[] blob;
         private int useCount;
         private int errorCount;
         private Date lastTimeUsed;
         private Date firstTimeUsed;
         private Date lastAuthentication;
         private Date tokenExpectedDateTime;
         /**
          * this will override the existing tokenBean object
          * this will override the existing serial number, authentication mode and blob
+         *
          * @param tokenBean
          */
         public GemaltoTokenControllerImpl(TokenBean tokenBean)
+        {
                 this.tb = tokenBean;
                 setSerialNumber();
                 setAuthMode();
                 setBlob();
+        }
         /**
          * this will override the existing last authentication date
+         *
          * @param LastAuthentication
          */
         public void setLastAuthentication(Date lastAuthentication)
+        {
                 this.lastAuthentication = lastAuthentication;
+        }
         /**
          * this will return updated last authentication date
+         *
          * @return
          */
         public Date getLastAuthentication()
+        {
                 return lastAuthentication;
+        }
         /**
          * this will override the existing token expected date and time
+         *
          * @param LastAuthentication
          */
         public void setTokenExpectedDateTime(Date tokenExpectedDateTime)
+        {
                 this.tokenExpectedDateTime = tokenExpectedDateTime;
+        }
         /**
          * this will return updated token expected date and time
+         *
          * @return
          */
         public Date getTokenExpectedDateTime()
+        {
                 return tokenExpectedDateTime;
+        }
         /**
          * this will override the existing tokenBean
+         *
          */
         public void setObject(TokenBean tokenBean)
+        {
                 this.tb = tokenBean;
+        }
         /**
          * this will return the updated object (tokenBean)
+         *
          */
         public TokenBean getUpdatedObject()
+        {
                 return tb;
+        }
         /**
          * this will override the existing serial number
+         *
          */
         private void setSerialNumber()
+        {
                 this.serialNumber = tb.getVserialNumber();
+        }
         /**
          * this will override the existing authentication mode
+         *
          */
         private void setAuthMode()
+        {
                 this.authMode = tb.getVdpAuthMode();
+        }
         /**
          * this will override the existing blob
+         *
          */
         private void setBlob()
+        {
                 this.blob = tb.getVdpCipherText();
+        }
         /**
          * this will return the updated blob
+         *
          */
         public byte[] getUpdatedBlob()
+        {
                 return this.blob;
+        }
         /**
          * this will override the existing useCount
+         *
          */
         public void setUseCount()
+        {
                 this.useCount = tb.getVuseCount();
+        }
         /**
          * this will increase the existing useCount by 1 whenever it is invoked.
+         *
          */
         public void increaseUseCount()
+        {
                 this.useCount++;
+        }
         /**
          * this will return the updated useCount
+         *
          */
         public int getUseCount()
+        {
                 return this.useCount;
+        }
         /**
          * this will override the existing errorCount
+         *
          */
         public void setErrorCount()
+        {
                 this.errorCount = tb.getVerrorCount();
+        }
         /**
          * this will increase the existing errorCount by 1 whenever it is invoked.
+         *
          */
         public void increaseErrorCount()
+        {
                 this.errorCount++;
+        }
         /**
          * this will return the updated errorCount
+         *
          */
         public int getErrorCount()
+        {
                 return this.errorCount;
+        }
         /**
          * this will override the existing first used date
+         *
          */
         public void setFirstTimeUsed()
+        {
                 this.firstTimeUsed = tb.getVdateFirstUsed();
+        }
         /**
          * case 1: if first used date is null, then first used date will be override by current date.
          * case 2: throw exception if first used date is after last used date.
+         *
          * @param currentDate
          * @throws Exception
          */
         public void setFirstTimeUsed(Date currentDate) throws Exception
+        {
                 if(this.firstTimeUsed == null)
+                {
                         this.firstTimeUsed = currentDate;
+                }
                 else if(this.firstTimeUsed.compareTo(this.lastTimeUsed) > 0)
+                {
                         throw new Exception("Invalid date. First used date cannot be after last used date.");
+                }
+        }
         /**
          * this will return the updated first used date
+         *
          */
         public Date getFirstTimeUsed()
+        {
                 return firstTimeUsed;
+        }
         /**
          * this will override the existing last used date.
+         *
          */
         public void setLastTimeUsed()
+        {
                 this.lastTimeUsed = tb.getVdateFirstUsed();
+        }
         /**
          * case 1: if last used date is null, then last used date will be override by current date.
          * case 2: if last used date is before the current date, then last used date will be override by current date.
          * case 3: throw exception if last used date is after the current date.
          * case 4: throw exception if last used date is before first used date.
+         *
          * @param currentDate
          * @throws Exception
          */
         public void setLastTimeUsed(Date currentDate) throws Exception
+        {
                 if(this.lastTimeUsed == null)
+                {
                         this.lastTimeUsed = currentDate;
+                }
                 else if(this.lastTimeUsed.compareTo(currentDate) < 0)
+                {
                         this.lastTimeUsed = currentDate;
+                }
                 else if(this.lastTimeUsed.compareTo(currentDate) > 0)
+                {
                         throw new Exception("Invalid date. Last used date cannot be after current date.");
+                }
                 else if(this.lastTimeUsed.compareTo(this.firstTimeUsed) < 0)
+                {
                         throw new Exception("Invalid date. Last used date cannot be before first used date.");
+                }
+        }
         /**
          * this will return the updated last used date
+         *
          */
         public Date getLastTimeUsed()
+        {
                 return lastTimeUsed;
+        }
         /**
          * this will return the updated returned code by each invoked method
          * it also acts as last returned error code.
+         *
          */
         public int getRetCode()
+        {
                 return retCode;
+        }
         /**
          * this will return the updated error text based on the error code
+         *
          */
         public String getLastError()
+        {
                 String code = null;
                 switch(this.retCode)
+                {
                         case 0: code = "0";
                         case 1: code = "1";
                         case 2: code = "18";
                         case 3: code = "19";
                         case 4: code = "20";
                         case 5: code = "21";
                         case 6: code = "22";
                         case 7: code = "3";
                         case 8: code = "23";
                         case 9: code = "24";
                         case 10: code = "25";
                         case 11: code = "26";
                         default:
                                 try
+                                {
                                         throw new Exception("Invalid error code.");
+                                }
                                 catch (Exception e)
+                                {
                                         e.printStackTrace();
+                                }
+                }
                 return Constants.getErrText(code).get(code);
+        }
         /**
          * Verify the entered On Time Password (OTP/password) for the given token
+         *
          */
         public int verifyToken(String otp, String userAlias, String pin) throws Exception
+        {
                 return verifyToken(otp);
+        }
         /**
          * Verify the entered On Time Password (OTP/password) for the given token
+         *
          */
         public int verifyToken(String password)
+        {
                 int[] blobLen = new int[1];
                 blobLen[0]=500;
                 String[] blobInString = new String[1];
                 blobInString[0] = new String(this.blob);
                 //Time based OTP verification
                 //Authentication window need to be bigger for first OTP verification.
                 int result = myocra.comAuthBlob(0, 0, this.serialNumber, Constants.getAuthenticationMode(this.authMode), 20, 1, 100,
                                                         new byte[0], 0,
                                                         new byte[0], 0,
                                                         new byte[0], 0,
 , password,
                                                         blobInString, blobLen);
                 this.useCount++;
                 this.firstTimeUsed = new Date();
                 this.lastTimeUsed = new Date();
                 if(result == 0)
+                {
                         this.blob = blobInString[0].getBytes();
                         this.retCode = result;
                         updateTokenObject();
+                }
                 else
+                {
                         try
+                        {
                                 this.errorCount++;
                                 this.retCode = result;
                                 updateTokenObject();
                                 return errorCodeConversion(result);
+                        }
                         catch (Exception e)
+                        {
                                 e.printStackTrace();
+                        }
+                }
                 return Constants.ERR_SUCCESS;
+        }
         /**
          * Check last successful authentication
+         *
          * @return
          */
         public int checkLastAuthentication()
+        {
                 String[] blobInString = new String[1];
                 blobInString[0] = new String(this.blob);
                 int [] LastAuthTime = new int[1];
         int [] TokenExpectedTime = new int[1];
                 int result = myocra.comGetInfo(0, 0, serialNumber, Constants.getAuthenticationMode("AUTH_OCRA"), blobInString, blobInString[0].length(), LastAuthTime, TokenExpectedTime);
                 if(result == 0)
+                {
                         //For first use of blob, LastAuthTimeDate returns a value of 0 or in Date format, Thu Jan 01 07:30:00 SGT 1970.
                         if(LastAuthTime[0] == 0)
+                        {
                                 System.out.println("No Last authentication.");
+                        }
                         else
+                        {
                                 this.blob = blobInString[0].getBytes();
                                 this.lastAuthentication = new Date(Long.parseLong(""+LastAuthTime[0])* 1000);
                     this.tokenExpectedDateTime = new Date(Long.parseLong(""+TokenExpectedTime[0])* 1000);
                     this.retCode = result;
+                        }
+                }
                 else
+                {
                         try
+                        {
                                 this.errorCount++;
                                 this.retCode = result;
                                 updateTokenObject();
                                 return errorCodeConversion(result);
+                        }
                         catch (Exception e)
+                        {
                                 e.printStackTrace();
+                        }
+                }
                 return Constants.ERR_SUCCESS;
+        }
         /**
          * In order to perform blob synchronization, 2 token verifications shall be performed .
          * First token verification must have larger time drift windows then the second's.
          * First token verification must be executed first before execute the second.
          * Second token verification must use new password (OTP) and lesser time drift window.
          * If the returned result of first verification is successful or 0, then second verification will be executed.
          * If the returned results of both first and second verifications are successful or 0, then blobSynchronization is successful,
          * otherwise, it is failed.
+         *
+         *
          * @param timeDriftWindow
          * @param password
          * @return
          */
         public int blobSynchronization(int timeDriftWindow1, String password1, int timeDriftWindow2, String password2)
+        {
                 int result = blobSynchronizationTokenVerification(timeDriftWindow1, password1);
                 if(result == 0)
+                {
                         result = blobSynchronizationTokenVerification(timeDriftWindow2, password2);
                         if(result == 0)
+                        {
                                 this.retCode = result;
                                 updateTokenObject();
+                        }
                         else
+                        {
                                 try
+                                {
                                         this.errorCount++;
                                         this.retCode = result;
                                         updateTokenObject();
                                         return errorCodeConversion(result);
+                                }
                                 catch (Exception e)
+                                {
                                         e.printStackTrace();
+                                }
+                        }
+                }
                 else
+                {
                         try
+                        {
                                 this.retCode = result;
                                 return errorCodeConversion(result);
+                        }
                         catch (Exception e)
+                        {
                                 e.printStackTrace();
+                        }
+                }
                 return Constants.ERR_SUCCESS;
+        }
         /**
          * This method will be used in blobSynchronization to verify the token and blob synchronization
+         *
          * @param timeDriftWindow
          * @param password
          * @return
          */
         private int blobSynchronizationTokenVerification(int timeDriftWindow, String password)
+        {
                 if(this.retCode == 0)
+                {
                         int[] blobLen = new int[1];
                         blobLen[0]=500;
                         String[] blobInString = new String[1];
                         blobInString[0] = new String(this.blob);
                         //Time based OTP verification
                         //Authentication window need to be bigger for first OTP verification.
                         int result = myocra.comAuthBlob(0, 0, this.serialNumber, Constants.getAuthenticationMode(this.authMode), timeDriftWindow, 1, 100,
                                                                 new byte[0], 0,
                                                                 new byte[0], 0,
                                                                 new byte[0], 0,
 , password,
                                                                 blobInString, blobLen);
                         this.useCount++;
                         this.firstTimeUsed = new Date();
                         this.lastTimeUsed = new Date();
                         if(result == 0)
+                        {
                                 this.blob = blobInString[0].getBytes();
                                 this.retCode = result;
                                 updateTokenObject();
+                        }
                         else
+                        {
                                 try
+                                {
                                         this.errorCount++;
                                         this.retCode = result;
                                         updateTokenObject();
                                         return errorCodeConversion(result);
+                                }
                                 catch (Exception e)
+                                {
                                         e.printStackTrace();
+                                }
+                        }
+                }
                 return Constants.ERR_SUCCESS;
+        }
         /**
          * This will reset the token back to the initial state
          * The blob will be regenerated with the backup blob which is initially generated when it is imported from the pskc file.
+         *
          */
         public int resetToken()
+        {
                 this.retCode = 0;
                 this.blob = tb.getVbkCipherText();
                 this.useCount = 0;
                 this.errorCount = 0;
                 this.lastTimeUsed = null;
                 this.firstTimeUsed = null;
                 this.lastAuthentication = null;
                 this.tokenExpectedDateTime = null;
                 updateTokenObject();
                 return Constants.ERR_SUCCESS;
+        }
         public HashMap<String, String> getTokenBlobInfo()
+        {
                 HashMap<String,String>  map = new HashMap<String,String>();
                 map.put("TOKEN_MODEL", tb.getVdpModel());
                 map.put("USE_COUNT",  Integer.toString(tb.getVuseCount()));
                 map.put("ERROR_COUNT",  Integer.toString(tb.getVerrorCount()));
                 map.put("LAST_TIME_USED", String.valueOf (tb.getVdateLastUsed()));
                 map.put("TIME_STEP_USED", Integer.toString(Constants.TIMESTEPUSED));
                 return map;
+        }
         /**
          * display gemalto token information
          * In comparion with vasco, only limited information will be displayed.
+         *
          */
         public void displayTokenInfo()
+        {
                 System.out.println("--Info----------------------------------------------");
                 System.out.println("TOKEN_MODEL......." + tb.getVdpModel());
                 System.out.println("USE_COUNT........." + tb.getVuseCount());
                 System.out.println("ERR_COUNT........." + tb.getVerrorCount());
                 System.out.println("LAST_TIME_USED...." + tb.getVdateLastUsed());
                 System.out.println("TIME_STEP_USED...." + Constants.TIMESTEPUSED);
                 System.out.println("----------------------------------------------------");
+        }
         /**
          * This will override the existing tokenBean object
+         *
          */
         private void updateTokenObject()
+        {
                 tb.setVuseCount(this.useCount );
                 tb.setVerrorCount(this.errorCount );
                 tb.setVdpCipherText(this.blob);
                 tb.setVdateFirstUsed(this.firstTimeUsed);
                 tb.setVdateLastUsed(this.lastTimeUsed);
+        }
         /*
          * Code the gemalto returned error code to match with vasco's
+         *
          */
         private int errorCodeConversion(int errorCode) throws Exception
+        {
                 switch(errorCode)
+                {
                         case 0: return Constants.ERR_SUCCESS;
                         case 1: return Constants.ERR_INVALID_CREDENTIAL;
                         case 2: return Constants.ERR_BLOBINVALID;
                         case 3: return Constants.ERR_BUFFER;
                         case 4: return Constants.ERR_PARAM;
                         case 5: return Constants.ERR_SNOINVALID;
                         case 6: return Constants.ERR_OTPINVALID;
                         case 7: return Constants.ERR_REUSED_PASSWD;
                         case 8: return Constants.ERR_BLOBOTINIT;
                         case 9: return Constants.ERR_FAILED;
                         case 10: return Constants.ERR_REQINVALID;
                         case 11: return Constants.ERR_AUTH_MODE;
                         default: throw new Exception("Invalid error code.");
+                }
+        }
         public int syncToken(String userAlias, String otp1, String otp2) {
                 // TODO Auto-generated method stub
                 return 0;
+        }
+}

Z-Archive » Maybank Projects » M2U UPASS Project

m2u-upass-core / src / my / com / upass / gemalto / GemaltoTokenControllerImpl.java @ 5:f608e6319b70