Z-Archive » Maybank Projects » M2U UPASS Project

/**

 * 

 */

package my.com.upass.spassword;

import java.io.UnsupportedEncodingException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Date;

import java.util.Calendar;

import java.util.Map;

import java.util.Properties;

import java.util.StringTokenizer;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import my.com.upass.Config;

import my.com.upass.ConfigBean;

import my.com.upass.Constants;

import my.com.upass.pojo.UserBean;

/**

 * @author Administrator

 *

 */

public class PasswordController {

        private static  final Logger logger = Logger.getLogger (PasswordController.class);

        static int _MAX_ERROR = 3;

        static int _MAX_PASSWD_REUSED = 3;

        static int _EXPIRY_DAY = 0;

        static int _MIN_LENGTH = 0;

        static int _COMPLEXITY = 0;

        static String _PASSWORD_PATTERN = "(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+<>?]).{8,}";

        static String _USERNAME_PATTERN = "^[a-zA-Z0-9_-]{6,}$";

        static String _PASSWORD_ACCEPT_PATTERN = "^[a-zA-Z0-9!@#$%^&*()_+<>?]{0,}$";

        static int _USER_DORMANT_PERIOD = 0;

        private UserBean userBean; 

        private Map<Integer, ConfigBean> configurationsMap;

        public PasswordController(UserBean userBean,

                        Map<Integer, ConfigBean> configurationsMap)

                        throws Exception

        {

                this.userBean = userBean;

                this.configurationsMap = configurationsMap;

        }

        public ConfigBean getConfigBean()

        {

                return configurationsMap.get (this.userBean.getApplicationId());

        }

        public PasswordController(){

                getSystemProperties();

        }

        public PasswordController(UserBean userBean){

                this.userBean = userBean;

                getSystemProperties();

        }

        public PasswordController(UserBean userBean, boolean loadConfig){

                this.userBean = userBean;

                if(loadConfig){getSystemProperties ();}

        }

        public void setObject(UserBean userBean) {

                this.userBean = userBean;

        }

        public UserBean getUpdatedObject() {

                return (UserBean)userBean;

        }

        private void getSystemProperties() {

                Config cfg = Config.getInstance();

                Properties cfgData = cfg.getConfig();

                try {

                        _MAX_ERROR = Integer.parseInt(cfgData.get("PASSWORD_MAX_ERROR").toString());

                        _MAX_PASSWD_REUSED = Integer.parseInt(cfgData.get("PASSWORD_GENERAION").toString());

                        _EXPIRY_DAY = Integer.parseInt(cfgData.get("PASSWORD_EXPIRY_DAY").toString());

                        _MIN_LENGTH = Integer.parseInt(cfgData.get("PASSWORD_MIN_LENGTH").toString());

                        _COMPLEXITY = Integer.parseInt(cfgData.get("PASSWORD_COMPLEXITY").toString());

                        _PASSWORD_PATTERN = cfgData.get("PASSWORD_PATTERN").toString();

                        _USERNAME_PATTERN = cfgData.get("USERNAME_PATTERN").toString();

                        _PASSWORD_ACCEPT_PATTERN = cfgData.get("PASSWORD_ACCEPT_PATTERN").toString();

                } catch (Exception e) {

                        logger.error("ERR: Property entry not found..");

                }

        }

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

        // Public Verify User Alias  

        // 20120627 - Return ERR_INVALID_USERALIAS if the given name is not matching the pattern

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

        public int VerifyUserAlias(String userAlias) {

                logger.info("userAlias="+userAlias+" Regular Expression="+_USERNAME_PATTERN);

                if (patternValidator(userAlias, getConfigBean().getUserNameValidPattern())) {

                        return Constants.ERR_SUCCESS;

                }

                return Constants.ERR_INVALID_USERALIAS;

        }

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

        // Public Verify Password  

        // 20081113 - Return passwd expired means the passwd is valid but expired

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

