Session key and MAC generation in SCP '02' i='15'

Question

Hi,
I am trying send a PUT KEY command and it resolves to '6982' after a '9000' EXTERNAL AUTHENTICATE.
I suspect that my encryption is causing the problem.(not really sure!)
I compare my session keys to some that ppl had derived and posted on the forum and I don't really get what they did.
I am trying to find out if I'm deriving the correct session keys or not?!?!
e.g
//Calculating session keys with
//static key = '404142434445464748494a4b4c4d4e4f' (keyData)
//sequence counter = '003b'
//"0101" + sequenceCounter + "000000000000000000000000" for session CMAC key (data)
//"0102" + sequenceCounter + "000000000000000000000000" for session RMAC key (data)
//"0181" + sequenceCounter + "000000000000000000000000" for session DEK key (data)
//"0182" + sequenceCounter + "000000000000000000000000" for session ENC key (data)
//sessionCMAC is :3213860da8f8d9796794cbcec43ef7a23213860da8f8d979: with sequence counter:003b (result)
//sessionRMAC is :042a687f6e0dd3f80eabf1e5d51ccefe042a687f6e0dd3f8: with sequence counter:003b (result)
//sessionDEK is :1fe31370c22354e3b90d6b8ad5686d371fe31370c22354e3: with sequence counter:003b (result)
//sessionENC is :94a47ad54ffbf423fe4a9d915befab5294a47ad54ffbf423: with sequence counter:003b (result)
<code>
if (keyData.length == 16) {
byte[] temp = (byte[]) keyData.clone();
keyData = new byte[24];
System.arraycopy(temp, 0, keyData, 0, temp.length);
System.arraycopy(temp, 0, keyData, 16, 8);
DESedeKeySpec keySpec = new DESedeKeySpec(keyData);
SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
SecretKey key = secretKeyFactory.generateSecret(keySpec);
IvParameterSpec iv = new IvParameterSpec(new byte[]{0, 0, 0, 0, 0, 0, 0, 0});
Cipher desedeCBCCipher = Cipher.getInstance("DESede/CBC/NoPadding");
desedeCBCCipher.init(Cipher.ENCRYPT_MODE, key, iv);
byte[] result = desedeCBCCipher.doFinal(data);
if (result .length == 16) {
byte[] temp = (byte[]) result .clone();
result = new byte[24];
System.arraycopy(temp, 0, result , 0, temp.length);
System.arraycopy(temp, 0, result , 16, 8);
keySpec = new DESedeKeySpec(result);
secretKeyFactory = SecretKeyFactory.getInstance("DESede");
key = secretKeyFactory.generateSecret(keySpec);
</code>
I use the same encrytion to derive KeyCheckValue with
newKey ='505152535455565758595a5b5c5d5e5f', data = '0000000000000000'
and it results to : '6d377e' (of course the last 3 bytes)
Even though my CMAC session key is different from others (e.g "RLopes" in "http://192.9.162.102/thread.jspa?threadID=5365173&tstart=363" and I have seen it in others too and its really odd to me that its slightly different if you take a close look you will get what i mean) i get the EXTERNAL AUTHENTICATION to work.
If there is anyone who is 100% sure meaning he/she got other commands to work after EXTERNAL AUTHENTICATE using CMAC please help me verify the keys I got?
Can he/she test with his code to see if he/she is getting the same session keys or check value?
Thanks in advance
Kamran

Answer 1

Hi,
Here is the Class and thanks for the tip, I've honestly tried these <code></code> but didn't work and I know it is indeed annoying without the tags :D
I really hope it helps...
* To change this template, choose Tools | Templates
* and open the template in the editor.
package terminalpcsc;
import java.lang.Exception;
import java.security.GeneralSecurityException;
import java.security.Key;
import java.security.SecureRandom;
import java.util.List;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.security.sasl.AuthenticationException;
import javax.smartcardio.*;
* @author Kamran
* @param args the command line arguments
public class Main {
    private static CardChannel channel;
    private static Card card;
    private static int CHALLENGE_LENGTH = 8;
    private static byte[] keyDiversification = new byte[10];
    private static byte[] keyInformation = new byte[2];
    private static byte[] sequenceCounter = new byte[2];
    private static byte[] cardChallenge = new byte[6];
    private static byte[] cardCryptogram = new byte[8];
    private static byte[] hostChallenge = new byte[8];
    private static byte[] hostCryptogram = new byte[8];
    private static String keyDiversificationHexString;
    private static String keyInformationHexString;
    private static String sequenceCounterHexString;
    private static String cardChallengeHexString;
    private static String cardCryptogramHexString;
    private static String hostChallengeHexString;
    private static String hostCryptogramHexString;
    private static byte[] sessionCMAC;
    private static byte[] sessionDEK;
    private static byte[] sessionENC;
    private static byte[] sessionRMAC;
    private static byte[] icvNextCommand;
    private static IvParameterSpec ivAllZeros = new IvParameterSpec(new byte[]{0, 0, 0, 0, 0, 0, 0, 0});
    private static byte[] staticKey = hexStringToByteArray("404142434445464748494a4b4c4d4e4f4041424344454647");
    private static byte[] newKey = hexStringToByteArray("505152535455565758595a5b5c5d5e5f");
    private static byte[] CMAC;
     * @param args the command line arguments
    public static void main(String[] args) throws Exception {
        initiateCardChannel();
        String apduString = generateSelectAPDU("a000000003535041");
        byte[] bufferC = hexStringToByteArray(apduString);
        CommandAPDU capdu = new CommandAPDU(bufferC);
        System.out.println("Sending APDU Select AID: " + byteArrayToHexString(bufferC));
        ResponseAPDU rapdu = channel.transmit(capdu);
        System.out.println("Sending Apdu: Done!");
        System.out.println("Waiting For Response...");
        byte[] bufferR = rapdu.getData();
        String responseData = byteArrayToHexString(rapdu.getBytes());
        System.out.println("Response: " + responseData);
        apduString = generateInitializeUpdateAPDU();
        bufferC = hexStringToByteArray(apduString);
        capdu = new CommandAPDU(bufferC);
        System.out.println("Sending APDU Initialize Update: " + byteArrayToHexString(bufferC));
        rapdu = channel.transmit(capdu);
        System.out.println("Sending Apdu: Done!");
        System.out.println("Waiting For Response...");
        bufferR = rapdu.getData();
        responseData = byteArrayToHexString(rapdu.getBytes());
        System.out.println("Response: " + responseData);
        // protocol 01
        //System.arraycopy(bufferR,0,keyDiversification,0,10);
        //System.arraycopy(bufferR,10,keyInformation,0,2);
        //System.arraycopy(bufferR,12,cardChallenge,0,8);
        //System.arraycopy(bufferR,20,cardCryptogram,0,8);
        // protocol 02
        System.arraycopy(bufferR, 0, keyDiversification, 0, 10);
        System.arraycopy(bufferR, 10, keyInformation, 0, 2);
        System.arraycopy(bufferR, 12, sequenceCounter, 0, 2);
        System.arraycopy(bufferR, 14, cardChallenge, 0, 6);
        System.arraycopy(bufferR, 20, cardCryptogram, 0, 8);
        keyDiversificationHexString = byteArrayToHexString(keyDiversification);
        keyInformationHexString = byteArrayToHexString(keyInformation);
        sequenceCounterHexString = byteArrayToHexString(sequenceCounter);
        cardChallengeHexString = byteArrayToHexString(cardChallenge);
        cardCryptogramHexString = byteArrayToHexString(cardCryptogram);
        System.out.println("keyDiversification: " + keyDiversificationHexString);
        System.out.println("keyInformation: " + keyInformationHexString);
        System.out.println("sequenceCounter: " + sequenceCounterHexString);
        System.out.println("cardChallenge: " + cardChallengeHexString);
        System.out.println("cardCryptogram: " + cardCryptogramHexString);
        System.out.println("Calculating Session Keys... encryption with CBC");
        //E.4.1 GP 2.1.1
        sessionCMAC = deriveEncryptionCBC(staticKey, hexStringToByteArray("0101" + sequenceCounterHexString + "000000000000000000000000"));
        System.out.println("sessionCMAC is :" + byteArrayToHexString(sessionCMAC) + ": with sequence counter:" + sequenceCounterHexString);
        sessionRMAC = deriveEncryptionCBC(staticKey, hexStringToByteArray("0102" + sequenceCounterHexString + "000000000000000000000000"));
        System.out.println("sessionRMAC is :" + byteArrayToHexString(sessionRMAC) + ": with sequence counter:" + sequenceCounterHexString);
        sessionDEK = deriveEncryptionCBC(staticKey, hexStringToByteArray("0181" + sequenceCounterHexString + "000000000000000000000000"));
        System.out.println("sessionDEK is :" + byteArrayToHexString(sessionDEK) + ": with sequence counter:" + sequenceCounterHexString);
        sessionENC = deriveEncryptionCBC(staticKey, hexStringToByteArray("0182" + sequenceCounterHexString + "000000000000000000000000"));
        System.out.println("sessionENC is :" + byteArrayToHexString(sessionENC) + ": with sequence counter:" + sequenceCounterHexString);
        System.out.println("Calculating and Verifying Card Cryptogram...");
        byte[] signature = cbcMACSignature(hexStringToByteArray(hostChallengeHexString + sequenceCounterHexString + cardChallengeHexString + "8000000000000000"), sessionENC);
        String signatureHexString = byteArrayToHexString(signature);
        if (signatureHexString.equalsIgnoreCase(cardCryptogramHexString)) {
            System.out.println("signature is :" + signatureHexString + "\ncardCryptogram is :" + cardCryptogramHexString + " \nCard cryptogram authenticated");
            apduString = generateExternalAuthenticateAPDU();
            bufferC = hexStringToByteArray(apduString);
            capdu = new CommandAPDU(bufferC);
            System.out.println("Sending APDU External Authenticate: " + byteArrayToHexString(bufferC));
            rapdu = channel.transmit(capdu);
            System.out.println("Sending Apdu: Done!");
            System.out.println("Waiting For Response...");
            bufferR = rapdu.getData();
            responseData = byteArrayToHexString(rapdu.getBytes());
            System.out.println("Response: " + responseData);
            apduString = generatePutKeyAPDU();
            bufferC = hexStringToByteArray(apduString);
            capdu = new CommandAPDU(bufferC);
            System.out.println("Sending APDU Put Key: " + byteArrayToHexString(bufferC));
            rapdu = channel.transmit(capdu);
            System.out.println("Sending Apdu: Done!");
            System.out.println("Waiting For Response...");
            bufferR = rapdu.getData();
            responseData = byteArrayToHexString(rapdu.getBytes());
            System.out.println("Response: " + responseData);
        } else {
            System.out.println("signature is :" + signatureHexString + "\ncardCryptogram is :" + cardCryptogramHexString + " \nCard cryptogram is not authenticated");
        releaseCardChannel();
    public static byte[] cbcMACSignature(byte[] data, byte[] sessionSENC) throws AuthenticationException {
        IvParameterSpec params =
                new IvParameterSpec(new byte[]{0, 0, 0, 0, 0, 0, 0, 0});
        if (sessionSENC.length == 16) {
            byte[] temp = (byte[]) sessionSENC.clone();
            sessionSENC = new byte[24];
            System.arraycopy(temp, 0, sessionSENC, 0, temp.length);
            System.arraycopy(temp, 0, sessionSENC, 16, 8);
        byte[] temp = null;
        SecretKey secretKey = new SecretKeySpec(sessionSENC, "DESede");
        try {
            Cipher cbcDES = Cipher.getInstance("DESede/CBC/NoPadding");
            cbcDES.init(Cipher.ENCRYPT_MODE, secretKey, params);
            temp = cbcDES.doFinal(data);
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        byte[] signature = new byte[8];
        System.arraycopy(temp, temp.length - 8, signature, 0, signature.length);
        return signature;
    // generateInitialUpdateAPDU()
    //CLA '80'
    //INS '50' INITIALIZE UPDATE
    //P1 'xx' Key Version Number
    //P2 '00' Reference control parameter P2
    //Lc '08' Length of host challenge
    //Data 'xx xx…' Host challenge
    //Le '00'
    //RESPONSE TEMPLATE
    //Key diversification data 10 bytes
    //Key information 2 bytes
    //Card challenge 8 bytes
    //Card cryptogram 8 bytes
    public static String generateInitializeUpdateAPDU() throws Exception {
        hostChallenge = generateHostChallenge();
        hostChallengeHexString = byteArrayToHexString(hostChallenge);
        return "8050000008" + hostChallengeHexString + "00";
    //CLA '80' or '84'
    //INS 'D8' PUT KEY
    //P1 'xx' Reference control parameter P1 Key Version Number -- '00' is new key  range is '01' to '7F'
    //P2 'xx' Reference control parameter P2 Key Identifier     -- '00' to '7F'
    //Lc 'xx' Length of data field
    //Data 'xxxx..' Key data (and MAC if present)
    //Le '00'
    public static String generatePutKeyAPDU() throws Exception {
        String keyCheckValue = new String();
        //keyCheckValue = keyCheckValue.substring(keyCheckValue.length() - (3 * 2));
        keyCheckValue = byteArrayToHexString(deriveEncryptionECB(newKey, hexStringToByteArray("0000000000000000")));
        keyCheckValue = keyCheckValue.substring(keyCheckValue.length() - (3 * 2));
        System.out.println("keyCheckValue :" + keyCheckValue + " 3DES ECB, key is new key '505152535455565758595a5b5c5d5e5f5051525354555657', data is 8 zeroes");
        String encryptedNewKey = byteArrayToHexString(deriveEncryptionECB(sessionDEK, newKey));
        //System.out.println("sessionDEK.getEncoded() :" + sessionDEK.getEncoded() + " len is:" + sessionDEK.getEncoded().length);
        System.out.println("encryptedNewKey :" + encryptedNewKey);
        //testing newKey
        String dataField = "01" + "8010" + encryptedNewKey + "03" + keyCheckValue + "8010" + encryptedNewKey + "03" + keyCheckValue + "8010" + encryptedNewKey + "03" + keyCheckValue;
        // String dataField2 = "01" + "8010" + byteArrayToHexString(newKey) + "03" + keyCheckValue + "8010" + byteArrayToHexString(newKey) + "03" + keyCheckValue + "8010" + byteArrayToHexString(newKey) + "03" + keyCheckValue;
        System.out.println("datafield to calculate cmac :" + dataField);
        System.out.println("icv to calculate cmac is previous mac first 8 byte sessionCMAC in CBC single des :" + byteArrayToHexString(icvNextCommand));
        CMAC = generateCMac2((byte) 0x84, (byte) 0xD8, (byte) 0x00, (byte) 0x81, hexStringToByteArray(dataField), sessionCMAC, icvNextCommand);
        System.out.println("data field with des padding for encryption (encryption in CBC sessionENC) :" + desPadding(dataField));
        String dataField3 = byteArrayToHexString(deriveEncryptionCBC(sessionENC, hexStringToByteArray(desPadding(dataField))));
        System.out.println("data field after encryption :" + dataField3);
        Integer CMACLen = byteArrayToHexString(CMAC).length() / 2;
        System.out.println("CMACLen :" + CMACLen);
        Integer dataFieldLen = dataField3.length() / 2;
        System.out.println("dataFieldLen :" + dataFieldLen);
        Integer intLc = dataFieldLen + CMACLen;
        System.out.println("intLc :" + intLc);
        String hexLc = Integer.toString(intLc, 16);
        System.out.println("hexLc :" + hexLc);
        return "84D80081" + hexLc + dataField3 + byteArrayToHexString(CMAC) + "00";
    //generateExternalAuthenticateAPDU()
    //CLA '84'
    //INS '82' EXTERNAL AUTHENTICATE
    //P1 'xx' Security level  --'03' C-DECRYPTION and C-MAC.--'01' C-MAC.'00' No secure messaging expected.
    //P2 '00' Reference control parameter P2
    //Lc '10' Length of host cryptogram and MAC
    //Data 'xx xx…' Host cryptogram and MAC
    //Le Not present
    public static String generateExternalAuthenticateAPDU() throws Exception {
        System.out.println("Calculating and Verifying Host Cryptogram...");
        hostCryptogram = cbcMACSignature(hexStringToByteArray(sequenceCounterHexString + cardChallengeHexString + hostChallengeHexString + "8000000000000000"), sessionENC);
        hostCryptogramHexString = byteArrayToHexString(hostCryptogram);
        System.out.println("hostCryptogram is :" + hostCryptogramHexString);
        CMAC = generateCMac2((byte) 0x84, (byte) 0x82, (byte) 0x03, (byte) 0x00, hostCryptogram, sessionCMAC, new byte[]{0, 0, 0, 0, 0, 0, 0, 0});
        return "8482030010" + hostCryptogramHexString + byteArrayToHexString(CMAC);
    // generateSelectAPDU()
    //CLA '00' ISO/IEC 7816-4 command
    //INS 'A4' SELECT
    //P1 'xx' Reference control parameter P1 --'04' select by name
    //P2 'xx' Reference control parameter P2 --'00' First or only occurrence --'02' Next occurrence
    //Lc 'xx' Length of AID
    //Data 'xxxx..' AID of Application to be selected
    //Le '00'
    // RESPONSE TEMPLATE
    //'6F' File Control Information (FCI template) Mandatory
    //'84' Application / file AID Mandatory
    //'A5' Proprietary data Mandatory
    //'73' Security Domain Management Data (see Appendix F for detailed coding) Optional
    //'9F6E' Application production life cycle data Optional
    //'9F65' Maximum length of data field in command message Mandatory
    public static String generateSelectAPDU(String AID) throws Exception {
        String AIDlen = Integer.toString(AID.length() / 2, 16);
        if (AIDlen.length() == 1) {
            AIDlen = "0" + AIDlen;
        System.out.println("00A40400" + AIDlen + AID);
        return "00A40400" + AIDlen + AID;
    public static String byteArrayToHexString(byte[] b) throws Exception {
        String result = "";
        for (int i = 0; i < b.length; i++) {
            result +=
                    Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1);
        return result;
    public static void initiateCardChannel() throws CardException {
        System.out.println("Connecting to Java Card...");
        TerminalFactory factory = TerminalFactory.getDefault();
        List<CardTerminal> terminals = factory.terminals().list();
        System.out.println("Terminals Detected: " + terminals);
        // get the first terminal
        System.out.println("Connecting to: " + terminals + "...");
        CardTerminal terminal = terminals.get(0);
        System.out.println("Connected to: " + terminals);
        // establish a connection with the card
        System.out.println("Connecting to Java Card...");
        card = terminal.connect("T=0");
        System.out.println("Connected to card: " + card);
        System.out.println("Obtaining Channel...");
        channel = card.getBasicChannel();
        System.out.println("Connecting to Channel: " + channel.getChannelNumber());
    public static void releaseCardChannel() throws CardException {
        System.out.println("Disconnection all...");
        card.disconnect(false);
        System.out.println("Disconnection Done");
        System.out.println("*END*");
    public static byte[] hexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
        return data;
    //To generate the derivation data:
    public static byte[] deriveEncryptionCBC(byte[] keyData, byte[] data) throws GeneralSecurityException {
        //Key key = getSecretKey(keyData);
        if (keyData.length == 16) {
            byte[] temp = (byte[]) keyData.clone();
            keyData = new byte[24];
            System.arraycopy(temp, 0, keyData, 0, temp.length);
            System.arraycopy(temp, 0, keyData, 16, 8);
        SecretKey secretKey = new SecretKeySpec(keyData, "DESede");
        IvParameterSpec dps =
                new IvParameterSpec(new byte[]{0, 0, 0, 0, 0, 0, 0, 0});
        String algorithm = "DESede/CBC/NoPadding";
        Cipher desedeCBCCipher = Cipher.getInstance(algorithm);
        desedeCBCCipher.init(Cipher.ENCRYPT_MODE, secretKey, dps);
        byte[] result = desedeCBCCipher.doFinal(data);
        //adjustParity(result);
        return result;
    public static byte[] deriveEncryptionECB(byte[] keyData, byte[] data) throws GeneralSecurityException {
        //Key key = getSecretKey(keyData);
        if (keyData.length == 16) {
            byte[] temp = (byte[]) keyData.clone();
            keyData = new byte[24];
            System.arraycopy(temp, 0, keyData, 0, temp.length);
            System.arraycopy(temp, 0, keyData, 16, 8);
        SecretKey secretKey = new SecretKeySpec(keyData, "DESede");
        String algorithm = "DESede/ECB/NoPadding";
        Cipher desedeCBCCipher = Cipher.getInstance(algorithm);
        desedeCBCCipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] result = desedeCBCCipher.doFinal(data);
        //adjustParity(result);
        return result;
     * Adjust a DES key to odd parity
     * @param key
     *            to be adjusted
    public static byte[] adjustParity(byte[] key) {
        for (int i = 0; i < key.length; i++) {
            int akku = (key[i] & 0xFF) | 1;
            for (int c = 7; c > 0; c--) {
                akku = (akku & 1) ^ (akku >> 1);
            key[i] = (byte) ((key[i] & 0xFE) | akku);
        return key;
    public static byte[] generateCMac2(byte cla, byte ins, byte p1, byte p2, byte[] dataField, byte[] SMacSessionKey, byte[] icv) throws GeneralSecurityException, Exception {
        if (SMacSessionKey.length == 16) {
            byte[] temp = (byte[]) SMacSessionKey.clone();
            SMacSessionKey = new byte[24];
            System.arraycopy(temp, 0, SMacSessionKey, 0, temp.length);
            System.arraycopy(temp, 0, SMacSessionKey, 16, 8);
        byte[] cMac = new byte[8];
        byte[] padding = {(byte) 0x80, 0, 0, 0, 0, 0, 0, 0};
        int paddingRequired = 8 - (5 + dataField.length) % 8;
        byte[] data = new byte[5 + dataField.length + paddingRequired];
        //Build APDU
        data[0] = cla;
        data[1] = ins;
        data[2] = p1;
        data[3] = p2;
        data[4] = (byte) ((byte) dataField.length + (byte) 0x08);
        System.arraycopy(dataField, 0, data, 5, dataField.length);
        System.arraycopy(padding, 0, data, 5 + dataField.length, paddingRequired);
        System.out.println("data to calculate mac :" + byteArrayToHexString(data));
        System.out.println("icv to calculate mac :" + byteArrayToHexString(icv));
        Cipher cipher = Cipher.getInstance("DESede/CBC/NoPadding");
        Cipher singleDesCipher = Cipher.getInstance("DES/CBC/NoPadding", "SunJCE");
        SecretKeySpec desSingleKey = new SecretKeySpec(SMacSessionKey, 0, 8, "DES");
        SecretKey secretKey = new SecretKeySpec(SMacSessionKey, "DESede");
        //Calculate the first n - 1 block. For this case, n = 1
        IvParameterSpec ivSpec = new IvParameterSpec(icv);
        singleDesCipher.init(Cipher.ENCRYPT_MODE, desSingleKey, ivSpec);
        byte ivForLastBlock[] = singleDesCipher.doFinal(data, 0, 8);
        int blocks = data.length / 8;
        for (int i = 0; i < blocks - 1; i++) {
            singleDesCipher.init(Cipher.ENCRYPT_MODE, desSingleKey, ivSpec);
            byte[] block = singleDesCipher.doFinal(data, i * 8, 8);
            ivSpec = new IvParameterSpec(block);
        int offset = (blocks - 1) * 8;
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec);
        cMac = cipher.doFinal(data, offset, 8);
        ivSpec = new IvParameterSpec(new byte[8]);
        singleDesCipher.init(Cipher.ENCRYPT_MODE, desSingleKey, ivSpec);
        icvNextCommand = singleDesCipher.doFinal(cMac);
        return cMac;
    public static byte[] generateHostChallenge() {
        byte[] hostChallenge = new byte[CHALLENGE_LENGTH];
        SecureRandom random = new SecureRandom();
        random.nextBytes(hostChallenge);
        return hostChallenge;
    public static String desPadding(String hexString) {
        System.out.println("String to pad before:" + hexString);
        hexString = hexString + "80";
        int hexStringLen = hexString.length() / 2;
        int padding = 8 - (hexStringLen % 8);
        for (int i = 0; i < padding; i++) {
            hexString = hexString + "00";
        System.out.println("String to pad after :" + hexString);
        return hexString;
}Thanks in advance
Kamran