mirror of
https://github.com/veracrypt/VeraCrypt.git
synced 2026-10-22 14:22:36 +00:00
Mounir IDRASSI
b4c4290588
Check wrapper type alignment in both test suites so incidental alignment can't hide an empty CRYPTOPP_ALIGN_DATA, including in ASan builds. Clarify that the compiler may fold the existing address checks.
1489 lines
73 KiB
C++
1489 lines
73 KiB
C++
/*
|
|
Derived from source code of TrueCrypt 7.1a, which is
|
|
Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed
|
|
by the TrueCrypt License 3.0.
|
|
|
|
Modifications and additions to the original source code (contained in this file)
|
|
and all other portions of this file are Copyright (c) 2013-2026 AM Crypto
|
|
and are governed by the Apache License 2.0 the full text of which is
|
|
contained in the file License.txt included in VeraCrypt binary and source
|
|
code distribution packages.
|
|
*/
|
|
|
|
#include "Cipher.h"
|
|
#include "Common/Crc.h"
|
|
#include "Crc32.h"
|
|
#include "EncryptionAlgorithm.h"
|
|
#include "EncryptionMode.h"
|
|
#include "EncryptionModeXTS.h"
|
|
#ifdef WOLFCRYPT_BACKEND
|
|
#include "EncryptionModeWolfCryptXTS.h"
|
|
#endif
|
|
#include "EncryptionTest.h"
|
|
#include "Pkcs5Kdf.h"
|
|
#include "VolumeHeader.h"
|
|
|
|
namespace VeraCrypt
|
|
{
|
|
#if !defined (WOLFCRYPT_BACKEND) && !defined (VC_DCS_DISABLE_ARGON2)
|
|
class FailingArgon2Kdf : public Pkcs5Kdf
|
|
{
|
|
public:
|
|
FailingArgon2Kdf () : Pkcs5Kdf() { }
|
|
virtual ~FailingArgon2Kdf () { }
|
|
|
|
virtual int DeriveKey (const BufferPtr &key, const VolumePassword &password, int pim, const ConstBufferPtr &salt) const
|
|
{
|
|
(void) key;
|
|
(void) password;
|
|
(void) pim;
|
|
(void) salt;
|
|
return 1;
|
|
}
|
|
|
|
virtual int DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount) const
|
|
{
|
|
(void) key;
|
|
(void) password;
|
|
(void) salt;
|
|
(void) iterationCount;
|
|
return 1;
|
|
}
|
|
|
|
virtual int DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount, long volatile *pAbortKeyDerivation) const
|
|
{
|
|
(void) pAbortKeyDerivation;
|
|
return DeriveKey (key, password, salt, iterationCount);
|
|
}
|
|
|
|
virtual shared_ptr <Hash> GetHash () const { return shared_ptr <Hash> (new Blake2b); }
|
|
virtual int GetIterationCount (int pim) const { return 1; }
|
|
virtual wstring GetName () const { return L"Argon2"; }
|
|
virtual Pkcs5Kdf* Clone () const { return new FailingArgon2Kdf(); }
|
|
virtual bool IsArgon2 () const { return true; }
|
|
|
|
private:
|
|
FailingArgon2Kdf (const FailingArgon2Kdf &);
|
|
FailingArgon2Kdf &operator= (const FailingArgon2Kdf &);
|
|
};
|
|
#endif
|
|
|
|
void EncryptionTest::TestAll ()
|
|
{
|
|
TestAlignment();
|
|
TestAll (false);
|
|
TestAll (true);
|
|
}
|
|
|
|
#define TC_ALIGNMENT_PROBE_SIZE 4
|
|
|
|
// The compiler may fold the address checks using the declared alignment.
|
|
void EncryptionTest::TestAlignment ()
|
|
{
|
|
// Check type alignment at compile time: static probes can be aligned even with an
|
|
// empty CRYPTOPP_ALIGN_DATA, for example in AddressSanitizer builds.
|
|
struct DerivedKeyAlignmentProbe
|
|
{
|
|
CRYPTOPP_ALIGN_DATA(TC_DERIVED_KEY_BUFFER_ALIGNMENT) uint8 buffer[TC_ALIGNMENT_PROBE_SIZE];
|
|
};
|
|
|
|
struct KeyInfoAlignmentProbe
|
|
{
|
|
CRYPTOPP_ALIGN_DATA(TC_KEY_INFO_BUFFER_ALIGNMENT) uint8 buffer[TC_ALIGNMENT_PROBE_SIZE];
|
|
};
|
|
|
|
static_assert (alignof (DerivedKeyAlignmentProbe) >= TC_DERIVED_KEY_BUFFER_ALIGNMENT, "Insufficient derived key buffer alignment");
|
|
static_assert (alignof (KeyInfoAlignmentProbe) >= TC_KEY_INFO_BUFFER_ALIGNMENT, "Insufficient key info buffer alignment");
|
|
|
|
static CRYPTOPP_ALIGN_DATA(TC_DERIVED_KEY_BUFFER_ALIGNMENT) uint8 derivedKeyProbe[TC_ALIGNMENT_PROBE_SIZE];
|
|
static CRYPTOPP_ALIGN_DATA(TC_KEY_INFO_BUFFER_ALIGNMENT) uint8 keyInfoProbe[TC_ALIGNMENT_PROBE_SIZE];
|
|
|
|
if (!TC_IS_ALIGNED (derivedKeyProbe, TC_DERIVED_KEY_BUFFER_ALIGNMENT))
|
|
throw TestFailed (SRC_POS);
|
|
|
|
if (!TC_IS_ALIGNED (keyInfoProbe, TC_KEY_INFO_BUFFER_ALIGNMENT))
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
|
|
void EncryptionTest::TestAll (bool enableCpuEncryptionSupport)
|
|
{
|
|
bool hwSupportEnabled = Cipher::IsHwSupportEnabled();
|
|
finally_do_arg (bool, hwSupportEnabled, { Cipher::EnableHwSupport (finally_arg); });
|
|
|
|
Cipher::EnableHwSupport (enableCpuEncryptionSupport);
|
|
|
|
TestCiphers();
|
|
TestXtsAES();
|
|
TestXts();
|
|
TestPkcs5();
|
|
}
|
|
|
|
|
|
struct CipherTestVector
|
|
{
|
|
uint8 Key[32];
|
|
size_t KeyLength;
|
|
uint8 Plaintext[16];
|
|
uint8 Ciphertext[16];
|
|
};
|
|
|
|
static const CipherTestVector AESTestVectors[] =
|
|
{
|
|
{
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
},
|
|
32,
|
|
{
|
|
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
|
|
},
|
|
{
|
|
0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf, 0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89
|
|
}
|
|
}
|
|
};
|
|
|
|
#ifndef WOLFCRYPT_BACKEND
|
|
static const CipherTestVector SerpentTestVectors[] =
|
|
{
|
|
{
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
|
|
},
|
|
32,
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
|
|
},
|
|
{
|
|
0xde, 0x26, 0x9f, 0xf8, 0x33, 0xe4, 0x32, 0xb8, 0x5b, 0x2e, 0x88, 0xd2, 0x70, 0x1c, 0xe7, 0x5c
|
|
}
|
|
}
|
|
};
|
|
|
|
static const CipherTestVector TwofishTestVectors[] =
|
|
{
|
|
{
|
|
{
|
|
0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46, 0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D,
|
|
0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B, 0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F
|
|
},
|
|
32,
|
|
{
|
|
0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F, 0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6
|
|
},
|
|
{
|
|
0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97, 0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA
|
|
}
|
|
}
|
|
};
|
|
|
|
static const CipherTestVector CamelliaTestVectors[] =
|
|
{
|
|
{
|
|
{
|
|
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
|
|
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
|
|
},
|
|
32,
|
|
{
|
|
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10
|
|
},
|
|
{
|
|
0x9A, 0xCC, 0x23, 0x7D, 0xFF, 0x16, 0xD7, 0x6C, 0x20, 0xEF, 0x7C, 0x91, 0x9E, 0x3A, 0x75, 0x09
|
|
}
|
|
},
|
|
{
|
|
{
|
|
0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00, 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48,
|
|
0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00, 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
|
|
},
|
|
32,
|
|
{
|
|
0xE6, 0x84, 0x42, 0x17, 0x16, 0xFC, 0x0B, 0x01, 0xAE, 0xB5, 0xC6, 0x76, 0x51, 0x20, 0xF9, 0x5F
|
|
},
|
|
{
|
|
0xEA, 0x02, 0x47, 0x14, 0xAD, 0x5C, 0x4D, 0x84, 0xEA, 0x02, 0x47, 0x14, 0xAD, 0x5C, 0x4D, 0x84
|
|
}
|
|
}
|
|
};
|
|
|
|
static const CipherTestVector KuznyechikTestVectors[] =
|
|
{
|
|
{
|
|
{
|
|
0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
|
|
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
|
|
},
|
|
32,
|
|
{
|
|
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x00, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88
|
|
},
|
|
{
|
|
0x7F, 0x67, 0x9D, 0x90, 0xBE, 0xBC, 0x24, 0x30, 0x5A, 0x46, 0x8D, 0x42, 0xB9, 0xD4, 0xED, 0xCD
|
|
}
|
|
},
|
|
{
|
|
{
|
|
0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
|
|
0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
|
|
},
|
|
32,
|
|
{
|
|
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xEE, 0xFF, 0x0A
|
|
},
|
|
{
|
|
0xB4, 0x29, 0x91, 0x2C, 0x6E, 0x00, 0x32, 0xF9, 0x28, 0x54, 0x52, 0xD7, 0x67, 0x18, 0xD0, 0x8B
|
|
}
|
|
}
|
|
};
|
|
#endif
|
|
|
|
static void TestCipher (Cipher &cipher, const CipherTestVector *testVector, size_t testVectorCount)
|
|
{
|
|
Buffer buffer (cipher.GetBlockSize());
|
|
for (size_t i = 0; i < testVectorCount; ++i)
|
|
{
|
|
cipher.SetKey (ConstBufferPtr (testVector[i].Key, testVector[i].KeyLength));
|
|
buffer.CopyFrom (ConstBufferPtr (testVector[i].Plaintext, sizeof (testVector[i].Plaintext)));
|
|
cipher.EncryptBlock (buffer);
|
|
|
|
if (memcmp (buffer, testVector[i].Ciphertext, buffer.Size()) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
}
|
|
|
|
void EncryptionTest::TestCiphers ()
|
|
{
|
|
CipherAES aes;
|
|
TestCipher (aes, AESTestVectors, array_capacity (AESTestVectors));
|
|
|
|
Buffer testData (1024);
|
|
for (size_t i = 0; i < testData.Size(); ++i)
|
|
{
|
|
testData[i] = (uint8) i;
|
|
}
|
|
|
|
uint32 origCrc = Crc32::ProcessBuffer (testData);
|
|
|
|
aes.SetKey (ConstBufferPtr (testData, aes.GetKeySize()));
|
|
aes.EncryptBlocks (testData, testData.Size() / aes.GetBlockSize());
|
|
|
|
if (Crc32::ProcessBuffer (testData) != 0xb5cd5631)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
aes.DecryptBlocks (testData, testData.Size() / aes.GetBlockSize());
|
|
|
|
if (origCrc != Crc32::ProcessBuffer (testData))
|
|
throw TestFailed (SRC_POS);
|
|
|
|
#ifndef WOLFCRYPT_BACKEND
|
|
CipherSerpent serpent;
|
|
TestCipher (serpent, SerpentTestVectors, array_capacity (SerpentTestVectors));
|
|
|
|
CipherTwofish twofish;
|
|
TestCipher (twofish, TwofishTestVectors, array_capacity (TwofishTestVectors));
|
|
|
|
CipherCamellia camellia;
|
|
TestCipher (camellia, CamelliaTestVectors, array_capacity (CamelliaTestVectors));
|
|
|
|
CipherKuznyechik kuznyechik;
|
|
TestCipher (kuznyechik, KuznyechikTestVectors, array_capacity (KuznyechikTestVectors));
|
|
#endif
|
|
}
|
|
|
|
const EncryptionTest::XtsTestVector EncryptionTest::XtsTestVectors[] =
|
|
{
|
|
/* XTS-AES-256 */
|
|
{
|
|
// IEEE 1619 - Vector 10
|
|
|
|
{ 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
|
|
{ 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
|
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
|
|
0,
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
|
|
},
|
|
{
|
|
0x1c, 0x3b, 0x3a, 0x10, 0x2f, 0x77, 0x03, 0x86, 0xe4, 0x83, 0x6c, 0x99, 0xe3, 0x70, 0xcf, 0x9b, 0xea, 0x00, 0x80, 0x3f, 0x5e, 0x48, 0x23, 0x57, 0xa4, 0xae, 0x12, 0xd4, 0x14, 0xa3, 0xe6, 0x3b,
|
|
0x5d, 0x31, 0xe2, 0x76, 0xf8, 0xfe, 0x4a, 0x8d, 0x66, 0xb3, 0x17, 0xf9, 0xac, 0x68, 0x3f, 0x44, 0x68, 0x0a, 0x86, 0xac, 0x35, 0xad, 0xfc, 0x33, 0x45, 0xbe, 0xfe, 0xcb, 0x4b, 0xb1, 0x88, 0xfd,
|
|
0x57, 0x76, 0x92, 0x6c, 0x49, 0xa3, 0x09, 0x5e, 0xb1, 0x08, 0xfd, 0x10, 0x98, 0xba, 0xec, 0x70, 0xaa, 0xa6, 0x69, 0x99, 0xa7, 0x2a, 0x82, 0xf2, 0x7d, 0x84, 0x8b, 0x21, 0xd4, 0xa7, 0x41, 0xb0,
|
|
0xc5, 0xcd, 0x4d, 0x5f, 0xff, 0x9d, 0xac, 0x89, 0xae, 0xba, 0x12, 0x29, 0x61, 0xd0, 0x3a, 0x75, 0x71, 0x23, 0xe9, 0x87, 0x0f, 0x8a, 0xcf, 0x10, 0x00, 0x02, 0x08, 0x87, 0x89, 0x14, 0x29, 0xca,
|
|
0x2a, 0x3e, 0x7a, 0x7d, 0x7d, 0xf7, 0xb1, 0x03, 0x55, 0x16, 0x5c, 0x8b, 0x9a, 0x6d, 0x0a, 0x7d, 0xe8, 0xb0, 0x62, 0xc4, 0x50, 0x0d, 0xc4, 0xcd, 0x12, 0x0c, 0x0f, 0x74, 0x18, 0xda, 0xe3, 0xd0,
|
|
0xb5, 0x78, 0x1c, 0x34, 0x80, 0x3f, 0xa7, 0x54, 0x21, 0xc7, 0x90, 0xdf, 0xe1, 0xde, 0x18, 0x34, 0xf2, 0x80, 0xd7, 0x66, 0x7b, 0x32, 0x7f, 0x6c, 0x8c, 0xd7, 0x55, 0x7e, 0x12, 0xac, 0x3a, 0x0f,
|
|
0x93, 0xec, 0x05, 0xc5, 0x2e, 0x04, 0x93, 0xef, 0x31, 0xa1, 0x2d, 0x3d, 0x92, 0x60, 0xf7, 0x9a, 0x28, 0x9d, 0x6a, 0x37, 0x9b, 0xc7, 0x0c, 0x50, 0x84, 0x14, 0x73, 0xd1, 0xa8, 0xcc, 0x81, 0xec,
|
|
0x58, 0x3e, 0x96, 0x45, 0xe0, 0x7b, 0x8d, 0x96, 0x70, 0x65, 0x5b, 0xa5, 0xbb, 0xcf, 0xec, 0xc6, 0xdc, 0x39, 0x66, 0x38, 0x0a, 0xd8, 0xfe, 0xcb, 0x17, 0xb6, 0xba, 0x02, 0x46, 0x9a, 0x02, 0x0a,
|
|
0x84, 0xe1, 0x8e, 0x8f, 0x84, 0x25, 0x20, 0x70, 0xc1, 0x3e, 0x9f, 0x1f, 0x28, 0x9b, 0xe5, 0x4f, 0xbc, 0x48, 0x14, 0x57, 0x77, 0x8f, 0x61, 0x60, 0x15, 0xe1, 0x32, 0x7a, 0x02, 0xb1, 0x40, 0xf1,
|
|
0x50, 0x5e, 0xb3, 0x09, 0x32, 0x6d, 0x68, 0x37, 0x8f, 0x83, 0x74, 0x59, 0x5c, 0x84, 0x9d, 0x84, 0xf4, 0xc3, 0x33, 0xec, 0x44, 0x23, 0x88, 0x51, 0x43, 0xcb, 0x47, 0xbd, 0x71, 0xc5, 0xed, 0xae,
|
|
0x9b, 0xe6, 0x9a, 0x2f, 0xfe, 0xce, 0xb1, 0xbe, 0xc9, 0xde, 0x24, 0x4f, 0xbe, 0x15, 0x99, 0x2b, 0x11, 0xb7, 0x7c, 0x04, 0x0f, 0x12, 0xbd, 0x8f, 0x6a, 0x97, 0x5a, 0x44, 0xa0, 0xf9, 0x0c, 0x29,
|
|
0xa9, 0xab, 0xc3, 0xd4, 0xd8, 0x93, 0x92, 0x72, 0x84, 0xc5, 0x87, 0x54, 0xcc, 0xe2, 0x94, 0x52, 0x9f, 0x86, 0x14, 0xdc, 0xd2, 0xab, 0xa9, 0x91, 0x92, 0x5f, 0xed, 0xc4, 0xae, 0x74, 0xff, 0xac,
|
|
0x6e, 0x33, 0x3b, 0x93, 0xeb, 0x4a, 0xff, 0x04, 0x79, 0xda, 0x9a, 0x41, 0x0e, 0x44, 0x50, 0xe0, 0xdd, 0x7a, 0xe4, 0xc6, 0xe2, 0x91, 0x09, 0x00, 0x57, 0x5d, 0xa4, 0x01, 0xfc, 0x07, 0x05, 0x9f,
|
|
0x64, 0x5e, 0x8b, 0x7e, 0x9b, 0xfd, 0xef, 0x33, 0x94, 0x30, 0x54, 0xff, 0x84, 0x01, 0x14, 0x93, 0xc2, 0x7b, 0x34, 0x29, 0xea, 0xed, 0xb4, 0xed, 0x53, 0x76, 0x44, 0x1a, 0x77, 0xed, 0x43, 0x85,
|
|
0x1a, 0xd7, 0x7f, 0x16, 0xf5, 0x41, 0xdf, 0xd2, 0x69, 0xd5, 0x0d, 0x6a, 0x5f, 0x14, 0xfb, 0x0a, 0xab, 0x1c, 0xbb, 0x4c, 0x15, 0x50, 0xbe, 0x97, 0xf7, 0xab, 0x40, 0x66, 0x19, 0x3c, 0x4c, 0xaa,
|
|
0x77, 0x3d, 0xad, 0x38, 0x01, 0x4b, 0xd2, 0x09, 0x2f, 0xa7, 0x55, 0xc8, 0x24, 0xbb, 0x5e, 0x54, 0xc4, 0xf3, 0x6f, 0xfd, 0xa9, 0xfc, 0xea, 0x70, 0xb9, 0xc6, 0xe6, 0x93, 0xe1, 0x48, 0xc1, 0x51
|
|
}
|
|
},
|
|
{
|
|
// IEEE 1619 - Vector 11
|
|
|
|
{ 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
|
|
{ 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
|
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff },
|
|
0,
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
|
|
},
|
|
{
|
|
0x77, 0xa3, 0x12, 0x51, 0x61, 0x8a, 0x15, 0xe6, 0xb9, 0x2d, 0x1d, 0x66, 0xdf, 0xfe, 0x7b, 0x50, 0xb5, 0x0b, 0xad, 0x55, 0x23, 0x05, 0xba, 0x02, 0x17, 0xa6, 0x10, 0x68, 0x8e, 0xff, 0x7e, 0x11,
|
|
0xe1, 0xd0, 0x22, 0x54, 0x38, 0xe0, 0x93, 0x24, 0x2d, 0x6d, 0xb2, 0x74, 0xfd, 0xe8, 0x01, 0xd4, 0xca, 0xe0, 0x6f, 0x20, 0x92, 0xc7, 0x28, 0xb2, 0x47, 0x85, 0x59, 0xdf, 0x58, 0xe8, 0x37, 0xc2,
|
|
0x46, 0x9e, 0xe4, 0xa4, 0xfa, 0x79, 0x4e, 0x4b, 0xbc, 0x7f, 0x39, 0xbc, 0x02, 0x6e, 0x3c, 0xb7, 0x2c, 0x33, 0xb0, 0x88, 0x8f, 0x25, 0xb4, 0xac, 0xf5, 0x6a, 0x2a, 0x98, 0x04, 0xf1, 0xce, 0x6d,
|
|
0x3d, 0x6e, 0x1d, 0xc6, 0xca, 0x18, 0x1d, 0x4b, 0x54, 0x61, 0x79, 0xd5, 0x55, 0x44, 0xaa, 0x77, 0x60, 0xc4, 0x0d, 0x06, 0x74, 0x15, 0x39, 0xc7, 0xe3, 0xcd, 0x9d, 0x2f, 0x66, 0x50, 0xb2, 0x01,
|
|
0x3f, 0xd0, 0xee, 0xb8, 0xc2, 0xb8, 0xe3, 0xd8, 0xd2, 0x40, 0xcc, 0xae, 0x2d, 0x4c, 0x98, 0x32, 0x0a, 0x74, 0x42, 0xe1, 0xc8, 0xd7, 0x5a, 0x42, 0xd6, 0xe6, 0xcf, 0xa4, 0xc2, 0xec, 0xa1, 0x79,
|
|
0x8d, 0x15, 0x8c, 0x7a, 0xec, 0xdf, 0x82, 0x49, 0x0f, 0x24, 0xbb, 0x9b, 0x38, 0xe1, 0x08, 0xbc, 0xda, 0x12, 0xc3, 0xfa, 0xf9, 0xa2, 0x11, 0x41, 0xc3, 0x61, 0x3b, 0x58, 0x36, 0x7f, 0x92, 0x2a,
|
|
0xaa, 0x26, 0xcd, 0x22, 0xf2, 0x3d, 0x70, 0x8d, 0xae, 0x69, 0x9a, 0xd7, 0xcb, 0x40, 0xa8, 0xad, 0x0b, 0x6e, 0x27, 0x84, 0x97, 0x3d, 0xcb, 0x60, 0x56, 0x84, 0xc0, 0x8b, 0x8d, 0x69, 0x98, 0xc6,
|
|
0x9a, 0xac, 0x04, 0x99, 0x21, 0x87, 0x1e, 0xbb, 0x65, 0x30, 0x1a, 0x46, 0x19, 0xca, 0x80, 0xec, 0xb4, 0x85, 0xa3, 0x1d, 0x74, 0x42, 0x23, 0xce, 0x8d, 0xdc, 0x23, 0x94, 0x82, 0x8d, 0x6a, 0x80,
|
|
0x47, 0x0c, 0x09, 0x2f, 0x5b, 0xa4, 0x13, 0xc3, 0x37, 0x8f, 0xa6, 0x05, 0x42, 0x55, 0xc6, 0xf9, 0xdf, 0x44, 0x95, 0x86, 0x2b, 0xbb, 0x32, 0x87, 0x68, 0x1f, 0x93, 0x1b, 0x68, 0x7c, 0x88, 0x8a,
|
|
0xbf, 0x84, 0x4d, 0xfc, 0x8f, 0xc2, 0x83, 0x31, 0xe5, 0x79, 0x92, 0x8c, 0xd1, 0x2b, 0xd2, 0x39, 0x0a, 0xe1, 0x23, 0xcf, 0x03, 0x81, 0x8d, 0x14, 0xde, 0xdd, 0xe5, 0xc0, 0xc2, 0x4c, 0x8a, 0xb0,
|
|
0x18, 0xbf, 0xca, 0x75, 0xca, 0x09, 0x6f, 0x2d, 0x53, 0x1f, 0x3d, 0x16, 0x19, 0xe7, 0x85, 0xf1, 0xad, 0xa4, 0x37, 0xca, 0xb9, 0x2e, 0x98, 0x05, 0x58, 0xb3, 0xdc, 0xe1, 0x47, 0x4a, 0xfb, 0x75,
|
|
0xbf, 0xed, 0xbf, 0x8f, 0xf5, 0x4c, 0xb2, 0x61, 0x8e, 0x02, 0x44, 0xc9, 0xac, 0x0d, 0x3c, 0x66, 0xfb, 0x51, 0x59, 0x8c, 0xd2, 0xdb, 0x11, 0xf9, 0xbe, 0x39, 0x79, 0x1a, 0xbe, 0x44, 0x7c, 0x63,
|
|
0x09, 0x4f, 0x7c, 0x45, 0x3b, 0x7f, 0xf8, 0x7c, 0xb5, 0xbb, 0x36, 0xb7, 0xc7, 0x9e, 0xfb, 0x08, 0x72, 0xd1, 0x70, 0x58, 0xb8, 0x3b, 0x15, 0xab, 0x08, 0x66, 0xad, 0x8a, 0x58, 0x65, 0x6c, 0x5a,
|
|
0x7e, 0x20, 0xdb, 0xdf, 0x30, 0x8b, 0x24, 0x61, 0xd9, 0x7c, 0x0e, 0xc0, 0x02, 0x4a, 0x27, 0x15, 0x05, 0x52, 0x49, 0xcf, 0x3b, 0x47, 0x8d, 0xdd, 0x47, 0x40, 0xde, 0x65, 0x4f, 0x75, 0xca, 0x68,
|
|
0x6e, 0x0d, 0x73, 0x45, 0xc6, 0x9e, 0xd5, 0x0c, 0xdc, 0x2a, 0x8b, 0x33, 0x2b, 0x1f, 0x88, 0x24, 0x10, 0x8a, 0xc9, 0x37, 0xeb, 0x05, 0x05, 0x85, 0x60, 0x8e, 0xe7, 0x34, 0x09, 0x7f, 0xc0, 0x90,
|
|
0x54, 0xfb, 0xff, 0x89, 0xee, 0xae, 0xea, 0x79, 0x1f, 0x4a, 0x7a, 0xb1, 0xf9, 0x86, 0x82, 0x94, 0xa4, 0xf9, 0xe2, 0x7b, 0x42, 0xaf, 0x81, 0x00, 0xcb, 0x9d, 0x59, 0xce, 0xf9, 0x64, 0x58, 0x03
|
|
}
|
|
},
|
|
{
|
|
// IEEE 1619 - Vector 12
|
|
|
|
{ 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
|
|
{ 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
|
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff },
|
|
0,
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
|
|
},
|
|
{
|
|
0xe3, 0x87, 0xaa, 0xa5, 0x8b, 0xa4, 0x83, 0xaf, 0xa7, 0xe8, 0xeb, 0x46, 0x97, 0x78, 0x31, 0x7e, 0xcf, 0x4c, 0xf5, 0x73, 0xaa, 0x9d, 0x4e, 0xac, 0x23, 0xf2, 0xcd, 0xf9, 0x14, 0xe4, 0xe2, 0x00,
|
|
0xa8, 0xb4, 0x90, 0xe4, 0x2e, 0xe6, 0x46, 0x80, 0x2d, 0xc6, 0xee, 0x2b, 0x47, 0x1b, 0x27, 0x81, 0x95, 0xd6, 0x09, 0x18, 0xec, 0xec, 0xb4, 0x4b, 0xf7, 0x99, 0x66, 0xf8, 0x3f, 0xab, 0xa0, 0x49,
|
|
0x92, 0x98, 0xeb, 0xc6, 0x99, 0xc0, 0xc8, 0x63, 0x47, 0x15, 0xa3, 0x20, 0xbb, 0x4f, 0x07, 0x5d, 0x62, 0x2e, 0x74, 0xc8, 0xc9, 0x32, 0x00, 0x4f, 0x25, 0xb4, 0x1e, 0x36, 0x10, 0x25, 0xb5, 0xa8,
|
|
0x78, 0x15, 0x39, 0x1f, 0x61, 0x08, 0xfc, 0x4a, 0xfa, 0x6a, 0x05, 0xd9, 0x30, 0x3c, 0x6b, 0xa6, 0x8a, 0x12, 0x8a, 0x55, 0x70, 0x5d, 0x41, 0x59, 0x85, 0x83, 0x2f, 0xde, 0xaa, 0xe6, 0xc8, 0xe1,
|
|
0x91, 0x10, 0xe8, 0x4d, 0x1b, 0x1f, 0x19, 0x9a, 0x26, 0x92, 0x11, 0x9e, 0xdc, 0x96, 0x13, 0x26, 0x58, 0xf0, 0x9d, 0xa7, 0xc6, 0x23, 0xef, 0xce, 0xc7, 0x12, 0x53, 0x7a, 0x3d, 0x94, 0xc0, 0xbf,
|
|
0x5d, 0x7e, 0x35, 0x2e, 0xc9, 0x4a, 0xe5, 0x79, 0x7f, 0xdb, 0x37, 0x7d, 0xc1, 0x55, 0x11, 0x50, 0x72, 0x1a, 0xdf, 0x15, 0xbd, 0x26, 0xa8, 0xef, 0xc2, 0xfc, 0xaa, 0xd5, 0x68, 0x81, 0xfa, 0x9e,
|
|
0x62, 0x46, 0x2c, 0x28, 0xf3, 0x0a, 0xe1, 0xce, 0xac, 0xa9, 0x3c, 0x34, 0x5c, 0xf2, 0x43, 0xb7, 0x3f, 0x54, 0x2e, 0x20, 0x74, 0xa7, 0x05, 0xbd, 0x26, 0x43, 0xbb, 0x9f, 0x7c, 0xc7, 0x9b, 0xb6,
|
|
0xe7, 0x09, 0x1e, 0xa6, 0xe2, 0x32, 0xdf, 0x0f, 0x9a, 0xd0, 0xd6, 0xcf, 0x50, 0x23, 0x27, 0x87, 0x6d, 0x82, 0x20, 0x7a, 0xbf, 0x21, 0x15, 0xcd, 0xac, 0xf6, 0xd5, 0xa4, 0x8f, 0x6c, 0x18, 0x79,
|
|
0xa6, 0x5b, 0x11, 0x5f, 0x0f, 0x8b, 0x3c, 0xb3, 0xc5, 0x9d, 0x15, 0xdd, 0x8c, 0x76, 0x9b, 0xc0, 0x14, 0x79, 0x5a, 0x18, 0x37, 0xf3, 0x90, 0x1b, 0x58, 0x45, 0xeb, 0x49, 0x1a, 0xdf, 0xef, 0xe0,
|
|
0x97, 0xb1, 0xfa, 0x30, 0xa1, 0x2f, 0xc1, 0xf6, 0x5b, 0xa2, 0x29, 0x05, 0x03, 0x15, 0x39, 0x97, 0x1a, 0x10, 0xf2, 0xf3, 0x6c, 0x32, 0x1b, 0xb5, 0x13, 0x31, 0xcd, 0xef, 0xb3, 0x9e, 0x39, 0x64,
|
|
0xc7, 0xef, 0x07, 0x99, 0x94, 0xf5, 0xb6, 0x9b, 0x2e, 0xdd, 0x83, 0xa7, 0x1e, 0xf5, 0x49, 0x97, 0x1e, 0xe9, 0x3f, 0x44, 0xea, 0xc3, 0x93, 0x8f, 0xcd, 0xd6, 0x1d, 0x01, 0xfa, 0x71, 0x79, 0x9d,
|
|
0xa3, 0xa8, 0x09, 0x1c, 0x4c, 0x48, 0xaa, 0x9e, 0xd2, 0x63, 0xff, 0x07, 0x49, 0xdf, 0x95, 0xd4, 0x4f, 0xef, 0x6a, 0x0b, 0xb5, 0x78, 0xec, 0x69, 0x45, 0x6a, 0xa5, 0x40, 0x8a, 0xe3, 0x2c, 0x7a,
|
|
0xf0, 0x8a, 0xd7, 0xba, 0x89, 0x21, 0x28, 0x7e, 0x3b, 0xbe, 0xe3, 0x1b, 0x76, 0x7b, 0xe0, 0x6a, 0x0e, 0x70, 0x5c, 0x86, 0x4a, 0x76, 0x91, 0x37, 0xdf, 0x28, 0x29, 0x22, 0x83, 0xea, 0x81, 0xa2,
|
|
0x48, 0x02, 0x41, 0xb4, 0x4d, 0x99, 0x21, 0xcd, 0xbe, 0xc1, 0xbc, 0x28, 0xdc, 0x1f, 0xda, 0x11, 0x4b, 0xd8, 0xe5, 0x21, 0x7a, 0xc9, 0xd8, 0xeb, 0xaf, 0xa7, 0x20, 0xe9, 0xda, 0x4f, 0x9a, 0xce,
|
|
0x23, 0x1c, 0xc9, 0x49, 0xe5, 0xb9, 0x6f, 0xe7, 0x6f, 0xfc, 0x21, 0x06, 0x3f, 0xdd, 0xc8, 0x3a, 0x6b, 0x86, 0x79, 0xc0, 0x0d, 0x35, 0xe0, 0x95, 0x76, 0xa8, 0x75, 0x30, 0x5b, 0xed, 0x5f, 0x36,
|
|
0xed, 0x24, 0x2c, 0x89, 0x00, 0xdd, 0x1f, 0xa9, 0x65, 0xbc, 0x95, 0x0d, 0xfc, 0xe0, 0x9b, 0x13, 0x22, 0x63, 0xa1, 0xee, 0xf5, 0x2d, 0xd6, 0x88, 0x8c, 0x30, 0x9f, 0x5a, 0x7d, 0x71, 0x28, 0x26
|
|
}
|
|
},
|
|
{
|
|
// IEEE 1619 - Vector 13
|
|
|
|
{ 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
|
|
{ 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
|
|
{ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff },
|
|
0,
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
|
|
},
|
|
{
|
|
0xbf, 0x53, 0xd2, 0xda, 0xde, 0x78, 0xe8, 0x22, 0xa4, 0xd9, 0x49, 0xa9, 0xbc, 0x67, 0x66, 0xb0, 0x1b, 0x06, 0xa8, 0xef, 0x70, 0xd2, 0x67, 0x48, 0xc6, 0xa7, 0xfc, 0x36, 0xd8, 0x0a, 0xe4, 0xc5,
|
|
0x52, 0x0f, 0x7c, 0x4a, 0xb0, 0xac, 0x85, 0x44, 0x42, 0x4f, 0xa4, 0x05, 0x16, 0x2f, 0xef, 0x5a, 0x6b, 0x7f, 0x22, 0x94, 0x98, 0x06, 0x36, 0x18, 0xd3, 0x9f, 0x00, 0x03, 0xcb, 0x5f, 0xb8, 0xd1,
|
|
0xc8, 0x6b, 0x64, 0x34, 0x97, 0xda, 0x1f, 0xf9, 0x45, 0xc8, 0xd3, 0xbe, 0xde, 0xca, 0x4f, 0x47, 0x97, 0x02, 0xa7, 0xa7, 0x35, 0xf0, 0x43, 0xdd, 0xb1, 0xd6, 0xaa, 0xad, 0xe3, 0xc4, 0xa0, 0xac,
|
|
0x7c, 0xa7, 0xf3, 0xfa, 0x52, 0x79, 0xbe, 0xf5, 0x6f, 0x82, 0xcd, 0x7a, 0x2f, 0x38, 0x67, 0x2e, 0x82, 0x48, 0x14, 0xe1, 0x07, 0x00, 0x30, 0x0a, 0x05, 0x5e, 0x16, 0x30, 0xb8, 0xf1, 0xcb, 0x0e,
|
|
0x91, 0x9f, 0x5e, 0x94, 0x20, 0x10, 0xa4, 0x16, 0xe2, 0xbf, 0x48, 0xcb, 0x46, 0x99, 0x3d, 0x3c, 0xb6, 0xa5, 0x1c, 0x19, 0xba, 0xcf, 0x86, 0x47, 0x85, 0xa0, 0x0b, 0xc2, 0xec, 0xff, 0x15, 0xd3,
|
|
0x50, 0x87, 0x5b, 0x24, 0x6e, 0xd5, 0x3e, 0x68, 0xbe, 0x6f, 0x55, 0xbd, 0x7e, 0x05, 0xcf, 0xc2, 0xb2, 0xed, 0x64, 0x32, 0x19, 0x8a, 0x64, 0x44, 0xb6, 0xd8, 0xc2, 0x47, 0xfa, 0xb9, 0x41, 0xf5,
|
|
0x69, 0x76, 0x8b, 0x5c, 0x42, 0x93, 0x66, 0xf1, 0xd3, 0xf0, 0x0f, 0x03, 0x45, 0xb9, 0x61, 0x23, 0xd5, 0x62, 0x04, 0xc0, 0x1c, 0x63, 0xb2, 0x2c, 0xe7, 0x8b, 0xaf, 0x11, 0x6e, 0x52, 0x5e, 0xd9,
|
|
0x0f, 0xde, 0xa3, 0x9f, 0xa4, 0x69, 0x49, 0x4d, 0x38, 0x66, 0xc3, 0x1e, 0x05, 0xf2, 0x95, 0xff, 0x21, 0xfe, 0xa8, 0xd4, 0xe6, 0xe1, 0x3d, 0x67, 0xe4, 0x7c, 0xe7, 0x22, 0xe9, 0x69, 0x8a, 0x1c,
|
|
0x10, 0x48, 0xd6, 0x8e, 0xbc, 0xde, 0x76, 0xb8, 0x6f, 0xcf, 0x97, 0x6e, 0xab, 0x8a, 0xa9, 0x79, 0x02, 0x68, 0xb7, 0x06, 0x8e, 0x01, 0x7a, 0x8b, 0x9b, 0x74, 0x94, 0x09, 0x51, 0x4f, 0x10, 0x53,
|
|
0x02, 0x7f, 0xd1, 0x6c, 0x37, 0x86, 0xea, 0x1b, 0xac, 0x5f, 0x15, 0xcb, 0x79, 0x71, 0x1e, 0xe2, 0xab, 0xe8, 0x2f, 0x5c, 0xf8, 0xb1, 0x3a, 0xe7, 0x30, 0x30, 0xef, 0x5b, 0x9e, 0x44, 0x57, 0xe7,
|
|
0x5d, 0x13, 0x04, 0xf9, 0x88, 0xd6, 0x2d, 0xd6, 0xfc, 0x4b, 0x94, 0xed, 0x38, 0xba, 0x83, 0x1d, 0xa4, 0xb7, 0x63, 0x49, 0x71, 0xb6, 0xcd, 0x8e, 0xc3, 0x25, 0xd9, 0xc6, 0x1c, 0x00, 0xf1, 0xdf,
|
|
0x73, 0x62, 0x7e, 0xd3, 0x74, 0x5a, 0x5e, 0x84, 0x89, 0xf3, 0xa9, 0x5c, 0x69, 0x63, 0x9c, 0x32, 0xcd, 0x6e, 0x1d, 0x53, 0x7a, 0x85, 0xf7, 0x5c, 0xc8, 0x44, 0x72, 0x6e, 0x8a, 0x72, 0xfc, 0x00,
|
|
0x77, 0xad, 0x22, 0x00, 0x0f, 0x1d, 0x50, 0x78, 0xf6, 0xb8, 0x66, 0x31, 0x8c, 0x66, 0x8f, 0x1a, 0xd0, 0x3d, 0x5a, 0x5f, 0xce, 0xd5, 0x21, 0x9f, 0x2e, 0xab, 0xbd, 0x0a, 0xa5, 0xc0, 0xf4, 0x60,
|
|
0xd1, 0x83, 0xf0, 0x44, 0x04, 0xa0, 0xd6, 0xf4, 0x69, 0x55, 0x8e, 0x81, 0xfa, 0xb2, 0x4a, 0x16, 0x79, 0x05, 0xab, 0x4c, 0x78, 0x78, 0x50, 0x2a, 0xd3, 0xe3, 0x8f, 0xdb, 0xe6, 0x2a, 0x41, 0x55,
|
|
0x6c, 0xec, 0x37, 0x32, 0x57, 0x59, 0x53, 0x3c, 0xe8, 0xf2, 0x5f, 0x36, 0x7c, 0x87, 0xbb, 0x55, 0x78, 0xd6, 0x67, 0xae, 0x93, 0xf9, 0xe2, 0xfd, 0x99, 0xbc, 0xbc, 0x5f, 0x2f, 0xbb, 0xa8, 0x8c,
|
|
0xf6, 0x51, 0x61, 0x39, 0x42, 0x0f, 0xcf, 0xf3, 0xb7, 0x36, 0x1d, 0x86, 0x32, 0x2c, 0x4b, 0xd8, 0x4c, 0x82, 0xf3, 0x35, 0xab, 0xb1, 0x52, 0xc4, 0xa9, 0x34, 0x11, 0x37, 0x3a, 0xaa, 0x82, 0x20
|
|
}
|
|
},
|
|
{
|
|
// IEEE 1619 - Vector 14
|
|
|
|
{ 0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27 },
|
|
{ 0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92 },
|
|
{ 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff },
|
|
0,
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
|
|
},
|
|
{
|
|
0x64, 0x49, 0x7e, 0x5a, 0x83, 0x1e, 0x4a, 0x93, 0x2c, 0x09, 0xbe, 0x3e, 0x53, 0x93, 0x37, 0x6d, 0xaa, 0x59, 0x95, 0x48, 0xb8, 0x16, 0x03, 0x1d, 0x22, 0x4b, 0xbf, 0x50, 0xa8, 0x18, 0xed, 0x23,
|
|
0x50, 0xea, 0xe7, 0xe9, 0x60, 0x87, 0xc8, 0xa0, 0xdb, 0x51, 0xad, 0x29, 0x0b, 0xd0, 0x0c, 0x1a, 0xc1, 0x62, 0x08, 0x57, 0x63, 0x5b, 0xf2, 0x46, 0xc1, 0x76, 0xab, 0x46, 0x3b, 0xe3, 0x0b, 0x80,
|
|
0x8d, 0xa5, 0x48, 0x08, 0x1a, 0xc8, 0x47, 0xb1, 0x58, 0xe1, 0x26, 0x4b, 0xe2, 0x5b, 0xb0, 0x91, 0x0b, 0xbc, 0x92, 0x64, 0x71, 0x08, 0x08, 0x94, 0x15, 0xd4, 0x5f, 0xab, 0x1b, 0x3d, 0x26, 0x04,
|
|
0xe8, 0xa8, 0xef, 0xf1, 0xae, 0x40, 0x20, 0xcf, 0xa3, 0x99, 0x36, 0xb6, 0x68, 0x27, 0xb2, 0x3f, 0x37, 0x1b, 0x92, 0x20, 0x0b, 0xe9, 0x02, 0x51, 0xe6, 0xd7, 0x3c, 0x5f, 0x86, 0xde, 0x5f, 0xd4,
|
|
0xa9, 0x50, 0x78, 0x19, 0x33, 0xd7, 0x9a, 0x28, 0x27, 0x2b, 0x78, 0x2a, 0x2e, 0xc3, 0x13, 0xef, 0xdf, 0xcc, 0x06, 0x28, 0xf4, 0x3d, 0x74, 0x4c, 0x2d, 0xc2, 0xff, 0x3d, 0xcb, 0x66, 0x99, 0x9b,
|
|
0x50, 0xc7, 0xca, 0x89, 0x5b, 0x0c, 0x64, 0x79, 0x1e, 0xea, 0xa5, 0xf2, 0x94, 0x99, 0xfb, 0x1c, 0x02, 0x6f, 0x84, 0xce, 0x5b, 0x5c, 0x72, 0xba, 0x10, 0x83, 0xcd, 0xdb, 0x5c, 0xe4, 0x54, 0x34,
|
|
0x63, 0x16, 0x65, 0xc3, 0x33, 0xb6, 0x0b, 0x11, 0x59, 0x3f, 0xb2, 0x53, 0xc5, 0x17, 0x9a, 0x2c, 0x8d, 0xb8, 0x13, 0x78, 0x2a, 0x00, 0x48, 0x56, 0xa1, 0x65, 0x30, 0x11, 0xe9, 0x3f, 0xb6, 0xd8,
|
|
0x76, 0xc1, 0x83, 0x66, 0xdd, 0x86, 0x83, 0xf5, 0x34, 0x12, 0xc0, 0xc1, 0x80, 0xf9, 0xc8, 0x48, 0x59, 0x2d, 0x59, 0x3f, 0x86, 0x09, 0xca, 0x73, 0x63, 0x17, 0xd3, 0x56, 0xe1, 0x3e, 0x2b, 0xff,
|
|
0x3a, 0x9f, 0x59, 0xcd, 0x9a, 0xeb, 0x19, 0xcd, 0x48, 0x25, 0x93, 0xd8, 0xc4, 0x61, 0x28, 0xbb, 0x32, 0x42, 0x3b, 0x37, 0xa9, 0xad, 0xfb, 0x48, 0x2b, 0x99, 0x45, 0x3f, 0xbe, 0x25, 0xa4, 0x1b,
|
|
0xf6, 0xfe, 0xb4, 0xaa, 0x0b, 0xef, 0x5e, 0xd2, 0x4b, 0xf7, 0x3c, 0x76, 0x29, 0x78, 0x02, 0x54, 0x82, 0xc1, 0x31, 0x15, 0xe4, 0x01, 0x5a, 0xac, 0x99, 0x2e, 0x56, 0x13, 0xa3, 0xb5, 0xc2, 0xf6,
|
|
0x85, 0xb8, 0x47, 0x95, 0xcb, 0x6e, 0x9b, 0x26, 0x56, 0xd8, 0xc8, 0x81, 0x57, 0xe5, 0x2c, 0x42, 0xf9, 0x78, 0xd8, 0x63, 0x4c, 0x43, 0xd0, 0x6f, 0xea, 0x92, 0x8f, 0x28, 0x22, 0xe4, 0x65, 0xaa,
|
|
0x65, 0x76, 0xe9, 0xbf, 0x41, 0x93, 0x84, 0x50, 0x6c, 0xc3, 0xce, 0x3c, 0x54, 0xac, 0x1a, 0x6f, 0x67, 0xdc, 0x66, 0xf3, 0xb3, 0x01, 0x91, 0xe6, 0x98, 0x38, 0x0b, 0xc9, 0x99, 0xb0, 0x5a, 0xbc,
|
|
0xe1, 0x9d, 0xc0, 0xc6, 0xdc, 0xc2, 0xdd, 0x00, 0x1e, 0xc5, 0x35, 0xba, 0x18, 0xde, 0xb2, 0xdf, 0x1a, 0x10, 0x10, 0x23, 0x10, 0x83, 0x18, 0xc7, 0x5d, 0xc9, 0x86, 0x11, 0xa0, 0x9d, 0xc4, 0x8a,
|
|
0x0a, 0xcd, 0xec, 0x67, 0x6f, 0xab, 0xdf, 0x22, 0x2f, 0x07, 0xe0, 0x26, 0xf0, 0x59, 0xb6, 0x72, 0xb5, 0x6e, 0x5c, 0xbc, 0x8e, 0x1d, 0x21, 0xbb, 0xd8, 0x67, 0xdd, 0x92, 0x72, 0x12, 0x05, 0x46,
|
|
0x81, 0xd7, 0x0e, 0xa7, 0x37, 0x13, 0x4c, 0xdf, 0xce, 0x93, 0xb6, 0xf8, 0x2a, 0xe2, 0x24, 0x23, 0x27, 0x4e, 0x58, 0xa0, 0x82, 0x1c, 0xc5, 0x50, 0x2e, 0x2d, 0x0a, 0xb4, 0x58, 0x5e, 0x94, 0xde,
|
|
0x69, 0x75, 0xbe, 0x5e, 0x0b, 0x4e, 0xfc, 0xe5, 0x1c, 0xd3, 0xe7, 0x0c, 0x25, 0xa1, 0xfb, 0xbb, 0xd6, 0x09, 0xd2, 0x73, 0xad, 0x5b, 0x0d, 0x59, 0x63, 0x1c, 0x53, 0x1f, 0x6a, 0x0a, 0x57, 0xb9
|
|
}
|
|
}
|
|
};
|
|
|
|
void EncryptionTest::TestXtsAES ()
|
|
{
|
|
unsigned __int8 p[ENCRYPTION_DATA_UNIT_SIZE];
|
|
uint64 dataUnitNo;
|
|
size_t i;
|
|
|
|
for (i = 0; i < array_capacity (XtsTestVectors); i++)
|
|
{
|
|
AES aes;
|
|
#ifdef WOLFCRYPT_BACKEND
|
|
shared_ptr <EncryptionMode> xts (new EncryptionModeWolfCryptXTS);
|
|
#else
|
|
shared_ptr <EncryptionMode> xts (new EncryptionModeXTS);
|
|
#endif
|
|
|
|
aes.SetKey (ConstBufferPtr (XtsTestVectors[i].key1, sizeof (XtsTestVectors[i].key1)));
|
|
#ifdef WOLFCRYPT_BACKEND
|
|
aes.SetKeyXTS (ConstBufferPtr (XtsTestVectors[i].key2, sizeof (XtsTestVectors[i].key2)));
|
|
#endif
|
|
xts->SetKey (ConstBufferPtr (XtsTestVectors[i].key2, sizeof (XtsTestVectors[i].key2)));
|
|
aes.SetMode (xts);
|
|
|
|
memcpy (p, XtsTestVectors[i].plaintext, sizeof (p));
|
|
|
|
memcpy (&dataUnitNo, XtsTestVectors[i].dataUnitNo, sizeof (dataUnitNo));
|
|
dataUnitNo = Endian::Big (dataUnitNo);
|
|
|
|
aes.EncryptSectors (p, dataUnitNo, sizeof (p) / ENCRYPTION_DATA_UNIT_SIZE, ENCRYPTION_DATA_UNIT_SIZE);
|
|
|
|
aes.DecryptSectors (p, dataUnitNo, sizeof (p) / ENCRYPTION_DATA_UNIT_SIZE, ENCRYPTION_DATA_UNIT_SIZE);
|
|
if (memcmp (XtsTestVectors[i].ciphertext, p, sizeof (p)) == 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
aes.EncryptSectors (p, dataUnitNo, sizeof (p) / ENCRYPTION_DATA_UNIT_SIZE, ENCRYPTION_DATA_UNIT_SIZE);
|
|
|
|
if (memcmp (XtsTestVectors[i].ciphertext, p, sizeof (p)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
}
|
|
|
|
void EncryptionTest::TestXts ()
|
|
{
|
|
unsigned char buf [ENCRYPTION_DATA_UNIT_SIZE * 4];
|
|
unsigned int i;
|
|
uint32 crc;
|
|
uint64 unitNo;
|
|
uint64 nbrUnits;
|
|
uint64 writeOffset;
|
|
int testCase = 0;
|
|
int nTestsPerformed = 0;
|
|
|
|
static const uint8 testKey[] =
|
|
{
|
|
0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27,
|
|
0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92,
|
|
0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
|
|
};
|
|
|
|
/* Encryption/decryption of data units (typically, volume data sectors) */
|
|
|
|
nbrUnits = sizeof (buf) / ENCRYPTION_DATA_UNIT_SIZE;
|
|
|
|
/* The buffer can accommodate 4 data units and we'll test 4 cases by "scrolling". The data unit 0xFFFFFFFFFF
|
|
will "move" from the start of the buffer to its end. For a 512-byte data unit, the byte offset 562949953420800
|
|
corresponds to the data unit 0xFFFFFFFFFF. */
|
|
for (writeOffset = 562949953420800LL;
|
|
writeOffset > 562949953420800LL - nbrUnits * ENCRYPTION_DATA_UNIT_SIZE;
|
|
writeOffset -= ENCRYPTION_DATA_UNIT_SIZE)
|
|
{
|
|
unitNo = writeOffset / ENCRYPTION_DATA_UNIT_SIZE;
|
|
|
|
// Test all EAs that support this mode of operation
|
|
foreach_ref (EncryptionAlgorithm &ea, EncryptionAlgorithm::GetAvailableAlgorithms())
|
|
{
|
|
#ifdef WOLFCRYPT_BACKEND
|
|
shared_ptr <EncryptionMode> mode (new EncryptionModeWolfCryptXTS);
|
|
#else
|
|
shared_ptr <EncryptionMode> mode (new EncryptionModeXTS);
|
|
#endif
|
|
|
|
if (!ea.IsModeSupported (mode))
|
|
continue;
|
|
|
|
ea.SetKey (ConstBufferPtr (testKey, ea.GetKeySize()));
|
|
|
|
Buffer modeKey (ea.GetKeySize());
|
|
for (size_t mi = 0; mi < modeKey.Size(); mi++)
|
|
modeKey[mi] = (uint8) mi;
|
|
size_t copySize = VC_MIN(modeKey.Size(), sizeof (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2));
|
|
modeKey.CopyFrom (ConstBufferPtr (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2, copySize));
|
|
|
|
mode->SetKey (modeKey);
|
|
ea.SetMode (mode);
|
|
#ifdef WOLFCRYPT_BACKEND
|
|
ea.SetKeyXTS (modeKey);
|
|
#endif
|
|
|
|
// Each data unit will contain the same plaintext
|
|
for (i = 0; i < nbrUnits; i++)
|
|
{
|
|
memcpy ((unsigned char *) buf + i * ENCRYPTION_DATA_UNIT_SIZE,
|
|
XtsTestVectors[array_capacity (XtsTestVectors)-1].plaintext,
|
|
ENCRYPTION_DATA_UNIT_SIZE);
|
|
}
|
|
|
|
ea.EncryptSectors (buf, unitNo, nbrUnits, ENCRYPTION_DATA_UNIT_SIZE);
|
|
|
|
crc = GetCrc32 (buf, sizeof (buf));
|
|
|
|
if (typeid (ea) == typeid (AES))
|
|
{
|
|
// Verify the ciphertext of the "moving" data unit using the IEEE test vector #14
|
|
if (memcmp (XtsTestVectors[array_capacity (XtsTestVectors)-1].ciphertext,
|
|
(unsigned char *) buf + testCase * ENCRYPTION_DATA_UNIT_SIZE,
|
|
ENCRYPTION_DATA_UNIT_SIZE) != 0)
|
|
{
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
|
|
// CRC of all data units in the buffer for each test case
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x888f2990)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0xea28ea34)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xe058f5a2)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0x10473dc9)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
#ifndef WOLFCRYPT_BACKEND
|
|
else if (typeid (ea) == typeid (Serpent))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x7edfecb3)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x357baaaa)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xc7b9fca5)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xb5263e0c)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (Twofish))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x91525124)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x2895cc47)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0x6bee346d)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xb1c45759)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (Camellia))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x2436badb)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x247d2272)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0x72b49cde)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xb838d2c1)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (Kuznyechik))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x6b86e72e)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0xa4f8637d)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xfd83e76d)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xb24fc47b)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (AESTwofish))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x6cea7fa2)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x69052c4c)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0x88db8de5)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xf16fd8c5)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (AESTwofishSerpent))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0xa2d7d82a)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0xdbf76412)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xdf0ea03e)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xdadedff7)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (SerpentAES))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x6dd133b3)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x0e5717d2)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0x39f83cd9)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0x8a79fa2c)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (SerpentTwofishAES))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0xe536daf8)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x3ae89e7f)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0x2cc1301a)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xcac7bdc7)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (TwofishSerpent))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x2686c859)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x8a201780)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0x8dd13796)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xe95196cb)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (CamelliaKuznyechik))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x4ea34e89)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0xb3ad8559)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xde361313)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0x519d2bf9)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (KuznyechikTwofish))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x748f8631)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x8a4b0888)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xe0310188)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xfc2b6b45)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (CamelliaSerpent))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x10569a42)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x4de95152)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xe17b5fe7)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0xdbf993fa)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (KuznyechikAES))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0xc479f95d)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x58eaf88d)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0xbe300cc2)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0x9b681c2e)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
else if (typeid (ea) == typeid (KuznyechikSerpentCamellia))
|
|
{
|
|
switch (testCase)
|
|
{
|
|
case 0:
|
|
if (crc != 0x9d8ac7ee)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 1:
|
|
if (crc != 0x5d7d347f)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 2:
|
|
if (crc != 0x884b62ee)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
case 3:
|
|
if (crc != 0x5c6c3997)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
if (crc == 0x9f5edd58)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
ea.DecryptSectors (buf, unitNo, nbrUnits, ENCRYPTION_DATA_UNIT_SIZE);
|
|
|
|
if (GetCrc32 (buf, sizeof (buf)) != 0x9f5edd58)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
nTestsPerformed++;
|
|
}
|
|
testCase++;
|
|
}
|
|
|
|
/* Encryption/decryption of a buffer (typically, a volume header) */
|
|
|
|
nbrUnits = sizeof (buf) / ENCRYPTION_DATA_UNIT_SIZE;
|
|
|
|
// Test all EAs that support this mode of operation
|
|
foreach_ref (EncryptionAlgorithm &ea, EncryptionAlgorithm::GetAvailableAlgorithms())
|
|
{
|
|
#ifdef WOLFCRYPT_BACKEND
|
|
shared_ptr <EncryptionMode> mode (new EncryptionModeWolfCryptXTS);
|
|
#else
|
|
shared_ptr <EncryptionMode> mode (new EncryptionModeXTS);
|
|
#endif
|
|
|
|
if (!ea.IsModeSupported (mode))
|
|
continue;
|
|
|
|
ea.SetKey (ConstBufferPtr (testKey, ea.GetKeySize()));
|
|
|
|
Buffer modeKey (ea.GetKeySize());
|
|
for (size_t mi = 0; mi < modeKey.Size(); mi++)
|
|
modeKey[mi] = (uint8) mi;
|
|
size_t copySize = VC_MIN(modeKey.Size(), sizeof (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2));
|
|
modeKey.CopyFrom (ConstBufferPtr (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2, copySize));
|
|
|
|
mode->SetKey (modeKey);
|
|
ea.SetMode (mode);
|
|
#ifdef WOLFCRYPT_BACKEND
|
|
ea.SetKeyXTS (modeKey);
|
|
#endif
|
|
|
|
// Each data unit will contain the same plaintext
|
|
for (i = 0; i < nbrUnits; i++)
|
|
{
|
|
memcpy ((unsigned char *) buf + i * ENCRYPTION_DATA_UNIT_SIZE,
|
|
XtsTestVectors[array_capacity (XtsTestVectors)-1].plaintext,
|
|
ENCRYPTION_DATA_UNIT_SIZE);
|
|
}
|
|
|
|
ea.Encrypt (buf, sizeof (buf));
|
|
|
|
crc = GetCrc32 (buf, sizeof (buf));
|
|
|
|
if (typeid (ea) == typeid (AES))
|
|
{
|
|
if (crc != 0x33b91fab)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
#ifndef WOLFCRYPT_BACKEND
|
|
else if (typeid (ea) == typeid (Serpent))
|
|
{
|
|
if (crc != 0x3494d480)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (Twofish))
|
|
{
|
|
if (crc != 0xc4d65b46)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (Camellia))
|
|
{
|
|
if (crc != 0x8176b223)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (Kuznyechik))
|
|
{
|
|
if (crc != 0xd6d39cdb)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (AESTwofish))
|
|
{
|
|
if (crc != 0x14ce7385)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (AESTwofishSerpent))
|
|
{
|
|
if (crc != 0x0ec81bf7)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (SerpentAES))
|
|
{
|
|
if (crc != 0x42f919ad)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (SerpentTwofishAES))
|
|
{
|
|
if (crc != 0x208d5c58)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (TwofishSerpent))
|
|
{
|
|
if (crc != 0xbe78cec1)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (CamelliaKuznyechik))
|
|
{
|
|
if (crc != 0xe69d680d)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (KuznyechikTwofish))
|
|
{
|
|
if (crc != 0xe0aef0d1)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (CamelliaSerpent))
|
|
{
|
|
if (crc != 0x58aad727)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (KuznyechikAES))
|
|
{
|
|
if (crc != 0x4641234a)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
else if (typeid (ea) == typeid (KuznyechikSerpentCamellia))
|
|
{
|
|
if (crc != 0x755dad72)
|
|
throw TestFailed (SRC_POS);
|
|
nTestsPerformed++;
|
|
}
|
|
#endif
|
|
|
|
if (crc == 0x9f5edd58)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
ea.Decrypt (buf, sizeof (buf));
|
|
|
|
if (GetCrc32 (buf, sizeof (buf)) != 0x9f5edd58)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
nTestsPerformed++;
|
|
}
|
|
#ifndef WOLFCRYPT_BACKEND
|
|
if (nTestsPerformed != 150)
|
|
#else
|
|
if (nTestsPerformed != 10)
|
|
#endif
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
|
|
void EncryptionTest::TestPkcs5 ()
|
|
{
|
|
VolumePassword password ((uint8*) "password", 8);
|
|
static const uint8 saltData[] = { 0x12, 0x34, 0x56, 0x78 };
|
|
ConstBufferPtr salt (saltData, sizeof (saltData));
|
|
Buffer derivedKey (4);
|
|
|
|
#ifndef WOLFCRYPT_BACKEND
|
|
Pkcs5HmacBlake2s pkcs5HmacBlake2s;
|
|
if (pkcs5HmacBlake2s.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (derivedKey.Ptr(), "\x8d\x51\xfa\x31", 4) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
Pkcs5HmacSha512 pkcs5HmacSha512;
|
|
if (pkcs5HmacSha512.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (derivedKey.Ptr(), "\x13\x64\xae\xf8", 4) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
Pkcs5HmacWhirlpool pkcs5HmacWhirlpool;
|
|
if (pkcs5HmacWhirlpool.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (derivedKey.Ptr(), "\x50\x7c\x36\x6f", 4) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
Pkcs5HmacSha256 pkcs5HmacSha256;
|
|
if (pkcs5HmacSha256.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (derivedKey.Ptr(), "\xf2\xa0\x4f\xb2", 4) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
Pkcs5HmacStreebog pkcs5HmacStreebog;
|
|
if (pkcs5HmacStreebog.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (derivedKey.Ptr(), "\xd0\x53\xa2\x30", 4) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
// Output longer than one hash block: PBKDF2 block counters 2 and up,
|
|
// and how the output blocks are joined (password "password", salt
|
|
// 0x12345678, 5 iterations, 192 bytes).
|
|
static const uint8 longKeyBlake2s[192] =
|
|
{
|
|
0x8d, 0x51, 0xfa, 0x31, 0x46, 0x25, 0x37, 0x67, 0xa3, 0x29, 0x6b, 0x3c,
|
|
0x6b, 0xc1, 0x5d, 0xb2, 0xee, 0xe1, 0x6c, 0x28, 0x00, 0x26, 0xea, 0x08,
|
|
0x65, 0x9c, 0x12, 0xf1, 0x07, 0xde, 0x0d, 0xb9, 0x9b, 0x4f, 0x39, 0xfa,
|
|
0xc6, 0x80, 0x26, 0xb1, 0x8f, 0x8e, 0x48, 0x89, 0x85, 0x2d, 0x24, 0x2d,
|
|
0xbd, 0x63, 0x72, 0x4a, 0x6c, 0xc6, 0x19, 0x7e, 0xc3, 0x1a, 0x5d, 0xf7,
|
|
0x61, 0xdc, 0x0d, 0xc8, 0x16, 0x3d, 0xd1, 0x1b, 0x02, 0x9b, 0x84, 0xd1,
|
|
0xc1, 0xee, 0x73, 0xf7, 0x1a, 0x36, 0x82, 0x50, 0xd0, 0xe7, 0x57, 0x16,
|
|
0x2b, 0x27, 0x00, 0x97, 0xee, 0x6e, 0xa1, 0x55, 0x44, 0x55, 0x19, 0x4f,
|
|
0x1f, 0xea, 0xe4, 0x48, 0x30, 0xfd, 0xaa, 0xa1, 0xe6, 0x9e, 0x1e, 0x3c,
|
|
0x5c, 0x43, 0x56, 0x10, 0x29, 0x4f, 0x72, 0x57, 0x3a, 0x14, 0x15, 0x77,
|
|
0xa6, 0x0a, 0x56, 0xd2, 0x7b, 0xfa, 0x86, 0x22, 0x20, 0x65, 0xd8, 0xc2,
|
|
0x64, 0x24, 0x68, 0x95, 0xc5, 0x52, 0x0d, 0x22, 0x33, 0x3c, 0xa6, 0x7c,
|
|
0x89, 0x17, 0xde, 0x0b, 0xc9, 0x62, 0xaf, 0x52, 0x2b, 0xda, 0x14, 0x24,
|
|
0xb0, 0x3d, 0xe1, 0x2b, 0xea, 0x23, 0x3c, 0xd8, 0xca, 0x8a, 0xe3, 0x7a,
|
|
0xa7, 0x6f, 0xdd, 0x4a, 0x2c, 0x31, 0x46, 0xa2, 0xeb, 0x3e, 0x2a, 0x07,
|
|
0xf2, 0x08, 0x21, 0x42, 0xb3, 0xde, 0x03, 0x53, 0x36, 0xb5, 0xff, 0x24
|
|
};
|
|
static const uint8 longKeySha512[192] =
|
|
{
|
|
0x13, 0x64, 0xae, 0xf8, 0x0d, 0xf5, 0x57, 0x6c, 0x30, 0xd5, 0x71, 0x4c,
|
|
0xa7, 0x75, 0x3f, 0xfd, 0x00, 0xe5, 0x25, 0x8b, 0x39, 0xc7, 0x44, 0x7f,
|
|
0xce, 0x23, 0x3d, 0x08, 0x75, 0xe0, 0x2f, 0x48, 0xd6, 0x30, 0xd7, 0x00,
|
|
0xb6, 0x24, 0xdb, 0xe0, 0x5a, 0xd7, 0x47, 0xef, 0x52, 0xca, 0xa6, 0x34,
|
|
0x83, 0x47, 0xe5, 0xcb, 0xe9, 0x87, 0xf1, 0x20, 0x59, 0x6a, 0xe6, 0xa9,
|
|
0xcf, 0x51, 0x78, 0xc6, 0xb6, 0x23, 0xa6, 0x74, 0x0d, 0xe8, 0x91, 0xbe,
|
|
0x1a, 0xd0, 0x28, 0xcc, 0xce, 0x16, 0x98, 0x9a, 0xbe, 0xfb, 0xdc, 0x78,
|
|
0xc9, 0xe1, 0x7d, 0x72, 0x67, 0xce, 0xe1, 0x61, 0x56, 0x5f, 0x96, 0x68,
|
|
0xe6, 0xe1, 0xdd, 0xf4, 0xbf, 0x1b, 0x80, 0xe0, 0x19, 0x1c, 0xf4, 0xc4,
|
|
0xd3, 0xdd, 0xd5, 0xd5, 0x57, 0x2d, 0x83, 0xc7, 0xa3, 0x37, 0x87, 0xf4,
|
|
0x4e, 0xe0, 0xf6, 0xd8, 0x6d, 0x65, 0xdc, 0xa0, 0x52, 0xa3, 0x13, 0xbe,
|
|
0x81, 0xfc, 0x30, 0xbe, 0x7d, 0x69, 0x58, 0x34, 0xb6, 0xdd, 0x41, 0xc6,
|
|
0x21, 0x50, 0xf5, 0x60, 0x44, 0xf9, 0x87, 0x69, 0xfd, 0x75, 0x75, 0xcb,
|
|
0x10, 0xe5, 0xe0, 0xfd, 0xf0, 0x7d, 0x3f, 0x79, 0xe2, 0xa0, 0x68, 0xb5,
|
|
0xbf, 0xd1, 0x76, 0x91, 0xc8, 0x68, 0x67, 0xd9, 0x01, 0x00, 0x4c, 0x1b,
|
|
0xfc, 0x1a, 0xd3, 0x39, 0x7b, 0x9d, 0x3d, 0x88, 0x71, 0xfc, 0x55, 0x1a
|
|
};
|
|
static const uint8 longKeyWhirlpool[192] =
|
|
{
|
|
0x50, 0x7c, 0x36, 0x6f, 0xee, 0x10, 0x2e, 0x9a, 0xe2, 0x8a, 0xd5, 0x82,
|
|
0x72, 0x7d, 0x27, 0x0f, 0xe8, 0x4d, 0x7f, 0x68, 0x7a, 0xcf, 0xb5, 0xe7,
|
|
0x43, 0x67, 0xaa, 0x98, 0x93, 0x52, 0x2b, 0x09, 0x6e, 0x42, 0xdf, 0x2c,
|
|
0x59, 0x4a, 0x91, 0x6d, 0x7e, 0x10, 0xae, 0xb2, 0x1a, 0x89, 0x8f, 0xb9,
|
|
0x8f, 0xe6, 0x31, 0xa9, 0xd8, 0x9f, 0x98, 0x26, 0xf4, 0xda, 0xcd, 0x7d,
|
|
0x65, 0x65, 0xde, 0x10, 0x95, 0x91, 0xb4, 0x84, 0x26, 0xae, 0x43, 0xa1,
|
|
0x00, 0x5b, 0x1e, 0xb8, 0x38, 0x97, 0xa4, 0x1e, 0x4b, 0xd2, 0x65, 0x64,
|
|
0xbc, 0xfa, 0x1f, 0x35, 0x85, 0xdb, 0x4f, 0x97, 0x65, 0x6f, 0xbd, 0x24,
|
|
0xd4, 0xe2, 0x28, 0x89, 0xec, 0xcf, 0x3a, 0xa4, 0x1b, 0x56, 0xe9, 0x61,
|
|
0xa3, 0x1f, 0x6f, 0xd6, 0xac, 0x9b, 0x92, 0xf4, 0xe6, 0xc2, 0x26, 0xbc,
|
|
0xd4, 0x99, 0x45, 0xf2, 0xcd, 0x46, 0xd0, 0x57, 0x44, 0xc7, 0x4b, 0x5d,
|
|
0xed, 0x17, 0x8e, 0x68, 0x0a, 0x6d, 0x5d, 0xbe, 0x72, 0xf4, 0x6d, 0xc6,
|
|
0x9e, 0x19, 0xcc, 0x09, 0xaa, 0x90, 0xb0, 0xcb, 0x40, 0xa3, 0x61, 0xd1,
|
|
0xe5, 0x1b, 0x90, 0xfb, 0x82, 0x5d, 0xec, 0xd6, 0xb9, 0x11, 0x9b, 0xe9,
|
|
0xa3, 0x70, 0xe5, 0x9a, 0x2e, 0x9c, 0x3a, 0x35, 0x25, 0xcd, 0x15, 0xe3,
|
|
0xfc, 0x1a, 0x00, 0x40, 0xa5, 0x71, 0x11, 0xfc, 0x82, 0x74, 0xe3, 0x90
|
|
};
|
|
static const uint8 longKeySha256[192] =
|
|
{
|
|
0xf2, 0xa0, 0x4f, 0xb2, 0xd3, 0xe9, 0xa5, 0xd8, 0x51, 0x0b, 0x5c, 0x06,
|
|
0xdf, 0x70, 0x8e, 0x24, 0xe9, 0xc7, 0xd9, 0x15, 0x3d, 0x22, 0xcd, 0xde,
|
|
0xb8, 0xa6, 0xdb, 0xfd, 0x71, 0x85, 0xc6, 0x99, 0x32, 0xc0, 0xee, 0x37,
|
|
0x27, 0xf7, 0x24, 0xcf, 0xea, 0xa6, 0xac, 0x73, 0xa1, 0x4c, 0x4e, 0x52,
|
|
0x9b, 0x94, 0xf3, 0x54, 0x06, 0xfc, 0x04, 0x65, 0xa1, 0x0a, 0x24, 0xfe,
|
|
0xf0, 0x98, 0x1d, 0xa6, 0x22, 0x28, 0xeb, 0x24, 0x55, 0x74, 0xce, 0x6a,
|
|
0x3a, 0x28, 0xe2, 0x04, 0x3a, 0x59, 0x13, 0xec, 0x3f, 0xf2, 0xdb, 0xcf,
|
|
0x58, 0xdd, 0x53, 0xd9, 0xf9, 0x17, 0xf6, 0xda, 0x74, 0x06, 0x3c, 0x0b,
|
|
0x66, 0xf5, 0x0f, 0xf5, 0x58, 0xa3, 0x27, 0x52, 0x8c, 0x5b, 0x07, 0x91,
|
|
0xd0, 0x81, 0xeb, 0xb6, 0xbc, 0x30, 0x69, 0x42, 0x71, 0xf2, 0xd7, 0x18,
|
|
0x42, 0xbe, 0xe8, 0x02, 0x93, 0x70, 0x66, 0xad, 0x35, 0x65, 0xbc, 0xf7,
|
|
0x96, 0x8e, 0x64, 0xf1, 0xc6, 0x92, 0xda, 0xe0, 0xdc, 0x1f, 0xb5, 0xf4,
|
|
0x15, 0xe8, 0xda, 0x2b, 0xb8, 0xd5, 0x96, 0x06, 0x50, 0x0e, 0xdb, 0xd7,
|
|
0xbf, 0x5d, 0x14, 0x7e, 0x16, 0x3c, 0xbd, 0x69, 0x29, 0x11, 0x45, 0x25,
|
|
0xaa, 0xc1, 0x7c, 0x6f, 0x0e, 0xcb, 0xe6, 0x86, 0x83, 0x77, 0xf0, 0xf4,
|
|
0x66, 0xbb, 0x34, 0x82, 0x3a, 0x84, 0x88, 0xde, 0xda, 0x8e, 0xce, 0x85
|
|
};
|
|
static const uint8 longKeyStreebog[192] =
|
|
{
|
|
0xd0, 0x53, 0xa2, 0x30, 0x6f, 0x45, 0x81, 0xeb, 0xbc, 0x06, 0x81, 0xc5,
|
|
0xe7, 0x53, 0xa8, 0x5d, 0xc7, 0xf1, 0x23, 0x33, 0x1e, 0xbe, 0x64, 0x2c,
|
|
0x3b, 0x0f, 0x26, 0xd7, 0x00, 0xe1, 0x95, 0xc9, 0x65, 0x26, 0xb1, 0x85,
|
|
0xbe, 0x1e, 0xe2, 0xf4, 0x9b, 0xfc, 0x6b, 0x14, 0x84, 0xda, 0x24, 0x61,
|
|
0xa0, 0x1b, 0x9e, 0x79, 0x5c, 0xee, 0x69, 0x6e, 0xf9, 0x25, 0xb1, 0x1d,
|
|
0xca, 0xa0, 0x31, 0xba, 0x02, 0x6f, 0x9e, 0x99, 0x0f, 0xdb, 0x25, 0x01,
|
|
0x5b, 0xf1, 0xc7, 0x10, 0x19, 0x53, 0x3b, 0x29, 0x3f, 0x18, 0x00, 0xd6,
|
|
0xfc, 0x85, 0x03, 0xdc, 0xf2, 0xe5, 0xe9, 0x5a, 0xb1, 0x1e, 0x61, 0xde,
|
|
0xa7, 0xc8, 0xd0, 0x4c, 0x72, 0xca, 0xfb, 0x01, 0x37, 0x13, 0x89, 0x3f,
|
|
0x90, 0x3c, 0x38, 0xe8, 0x4c, 0xfd, 0x72, 0x23, 0x61, 0x10, 0x81, 0x59,
|
|
0x0c, 0xcc, 0x97, 0xd6, 0x8a, 0x66, 0xbb, 0xc4, 0xd7, 0xbc, 0x76, 0xfc,
|
|
0xdc, 0xbf, 0x5c, 0xc4, 0x7c, 0xd1, 0x4f, 0xb5, 0xaa, 0x34, 0x32, 0x4c,
|
|
0x1a, 0x98, 0x68, 0x7c, 0x18, 0xf4, 0x0a, 0xc4, 0x03, 0x9e, 0x86, 0x9b,
|
|
0x87, 0x5e, 0x25, 0x1a, 0x38, 0x90, 0x49, 0x22, 0xdd, 0xfc, 0x83, 0x43,
|
|
0x9e, 0x83, 0xb5, 0xf9, 0x2c, 0x2d, 0x88, 0x1b, 0x53, 0xb2, 0x0a, 0x2a,
|
|
0xf7, 0x0b, 0x5b, 0xac, 0x6b, 0xc2, 0xa0, 0x53, 0x7f, 0x07, 0xa2, 0xea
|
|
};
|
|
Buffer longKey (192);
|
|
if (pkcs5HmacBlake2s.DeriveKey (longKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (longKey.Ptr(), longKeyBlake2s, sizeof (longKeyBlake2s)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (pkcs5HmacSha512.DeriveKey (longKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (longKey.Ptr(), longKeySha512, sizeof (longKeySha512)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (pkcs5HmacWhirlpool.DeriveKey (longKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (longKey.Ptr(), longKeyWhirlpool, sizeof (longKeyWhirlpool)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (pkcs5HmacSha256.DeriveKey (longKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (longKey.Ptr(), longKeySha256, sizeof (longKeySha256)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (pkcs5HmacStreebog.DeriveKey (longKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (longKey.Ptr(), longKeyStreebog, sizeof (longKeyStreebog)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
// Streebog: message blocks whose 512-bit sum hits the carry case of
|
|
// add512() must hash the same on every CPU. VeraCrypt's add512()
|
|
// drops this carry on purpose (existing volumes depend on it), so
|
|
// the expected digest is not the GOST R 34.11-2012 one (which would
|
|
// be c392d229...83639757).
|
|
{
|
|
// Read as 64-bit words by the portable Streebog code.
|
|
CRYPTOPP_ALIGN_DATA(8) uint8 message[128];
|
|
memset (message, 0, sizeof (message));
|
|
memset (message, 0xff, 16);
|
|
message[64] = 1;
|
|
|
|
Streebog streebog;
|
|
Buffer digest (streebog.GetDigestSize ());
|
|
streebog.ProcessData (ConstBufferPtr (message, sizeof (message)));
|
|
streebog.GetDigest (digest);
|
|
if (memcmp (digest.Ptr(), "\xf0\x7f\x6f\xae\x81\x90\xe4\x9d\x54\xe6\x98\x5a\x30\x44\xb3\x3d\xd8\xdb\x37\x08\x6b\x81\x83\x16\xcb\x19\xe2\x33\xf1\xa5\x81\x08"
|
|
"\xb1\x2e\x7f\x02\x74\x48\x32\x31\x1c\x09\x44\x68\x70\xb4\xbb\x45\x4b\xb5\x4f\xa3\x41\x39\x2a\xfd\xdd\x62\x25\x2b\xaf\x8a\x08\x09", 64) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
|
|
#ifndef VC_DCS_DISABLE_ARGON2
|
|
Pkcs5Argon2 pkcs5Argon2;
|
|
static const uint8 argon2SaltData[] = { 's', 'o', 'm', 'e', 's', 'a', 'l', 't' };
|
|
static const uint8 argon2Pim1DerivedKey[] =
|
|
{
|
|
0x9e, 0x87, 0x89, 0xc8, 0xb4, 0x28, 0x34, 0x22,
|
|
0x0a, 0xfc, 0x00, 0x08, 0x5a, 0xc7, 0x3a, 0xcc,
|
|
0x30, 0x86, 0x51, 0x21, 0x69, 0x94, 0xab, 0xbf,
|
|
0xdd, 0xd6, 0x9b, 0x25, 0x92, 0x03, 0x2e, 0xfd
|
|
};
|
|
static const uint8 argon2Pim1HeaderKeyPrefix[] =
|
|
{
|
|
0x48, 0x8d, 0x71, 0xbd, 0x71, 0x6e, 0x68, 0x45,
|
|
0xaa, 0xe6, 0xe2, 0x29, 0x74, 0x18, 0x2c, 0x20,
|
|
0xe9, 0x42, 0x8d, 0x7b, 0x3d, 0x4b, 0xcf, 0x54,
|
|
0x04, 0x6c, 0x3e, 0xbe, 0x80, 0x33, 0x8f, 0x20
|
|
};
|
|
ConstBufferPtr argon2Salt (argon2SaltData, sizeof (argon2SaltData));
|
|
Buffer argon2DerivedKey (sizeof (argon2Pim1DerivedKey));
|
|
Buffer argon2HeaderKey (ARGON2_HEADER_KEYDATA_SIZE);
|
|
|
|
// PIM 1 maps to Argon2id t=3, m=64 MiB, p=1.
|
|
if (pkcs5Argon2.DeriveKey (argon2DerivedKey, password, 1, argon2Salt) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (argon2DerivedKey.Ptr(), argon2Pim1DerivedKey, sizeof (argon2Pim1DerivedKey)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (pkcs5Argon2.DeriveKey (argon2HeaderKey, password, 1, argon2Salt) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (argon2HeaderKey.Ptr(), argon2Pim1HeaderKeyPrefix, sizeof (argon2Pim1HeaderKeyPrefix)) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
try
|
|
{
|
|
if (pkcs5Argon2.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
catch (ParameterIncorrect&)
|
|
{
|
|
}
|
|
|
|
shared_ptr <Pkcs5Kdf> sha512Kdf (new Pkcs5HmacSha512);
|
|
shared_ptr <Pkcs5Kdf> failingArgon2Kdf (new FailingArgon2Kdf);
|
|
shared_ptr <EncryptionAlgorithm> ea (new AES);
|
|
SecureBuffer headerBuffer (TC_VOLUME_HEADER_SIZE);
|
|
SecureBuffer dataKey (ea->GetKeySize() * 2);
|
|
SecureBuffer headerSalt (VolumeHeader::GetSaltSize());
|
|
SecureBuffer headerKey (VolumeHeader::GetLargestSerializedKeySize());
|
|
|
|
for (size_t i = 0; i < dataKey.Size(); ++i)
|
|
dataKey.Ptr()[i] = (uint8) (i + 1);
|
|
|
|
for (size_t i = 0; i < headerSalt.Size(); ++i)
|
|
headerSalt.Ptr()[i] = (uint8) (i + 2);
|
|
|
|
if (sha512Kdf->DeriveKey (headerKey, password, 1, headerSalt) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
VolumeHeaderCreationOptions options;
|
|
options.DataKey = dataKey;
|
|
options.EA = ea;
|
|
options.Kdf = sha512Kdf;
|
|
options.HeaderKey = headerKey;
|
|
options.Salt = headerSalt;
|
|
options.SectorSize = TC_SECTOR_SIZE_FILE_HOSTED_VOLUME;
|
|
options.VolumeDataStart = TC_VOLUME_HEADER_GROUP_SIZE;
|
|
options.VolumeDataSize = TC_MIN_VOLUME_SIZE;
|
|
options.Type = VolumeType::Normal;
|
|
|
|
VolumeHeader header (TC_VOLUME_HEADER_SIZE);
|
|
header.Create (headerBuffer, options);
|
|
|
|
Pkcs5KdfList kdfs;
|
|
kdfs.push_back (failingArgon2Kdf);
|
|
kdfs.push_back (sha512Kdf);
|
|
|
|
EncryptionAlgorithmList encryptionAlgorithms;
|
|
encryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new AES));
|
|
|
|
EncryptionModeList encryptionModes;
|
|
encryptionModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS));
|
|
|
|
VolumeHeader decryptedHeader (TC_VOLUME_HEADER_SIZE);
|
|
if (!decryptedHeader.Decrypt (headerBuffer, password, 1, shared_ptr <Pkcs5Kdf> (), kdfs, encryptionAlgorithms, encryptionModes)
|
|
|| decryptedHeader.GetPkcs5Kdf()->GetName() != sha512Kdf->GetName())
|
|
{
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
|
|
try
|
|
{
|
|
decryptedHeader.Decrypt (headerBuffer, password, 1, failingArgon2Kdf, kdfs, encryptionAlgorithms, encryptionModes);
|
|
throw TestFailed (SRC_POS);
|
|
}
|
|
catch (ExternalException&)
|
|
{
|
|
}
|
|
#endif
|
|
#else
|
|
Pkcs5HmacSha256 pkcs5HmacSha256;
|
|
if (pkcs5HmacSha256.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (derivedKey.Ptr(), "\x64\xf3\xa5\xa3", 4) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
|
|
Pkcs5HmacSha512 pkcs5HmacSha512;
|
|
if (pkcs5HmacSha512.DeriveKey (derivedKey, password, salt, 5) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
if (memcmp (derivedKey.Ptr(), "\x55\xa1\x76\xbb", 4) != 0)
|
|
throw TestFailed (SRC_POS);
|
|
#endif
|
|
}
|
|
}
|