        public int VerifyPassword(String password) {

                Date ts = new Date();

                userBean.setPdateLastUsed(ts);         

                userBean.setPuseCount( userBean.getPuseCount() + 1 );

                if (userBean.getPstate() != Constants.PASSWD_STATUS_ENABLE) {

                        userBean.setPerrorCount( userBean.getPerrorCount() + 1 ); 

                        return Constants.ERR_INVALID_STATE; 

                }

                if (userBean.getPerrorCount() > getConfigBean().getPasswordMaxTryError()-1) {

                        userBean.setPerrorCount( userBean.getPerrorCount() + 1 ); 

                        return Constants.ERR_EXCEED_MAX_TRIES; 

                }

                if (userBean.getPdateFirstUsed() == null) {

                        userBean.setPdateFirstUsed(ts); 

                }

                if ( comparePassword(password) ) {

                        //valid password

                        userBean.setPerrorCount(0); //reset error count

                        //modified on July 03, 2012 by Tan Lee Yong

                        //the require changed that password expire date must take effective as the _EXPIRY_DAY changed.

                        //therefore, the validation of this date change to dynamic, rather than static

                        if ( ( userBean.getPexpiredStatus() == Constants.PASSWD_WILL_EXPIRE) && 

                                        (userBean.getPdateExpired() != null) ){

                                        Date lastPasswordChangeDate = userBean.getPdateExpired();

                                        Calendar expiryDate = Calendar.getInstance();

                                        expiryDate.setTime(lastPasswordChangeDate);

                                        expiryDate.add(Calendar.DATE, +getConfigBean().getPasswordExpiry());

                                        Date passwordExpireDate = expiryDate.getTime();

                                        int notifAlert = getConfigBean().getPasswordExpiry() - getConfigBean().getNotifAlert();

                                        Calendar expiryDateNotification = Calendar.getInstance();

                                        expiryDateNotification.setTime(lastPasswordChangeDate);

                                        expiryDateNotification.add(Calendar.DATE, +notifAlert);

                                        Date expiryDateNotification1 = expiryDateNotification.getTime();

                                        if (ts.after(expiryDateNotification1) && ts.before(passwordExpireDate) ){

                                                return Constants.ERR_PASSWD_EXPIRED_NOTIFICATION;

                                        }

                                        //if the password expire date is a pass date compare to today's date

                                        //return password expired status

                                        if (passwordExpireDate.before(ts)) { 

                                                return Constants.ERR_PASSWD_EXPIRED;

                                        }

                        }

                        return Constants.ERR_SUCCESS;

                } else {

                        // invalid password

                        userBean.setPerrorCount( userBean.getPerrorCount() + 1 ); 

                        if (userBean.getPerrorCount () == getConfigBean().getPasswordMaxTryError())

                        {

                                return Constants.ERR_EXCEED_MAX_TRIES;

                        }

                        return Constants.ERR_INVALID_CREDENTIAL; 

                }

        }

        public int checkRegeneratePassword() {

                //added checking for password change interval.

                if (userBean.getPdateCreated() != null){

                        Date date= new Date();

                        Date lastPasswordGenerationDate = userBean.getPdateCreated();

                        Calendar generationDate = Calendar.getInstance();

                        generationDate.setTime(lastPasswordGenerationDate);

                        generationDate.add(Calendar.MINUTE, +getConfigBean().getChangePasswordInterval());

                        Date passRegenDate = generationDate.getTime();

                        if (date.before(passRegenDate)) { 

                                return Constants.ERR_PASSWD_CHANGE_INTERVAL;

                        }        

                }

                return Constants.ERR_SUCCESS;

        }

        private boolean comparePassword(String password) {

                String passwordCipherText = SHA256(userBean.getUserAlias(), password);

                return (passwordCipherText.equals(userBean.getPcipherText()));

        }

        public int GeneratePassword(String password, boolean enableHistCheck) {

                if ( !ValidatePasswordPattern(password) ) {

                        return Constants.ERR_PASSWD_WEAK;

                }

                return generatePassword (password, enableHistCheck);

        }

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

        // Public Generate Password  

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

