// EGPublicKey::EncryptData
// Encrypts a block of specified length into the specified queue. Determines the
// number of individual blocks to be encrypted. Adds block count to queue. Then
// calls EncryptBlock() to encrypt each block into the queue. Note that mCryptP
// must be valid before this method is called.
void
EGPublicKey::EncryptData(BufferedTransformation& aQueue, const unsigned char* theMsgP,
unsigned long theLen) const
{
WTRACE("EGPublicKey::EncryptData");
WDBG_LL("EGPublicKey::EncryptData, len=" << theLen);
// Determine block length and number of blocks
unsigned long aBlockLen = mCryptP->MaxPlainTextLength();
unsigned long aNumBlock = theLen / aBlockLen;
if ((theLen % aBlockLen) != 0) aNumBlock++;
WDBG_LL("EGPublicKey::EncryptBlock NumBlocks=" << aNumBlock << ", BlockLen=" << aBlockLen);
// A num blocks to output
unsigned long tmpNumBlock = getLittleEndian(aNumBlock);
aQueue.Put(reinterpret_cast<unsigned char*>(&tmpNumBlock), sizeof(tmpNumBlock));
// Encrypt the data, one block at a time
while (theLen > aBlockLen)
{
EncryptBlock(aQueue, theMsgP, aBlockLen);
theMsgP += aBlockLen;
theLen -= aBlockLen;
}
// Encrypt the last block and close the queue
EncryptBlock(aQueue, theMsgP, theLen);
aQueue.Close();
}
void Blowfish::SetKey(const unsigned char* key, int byte_length)
{
std::memcpy(pary_, initial_pary, sizeof(initial_pary));
std::memcpy(sbox_, initial_sbox, sizeof(initial_sbox));
static const int pary_length = sizeof(pary_) / sizeof(uint32_t);
static const int sbox_length = sizeof(sbox_) / sizeof(uint32_t);
{
int buffer_length = byte_length / GCD(byte_length, sizeof(uint32_t));
uint32_t *key_buffer = new uint32_t[buffer_length];
for (int i = 0; i < buffer_length; ++i)
{
Converter32 converter;
converter.bit_8.byte0 = key[(i * 4) % byte_length];
converter.bit_8.byte1 = key[(i * 4 + 1) % byte_length];
converter.bit_8.byte2 = key[(i * 4 + 2) % byte_length];
converter.bit_8.byte3 = key[(i * 4 + 3) % byte_length];
key_buffer[i] = converter.bit_32;
}
for (int i = 0; i < pary_length; ++i)
{
uint32_t key_uint32 = key_buffer[i % buffer_length];
pary_[i] ^= key_uint32;
}
delete[] key_buffer;
}
uint32_t left = 0x00000000;
uint32_t right = 0x00000000;
for (int i = 0; i < (pary_length / 2); ++i)
{
EncryptBlock(&left, &right);
pary_[i * 2] = left;
pary_[i * 2 + 1] = right;
}
for (int i = 0; i < (sbox_length / 2); ++i)
{
EncryptBlock(&left, &right);
reinterpret_cast<uint32_t*>(sbox_)[i * 2] = left;
reinterpret_cast<uint32_t*>(sbox_)[i * 2 + 1] = right;
}
}
void Blowfish::Encrypt(unsigned char* dst, const unsigned char* src, int byte_length) const
{
if (dst != src)
{
memcpy(dst, src, byte_length);
}
for (int i = 0; i < byte_length / sizeof(uint64_t); ++i)
{
uint32_t* left = &reinterpret_cast<uint32_t*>(dst)[i * 2];
uint32_t* right = &reinterpret_cast<uint32_t*>(dst)[i * 2 + 1];
EncryptBlock(left, right);
}
}
std::vector<char> Blowfish::Encrypt(const std::vector<char> &src) const {
std::vector<char> dst = src;
size_t padding_length = dst.size() % sizeof(uint64_t);
if (padding_length == 0) {
padding_length = sizeof(uint64_t);
} else {
padding_length = sizeof(uint64_t) - padding_length;
}
for (size_t i = 0; i < padding_length; ++i) {
dst.push_back(static_cast<char>(padding_length));
}
for (int i = 0; i < dst.size() / sizeof(uint64_t); ++i) {
uint32_t *left = &reinterpret_cast<uint32_t *>(dst.data())[i * 2];
uint32_t *right = &reinterpret_cast<uint32_t *>(dst.data())[i * 2 + 1];
EncryptBlock(left, right);
}
return dst;
}
// CBCEncrypt()
void CBCEncrypt(void *pTextIn, void* pBuffer, u_int32_ard length,
u_int32_ard padding, const u_int32_ard *pKeys,
const u_int16_ard *pIV)
{
byte_ard *pText = (byte_ard*)pTextIn;
byte_ard *cBuffer = (byte_ard*)pBuffer;
byte_ard lastblock[BLOCK_BYTE_SIZE];
byte_ard currblock[BLOCK_BYTE_SIZE];
u_int32_ard blocks = (length + padding) / BLOCK_BYTE_SIZE;
memcpy(lastblock,pIV,BLOCK_BYTE_SIZE);
if (padding == (BLOCK_BYTE_SIZE +1) )
{
// Decide on the padding
if ((length % BLOCK_BYTE_SIZE) == 0)
padding = 0;
else
padding = BLOCK_BYTE_SIZE - (length % BLOCK_BYTE_SIZE);
}
// Copy and pad the
for (u_int32_ard i = 0; i<(length + padding); i++)
{
if (i < length)
{
// Copy the string
cBuffer[i] = pText[i];
}
else
{
cBuffer[i] = 0x80;
}
}
// C_i = E_k(P_i XOR C_{i-1})
for (u_int32_ard i = 0; i < blocks; i++)
{
#if defined(unroll_cbc_encrypt_loop)
currblock[0] = cBuffer[(i*BLOCK_BYTE_SIZE)+0] ^ lastblock[0];
currblock[1] = cBuffer[(i*BLOCK_BYTE_SIZE)+1] ^ lastblock[1];
currblock[2] = cBuffer[(i*BLOCK_BYTE_SIZE)+2] ^ lastblock[2];
currblock[3] = cBuffer[(i*BLOCK_BYTE_SIZE)+3] ^ lastblock[3];
currblock[4] = cBuffer[(i*BLOCK_BYTE_SIZE)+4] ^ lastblock[4];
currblock[5] = cBuffer[(i*BLOCK_BYTE_SIZE)+5] ^ lastblock[5];
currblock[6] = cBuffer[(i*BLOCK_BYTE_SIZE)+6] ^ lastblock[6];
currblock[7] = cBuffer[(i*BLOCK_BYTE_SIZE)+7] ^ lastblock[7];
currblock[8] = cBuffer[(i*BLOCK_BYTE_SIZE)+8] ^ lastblock[8];
currblock[9] = cBuffer[(i*BLOCK_BYTE_SIZE)+9] ^ lastblock[9];
currblock[10] = cBuffer[(i*BLOCK_BYTE_SIZE)+10] ^ lastblock[10];
currblock[11] = cBuffer[(i*BLOCK_BYTE_SIZE)+11] ^ lastblock[11];
currblock[12] = cBuffer[(i*BLOCK_BYTE_SIZE)+12] ^ lastblock[12];
currblock[13] = cBuffer[(i*BLOCK_BYTE_SIZE)+13] ^ lastblock[13];
currblock[14] = cBuffer[(i*BLOCK_BYTE_SIZE)+14] ^ lastblock[14];
currblock[15] = cBuffer[(i*BLOCK_BYTE_SIZE)+15] ^ lastblock[15];
EncryptBlock((void*)currblock, pKeys);
cBuffer[(i*BLOCK_BYTE_SIZE)+0] = currblock[0];
cBuffer[(i*BLOCK_BYTE_SIZE)+1] = currblock[1];
cBuffer[(i*BLOCK_BYTE_SIZE)+2] = currblock[2];
cBuffer[(i*BLOCK_BYTE_SIZE)+3] = currblock[3];
cBuffer[(i*BLOCK_BYTE_SIZE)+4] = currblock[4];
cBuffer[(i*BLOCK_BYTE_SIZE)+5] = currblock[5];
cBuffer[(i*BLOCK_BYTE_SIZE)+6] = currblock[6];
cBuffer[(i*BLOCK_BYTE_SIZE)+7] = currblock[7];
cBuffer[(i*BLOCK_BYTE_SIZE)+8] = currblock[8];
cBuffer[(i*BLOCK_BYTE_SIZE)+9] = currblock[9];
cBuffer[(i*BLOCK_BYTE_SIZE)+10] = currblock[10];
cBuffer[(i*BLOCK_BYTE_SIZE)+11] = currblock[11];
cBuffer[(i*BLOCK_BYTE_SIZE)+12] = currblock[12];
cBuffer[(i*BLOCK_BYTE_SIZE)+13] = currblock[13];
cBuffer[(i*BLOCK_BYTE_SIZE)+14] = currblock[14];
cBuffer[(i*BLOCK_BYTE_SIZE)+15] = currblock[15];
#else
for (u_int16_ard j = 0; j < BLOCK_BYTE_SIZE; j++)
{
currblock[j] = cBuffer[(i*BLOCK_BYTE_SIZE)+j] ^ lastblock[j];
}
EncryptBlock((void*)currblock, pKeys);
// Copy the ciphered block into the buffer again.
for (u_int16_ard j = 0; j < BLOCK_BYTE_SIZE; j++)
{
cBuffer[(i*BLOCK_BYTE_SIZE)+j] = currblock[j];
}
#endif
// lastblock = currblock;
memcpy(lastblock,currblock,BLOCK_BYTE_SIZE);
} // for (blocks)
} // CBCEncrypt()
void Cbc512NoPaddingCryptoProvider::Encrypt(const uint8_t *pbIn,
uint32_t cbInUnsafe,
uint32_t dwStartingBlockNumberUnsafe,
bool isFinal,
uint8_t *pbOut,
uint32_t cbOutUnsafe,
uint32_t *pcbOut)
{
auto cbIn = cbInUnsafe, cbOut = cbOutUnsafe,
dwStartingBlockNumber = dwStartingBlockNumberUnsafe;
if (pbIn == nullptr) {
throw exceptions::RMSCryptoNullPointerException("Null pointer pbIn exception");
}
if (!isFinal && (0 != cbIn % CBC512_BLOCK_SIZE)) {
throw exceptions::RMSCryptoInvalidArgumentException("Block is not aligned");
}
if (nullptr == pcbOut) {
throw exceptions::RMSCryptoNullPointerException("Null pointer pcbOut exception");
}
if ((cbIn % AES128_BLOCK_SIZE) != 0) {
throw exceptions::RMSCryptoInvalidArgumentException("Block is not aligned");
}
auto cbResult = 0;
if (nullptr == pbOut)
{
// No need to do the encryption, just return the number of uint8_ts required
*pcbOut = (unsigned long)cbIn;
return;
}
while (cbIn > CBC512_BLOCK_SIZE)
{
if (cbOut < CBC512_BLOCK_SIZE) {
throw exceptions::RMSCryptoInvalidArgumentException("Invalid buffer size");
}
// Encrypt the current block
EncryptBlock(pbIn,
CBC512_BLOCK_SIZE,
dwStartingBlockNumber,
false,
pbOut,
cbOut);
// Go to the next block
pbIn += CBC512_BLOCK_SIZE;
cbIn -= CBC512_BLOCK_SIZE;
pbOut += CBC512_BLOCK_SIZE;
cbOut -= CBC512_BLOCK_SIZE;
++dwStartingBlockNumber;
cbResult += CBC512_BLOCK_SIZE;
}
if (!isFinal && (cbIn > CBC512_BLOCK_SIZE)) {
throw exceptions::RMSCryptoInvalidArgumentException("Invalid aligment");
}
cbResult += EncryptBlock(pbIn, cbIn, dwStartingBlockNumber, true, pbOut, cbOut);
*pcbOut = cbResult;
}
void
LRWMode::Encrypt(ThreadContext& context, uint8 *data, size_t length)
{
EncryptBlock(context, data, length, fOffset);
}
void
XTSMode::Encrypt(ThreadContext& context, uint8 *data, size_t length)
{
EncryptBlock(context, data, length, 0);
}
void RX_ISR(void)
{
received = U1ARXREG;
PORTD = 2;
if(received == 10)
{
i = 0;
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
TMR2 = 0;
while(username[i] != NULL)
{
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = username[i];
}
i++;
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
}
DelayMsec(5000);
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -3;
}
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
i = 0;
while(password[i] != NULL)
{
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = password[i];
}
i++;
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
}
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -3;
}
}
else if(received == -7)
{
if(receive_user == -1)
receive_user = 1;
else if(receive_user == 1)
receive_user = 0;
else
receive_user = -1;
i = 0;
}
else if(received == -4)
{
receive_file = 1;
file_pt = 0;
}
else if(received == -5)
{
receive_file = 0;
file_pt = 0;
//BYTE Key[2] = {'1','2'};
BYTE RoundKey[6];
Extend_Key(Key,RoundKey);
while(file[file_pt] != NULL)
{
BYTE temp[2];
BYTE temp_result[2];
temp[0] = file[file_pt];
temp[1] = file[file_pt+1];
EncryptBlock(temp,RoundKey,temp_result);
result[file_pt] = temp_result[0];
result[file_pt+1] = temp_result[1];
file_pt = file_pt + 2;
}
file_pt = 0;
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
while(result[file_pt] != NULL)
{
char to_send = result[file_pt];
file_pt++;
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = to_send;
}
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
}
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -3;
}
file_pt = 0;
}
else if(received == -6)
{
receive_file = 0;
file_pt = 0;
//BYTE Key[2] = {'1','2'};
BYTE RoundKey[6];
Extend_Key(Key,RoundKey);
while(file[file_pt] != NULL)
{
BYTE temp[2];
BYTE temp_result[2];
temp_result[0] = file[file_pt];
temp_result[1] = file[file_pt+1];
DecryptBlock(temp_result,RoundKey,temp);
file[file_pt] = temp[0];
file[file_pt+1] = temp[1];
file_pt = file_pt + 2;
}
file_pt = 0;
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
while(file[file_pt] != NULL)
{
char to_send = file[file_pt];
file_pt++;
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = to_send;
}
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -2;
}
}
TMR2 = 0;
while(TMR2 < 400)
{
U1ATXREG = -3;
}
file_pt = 0;
}
if(receive_file == 1 && received != -4 && received != -5)
{
file[file_pt] = received;
file_pt ++;
}
if(receive_user == 1 && received != -7)
{
username[i] = received;
i++;
}
else if(receive_user == 0 && received != -7)
{
password[i] = received;
i++;
}
PORTDINV = 2;
IFS0bits.U1RXIF = 0;
}
