Z-Archive » Maybank Projects » M2U UPASS Project

package my.com.upass.tac;

import java.io.UnsupportedEncodingException;

import java.lang.String;

import java.text.DecimalFormat;

import java.util.Date;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

import my.com.upass.pojo.TacBean;

public class TacCrypto {

        private long userID;

        private String Tac;

        private String CipherText;

        private static boolean isValid = false;

        private static String StatusCode;

        private Date timeStamp;

        private String nonce;

        private static final int defaultTimeout = 3600; // 1hr

        // /////////////////////////////////////////////////////////////////////

        // Constructors

        // /////////////////////////////////////////////////////////////////////

        public TacCrypto(TacBean tacBeanObject) {

                this.userID = tacBeanObject.getUserID();

                this.nonce = tacBeanObject.getNonce();

                Tac = Generate();

                CipherText = getOffset(userID, Tac);

        }

        public TacCrypto(TacBean tb, String Tac, int nTimeout) {

                this.userID = tb.getUserID();

                this.nonce = tb.getNonce();

                this.Tac = Tac;

                this.CipherText = tb.getCipherText();

                isValid = Verify(userID, Tac, tb.getCipherText(), nTimeout);

        }

        public TacCrypto(TacBean tb, String Tac, String CipherText) {

                this.userID = tb.getUserID();

                this.Tac = Tac;

                this.CipherText = CipherText;

                int nTimeout = defaultTimeout;

                isValid = Verify(userID, Tac, CipherText, nTimeout);

        }

        // /////////////////////////////////////////////////////////////////////

        // Public Method

        // /////////////////////////////////////////////////////////////////////

        public String getTac() {

                return Tac;

        }

        public String getOffset() {

                return CipherText;

        }

        public boolean getIsValid() {

                return isValid;

        }

        public String getStatusCode() {

                return StatusCode;

        }

        public Date getTimeStamp() {

                return timeStamp;

        }

        // /////////////////////////////////////////////////////////////////////

        // Convert byte to hex

        // /////////////////////////////////////////////////////////////////////

        private String convertToHex(byte[] data) {

                StringBuffer buf = new StringBuffer();

                for (int i = 0; i < 8 /* Or data.length */; i++) {

                        int halfbyte = (data[i] >>> 4) & 0x0F;

                        int two_halfs = 0;

                        do {

                                if ((0 <= halfbyte) && (halfbyte <= 9))

                                        buf.append((char) ('0' + halfbyte));

                                else

                                        buf.append((char) ('A' + (halfbyte - 10)));

                                halfbyte = data[i] & 0x0F;

                        } while (two_halfs++ < 1);

                }

                return buf.toString();

        }

        // /////////////////////////////////////////////////////////////////////

        // convert long to byte []

        // /////////////////////////////////////////////////////////////////////

        private final byte[] longToByteArray(long value) {

                return new byte[] {

                                (byte) (value >>> 56),

                                (byte) (value >>> 48),

                                (byte) (value >>> 40),

                                (byte) (value >>> 32),

                                (byte) (value >>> 24),

                                (byte) (value >>> 16),

                                (byte) (value >>> 8),

                                (byte) value };

        }

        // /////////////////////////////////////////////////////////////////////

        // Public Generate TAC

        // /////////////////////////////////////////////////////////////////////

        private String GenerateUTC() {

                Date now = new Date();

                // sTimeStamp = new String(Constants.defaultDateFormat.format(now));

                timeStamp = now;

                long UTC = now.getTime();

                byte[] bUTC = longToByteArray(UTC);

                return convertToHex(bUTC);

        }

        private int CompareUTC(String s) {

                long l = Long.parseLong(s, 16);

                Date now = new Date();

                long UTC = now.getTime();

                return (int) (UTC - l);

        }

        // /////////////////////////////////////////////////////////////////////

        // Generate 40-byte SHA-2

        // /////////////////////////////////////////////////////////////////////

        public String SHA2(long userID, String Tac, String nonce) {

                try {

                        String strID = Long.toString(userID);

                        if (nonce != null) {

                                strID = strID + nonce; // add additional nonce if provided

                        }

                        MessageDigest md;

                        md = MessageDigest.getInstance("SHA-256");

                        byte[] sha2hash = new byte[40];

                        md.update(Tac.getBytes("iso-8859-1"), 0, Tac.length());

                        md.update(strID.getBytes("iso-8859-1"), 0, strID.length());

                        sha2hash = md.digest();

                        return convertToHex(sha2hash);

                } catch (NoSuchAlgorithmException e) {

                        e.printStackTrace();

                } catch (UnsupportedEncodingException e) {

                        e.printStackTrace();

                }

                return new String("******");

        }

        // /////////////////////////////////////////////////////////////////////

        // Generate 6-digit random number from standard Java SecureRandam

        // /////////////////////////////////////////////////////////////////////

        private String getRandom6d() {

                try {

                        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");

                        byte[] seed = sr.getSeed(8);

                        sr.setSeed(seed);

                        int r = sr.nextInt(999999 + 1);

                        DecimalFormat df = new DecimalFormat("000000");

                        return new String(df.format(r));

                } catch (NoSuchAlgorithmException e) {

                        e.printStackTrace();

                }

                return new String("******");

        }

        // /////////////////////////////////////////////////////////////////////

        // Public Generate TAC

        // /////////////////////////////////////////////////////////////////////

        private String Generate() {

                return getRandom6d();

        }

        // /////////////////////////////////////////////////////////////////////

        // Public Generate TAC offset

        // /////////////////////////////////////////////////////////////////////

        private String getOffset0(long userID, String Tac) {

                return SHA2(userID, Tac, this.nonce);

        }

        private String getOffset(long userID, String Tac) {

                return SHA2(userID, Tac, this.nonce) + GenerateUTC();

        }

        // /////////////////////////////////////////////////////////////////////

        // Verify TAC

        // /////////////////////////////////////////////////////////////////////

        private boolean Verify(long userID, String Tac, String TacOffset, int nTimeout) {

                String TacOffset0 = TacOffset.substring(0, 16);

                String TacOffset1 = TacOffset.substring(16);

                boolean isTac = TacOffset0.equals(getOffset0(userID, Tac));

                boolean isNotExpired = (CompareUTC(TacOffset1) < (nTimeout * 1000));

                StatusCode = ((isTac) ? "0" : "1") + ((isNotExpired) ? "0" : "1");

                return (isTac && isNotExpired);

        }

} // end class TacCrypto