Imports System
Imports System.Diagnostics
Imports System.IO
Imports CryptoSysAPI

' Some tests using the CryptoSysAPI .NET interface.

' **************************** COPYRIGHT NOTICE ****************************
' Copyright (C) 2005-6 DI Management Services Pty Limited. 
' All rights reserved. <www.di-mgt.com.au> <www.cryptosys.net>
'   $Id: TestAPIvbnet.vb $
'   Last updated:
'   $Date: 2006-07-21 09:50:00 $
'   $Version: 3.2.0 $
' ************************* END OF COPYRIGHT NOTICE ************************

' This is a straight port of TestAPIcsharp.cs from C# to VB.NET.
' With thanks to Alex Lowe's "C# to VB.NET Translation tool"
' http://authors.aspalliance.com/aldotnet/examples/translate.aspx



Module TestAPIvbnet
    Sub Main()
        Dim s As String
        Dim okhex As String
        Dim filename As String
        Dim keyStr, ivStr, saltHex As String
        Dim plain, cipher As String
        Dim arrPlain() As Byte
        Dim arrCipher() As Byte
        Dim arrKey() As Byte
        Dim arrIV() As Byte
        Dim b() As Byte
        Dim salt() As Byte
        Dim arrPwd() As Byte
        Dim arrOk() As Byte
        Dim n, i As Integer
        Dim ch As Char
        Dim tf As Boolean
        Dim excontent As String
        Dim fnameData As String
        Dim fnameEnc As String
        Dim fnameCheck As String
        Dim a1000() As Byte

        '****************
        ' GENERAL TESTS *
        '****************
        Console.WriteLine("GENERAL FUNCTIONS:")
        n = General.Version()
        Console.WriteLine("Version={0}", n)

        n = General.PowerUpTests()
        Console.WriteLine("PowerUpTests={0}", n)

        s = General.CompileTime()
        Console.WriteLine("CompileTime={0}", s)

        s = General.ModuleName()
        Console.WriteLine("ModuleName={0}", s)

        ch = General.LicenceType()
        Console.WriteLine("LicenceType={0}", ch)

        '*******************************
        ' HEXADECIMAL CONVERSION TESTS *
        '*******************************
        Console.WriteLine("CONVERSION TESTS:")
        b = Cnv.FromHex("deadbeef")
        s = Cnv.ToHex(b)
        Console.WriteLine("ToHex={0}", s)
        b = Cnv.FromHex(s)
        Console.WriteLine("In base64='{0}'", Convert.ToBase64String(b))
        s = Cnv.StringFromHex("616263")
        Console.WriteLine("0x616263='{0}'", s)

        '**********************
        ' ERROR LOOKUP TESTS *
        '**********************
        Console.WriteLine("ERROR CODES:")
        For i = 0 To 9999
            s = General.ErrorLookup(i)
            If Not s.Equals([String].Empty) Then
                Console.WriteLine("Error {0}={1}", i, s)
            End If
        Next i

        '****************************
        ' BLOWFISH ENCRYPTION TESTS *
        '****************************
        Console.WriteLine("TESTING BLOWFISH:")
        keyStr = "FEDCBA9876543210"
        plain = "0123456789ABCDEF"
        cipher = "0ACEAB0FC6A0A28D"
        ' Encrypt in ECB mode using hex strings
        s = Blowfish.Encrypt(plain, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Blowfish.Encrypt failed")
        ' Decrypt
        s = Blowfish.Decrypt(cipher, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Blowfish.Decrypt failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        b = Blowfish.Encrypt(arrPlain, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), cipher, True) = 0, "Blowfish.Encrypt failed")
        b = Blowfish.Decrypt(arrCipher, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), plain, True) = 0, "Blowfish.Decrypt failed")

        ' Encrypt in CBC mode using hex strings
        keyStr = "0123456789ABCDEFF0E1D2C3B4A59687"
        ivStr = "FEDCBA9876543210"
        plain = "37363534333231204E6F77206973207468652074696D6520666F722000000000"
        cipher = "6B77B4D63006DEE605B156E27403979358DEB9E7154616D959F1652BD5FF92CC"
        s = Blowfish.Encrypt(plain, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Blowfish.Encrypt (CBC) failed")
        ' Decrypt
        s = Blowfish.Decrypt(cipher, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Blowfish.Decrypt (CBC) failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        arrIV = Cnv.FromHex(ivStr)
        b = Blowfish.Encrypt(arrPlain, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), cipher, True) = 0, "Blowfish.Encrypt (CBC) failed")
        b = Blowfish.Decrypt(arrCipher, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), plain, True) = 0, "Blowfish.Decrypt (CBC) failed")

        ' And again using base64 strings
        keyStr = "ASNFZ4mrze/w4dLDtKWWhw=="
        ivStr = "/ty6mHZUMhA="
        plain = "NzY1NDMyMSBOb3cgaXMgdGhlIHRpbWUgZm9yIAAAAAA="
        cipher = "a3e01jAG3uYFsVbidAOXk1jeuecVRhbZWfFlK9X/ksw="
        s = Blowfish.Encrypt(plain, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Blowfish.Encrypt (CBC-base64) failed")
        ' Decrypt
        s = Blowfish.Decrypt(cipher, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Blowfish.Decrypt (CBC-base64) failed")

        ' Pad some data ready for encryption - first in hex format
        okhex = "ffffff"
        s = okhex
        plain = Blowfish.Pad(s)
        Console.WriteLine("Blowfish.Pad('{0}')='{1}'", s, plain)
        Debug.Assert(plain.Length Mod Blowfish.BlockSize * 2 = 0, "Blowfish.Pad(hex) failed")
        ' and remove it
        s = Blowfish.Unpad(plain)
        Console.WriteLine("Blowfish.Unpad('{0}')='{1}'", plain, s)
        Debug.Assert(s = okhex, "Blowfish.Unpad(hex) failed")
        ' again padding an empty string
        okhex = ""
        s = okhex
        plain = Blowfish.Pad(s)
        Console.WriteLine("Blowfish.Pad('{0}')='{1}'", s, plain)
        Debug.Assert(plain.Length Mod Blowfish.BlockSize * 2 = 0, "Blowfish.Pad(hex) failed")
        ' and remove it
        s = Blowfish.Unpad(plain)
        Console.WriteLine("Blowfish.Unpad('{0}')='{1}'", plain, s)
        Debug.Assert(s = okhex, "Blowfish.Unpad(hex) failed")
        ' Pad using bytes
        arrOk = Cnv.FromHex("ffffffffffffffff")
        b = arrOk
        arrPlain = Blowfish.Pad(b)
        Console.WriteLine("Blowfish.Pad(0x{0})=0x{1}", Cnv.ToHex(b), Cnv.ToHex(arrPlain))
        Debug.Assert(arrPlain.Length Mod Blowfish.BlockSize = 0, "Blowfish.Pad(bytes) failed")
        b = Blowfish.Unpad(arrPlain)
        Console.WriteLine("Blowfish.Unpad(0x{0})=0x{1}", Cnv.ToHex(arrPlain), Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), Cnv.ToHex(arrOk)) = 0, "Blowfish.Unpad(bytes) failed")

        ' Now use Init-Update-Final
        keyStr = "FEDCBA9876543210"
        ivStr = "0123456789abcdef"
        ' Instantiate a new encryption object
        Dim oBlf As Blowfish = Blowfish.Instance()
        ' Setup to encrypt in CBC mode
        n = oBlf.InitEncrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oBlf.ErrCode = 0, "Blowfish.Initialize failed")

        plain = "0101010101010101"
        cipher = "46733BCD9C72C5E3"
        s = oBlf.Update(plain)
        Console.WriteLine("PT1={0}", plain)
        Console.WriteLine("CT1={0}", s)
        Console.WriteLine("OK1={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Blowfish.Update failed")
        ' Line 2 using bytes
        plain = "0202020202020202"
        cipher = "F434DA62B6869A06"
        b = Cnv.FromHex(plain)
        b = oBlf.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("PT2={0}", plain)
        Console.WriteLine("CT2={0}", s)
        Console.WriteLine("OK2={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Blowfish.Update failed")
        ' Lines 3 and 4 together using hex and a longer input
        plain = "03030303030303030404040404040404"
        cipher = "2AE6DFE458559138DEEBF97D6F83A5F3"
        s = oBlf.Update(plain)
        Console.WriteLine("PT3={0}", plain)
        Console.WriteLine("CT3={0}", s)
        Console.WriteLine("OK3={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Blowfish.Update failed")

        ' Create a second object this time to decrypt
        ' NB You can only have one Instance at a time in the same thread
        ' So this just overwrites the previous one as a test
        ' TODO: perhaps return an error here to emphasise the point?
        Dim oBlf2 As Blowfish = Blowfish.Instance()
        n = oBlf2.InitDecrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oBlf2.ErrCode = 0, "Blowfish.Init failed")

        plain = "0101010101010101"
        cipher = "46733BCD9C72C5E3"
        s = oBlf2.Update(cipher)
        Console.WriteLine("CT1={0}", cipher)
        Console.WriteLine("PT1={0}", s)
        Console.WriteLine("OK1={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Blowfish.Update failed")
        ' Line 2 using bytes
        plain = "0202020202020202"
        cipher = "F434DA62B6869A06"
        b = Cnv.FromHex(cipher)
        b = oBlf2.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("CT2={0}", cipher)
        Console.WriteLine("PT2={0}", s)
        Console.WriteLine("OK2={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Blowfish.Update failed")
        ' Lines 3 and 4 using hex
        plain = "03030303030303030404040404040404"
        cipher = "2AE6DFE458559138DEEBF97D6F83A5F3"
        s = oBlf2.Update(cipher)
        Console.WriteLine("CT3={0}", cipher)
        Console.WriteLine("PT3={0}", s)
        Console.WriteLine("OK3={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Blowfish.Update failed")

        ' Experiment with object methods
        s = oBlf.ToString()
        Console.WriteLine("oBlf.ToString()={0}", s)
        Dim ty As Type = oBlf.GetType()
        Console.WriteLine("oBlf.GetType()={0}", ty)
        n = oBlf.GetHashCode()
        Console.WriteLine("oBlf.GetHashCode()={0}", n)
        n = oBlf2.GetHashCode()
        Console.WriteLine("oBlf2.GetHashCode()={0}", n)

        ' Make sure keys are disposed of
        oBlf.Dispose()
        oBlf2.Dispose()
        Console.WriteLine("Blf Objects disposed of.")

        ' Create a test text file
        excontent = "This is some sample content."
        fnameData = "excontent.txt"
        MakeATextFile(fnameData, excontent)

        ' Encrypt a file
        keyStr = "fedcba9876543210"
        fnameEnc = "excontent.blf.enc.dat"
        okhex = "D45B1B15FA7960E34D67F6366B5ECDD91E941467F21F5BE34A1F5A5158A8569C"
        n = Blowfish.FileEncrypt(fnameEnc, fnameData, keyStr, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Blowfish.File created encrypted file '{0}'", fnameEnc)
        Else
            Console.WriteLine("Blowfish.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Blowfish.File failed.")

        ' Check we got what we should
        b = ReadABinaryFile(fnameEnc)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), okhex, True) = 0, "Blowfish.FileEncrypt failed")

        ' Decrypt it using byte format of key instead of hex
        fnameCheck = "excontent.blf.chk.txt"
        b = Cnv.FromHex(keyStr)
        n = Blowfish.FileDecrypt(fnameCheck, fnameEnc, b, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Blowfish.File decrypted to file '{0}'", fnameCheck)
            ' Show contents of file
            s = ReadATextFile(fnameCheck)
            Debug.Assert([String].Compare(s, excontent) = 0, "Decrypted file data does not match")
        Else
            Console.WriteLine("Blowfish.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Blowfish.File failed.")


        '***************************
        ' DES ENCRYPTION TESTS *
        '***************************
        Console.WriteLine("TESTING DES:")
        keyStr = "0123456789abcdef"
        plain = "4e6f772069732074"
        cipher = "3fa40e8a984d4815"
        ' Encrypt in ECB mode using hex strings
        s = Des.Encrypt(plain, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Des.HexECB failed")
        ' Decrypt
        s = Des.Decrypt(cipher, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Des.HexECB failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        b = Des.Encrypt(arrPlain, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Des.Decrypt(arrCipher, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))

        ' Encrypt in CBC mode using hex strings
        keyStr = "0123456789abcdef"
        ivStr = "1234567890abcdef"
        plain = "4e6f77206973207468652074696d6520666f7220616c6c20"
        cipher = "e5c7cdde872bf27c43e934008c389c0f683788499a7c05f6"
        s = Des.Encrypt(plain, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Des.Encrypt{Hex,CBC} failed")
        ' Decrypt
        s = Des.Decrypt(cipher, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Des.Decrypt{Hex,CBC} failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        arrIV = Cnv.FromHex(ivStr)
        b = Des.Encrypt(arrPlain, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Des.Decrypt(arrCipher, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(arrPlain), Cnv.ToHex(b)) = 0, "Des.BytesCBC failed")

        ' And again using base64 strings
        keyStr = "ASNFZ4mrze8="
        ivStr = "EjRWeJCrze8="
        plain = "Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwg"
        cipher = "5cfN3ocr8nxD6TQAjDicD2g3iEmafAX2"
        s = Des.Encrypt(plain, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Des.Encrypt{base64,CBC} failed")
        ' Decrypt
        s = Des.Decrypt(cipher, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Des.Decrypt{base64,CBC} failed")

        ' Pad some data ready for encryption - first in hex format
        okhex = "ffffff"
        s = okhex
        plain = Des.Pad(s)
        Console.WriteLine("Des.Pad('{0}')='{1}'", s, plain)
        Debug.Assert(plain.Length Mod Des.BlockSize * 2 = 0, "Des.Pad(hex) failed")
        ' and remove it
        s = Des.Unpad(plain)
        Console.WriteLine("Des.Unpad('{0}')='{1}'", plain, s)
        Debug.Assert(s = okhex, "Des.Unpad(hex) failed")
        ' Pad using bytes
        arrOk = Cnv.FromHex("ffffffffffffffff")
        b = arrOk
        arrPlain = Des.Pad(b)
        Console.WriteLine("Des.Pad(0x{0})=0x{1}", Cnv.ToHex(b), Cnv.ToHex(arrPlain))
        Debug.Assert(arrPlain.Length Mod Des.BlockSize = 0, "Des.Pad(bytes) failed")
        b = Des.Unpad(arrPlain)
        Console.WriteLine("Des.Unpad(0x{0})=0x{1}", Cnv.ToHex(arrPlain), Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), Cnv.ToHex(arrOk)) = 0, "Des.Unpad(bytes) failed")

        ' Now use Init-Update-Final
        keyStr = "0123456789abcdef"
        ivStr = "1234567890abcdef"
        ' Instantiate a new encryption object
        Dim oDes As Des = Des.Instance()
        n = oDes.InitEncrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oDes.ErrCode = 0, "Des.Initialize failed")

        plain = "4e6f772069732074"
        cipher = "E5C7CDDE872BF27C"
        s = oDes.Update(plain)
        Console.WriteLine("PT1={0}", plain)
        Console.WriteLine("CT1={0}", s)
        Console.WriteLine("OK1={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Des.Update failed")
        ' Line 2 using bytes
        plain = "68652074696d6520"
        cipher = "43E934008C389C0F"
        b = Cnv.FromHex(plain)
        b = oDes.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("PT2={0}", plain)
        Console.WriteLine("CT2={0}", s)
        Console.WriteLine("OK2={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Des.Update failed")
        ' Line 3 using hex
        plain = "666f7220616c6c20"
        cipher = "683788499A7C05F6"
        s = oDes.Update(plain)
        Console.WriteLine("PT3={0}", plain)
        Console.WriteLine("CT3={0}", s)
        Console.WriteLine("OK3={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Des.Update failed")

        n = oDes.InitDecrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oDes.ErrCode = 0, "Des.Initialize failed")

        plain = "4e6f772069732074"
        cipher = "E5C7CDDE872BF27C"
        s = oDes.Update(cipher)
        Console.WriteLine("CT1={0}", cipher)
        Console.WriteLine("PT1={0}", s)
        Console.WriteLine("OK1={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Des.Update failed")
        ' Line 2 using bytes
        plain = "68652074696d6520"
        cipher = "43E934008C389C0F"
        b = Cnv.FromHex(cipher)
        b = oDes.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("CT2={0}", cipher)
        Console.WriteLine("PT2={0}", s)
        Console.WriteLine("OK2={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Des.Update failed")
        ' Line 3 using hex
        plain = "666f7220616c6c20"
        cipher = "683788499A7C05F6"
        s = oDes.Update(cipher)
        Console.WriteLine("CT3={0}", cipher)
        Console.WriteLine("PT3={0}", s)
        Console.WriteLine("OK3={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Des.Update failed")

        ' Make sure keys are disposed of
        oDes.Dispose()
        Console.WriteLine("Des Object disposed of.")

        ' Create a test text file
        excontent = "This is some sample content."
        fnameData = "excontent.txt"
        MakeATextFile(fnameData, excontent)

        ' Encrypt a file
        keyStr = "fedcba9876543210"
        fnameEnc = "excontent.des.enc.dat"
        okhex = "84D1604C0A33D9335F7EDB5C7ABE73F86B9C87F0639D45F2C8172C8AA976B247"
        n = Des.FileEncrypt(fnameEnc, fnameData, keyStr, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Des.File created encrypted file '{0}'", fnameEnc)
        Else
            Console.WriteLine("Des.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Des.File failed.")

        ' Check we got what we should
        b = ReadABinaryFile(fnameEnc)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), okhex, True) = 0, "Des.FileEncrypt failed")

        ' Decrypt it using byte format of key instead of hex
        fnameCheck = "excontent.des.chk.txt"
        b = Cnv.FromHex(keyStr)
        n = Des.FileDecrypt(fnameCheck, fnameEnc, b, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Des.File decrypted to file '{0}'", fnameCheck)
            ' Show contents of file
            s = ReadATextFile(fnameCheck)
            Debug.Assert([String].Compare(s, excontent) = 0, "Decrypted file data does not match")
        Else
            Console.WriteLine("Des.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Des.File failed.")


        '*****************************************************
        ' TDEA (Triple DES, 3DES, DES-EDE3) ENCRYPTION TESTS *
        '*****************************************************
        Console.WriteLine("TESTING TRIPLE DES:")
        keyStr = "010101010101010101010101010101010101010101010101"
        plain = "8000000000000000"
        cipher = "95F8A5E5DD31D900"
        ' Encrypt in ECB mode using hex strings
        s = Tdea.Encrypt(plain, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Tdea.HexECB failed")
        ' Decrypt
        s = Tdea.Decrypt(cipher, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Tdea.HexECB failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        b = Tdea.Encrypt(arrPlain, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Tdea.Decrypt(arrCipher, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))

        ' Encrypt in CBC mode using hex strings
        keyStr = "737C791F25EAD0E04629254352F7DC6291E5CB26917ADA32"
        ivStr = "B36B6BFB6231084E"
        plain = "5468697320736F6D652073616D706520636F6E74656E742E0808080808080808"
        cipher = "d76fd1178fbd02f84231f5c1d2a2f74a4159482964f675248254223daf9af8e4"
        s = Tdea.Encrypt(plain, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Tdea.Encrypt{Hex,CBC} failed")
        ' Decrypt
        s = Tdea.Decrypt(cipher, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Tdea.Decrypt{Hex,CBC} failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        arrIV = Cnv.FromHex(ivStr)
        b = Tdea.Encrypt(arrPlain, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Tdea.Decrypt(arrCipher, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(arrPlain), Cnv.ToHex(b)) = 0, "Tdea.BytesCBC failed")

        ' ditto using base64 data
        keyStr = "c3x5HyXq0OBGKSVDUvfcYpHlyyaRetoy"
        ivStr = "s2tr+2IxCE4="
        plain = "VGhpcyBzb21lIHNhbXBlIGNvbnRlbnQuCAgICAgICAg="
        cipher = "12/RF4+9AvhCMfXB0qL3SkFZSClk9nUkglQiPa+a+OQ="
        s = Tdea.Encrypt(plain, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Tdea.Encrypt{Base64,CBC} failed")
        ' Decrypt
        s = Tdea.Decrypt(cipher, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Tdea.Decrypt{Base64,CBC} failed")

        ' Pad some data ready for encryption - first in hex format
        okhex = "ffffff"
        s = okhex
        plain = Tdea.Pad(s)
        Console.WriteLine("Tdea.Pad('{0}')='{1}'", s, plain)
        Debug.Assert(plain.Length Mod Tdea.BlockSize * 2 = 0, "Tdea.Pad(hex) failed")
        ' and remove it
        s = Tdea.Unpad(plain)
        Console.WriteLine("Tdea.Unpad('{0}')='{1}'", plain, s)
        Debug.Assert(s = okhex, "Tdea.Unpad(hex) failed")
        ' Pad using bytes
        arrOk = Cnv.FromHex("ffffffffffffffff")
        b = arrOk
        arrPlain = Tdea.Pad(b)
        Console.WriteLine("Tdea.Pad(0x{0})=0x{1}", Cnv.ToHex(b), Cnv.ToHex(arrPlain))
        Debug.Assert(arrPlain.Length Mod Tdea.BlockSize = 0, "Tdea.Pad(bytes) failed")
        b = Tdea.Unpad(arrPlain)
        Console.WriteLine("Tdea.Unpad(0x{0})=0x{1}", Cnv.ToHex(arrPlain), Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), Cnv.ToHex(arrOk)) = 0, "Tdea.Unpad(bytes) failed")

        ' Now use Init-Update-Final
        keyStr = "0123456789abcdeffedcba987654321089abcdef01234567"
        ivStr = "1234567890abcdef"
        ' Instantiate a new encryption object
        Dim oTdea As Tdea = Tdea.Instance()
        n = oTdea.InitEncrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oTdea.ErrCode = 0, "Tdea.Initialize failed")

        plain = "4e6f772069732074"
        cipher = "204011f986e35647"
        s = oTdea.Update(plain)
        Console.WriteLine("PT1={0}", plain)
        Console.WriteLine("CT1={0}", s)
        Console.WriteLine("OK1={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Tdea.Update failed")
        ' Line 2 using bytes
        plain = "68652074696d6520"
        cipher = "199e47af391620c5"
        b = Cnv.FromHex(plain)
        b = oTdea.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("PT2={0}", plain)
        Console.WriteLine("CT2={0}", s)
        Console.WriteLine("OK2={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Tdea.Update failed")
        ' Line 3 using hex
        plain = "666f7220616c6c20"
        cipher = "bb9a5bcfc86db0bb"
        s = oTdea.Update(plain)
        Console.WriteLine("PT3={0}", plain)
        Console.WriteLine("CT3={0}", s)
        Console.WriteLine("OK3={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Tdea.Update failed")

        ' Now decrypt
        n = oTdea.InitDecrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oTdea.ErrCode = 0, "Tdea.Initialize failed")

        plain = "4e6f772069732074"
        cipher = "204011f986e35647"
        s = oTdea.Update(cipher)
        Console.WriteLine("CT1={0}", cipher)
        Console.WriteLine("PT1={0}", s)
        Console.WriteLine("OK1={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Tdea.Update failed")
        ' Line 2 using bytes
        plain = "68652074696d6520"
        cipher = "199e47af391620c5"
        b = Cnv.FromHex(cipher)
        b = oTdea.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("CT2={0}", cipher)
        Console.WriteLine("PT2={0}", s)
        Console.WriteLine("OK2={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Tdea.Update failed")
        ' Line 3 using hex
        plain = "666f7220616c6c20"
        cipher = "bb9a5bcfc86db0bb"
        s = oTdea.Update(cipher)
        Console.WriteLine("CT3={0}", cipher)
        Console.WriteLine("PT3={0}", s)
        Console.WriteLine("OK3={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Tdea.Update failed")

        ' Make sure keys are disposed of
        oTdea.Dispose()
        Console.WriteLine("Tdea Object disposed of.")

        ' Create a test text file
        excontent = "This is some sample content."
        fnameData = "excontent.txt"
        MakeATextFile(fnameData, excontent)

        ' Encrypt a file
        keyStr = "fedcba98765432100123456789abcdeffedcba9876543210"
        fnameEnc = "excontent.tdea.enc.dat"
        okhex = "DD1E1FA430AE6BE1D3B83245F7A5B17C4BF03688238778E95F2CCD05AF1A8F44"
        n = Tdea.FileEncrypt(fnameEnc, fnameData, keyStr, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Tdea.File created encrypted file '{0}'", fnameEnc)
        Else
            Console.WriteLine("Tdea.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Tdea.File failed.")

        ' Check we got what we should
        b = ReadABinaryFile(fnameEnc)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), okhex, True) = 0, "Tdea.FileEncrypt failed")

        ' Decrypt it using byte format of key instead of hex
        fnameCheck = "excontent.tdea.chk.txt"
        b = Cnv.FromHex(keyStr)
        n = Tdea.FileDecrypt(fnameCheck, fnameEnc, b, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Tdea.File decrypted to file '{0}'", fnameCheck)
            ' Show contents of file
            s = ReadATextFile(fnameCheck)
            Debug.Assert([String].Compare(s, excontent) = 0, "Decrypted file data does not match")
        Else
            Console.WriteLine("Tdea.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Tdea.File failed.")


        '***************************
        ' AES-128 ENCRYPTION TESTS *
        '***************************
        Console.WriteLine("TESTING AES-128:")
        keyStr = "000102030405060708090a0b0c0d0e0f"
        plain = "00112233445566778899aabbccddeeff"
        cipher = "69c4e0d86a7b0430d8cdb78070b4c55a"
        ' Encrypt in ECB mode using hex strings
        s = Aes128.Encrypt(plain, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes128.HexECB failed")
        ' Decrypt
        s = Aes128.Decrypt(cipher, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes128.HexECB failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        b = Aes128.Encrypt(arrPlain, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Aes128.Decrypt(arrCipher, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))

        ' Encrypt in CBC mode using hex strings
        keyStr = "56e47a38c5598974bc46903dba290349"
        ivStr = "8ce82eefbea0da3c44699ed7db51b7d9"
        plain = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf" + "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" + "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf" + "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
        cipher = "c30e32ffedc0774e6aff6af0869f71aa" + "0f3af07a9a31a9c684db207eb0ef8e4e" + "35907aa632c3ffdf868bb7b29d3d46ad" + "83ce9f9a102ee99d49a53e87f4c3da55"
        s = Aes128.Encrypt(plain, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        ' Decrypt
        s = Aes128.Decrypt(cipher, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        arrIV = Cnv.FromHex(ivStr)
        b = Aes128.Encrypt(arrPlain, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Aes128.Decrypt(arrCipher, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(arrPlain), Cnv.ToHex(b)) = 0, "Aes128.BytesCBC failed")

        ' Ditto using base64 strings
        keyStr = "VuR6OMVZiXS8RpA9uikDSQ=="
        ivStr = "jOgu776g2jxEaZ7X21G32Q=="
        plain = "oKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/" + "AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3w=="
        cipher = "ww4y/+3Ad05q/2rwhp9xqg868HqaManGhNsgfrDvjk" + "41kHqmMsP/34aLt7KdPUatg86fmhAu6Z1JpT6H9MPaVQ=="
        s = Aes128.Encrypt(plain, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        ' Decrypt
        s = Aes128.Decrypt(cipher, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)

        ' Pad some data ready for encryption - first in hex format
        okhex = "ffffff"
        s = okhex
        plain = Aes128.Pad(s)
        Console.WriteLine("Aes128.Pad('{0}')='{1}'", s, plain)
        Debug.Assert(plain.Length Mod Aes128.BlockSize * 2 = 0, "Aes128.Pad(hex) failed")
        ' and remove it
        s = Aes128.Unpad(plain)
        Console.WriteLine("Aes128.Unpad('{0}')='{1}'", plain, s)
        Debug.Assert(s = okhex, "Aes128.Unpad(hex) failed")
        ' again padding an empty string
        okhex = ""
        s = okhex
        plain = Aes128.Pad(s)
        Console.WriteLine("Aes128.Pad('{0}')='{1}'", s, plain)
        Debug.Assert(plain.Length Mod Aes128.BlockSize * 2 = 0, "Aes128.Pad(hex) failed")
        ' and remove it
        s = Aes128.Unpad(plain)
        Console.WriteLine("Aes128.Unpad('{0}')='{1}'", plain, s)
        Debug.Assert(s = okhex, "Aes128.Unpad(hex) failed")
        ' Pad using bytes
        arrOk = Cnv.FromHex("ffffffffffffffff")
        b = arrOk
        arrPlain = Aes128.Pad(b)
        Console.WriteLine("Aes128.Pad(0x{0})=0x{1}", Cnv.ToHex(b), Cnv.ToHex(arrPlain))
        Debug.Assert(arrPlain.Length Mod Aes128.BlockSize = 0, "Aes128.Pad(bytes) failed")
        b = Aes128.Unpad(arrPlain)
        Console.WriteLine("Aes128.Unpad(0x{0})=0x{1}", Cnv.ToHex(arrPlain), Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), Cnv.ToHex(arrOk)) = 0, "Aes128.Unpad(bytes) failed")

        ' Now use Init-Update-Final
        keyStr = "56e47a38c5598974bc46903dba290349"
        ivStr = "8ce82eefbea0da3c44699ed7db51b7d9"
        ' Instantiate a new encryption object
        Dim oAes128 As Aes128 = Aes128.Instance()
        n = oAes128.InitEncrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oAes128.ErrCode = 0, "Aes128.Initialize failed")

        plain = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
        cipher = "c30e32ffedc0774e6aff6af0869f71aa"
        s = oAes128.Update(plain)
        Console.WriteLine("PT1={0}", plain)
        Console.WriteLine("CT1={0}", s)
        Console.WriteLine("OK1={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes128.Update failed")
        ' Line 2 using bytes
        plain = "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
        cipher = "0f3af07a9a31a9c684db207eb0ef8e4e"
        b = Cnv.FromHex(plain)
        b = oAes128.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("PT2={0}", plain)
        Console.WriteLine("CT2={0}", s)
        Console.WriteLine("OK2={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes128.Update failed")
        ' Lines 3 and 4 using hex
        plain = "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
        cipher = "35907aa632c3ffdf868bb7b29d3d46ad83ce9f9a102ee99d49a53e87f4c3da55"
        s = oAes128.Update(plain)
        Console.WriteLine("PT3={0}", plain)
        Console.WriteLine("CT3={0}", s)
        Console.WriteLine("OK3={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes128.Update failed")

        ' Now decrypt using the same object
        n = oAes128.InitDecrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oAes128.ErrCode = 0, "Aes128.Initialize failed")

        plain = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
        cipher = "c30e32ffedc0774e6aff6af0869f71aa"
        s = oAes128.Update(cipher)
        Console.WriteLine("CT1={0}", cipher)
        Console.WriteLine("PT1={0}", s)
        Console.WriteLine("OK1={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes128.Update failed")
        ' Line 2 using bytes
        plain = "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
        cipher = "0f3af07a9a31a9c684db207eb0ef8e4e"
        b = Cnv.FromHex(cipher)
        b = oAes128.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("CT2={0}", cipher)
        Console.WriteLine("PT2={0}", s)
        Console.WriteLine("OK2={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes128.Update failed")
        ' Lines 3 and 4 using hex
        plain = "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
        cipher = "35907aa632c3ffdf868bb7b29d3d46ad83ce9f9a102ee99d49a53e87f4c3da55"
        s = oAes128.Update(cipher)
        Console.WriteLine("CT3={0}", cipher)
        Console.WriteLine("PT3={0}", s)
        Console.WriteLine("OK3={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes128.Update failed")

        ' Make sure keys are disposed of
        oAes128.Dispose()
        Console.WriteLine("AES128 Objects disposed of.")

        ' Create a test text file
        excontent = "This is some sample content."
        fnameData = "excontent.txt"
        MakeATextFile(fnameData, excontent)

        ' Encrypt a file
        keyStr = "fedcba98765432100123456789abcdef"
        fnameEnc = "excontent.aes128.enc.dat"
        okhex = "DBBACBCC97FBFBE869079864B5077245FA9FD96992CFFF3F4387BD0ABC04EBCA"
        n = Aes128.FileEncrypt(fnameEnc, fnameData, keyStr, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Aes128.File created encrypted file '{0}'", fnameEnc)
        Else
            Console.WriteLine("Aes128.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Aes128.File failed.")

        ' Check we got what we should
        b = ReadABinaryFile(fnameEnc)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), okhex, True) = 0, "Aes128.FileEncrypt failed")

        ' Decrypt it using byte format of key instead of hex
        fnameCheck = "excontent.aes128.chk.txt"
        b = Cnv.FromHex(keyStr)
        n = Aes128.FileDecrypt(fnameCheck, fnameEnc, b, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Aes128.File decrypted to file '{0}'", fnameCheck)
            ' Show contents of file
            s = ReadATextFile(fnameCheck)
            Debug.Assert([String].Compare(s, excontent) = 0, "Decrypted file data does not match")
        Else
            Console.WriteLine("Aes128.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Aes128.File failed.")


        '***************************
        ' AES-192 ENCRYPTION TESTS *
        '***************************
        Console.WriteLine("TESTING AES-192:")
        keyStr = "000102030405060708090a0b0c0d0e0f1011121314151617"
        plain = "00112233445566778899aabbccddeeff"
        cipher = "dda97ca4864cdfe06eaf70a0ec0d7191"
        ' Encrypt in ECB mode using hex strings
        s = Aes192.Encrypt(plain, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes192.HexECB failed")
        ' Decrypt
        s = Aes192.Decrypt(cipher, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes192.HexECB failed")

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        b = Aes192.Encrypt(arrPlain, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Aes192.Decrypt(arrCipher, arrKey, Mode.ECB, Nothing)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))

        ' Encrypt in CBC mode using hex strings
        keyStr = "56e47a38c5598974bc46903dba29034906a9214036b8a15b"
        ivStr = "8ce82eefbea0da3c44699ed7db51b7d9"
        plain = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf" + "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" + "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf" + "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
        cipher = "738237036dfdde9dda3374fa182600c5" + "38d9187a0299725d0a7fdbe844d77578" + "1539e401b5597cbbfa836efd22d998d2" + "1605d8df340622417b911467b5e51a12"
        s = Aes192.Encrypt(plain, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        ' Decrypt
        s = Aes192.Decrypt(cipher, keyStr, Mode.CBC, ivStr)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)

        ' Ditto using byte arrays
        arrPlain = Cnv.FromHex(plain)
        arrCipher = Cnv.FromHex(cipher)
        arrKey = Cnv.FromHex(keyStr)
        arrIV = Cnv.FromHex(ivStr)
        b = Aes192.Encrypt(arrPlain, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        b = Aes192.Decrypt(arrCipher, arrKey, Mode.CBC, arrIV)
        Console.WriteLine("P'={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(arrPlain), Cnv.ToHex(b)) = 0, "Aes192.BytesCBC failed")

        ' Ditto using base64 strings
        keyStr = "VuR6OMVZiXS8RpA9uikDSQapIUA2uKFb"
        ivStr = "jOgu776g2jxEaZ7X21G32Q=="
        plain = "oKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/" + "AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3w=="
        cipher = "c4I3A2393p3aM3T6GCYAxTjZGHoCmXJdCn/b6" + "ETXdXgVOeQBtVl8u/qDbv0i2ZjSFgXY3zQGIkF7kRRnteUaEg=="
        s = Aes192.Encrypt(plain, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("IV={0}", ivStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        ' Decrypt
        s = Aes192.Decrypt(cipher, keyStr, Mode.CBC, ivStr, EncodingBase.Base64)
        Console.WriteLine("P'={0}", s)
        Console.WriteLine("OK={0}", plain)

        ' Pad some data ready for encryption - first in hex format
        okhex = "ffffff"
        s = okhex
        plain = Aes192.Pad(s)
        Console.WriteLine("Aes192.Pad('{0}')='{1}'", s, plain)
        Debug.Assert(plain.Length Mod Aes192.BlockSize * 2 = 0, "Aes192.Pad(hex) failed")
        ' and remove it
        s = Aes192.Unpad(plain)
        Console.WriteLine("Aes192.Unpad('{0}')='{1}'", plain, s)
        Debug.Assert(s = okhex, "Aes192.Unpad(hex) failed")
        ' Pad using bytes
        arrOk = Cnv.FromHex("ffffffffffffffff")
        b = arrOk
        arrPlain = Aes192.Pad(b)
        Console.WriteLine("Aes192.Pad(0x{0})=0x{1}", Cnv.ToHex(b), Cnv.ToHex(arrPlain))
        Debug.Assert(arrPlain.Length Mod Aes192.BlockSize = 0, "Aes192.Pad(bytes) failed")
        b = Aes192.Unpad(arrPlain)
        Console.WriteLine("Aes192.Unpad(0x{0})=0x{1}", Cnv.ToHex(arrPlain), Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), Cnv.ToHex(arrOk)) = 0, "Aes192.Unpad(bytes) failed")

        ' Now use Init-Update-Final
        keyStr = "56e47a38c5598974bc46903dba29034906a9214036b8a15b"
        ivStr = "8ce82eefbea0da3c44699ed7db51b7d9"
        ' Instantiate a new encryption object
        Dim oAes192 As Aes192 = Aes192.Instance()
        n = oAes192.InitEncrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oAes192.ErrCode = 0, "Aes192.Initialize failed")

        plain = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
        cipher = "738237036dfdde9dda3374fa182600c5"
        s = oAes192.Update(plain)
        Console.WriteLine("PT1={0}", plain)
        Console.WriteLine("CT1={0}", s)
        Console.WriteLine("OK1={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes192.Update failed")
        ' Line 2 using bytes
        plain = "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
        cipher = "38d9187a0299725d0a7fdbe844d77578"
        b = Cnv.FromHex(plain)
        b = oAes192.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("PT2={0}", plain)
        Console.WriteLine("CT2={0}", s)
        Console.WriteLine("OK2={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes192.Update failed")
        ' Lines 3 and 4 using hex
        plain = "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
        cipher = "1539e401b5597cbbfa836efd22d998d21605d8df340622417b911467b5e51a12"
        s = oAes192.Update(plain)
        Console.WriteLine("PT3={0}", plain)
        Console.WriteLine("CT3={0}", s)
        Console.WriteLine("OK3={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes192.Update failed")

        n = oAes192.InitDecrypt(keyStr, Mode.CBC, ivStr)
        Console.WriteLine("Initialize returns {0}", n)
        Debug.Assert(oAes192.ErrCode = 0, "Aes192.Initialize failed")

        plain = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
        cipher = "738237036dfdde9dda3374fa182600c5"
        s = oAes192.Update(cipher)
        Console.WriteLine("CT1={0}", cipher)
        Console.WriteLine("PT1={0}", s)
        Console.WriteLine("OK1={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes192.Update failed")
        ' Line 2 using bytes
        plain = "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
        cipher = "38d9187a0299725d0a7fdbe844d77578"
        b = Cnv.FromHex(cipher)
        b = oAes192.Update(b)
        s = Cnv.ToHex(b)
        Console.WriteLine("CT2={0}", cipher)
        Console.WriteLine("PT2={0}", s)
        Console.WriteLine("OK2={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes192.Update failed")
        ' Lines 3 and 4 using hex
        plain = "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
        cipher = "1539e401b5597cbbfa836efd22d998d21605d8df340622417b911467b5e51a12"
        s = oAes192.Update(cipher)
        Console.WriteLine("CT3={0}", cipher)
        Console.WriteLine("PT3={0}", s)
        Console.WriteLine("OK3={0}", plain)
        Debug.Assert([String].Compare(s, plain, True) = 0, "Aes192.Update failed")

        ' Make sure keys are disposed of
        oAes192.Dispose()
        Console.WriteLine("AES192 Objects disposed of.")

        ' Create a test text file
        excontent = "This is some sample content."
        fnameData = "excontent.txt"
        MakeATextFile(fnameData, excontent)

        ' Encrypt a file
        keyStr = "fedcba98765432100123456789abcdeffedcba9876543210"
        fnameEnc = "excontent.aes192.enc.dat"
        okhex = "37C94F74ADDC362FA16B2A16DE40B583296A25DB83136E2CD669351EFE61A6C0"
        n = Aes192.FileEncrypt(fnameEnc, fnameData, keyStr, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Aes192.File created encrypted file '{0}'", fnameEnc)
        Else
            Console.WriteLine("Aes192.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Aes192.File failed.")

        ' Check we got what we should
        b = ReadABinaryFile(fnameEnc)
        Console.WriteLine("CT={0}", Cnv.ToHex(b))
        Debug.Assert([String].Compare(Cnv.ToHex(b), okhex, True) = 0, "Aes192.FileEncrypt failed")

        ' Decrypt it using byte format of key instead of hex
        fnameCheck = "excontent.aes192.chk.txt"
        b = Cnv.FromHex(keyStr)
        n = Aes192.FileDecrypt(fnameCheck, fnameEnc, b, Mode.ECB, Nothing)
        If 0 = n Then
            Console.WriteLine("Aes192.File decrypted to file '{0}'", fnameCheck)
            ' Show contents of file
            s = ReadATextFile(fnameCheck)
            Debug.Assert([String].Compare(s, excontent) = 0, "Decrypted file data does not match")
        Else
            Console.WriteLine("Aes192.File returned error code {0}", n)
        End If
        Debug.Assert(0 = n, "Aes192.File failed.")

        '***************************
        ' AES-256 ENCRYPTION TESTS *
        '***************************
        Console.WriteLine("TESTING AES-256:")
        keyStr = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
        plain = "00112233445566778899aabbccddeeff"
        cipher = "8EA2B7CA516745BFEAFC49904B496089"
        ' Encrypt in ECB mode using hex strings
        s = Aes256.Encrypt(plain, keyStr, Mode.ECB, Nothing)
        Console.WriteLine("KY={0}", keyStr)
        Console.WriteLine("PT={0}", plain)
        Console.WriteLine("CT={0}", s)
        Console.WriteLine("OK={0}", cipher)
        Debug.Assert([String].Compare(s, cipher, True) = 0, "Aes256.HexECB failed")
        ' Decrypt
        s = Aes256.Decrypt(cip