        int generatePassword(String password, boolean enableHistCheck) {

//                if ( !ValidatePassword(password) ) {

//                        return Constants.ERR_PASSWD_WEAK;

//                }

                Date ts = new Date();

                String cipherText = SHA256(userBean.getUserAlias(), password);

                String token = null;

                StringBuffer sb = new StringBuffer(cipherText);

                if (enableHistCheck) {

                        // check password history here

                        String histList = userBean.getPhistoryList();

                        if (histList != null) {

                                StringTokenizer stz = new StringTokenizer(histList, ":");

                                while (stz.hasMoreTokens()){

                                        token = stz.nextToken();

                                        if ( cipherText.equals(token) ) {

                                                return Constants.ERR_REUSED_PASSWD;

                                        }

                                }

                                sb.append(":");

                                sb.append(histList);

                        }

                        // update the history list

                        int max_reused = (getConfigBean().getPasswordMaxReuse());

                        String theUpdatedHistList = sb.toString();

                        StringBuffer nsb = new StringBuffer();

                        StringTokenizer newstz = new StringTokenizer(theUpdatedHistList, ":");

                        if (newstz.countTokens() > max_reused) {

                                nsb.append(newstz.nextToken());

                                for (int i=0; i<max_reused-1; i++ ) {

                                        nsb.append(":");

                                        nsb.append(newstz.nextToken());

                                }

                                theUpdatedHistList = nsb.toString();

                        }

                        userBean.setPhistoryList( theUpdatedHistList );

                } //end enableHistCheck

                userBean.setPstate(Constants.PASSWD_STATUS_ENABLE);

                userBean.setPcipherText(cipherText);

                userBean.setPdateCreated(ts);

                userBean.setPerrorCount(0);

                if ( getConfigBean().getPasswordExpiry() > 0 ) {

                        userBean.setPexpiredStatus(Constants.PASSWD_WILL_EXPIRE);

                        Calendar expiryDate = Calendar.getInstance();

                        //modified on July 03, 2012 by Tan Lee Yong

                        //the require changed that password expire date must take effective as the _EXPIRY_DAY changed.

                        //therefore, the validation of this date change to dynamic, rather than static

//                        expiryDate.add(Calendar.DATE, +_EXPIRY_DAY);

//                        expiryDate.add(Calendar.DATE);

                        userBean.setPdateExpired(expiryDate.getTime());

                } else {

                        userBean.setPexpiredStatus(Constants.PASSWD_NEVER_EXPIRE);

                        userBean.setPdateExpired(null);

                }

                return Constants.ERR_SUCCESS;

        }

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

        //  validate Password - Length, complexity  

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

        public boolean ValidatePasswordPattern (String password)

        {

                //if acceptable characters are defined, then check does password contain unacceptable characters

                if (getConfigBean().getPasswordAcceptPattern()!=null || !getConfigBean().getPasswordAcceptPattern().isEmpty()) {

                        if (!patternValidator(password, getConfigBean().getPasswordAcceptPattern())) {

                                return false;

                        } 

                        return true;

                }

                return patternValidator(password, getConfigBean().getPasswordValidPattern());

        }

        public boolean ValidatePassword(String password){

                boolean l1, l2, l3, l4;

                l1 = l2 = l3 = l4 = true;

                if (password.length() < getConfigBean().getPasswordMinLength()) {

                        logger.info("Password length check failed");

                        return false;

                }

                logger.info("Password _COMPLEXITY " + getConfigBean().getPasswordComplexity());

                System.out.println("Password Complexity:"+ getConfigBean().getPasswordComplexity());

                if (getConfigBean().getPasswordComplexity() != 0) {

                        l1 = l2 = l3 = l4 = false;

                        String validLowerChars = "abcdefghijklmnopqrstuvwxyz";

                        String validUpperChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

                        String validNumber = "0123456789";

                        String validSpecialChar = "!@#$%^&*()_+<>?";

                        for (int i=0;i<password.length();i++) {

                          char c = password.charAt(i);

                          if (!l1 && validLowerChars.indexOf(c) != -1){

                                  //logger.info("lower.. Character[" + c + "] detected at position " + i);

                                  l1 = true;

                                 }

                          if (!l2 && validUpperChars.indexOf(c) != -1){

                                  //logger.info("upper.. Character[" + c + "] detected at position " + i);

                                  l2 = true;

                                  }

                          if (!l3 && validNumber.indexOf(c) != -1){

                                  //logger.info("digit.. Character[" + c + "] detected at position " + i);

                                  l3 = true;

                                  }

                          if (!l4 && validSpecialChar.indexOf(c) != -1){

                                  //logger.info("special Character[" + c + "] detected at position " + i);

                                  l4 = true;

                                  }

                        }

                }

                return ( l1 && l2 && l3 && l4);

        }

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

        // Generate 64-byte SHA-256

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

        public String SHA256(String userAlias, String password) {

                try {

                        String strID = userAlias;

                        MessageDigest md;

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

                        byte[] sha256hash = new byte[64];

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

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

                        sha256hash = md.digest();

                        return convertToHex(sha256hash);

                } catch (NoSuchAlgorithmException e) { e.printStackTrace(); }

                  catch (UnsupportedEncodingException e) { e.printStackTrace(); }

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

          }        

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

        // Generate 40-byte SHA-1

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

        public String SHA1(String userAlias, String password) {

                try {

                        String strID = userAlias;

                        MessageDigest md;

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

                        byte[] sha1hash = new byte[40];

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

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

                        sha1hash = md.digest();

                        return convertToHex(sha1hash);

                } catch (NoSuchAlgorithmException e) { e.printStackTrace(); }

                  catch (UnsupportedEncodingException e) { e.printStackTrace(); }

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

            }

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

        // Convert byte to hex

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

