bankingHcuConnectTest.php

<?php

use PHPUnit\Framework\TestCase;

require_once 'SSOEncryption.i';

class HcuConnectTest extends TestCase {
    function setUp() {
        $this->Cu = "SCRUBCU";
        $this->key = substr(hash("md5", $this->Cu.":testkeysuffix"), 0, 24);
        $this->key_pub = substr(hash("md5", $this->Cu.":testkeypub"), 0, 24);
        $this->common_cbc_iv = base64_decode("QvkbnYUwcyw=");
    }

    function test_3des_cbc_ticket_chkfree() {
        $digeststr = "ts=yyyy&ss=xxxx&pw=pwdpwd}";
        $digest = base64_encode(sha1("$digeststr", true));
        $ticket = "$digeststr&dg=$digest";

        list($enc_openssl,
             $ticket_padded_openssl) = encrypt_ticket_openssl($ticket,
                                                              $this->key,
                                                              $this->common_cbc_iv);

        $dec_openssl = decrypt_ticket_openssl($enc_openssl,
                                              $this->key,
                                              $this->common_cbc_iv);

        $this->assertEquals($dec_openssl, $ticket_padded_openssl);

        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {

            // encrypt padded string with mcrypt
             list($enc_mcrypt,
                 $ticket_padded_mcrypt) = encrypt_ticket_mcrypt($ticket,
                                                                $this->key,
                                                                $this->common_cbc_iv);
            // decrypt with mcrypt
            $dec_mcrypt = decrypt_ticket_mcrypt($enc_mcrypt,
                                                $this->key,
                                                $this->common_cbc_iv);
            $this->assertEquals($dec_mcrypt, $ticket_padded_mcrypt);

            // assert openssl and mcrypt generate same ciphertext
            $this->assertEquals($enc_openssl, $enc_mcrypt);

            // assert openssl and mcrypt used same padded string
            $this->assertEquals($ticket_padded_openssl, $ticket_padded_mcrypt);

            // decrypt the mcrypt encrypted content using the same encryption
            // mode, and assert with the original padded string
            $enc_mcrypt_dec_openssl = decrypt_ticket_openssl($enc_mcrypt,
                                                             $this->key,
                                                             $this->common_cbc_iv);
            $this->assertEquals($enc_mcrypt_dec_openssl, $ticket_padded_mcrypt);
        }
    }

