bool ScRC4EncodeFilter::writeData(const char* data, int dataLen)
{
bool rc4Success = true;
unsigned int count;
const unsigned char *p = (const unsigned char *) data;
if (!m_filterData)
return false;
while (dataLen) {
count = dataLen;
if (count > BUFFER_SIZE - m_filterData->available_in)
count = BUFFER_SIZE - m_filterData->available_in;
memcpy (m_filterData->input_buffer + m_filterData->available_in, p, count);
p += count;
m_filterData->available_in += count;
dataLen -= count;
if (m_filterData->available_in == BUFFER_SIZE)
{
rc4_encrypt(&m_filterData->rc4_context, m_filterData->input_buffer, m_filterData->output_buffer, m_filterData->available_in);
rc4Success &= writeDataInternal((const char*) m_filterData->output_buffer, m_filterData->available_in);
m_filterData->available_in = 0;
}
}
return rc4Success;
}
void rc4_handler::decrypt(std::vector<boost::asio::mutable_buffer>& buf
, int& consume
, int& produce
, int& packet_size)
{
// these are out-parameters that are not set
TORRENT_UNUSED(consume);
TORRENT_UNUSED(packet_size);
if (!m_decrypt) return;
int bytes_processed = 0;
for (std::vector<boost::asio::mutable_buffer>::iterator i = buf.begin();
i != buf.end(); ++i)
{
unsigned char* pos = boost::asio::buffer_cast<unsigned char*>(*i);
int len = boost::asio::buffer_size(*i);
TORRENT_ASSERT(len >= 0);
TORRENT_ASSERT(pos);
bytes_processed += len;
rc4_encrypt(pos, len, &m_rc4_incoming);
}
buf.clear();
produce = bytes_processed;
}
bool ScRC4EncodeFilter::closeFilter(void)
{
bool closeSucceed = true;
if (m_filterData->available_in > 0)
{
rc4_encrypt(&m_filterData->rc4_context, m_filterData->input_buffer, m_filterData->output_buffer, m_filterData->available_in);
closeSucceed &= writeDataInternal((const char*) m_filterData->output_buffer, m_filterData->available_in);
}
m_openedFilter = false;
closeSucceed &= ScStreamFilter::closeFilter();
return closeSucceed;
}
static
void
s_vSWencryption (
PSDevice pDevice,
PSKeyItem pTransmitKey,
PBYTE pbyPayloadHead,
WORD wPayloadSize
)
{
unsigned int cbICVlen = 4;
DWORD dwICV = 0xFFFFFFFFL;
PDWORD pdwICV;
if (pTransmitKey == NULL)
return;
if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
//=======================================================================
// Append ICV after payload
dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
pdwICV = (PDWORD)(pbyPayloadHead + wPayloadSize);
// finally, we must invert dwCRC to get the correct answer
*pdwICV = cpu_to_le32(~dwICV);
// RC4 encryption
rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength + 3);
rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
//=======================================================================
} else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
//=======================================================================
//Append ICV after payload
dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
pdwICV = (PDWORD)(pbyPayloadHead + wPayloadSize);
// finally, we must invert dwCRC to get the correct answer
*pdwICV = cpu_to_le32(~dwICV);
// RC4 encryption
rc4_init(&pDevice->SBox, pDevice->abyPRNG, TKIP_KEY_LEN);
rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
//=======================================================================
}
}
int rc4_handler::encrypt(std::vector<boost::asio::mutable_buffer>& buf)
{
if (!m_encrypt) return 0;
if (buf.empty()) return 0;
int bytes_processed = 0;
for (std::vector<boost::asio::mutable_buffer>::iterator i = buf.begin();
i != buf.end(); ++i)
{
unsigned char* pos = boost::asio::buffer_cast<unsigned char*>(*i);
int len = boost::asio::buffer_size(*i);
TORRENT_ASSERT(len >= 0);
TORRENT_ASSERT(pos);
bytes_processed += len;
rc4_encrypt(pos, len, &m_rc4_outgoing);
}
buf.clear();
return bytes_processed;
}
static void
EncryptPwBlockWithPasswordHash(const uint8_t * password,
uint32_t password_len,
const uint8_t pw_hash[NT_PASSWORD_HASH_SIZE],
NTPasswordBlockRef pwblock)
{
NTPasswordBlock clear_pwblock;
int offset;
uint32_t password_len_little_endian;
MSChapFillWithRandom(&clear_pwblock, sizeof(clear_pwblock));
offset = sizeof(clear_pwblock.password) - password_len;
bcopy(password, ((void *)&clear_pwblock) + offset, password_len);
/* convert password length to little endian */
password_len_little_endian = OSSwapHostToLittleInt32(password_len);
bcopy(&password_len_little_endian, clear_pwblock.password_length,
sizeof(uint32_t));
rc4_encrypt(&clear_pwblock, sizeof(clear_pwblock),
pw_hash, NT_PASSWORD_HASH_SIZE, pwblock);
return;
}
void rc4_decrypt(const u8 *key, uint keylen,
const u8 *c, uint clen, u8 *p)
{
rc4_encrypt(key, keylen, c, clen, p);
}