        private String convertToHex(byte[] data) {

                StringBuffer buf = new StringBuffer();

                for (int i = 0; i < 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();

            }

        /**

         * <pre>

         * Validate dataToValidate with regular expression the defined in the patternStr.

         * Sample Regular Expression for different needs:-

         *

         ======================

         Username Pattern

         ======================

        "^[a-zA-Z0-9_-]{6,16}$"

                        - allow a-z, A-Z, 0-9, dash and underscore characters, min length 6, max length 16

        "^[a-zA-Z0-9_-]{6,}$"

                        - allow a-z, A-Z, 0-9, dash and underscore characters, min length 6

         *</pre>

         <pre>

         ======================

         Password Pattern

         ======================

          "(?=.*\\d).*" 

                          - must contains at least one digit from 0-9

          "(?=.*\\w).*" 

                          - must contains at lease one character from 0-9, a-z or A-Z

          "(?=.*[A-Z]).*"         

                          - must contains at lease one UPPER case characters

          "(?=.*[a-z]).*"                 

                          - must contains at lease one lower case characters

          "(?=.*\\d)(?=.*[a-zA-Z]).*" 

                          - must contains at least one digit from 0-9 and at lease one character from 0-9, a-z or A-Z

          "(?=.*[!@#$%^&*()_+<>?]).*"  

                          - must contains one special symbols in the list "!@#$%^&*()_+<>?"

          "(?=.*\\d)(?=.*[A-Z]).*"                                  

                          - must contains one digit from 0-9 and one UPPER case characters

          "(?=.*\\d)(?=.*[a-z]).*"                                  

                          - must contains one digit from 0-9 and one lower case characters

          "(?=.*\\d)(?=.*[a-zA-Z]).*"                                  

                          - must contains one digit from 0-9, one lower case characters and one UPPER case characters

          "(?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+<>?]).*"                                  

                          - must contains one digit from 0-9, one lower case characters, one UPPER case characters and one special symbols in the list "!@#$%^&*()_+<>?"

          "(?=.*[a-z])(?=.*[A-Z]).{8,16}"                                  

                          - must contains one lower case characters and one UPPER case characters

          "(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+<>?]).*"                                  

                          - must contains one lower case characters, one UPPER case characters and one special symbols in the list "!@#$%^&*()_+<>?"

        </pre>

        ========================================================================

        <pre>

          "(?=.*\\d).{8,}" 

                          - must contains at least one digit from 0-9 and length at least 8 characters

          "(?=.*\\w).{8,}" 

                          - must contains at lease one character from 0-9, a-z or A-Z and length at least 8 characters

          "(?=.*[A-Z]).{8,}"         

                          - must contains at lease one UPPER case characters and length at least 8 characters

          "(?=.*[a-z]).{8,}"                 

                          - must contains at lease one lower case characters and length at least 8 characters

          "(?=.*[!@#$%^&*()_+<>?]).{8,}"  

                          - must contains one special symbols in the list "!@#$%^&*()_+<>?" and length at least 8 characters

          "(?=.*\\d)(?=.*[A-Z]).{8,}"                                  

                          - must contains one digit from 0-9, one UPPER case characters and length at least 8 characters

          "(?=.*\\d)(?=.*[a-z]).{8,}"                                  

                          - must contains one digit from 0-9, one lower case characters and length at least 8 characters

          "(?=.*\\d)(?=.*[a-zA-Z]).{8,}"                                  

                          - must contains one digit from 0-9, one lower case characters, one UPPER case characters and length at least 8 characters

          "(?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+<>?]).{8,}"                                  

                          - must contains one digit from 0-9, one lower case characters, one UPPER case characters, one special symbols in the list "!@#$%^&*()_+<>?" and length at least 8 characters

          "(?=.*[a-z])(?=.*[A-Z]).{8,16}"                                  

                          - must contains one lower case characters, one UPPER case characters and length at least 8 characters

          "(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+<>?]).{8,}"                                  

                          - must contains one lower case characters, one UPPER case characters, one special symbols in the list "!@#$%^&*()_+<>?" and length at least 8 characters

        </pre>

        ========================================================================

        <pre>

          "(?=.*\\d).{8,16}" 

                          - must contains at least one digit from 0-9 and length at least 8 characters and maximum of 16

          "(?=.*\\w).{8,16}" 

                          - must contains at lease one character from 0-9, a-z or A-Z and length at least 8 characters and maximum of 16

          "(?=.*[A-Z]).{8,16}"         

                          - must contains at lease one UPPER case characters and length at least 8 characters and maximum of 16

          "(?=.*[a-z]).{8,16}"                 

                          - must contains at lease one lower case characters and length at least 8 characters and maximum of 16

          "(?=.*[!@#$%^&*()_+<>?]).{8,16}"  

                          - must contains one special symbols in the list "!@#$%^&*()_+<>?" and length at least 8 characters and maximum of 16

          "(?=.*\\d)(?=.*[A-Z]).{8,16}"                                  

                          - must contains one digit from 0-9, one UPPER case characters and length at least 8 characters and maximum of 16

          "(?=.*\\d)(?=.*[a-z]).{8,16}"                                  

                          - must contains one digit from 0-9, one lower case characters and length at least 8 characters and maximum of 16

          "(?=.*\\d)(?=.*[a-zA-Z]).{8,16}"                                  

                          - must contains one digit from 0-9, one lower case characters, one UPPER case characters and length at least 8 characters and maximum of 16

          "(?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+<>?]).{8,16}"                                  

                          - must contains one digit from 0-9, one lower case characters, one UPPER case characters, one special symbols in the list "!@#$%^&*()_+<>?" and length at least 8 characters and maximum of 16

          "(?=.*[a-z])(?=.*[A-Z]).{8,16}"                                  

                          - must contains one lower case characters, one UPPER case characters and length at least 8 characters and maximum of 16

          "(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*()_+<>?]).{8,16}"                                  

                          - must contains one lower case characters, one UPPER case characters, one special symbols in the list "!@#$%^&*()_+<>?" and length at least 8 characters and maximum of 16

        </pre>

        *<pre>

         ======================

         Email Pattern

         ======================

                "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$"

        </pre>

        <pre>

        ===========================

        Acceptable patter

        ===========================

        "^[a-zA-Z0-9!@#$%^&*()_+<>?]{0,}$"

                - Accept a-z, A-Z, 0-9 and !@#$%^&*()_+<>? characters

        "^[a-zA-Z0-9]{0,}$"

            - Accept a-z, A-Z and 0-9

        </pre>

    * 

   * @param dataToValidate Data for validation

   * @param patternStr The java regular expression pattern

   * @see http://docs.oracle.com/javase/1.4.2/docs/api/java/util/regex/Pattern.html

   * @return true valid password, false invalid password

   */

        public boolean patternValidator(final String dataToValidate, final String patternStr) {

                 Matcher matcher;

                 Pattern pattern = Pattern.compile(patternStr);

                 matcher = pattern.matcher(dataToValidate);

                 boolean macth= matcher.matches();

                 if (!macth) {

                         logger.error("ValidatePassword: Pattern not match! "+"Data="+dataToValidate+" Pattern to match="+patternStr);

                 }

                 return macth;

        }

        /**

         * 

         * @return true if user is not active for N period of time; otherwise false

         */

        public boolean isUserDormant() 

        {

                //Root and Admin is exempted from dormant period

                if (userBean.getUserType() == Constants.UTYPE_STATE_ROOT || userBean.getUserType() == Constants.UTYPE_STATE_ADMIN) 

                {

                        logger.info("Admin Dormant Check");

                        return false;

                }

                Date lastUseDate = userBean.getPdateLastUsed();

                logger.info("User Dormant Check");

                int numberOfDayNotActive = getDiffDateInDays(lastUseDate,  new Date());

                if (numberOfDayNotActive> getConfigBean ().getUserDormantPeriod()) 

                {

                        logger.info("User Dormant Found");

                        return true;

                }

                return false;

        }

        /**

         * Will compare the given 2 time object and calculate the time difference in number of days.

         *

         * @param earlierDate The earlier date

         * @param laterDate The later date

         * @return The time different between two dates in number of days. 

         */

        public static int getDiffDateInDays(Date earlierDate, Date laterDate)

        {

                 Calendar calendar1 = Calendar.getInstance();

                 Calendar calendar2 = Calendar.getInstance();

                 calendar1.setTime(earlierDate);

                 calendar2.setTime(laterDate);

                 long milliseconds1 = calendar1.getTimeInMillis();

                 long milliseconds2 = calendar2.getTimeInMillis();

                 long diff = milliseconds2 - milliseconds1;

                 long diffDays = diff / 86400000; //(24 * 60 * 60 * 1000);

                 return (int)diffDays;

        }

        public static void main(String [] args)        {

                PasswordController pass = new PasswordController();

//                String cipherText1 = pass.SHA1("wakakaka", "aaaa0000");

                String cipherText256 = pass.SHA256("cust03", "aaaa1111");

                System.out.println(pass.patternValidator("aaaa7777","(?=.*\\w).{8,12}"));

//                System.out.println(cipherText1);

//                System.out.println("------------");

                System.out.println(cipherText256);

        }

}