    function test_3des_cbc_ezcard_sso() {
        // encryption and decryption compatibility test
        // does not use the actual keys and IVs
        $clientId = "12345";
        $sv0 = substr('00000000' . strval(rand(1, 99999999)), -8);
        $card4="4567";
        $cardsig="68iq1Lg3DZeJsvXtyryOkJEVuAgOp2CxDnu9YgTcaQax";
        $cardtype="P";
        $Ml="someone@sampleuser.com";
        $edate="11/13/2009 20:00:00";
        $salt = 'KLxK-We8';

        $sso_request = "<SSORequest AcctLast4=\"$card4\" AcctSignature=\"$cardsig\" CardType=\"$cardtype\" EmailAddress=\"$Ml\" ExpireDateTime=\"$edate\" sv0=\"$sv0\" />";
        $priviv = $this->common_cbc_iv;

        // OPENSSL based tests
        list($sso_request_openssl,
             $enc_inner_openssl,
             $sso_wrap_openssl,
             $enc_outer_openssl) = encrypt_ezcard_sso($sso_request,
                                                      $clientId,
                                                      $this->key,
                                                      $this->key_pub,
                                                      $priviv,
                                                      $salt);

        $dec_openssl_outer = decrypt_ezcard_openssl($enc_outer_openssl,
                                                  $this->key_pub,
                                                  $priviv);
        $this->assertEquals($dec_openssl_outer, $sso_wrap_openssl);

        $dec_openssl_inner = decrypt_ezcard_openssl($enc_inner_openssl,
                                                  $this->key,
                                                  $priviv);
        $this->assertEquals($dec_openssl_inner, $sso_request_openssl);

        // MCRYPT based test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {

            // encrypt inner and outer packet with mcrypt
            list($sso_request_mcrypt,
                 $enc_inner,
                 $sso_wrap_mcrypt,
                 $enc_out) = encrypt_ezcard_sso_mcrypt($sso_request,
                                                       $clientId,
                                                       $this->key,
                                                       $this->key_pub,
                                                       $priviv,
                                                       $salt);

            // decrypt outer packet with mcrypt
            $dec_mcrypt_outer = decrypt_ezcard_mcrypt($enc_out,
                                                      $this->key_pub,
                                                      $priviv);
            $this->assertEquals($dec_mcrypt_outer, $sso_wrap_mcrypt);


            // assert mcrypt and openssl generated same outer packet ciphertext
            $this->assertEquals($enc_out, $enc_outer_openssl);

            // assert mcrypt and openssl use same padded outer packet string
            $this->assertEquals($sso_wrap_mcrypt, $sso_wrap_openssl);

            // decrypt mcrypt encrypted outer packet with openssl
            $enc_mcrypt_dec_openssl_out = decrypt_ezcard_openssl($enc_out,
                                                                 $this->key_pub,
                                                                 $priviv);
            $this->assertEquals($enc_mcrypt_dec_openssl_out, $sso_wrap_mcrypt);


            // decrypt inner packet with mcrypt
            $dec_mcrypt_inner = decrypt_ezcard_mcrypt($enc_inner,
                                                      $this->key,
                                                      $priviv);
            $this->assertEquals($dec_mcrypt_inner, $sso_request_mcrypt);

            // assert mcrypt and openssl generated same inner packet ciphertext
            $this->assertEquals($enc_inner, $enc_inner_openssl);

            // assert mcrypt and openssl use same padded inner packet string
            $this->assertEquals($sso_request_mcrypt, $sso_request_openssl);

            // decrypt mcrypt encrypted inner packet with openssl
            $enc_mcrypt_dec_openssl_inner = decrypt_ezcard_openssl($enc_inner,
                                                                   $this->key,
                                                                   $priviv);
            $this->assertEquals($enc_mcrypt_dec_openssl_inner, $sso_request_mcrypt);
        }
    }

    function test_3des_cbc_ezcard_sso_2() {
        // Actual data received from logging for FIS_EZCARD
        // Uses the actual keys and IVs
        $clientId = "052514";
        $salt = "-1sOztns";

        $card4="0602";
        $cardsig="807vbxwWV9OveEbYK758phggvHWLWarl_wpGXhKodZK3";
        $cardtype="P";
        $Ml="anamagana13@yahoo.com";
        $edate="03/25/19 20:50:40";

        $sso_request = "<SSORequest AcctLast4=\"${card4}\" AcctSignature=\"${cardsig}\" CardType=\"${cardtype}\" EmailAddress=\"${Ml}\" ExpireDateTime=\"${edate}\" />";

        $expected_inner_enc = "5TLwHzkpv1kM4rvZjdegjEmXXKo0rOmJWgXEkkoR-002zQ5-5zuPeA96hmABKG5lhvMRga7f2J5oPZTB6Gsxxon8z8CY2gxFZHDpr-JrS0cWRe1RYH_wPkmxCuRufkmCPnoIGy_mNWkHtzeEYTVvUJ7EWI2uG4K70f98VCuHZZ1rmnNMdL492MFjCDnqoVWRYNbx6x5eAm-Cfe_S3rPdcwrmZiKJjsHbPUQLMZC_P3HdZGYlKgY68A..";

        $expected_wrap_enc = "xzzw8hA0oqkvwcEXncNI4gTzhbkMfMb4MWkRDH_7TnqifWxEjAYmcKMSD5-lCMRrqHc5Bqp4sKWjZ1rEOmKRg-BS3mT7-ciLsaEpsEEqXvvXcuOSPz4mbARQmWLm2M4YFLrxkevsbQT2Rgu56tocLnC2WjGZg79EYZGBzMxomVclstKrfImIl76Gf5vxnxcKDhFqxGZujX3C45FHASjuDUEPns-eElR278R3aPAp3mFHP2RGCmqs_mfi_r7KPyLdwMss6BhjXIWKq5mLD_z488cBBRXsCP-tuZ_G4BSBAFFoNZDqjDO6dnEbtN2TBXwydK-WS98eSYD1IysXpfhGrnV8gWVKttCQhU6dstsbTru6r2asUAXdZQUiNYSbyxn1tsZunPQU5rKAbuAfvd307kpNS3MhNfws";
        $priviv = hex2bin("000000000000000000000000");
        $ezkey_pub = hex2bin("BDA30F6A4DEAFDFA8ACEB0931D0A5BC2777F49EE27AE32B4");
        $ezkey_priv = hex2bin("F495840A66DCC85FF61F9C0C65CDBB38BC62E10AF51FCE78");

        // OPENSSL based tests
        list($sso_request_openssl,
             $enc_inner_openssl,
             $sso_wrap_openssl,
             $enc_outer_openssl) = encrypt_ezcard_sso($sso_request,
                                                      $clientId,
                                                      $ezkey_priv,
                                                      $ezkey_pub,
                                                      $priviv,
                                                      $salt);

        // decrypt outer packet with openssl
        $dec_openssl_outer = decrypt_ezcard_openssl($enc_outer_openssl,
                                                  $ezkey_pub,
                                                  $priviv);
        $this->assertEquals($dec_openssl_outer, $sso_wrap_openssl);

        // decrypt inner packet with openssl
        $dec_openssl_inner = decrypt_ezcard_openssl($enc_inner_openssl,
                                                  $ezkey_priv,
                                                  $priviv);
        $this->assertEquals($dec_openssl_inner, $sso_request_openssl);

        // verify both the inner and outer packet ciphertext are correct for openssl
        $this->assertEquals($enc_outer_openssl, $expected_wrap_enc);
        $this->assertEquals($enc_inner_openssl, $expected_inner_enc);

        // MCRYPT based test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {

            // encrypt inner and outer packet with mcrypt
            list($sso_request_mcrypt,
                 $enc_inner,
                 $sso_wrap_mcrypt,
                 $enc_out) = encrypt_ezcard_sso_mcrypt($sso_request,
                                                       $clientId,
                                                       $ezkey_priv,
                                                       $ezkey_pub,
                                                       $priviv,
                                                       $salt);

            // verify both the inner and outer packet ciphertext
            // are correct for mcrypt
            $this->assertEquals($enc_out, $expected_wrap_enc);
            $this->assertEquals($enc_inner, $expected_inner_enc);

            // decrypt outer packet with mcrypt
            $dec_mcrypt_outer = decrypt_ezcard_mcrypt($enc_out,
                                                      $ezkey_pub,
                                                      $priviv);
            $this->assertEquals($dec_mcrypt_outer, $sso_wrap_mcrypt);


            // assert mcrypt and openssl generated same outer packet ciphertext
            $this->assertEquals($enc_out, $enc_outer_openssl);

            // assert mcrypt and openssl use same padded outer packet string
            $this->assertEquals($sso_wrap_mcrypt, $sso_wrap_openssl);

            // decrypt mcrypt encrypted outer packet with openssl
            $enc_mcrypt_dec_openssl_out = decrypt_ezcard_openssl($enc_out,
                                                                 $ezkey_pub,
                                                                 $priviv);
            $this->assertEquals($enc_mcrypt_dec_openssl_out, $sso_wrap_mcrypt);

            // decrypt inner packet with mcrypt
            $dec_mcrypt_inner = decrypt_ezcard_mcrypt($enc_inner,
                                                      $ezkey_priv,
                                                      $priviv);

            $this->assertEquals($dec_mcrypt_inner, $sso_request_mcrypt);

            // assert mcrypt and openssl generated same inner packet ciphertext
            $this->assertEquals($enc_inner, $enc_inner_openssl);

            // assert mcrypt and openssl use same padded inner packet string
            $this->assertEquals($sso_request_mcrypt, $sso_request_openssl);

            // decrypt mcrypt encrypted inner packet with openssl
            $enc_mcrypt_dec_openssl_inner = decrypt_ezcard_openssl($enc_inner,
                                                                   $ezkey_priv,
                                                                   $priviv);
            $this->assertEquals($enc_mcrypt_dec_openssl_inner, $sso_request_mcrypt);
        }
    }

    function test_3des_ecb_certegy() {
        $showurl=1;
        $FIID="8000"; #CU Institution ID for testing
        // $ACCOUNT="214027153"; # not enrolled
        $ACCOUNT="210328770001"; # enrolled";

        // OPENSSL test
        // encrypt openssl
        list($account_enc_openssl,
             $account_padded_openssl) = encrypt_certegy_openssl($ACCOUNT,
                                                                $this->key);

        // decrypt openssl
        $account_dec_openssl = decrypt_certegy_openssl($account_enc_openssl, $this->key);
        $this->assertEquals($account_padded_openssl, $account_dec_openssl);

        // MCRYPT test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {
            // encrypt with mcrypt
            list($account_enc_mcrypt, $account_padded) = encrypt_certegy_account_mcrypt($ACCOUNT,
                                                                          $this->key);

            // assert mcrypt and openssl generate same ciphertext
            $this->assertEquals($account_enc_openssl, $account_enc_mcrypt);

            // assert mcrypt and openssl use same padded string before encryption
            $this->assertequals($account_padded_openssl, $account_padded);

            // decrypt mcrypt encrypted cipher using openssl
            $account_enc_mcrypt_dec_openssl = decrypt_certegy_openssl($account_enc_mcrypt,
                                                                      $this->key);
            $this->assertEquals($account_padded, $account_enc_mcrypt_dec_openssl);

            // decrypt with mcrypt
            $account_dec_mcrypt = decrypt_certegy_account_mcrypt($account_enc_mcrypt, $this->key);
            $this->assertequals($account_padded, $account_dec_mcrypt);
        }
    }

    function test_3des_ecb_digital() {
        # values for testing
        $CustID="103"; #static string assigned by DigitalMailer
        $ACCOUNT="88888888";
        $servicepass="thisisatest";
        $servicekey="52g2jajrt56syh5j2yf82ngf";
        $showurl=1; # look before we leap
        $currdate = gmdate('YmdHi'); # using GMT
        $GMT = 1;

        $srcstring = "ACCOUNT={$ACCOUNT}&TIMESTAMP={$currdate}&CID={$CustID}&PASS={$servicepass}&GMT={$GMT}";

        // OPENSSL test
        // encrypt openssl
        list($digital_enc_openssl,
             $srcstring_padded_openssl) = encrypt_digital_openssl($srcstring,
                                                                $servicekey);

        // // decrypt openssl
        $digital_dec_openssl = decrypt_digital_openssl($digital_enc_openssl, $servicekey);
        $this->assertEquals($srcstring_padded_openssl, $digital_dec_openssl);

        // MCRYPT test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {
            // encrypt with mcrypt
            list($digital_enc_mcrypt,
                 $srcstring_padded) = encrypt_digital_mcrypt($srcstring,
                                                             $servicekey);

            // assert mcrypt and openssl generate the same ciphertext
            $this->assertEquals($digital_enc_openssl, $digital_enc_mcrypt);

            // assert mcrypt and openssl encrypt same padded string
            $this->assertEquals($srcstring_padded_openssl, $srcstring_padded);

            // decrypt mcrypt encrypted cipher using openssl
            $digital_enc_mcrypt_dec_openssl = decrypt_digital_openssl($digital_enc_mcrypt,
                                                                      $servicekey);
            $this->assertEquals($srcstring_padded, $digital_enc_mcrypt_dec_openssl);

            // decrypt with mcrypt
            $digital_dec_mcrypt = decrypt_digital_mcrypt($digital_enc_mcrypt, $servicekey);
            $this->assertequals($srcstring_padded, $digital_dec_mcrypt);
        }

    }

    function test_3des_ecb_digital_2() {
        // values for testing, actual values from
        // the specification documentation
        $CustID="103"; #static string assigned by DigitalMailer
        $ACCOUNT="1231234";
        $servicepass="1test1";
        $servicekey="123456781234567812345678";
        $showurl="1"; # look before we leap
        $currdate = "200304210915"; # using GMT
        $GMT = 1;

        // last 16 bits are for padded characters
        $expected_enc_with_pads = hex2bin("e553273afd34f4b2fb7c430b0ace9d63b07cb006b2748dbb14091ffe808bf524bae218b3c06ce9fde1fb974e6a695842cdb63fdd92f837de1c569468ee764f7efeb959b7d4642fcb");

        $srcstring = "CID={$CustID}&ACCOUNT={$ACCOUNT}&PASS={$servicepass}&TIMESTAMP={$currdate}&GMT={$GMT}";

        // OPENSSL test
        // encrypt openssl
        list($digital_enc_openssl,
             $srcstring_padded_openssl) = encrypt_digital_openssl($srcstring,
                                                                $servicekey);

        // verify generated ciphertext
        $this->assertEquals($digital_enc_openssl, $expected_enc_with_pads);

        // decrypt openssl
        $digital_dec_openssl = decrypt_digital_openssl($digital_enc_openssl, $servicekey);
        $this->assertEquals($srcstring_padded_openssl, $digital_dec_openssl);

        // // MCRYPT test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {
            // encrypt with mcrypt
            list($digital_enc_mcrypt,
                 $srcstring_padded) = encrypt_digital_mcrypt($srcstring,
                                                             $servicekey);

            // verify generated ciphertext
            $this->assertEquals($digital_enc_mcrypt, $expected_enc_with_pads);

            // assert mcrypt and openssl generate the same ciphertext
            $this->assertEquals($digital_enc_openssl, $digital_enc_mcrypt);

            // assert mcrypt and openssl encrypt same padded string
            $this->assertEquals($srcstring_padded_openssl, $srcstring_padded);

            // decrypt mcrypt encrypted cipher using openssl
            $digital_enc_mcrypt_dec_openssl = decrypt_digital_openssl($digital_enc_mcrypt,
                                                                      $servicekey);
            $this->assertEquals($srcstring_padded, $digital_enc_mcrypt_dec_openssl);

            // decrypt with mcrypt
            $digital_dec_mcrypt = decrypt_digital_mcrypt($digital_enc_mcrypt, $servicekey);
            $this->assertequals($srcstring_padded, $digital_dec_mcrypt);

        }

    }

    function test_cast5_ecb_billpay() {
        # values for testing
        $billpayid = "billpayid sample data";
        $ipaykey = substr($this->key, 0, 16);

        // OPENSSL test
        // encrypt openssl
        list($billpayid_enc_openssl,
             $billpayid_padded_openssl) = encrypt_billpay_openssl($billpayid,
                                                                $ipaykey);

        // decrypt openssl
        $billpayid_dec_openssl = decrypt_billpay_openssl($billpayid_enc_openssl, $ipaykey);
        $this->assertEquals($billpayid_padded_openssl, $billpayid_dec_openssl);

        // MCRYPT test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {
            // encrypt with mcrypt
            list($billpayid_enc_mcrypt,
                 $billpayid_padded) = encrypt_billpay_mcrypt($billpayid,
                                                       $ipaykey);

            // assert that mcrypt and openssl generate the same encrypted string
            $this->assertEquals($billpayid_enc_openssl, $billpayid_enc_mcrypt);

            // assert that mcrypt and openssl apply the same padding before encryption
            $this->assertEquals($billpayid_padded_openssl, $billpayid_padded);

            // decrypt mcrypt encrypted cipher using openssl
            $billpayid_enc_mcrypt_dec_openssl = decrypt_billpay_openssl($billpayid_enc_mcrypt,
                                                                      $ipaykey);
            $this->assertEquals($billpayid_padded, $billpayid_enc_mcrypt_dec_openssl);

            // decrypt with mcrypt
            $billpayid_dec_mcrypt = decrypt_billpay_mcrypt($billpayid_enc_mcrypt,
                                                           $ipaykey);
            $this->assertequals($billpayid_padded, $billpayid_dec_mcrypt);
        }

    }

    function test_aes_256_ecb_vsoft() {
        # values for testing
        $vsoftquery = "vsoft query sample data";
        $vsoftkey = hash_hmac('md5', "somedata", "somekey");// 128bit key


        // OPENSSL test
        // encrypt openssl
        list($vsoft_enc_openssl,
             $vsoftquery_padded_openssl) = encrypt_vsoftquery_openssl($vsoftquery,
                                                                   $vsoftkey);

        // // decrypt openssl
        $vsoft_dec_openssl = decrypt_vsoftquery_openssl($vsoft_enc_openssl, $vsoftkey);
        $this->assertEquals($vsoftquery_padded_openssl, $vsoft_dec_openssl);

        // MCRYPT test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {
            // encrypt with mcrypt
            list($vsoft_enc_mcrypt,
                 $vsoftquery_padded) = encrypt_vsoftquery_mcrypt($vsoftquery,
                                                              $vsoftkey);

            // decrypt mcrypt encrypted cipher using openssl
            $vsoft_enc_mcrypt_dec_openssl = decrypt_vsoftquery_openssl($vsoft_enc_mcrypt,
                                                                      $vsoftkey);
            $this->assertEquals($vsoftquery_padded, $vsoft_enc_mcrypt_dec_openssl);

            // assert openssl and mcrypt generated the same ciphertext
            $this->assertEquals($vsoft_enc_openssl, $vsoft_enc_mcrypt);

            // assert openssl and mcrypt used the same padded string
            $this->assertEquals($vsoftquery_padded, $vsoftquery_padded_openssl);

            // decrypt with mcrypt
            $vsoft_dec_mcrypt = decrypt_vsoftquery_mcrypt($vsoft_enc_mcrypt,
                                                           $vsoftkey);
            $this->assertequals($vsoftquery_padded, $vsoft_dec_mcrypt);
        }

    }

    function test_hex2bin() {
        $this->assertEquals(hex2bin("613553673455396d31314d773274495a"), "a5Sg4U9m11Mw2tIZ");
        $this->assertEquals(bin2hex("a5Sg4U9m11Mw2tIZ"), "613553673455396d31314d773274495a");
    }

    function test_aes_256_cbc_mvi() {
        // actual data from the specification document
        $mvi_query = "2008-06-02 13:28:45,Statements,1234567,,06/01/2008,06/01/2008,0";
        $ckhexkey = "BTikvHBatPdAtgT3317QIQqGFY25WpIz";
        $iv_mvi = "a5Sg4U9m11Mw2tIZ";
        $expected_encrypted_value_hex = "b97f3985245be1065604c5808cebaa2e15813bf938cfaa3c198fd464565c13ced7c91ac6b68326ce5ed5e81cb7de81ac36b1106392bd8303d2aedf2c26161a8a";
        $expected_iv_hex = "613553673455396d31314d773274495a";

        // encrypt with openssl
        $mvi_cipher_iv_openssl = encrypt_mvi_openssl($mvi_query, $ckhexkey, $iv=$iv_mvi);
        $this->assertEquals($mvi_cipher_iv_openssl,
                            $expected_encrypted_value_hex.$expected_iv_hex);

        // decrypt with openssl
        $mvi_dec_openssl = decrypt_mvi_openssl($mvi_cipher_iv_openssl,
                                             $ckhexkey);
        $this->assertEquals($mvi_dec_openssl, $mvi_query);


        // MCRYPT test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {
            // encrypt with mcrypt
            $mvi_cipher_iv_mcrypt = encrypt_mvi_mcrypt($mvi_query,
                                                       $ckhexkey,$iv=$iv_mvi);

            // assert mcrypt and openssl generated same ciphertext
            $this->assertEquals($mvi_cipher_iv_mcrypt,
                                $expected_encrypted_value_hex.$expected_iv_hex);
            $this->assertEquals($mvi_cipher_iv_mcrypt, $mvi_cipher_iv_openssl);


            // decrypt mcrypt encrypted ciphertext with openssl
            $mvi_enc_mcrypt_dec_openssl = decrypt_mvi_openssl($mvi_cipher_iv_mcrypt,
                                                              $ckhexkey);
            $this->assertEquals($mvi_query, $mvi_enc_mcrypt_dec_openssl);


            // decrypt with mcrypt
            $mvi_dec_mcrypt = decrypt_mvi_mcrypt($mvi_cipher_iv_mcrypt,
                                                 $ckhexkey);
            $this->assertEquals($mvi_query, $mvi_dec_mcrypt);
        }
    }

    function test_aes_256_cbc_mvi_2() {
        // actual data taken from the logs
        $mvi_query = "2019-03-25 21:01:20,Checks,1000453728,4930,03/20/2019,03/20/2019,1";

        $ckhexkey = "lPVWJFs1F81j3nSkEIxFQqAI1Cu6YLrU";
        $expected_encrypted_value_hex = "78d4fa151d1bed1a07b68c817172a28a1211a82deec74a5411be558f5645201085e27588e8ccb9943d8ee3fa4e263981eb2dddf788eb83be8ab32c2932426d267ebd7adb87dbb918143843135cf6ca57";
        // inferred from the last 32 hexits of the expected encrypted hex value
        $expected_iv_hex = "a39235682bb1fbf9ae753f92624fe086";
        $iv_mvi = hex2bin("a39235682bb1fbf9ae753f92624fe086");


        // encrypt with openssl
        $mvi_cipher_iv_openssl = encrypt_mvi_openssl($mvi_query, $ckhexkey, $iv=$iv_mvi);
        $this->assertEquals($mvi_cipher_iv_openssl,
                            $expected_encrypted_value_hex.$expected_iv_hex);

        // decrypt with openssl
        $mvi_dec_openssl = decrypt_mvi_openssl($mvi_cipher_iv_openssl,
                                               $ckhexkey);
        $this->assertEquals($mvi_dec_openssl, $mvi_query);


        // MCRYPT test
        if (function_exists("mdecrypt_generic") && function_exists("mcrypt_generic")) {
            // encrypt with mcrypt
            $mvi_cipher_iv_mcrypt = encrypt_mvi_mcrypt($mvi_query,
                                                       $ckhexkey,$iv=$iv_mvi);

            // assert mcrypt and openssl generated same ciphertext
            $this->assertEquals($mvi_cipher_iv_mcrypt,
                                $expected_encrypted_value_hex.$expected_iv_hex);
            $this->assertEquals($mvi_cipher_iv_mcrypt, $mvi_cipher_iv_openssl);


            // decrypt mcrypt encrypted ciphertext with openssl
            $mvi_enc_mcrypt_dec_openssl = decrypt_mvi_openssl($mvi_cipher_iv_mcrypt,
                                                              $ckhexkey);
            $this->assertEquals($mvi_query, $mvi_enc_mcrypt_dec_openssl);


            // decrypt with mcrypt
            $mvi_dec_mcrypt = decrypt_mvi_mcrypt($mvi_cipher_iv_mcrypt,
                                                 $ckhexkey);
            $this->assertEquals($mvi_query, $mvi_dec_mcrypt);
        }
    }

    function tearDown() {

    }
}


?>