void
LRWMode::DecryptBlock(ThreadContext& context, uint8 *data, size_t length,
uint64 blockIndex)
{
uint8 i[8];
uint8 t[16];
int b;
blockIndex = ((blockIndex - fOffset) << 5) + 1;
*(uint64*)i = B_HOST_TO_BENDIAN_INT64(blockIndex);
for (b = 0; b < length >> 4; b++) {
gf128_mul_by_tab64(i, t,
(galois_field_context*)context.BufferFor(fGaloisField));
//dprintf(" t: %x\n", *(int*)t);
xor128((uint64*)data, (uint64 *)t);
fAlgorithm->Decrypt(context, data, 16);
xor128((uint64*)data, (uint64*)t);
data += 16;
if (i[7] != 0xff)
i[7]++;
else {
*(uint64*)i = B_HOST_TO_BENDIAN_INT64(
B_BENDIAN_TO_HOST_INT64(*(uint64*)i) + 1);
}
}
memset(t, 0, sizeof (t));
}
void
PackageWriter::_WriteTOC(hpkg_header& header)
{
// prepare the writer (zlib writer on top of a file writer)
off_t startOffset = fHeapEnd;
FDDataWriter realWriter(fFD, startOffset);
ZlibDataWriter zlibWriter(&realWriter);
fDataWriter = &zlibWriter;
zlibWriter.Init();
// write the sections
uint64 uncompressedAttributeTypesSize;
uint64 uncompressedStringsSize;
uint64 uncompressedMainSize;
int32 cachedStringsWritten = _WriteTOCSections(
uncompressedAttributeTypesSize, uncompressedStringsSize,
uncompressedMainSize);
// finish the writer
zlibWriter.Finish();
fHeapEnd = realWriter.Offset();
fDataWriter = NULL;
printf("attributes types size: %llu\n", uncompressedAttributeTypesSize);
printf("cached strings size: %llu\n", uncompressedStringsSize);
printf("TOC main size: %llu\n", uncompressedMainSize);
off_t endOffset = fHeapEnd;
printf("total TOC size: %llu (%llu)\n", endOffset - startOffset, zlibWriter.BytesWritten());
// update the header
// TOC
header.toc_compression = B_HOST_TO_BENDIAN_INT32(B_HPKG_COMPRESSION_ZLIB);
header.toc_length_compressed = B_HOST_TO_BENDIAN_INT64(
endOffset - startOffset);
header.toc_length_uncompressed = B_HOST_TO_BENDIAN_INT64(
zlibWriter.BytesWritten());
// TOC subsections
header.toc_attribute_types_length = B_HOST_TO_BENDIAN_INT64(
uncompressedAttributeTypesSize);
header.toc_attribute_types_count = B_HOST_TO_BENDIAN_INT64(
fAttributeTypes->CountElements());
header.toc_strings_length = B_HOST_TO_BENDIAN_INT64(
uncompressedStringsSize);
header.toc_strings_count = B_HOST_TO_BENDIAN_INT64(cachedStringsWritten);
}
void
AHCIPort::ScsiReadCapacity16(scsi_ccb* request)
{
TRACE("AHCIPort::ScsiReadCapacity16 port %d\n", fIndex);
scsi_res_read_capacity_long scsiData;
TRACE("SectorSize %" B_PRIu32 ", SectorCount 0x%" B_PRIx64 "\n",
fSectorSize, fSectorCount);
scsiData.block_size = B_HOST_TO_BENDIAN_INT32(fSectorSize);
scsiData.lba = B_HOST_TO_BENDIAN_INT64(fSectorCount - 1);
if (sg_memcpy(request->sg_list, request->sg_count, &scsiData,
sizeof(scsiData)) < B_OK) {
request->subsys_status = SCSI_DATA_RUN_ERR;
} else {
request->subsys_status = SCSI_REQ_CMP;
request->data_resid = request->data_length - sizeof(scsiData);
}
gSCSI->finished(request, 1);
}
status_t
VolumeCryptContext::SetPassword(int fd, const uint8* oldKey,
uint32 oldKeyLength, const uint8* newKey, uint32 newKeyLength)
{
off_t headerOffset;
uint8 buffer[BLOCK_SIZE];
true_crypt_header header;
status_t status = _Detect(fd, oldKey, oldKeyLength, headerOffset, buffer,
header);
if (status != B_OK)
return status;
// header.required_program_version = B_HOST_TO_BENDIAN_INT16(0x800);
header.volume_size = B_HOST_TO_BENDIAN_INT64(fSize);
header.crc_checksum = B_HOST_TO_BENDIAN_INT32(crc32(header.disk_key, 256));
header.header_crc_checksum
= B_HOST_TO_BENDIAN_INT32(crc32((uint8*)&header, 188));
memcpy(buffer + PKCS5_SALT_SIZE, &header, sizeof(true_crypt_header));
dprintf("HEADER OFFSET: %Ld\n", headerOffset);
dprintf("NEW KEY: %s\n", newKey);
return _WriteHeader(fd, newKey, newKeyLength, headerOffset, buffer);
}
status_t
PackageWriter::_Finish()
{
// write entries
for (EntryList::ConstIterator it = fRootEntry->ChildIterator();
Entry* entry = it.Next();) {
_AddEntry(AT_FDCWD, entry, entry->Name());
}
printf("header size: %lu\n", sizeof(hpkg_header));
printf("heap size: %lld\n", fHeapEnd - sizeof(hpkg_header));
hpkg_header header;
// write the TOC and package attributes
_WriteTOC(header);
_WritePackageAttributes(header);
off_t totalSize = fHeapEnd;
printf("total size: %lld\n", totalSize);
// prepare the header
// general
header.magic = B_HOST_TO_BENDIAN_INT32(B_HPKG_MAGIC);
header.header_size = B_HOST_TO_BENDIAN_INT16(
(uint16)sizeof(hpkg_header));
header.version = B_HOST_TO_BENDIAN_INT16(B_HPKG_VERSION);
header.total_size = B_HOST_TO_BENDIAN_INT64(totalSize);
// write the header
_WriteBuffer(&header, sizeof(hpkg_header), 0);
fFinished = true;
return B_OK;
}
void
MemoryView::_HandleContextMenu(BPoint point)
{
int32 offset = _GetOffsetAt(point);
if (offset < fSelectionStart || offset > fSelectionEnd)
return;
BPopUpMenu* menu = new(std::nothrow) BPopUpMenu("Options");
if (menu == NULL)
return;
ObjectDeleter<BPopUpMenu> menuDeleter(menu);
ObjectDeleter<BMenuItem> itemDeleter;
ObjectDeleter<BMessage> messageDeleter;
BMessage* message = NULL;
BMenuItem* item = NULL;
if (fSelectionEnd - fSelectionStart == fTargetAddressSize / 2) {
BMessage* message = new(std::nothrow) BMessage(MSG_INSPECT_ADDRESS);
if (message == NULL)
return;
target_addr_t address;
if (fTargetAddressSize == 8)
address = *((uint32*)(fTargetBlock->Data() + fSelectionStart));
else
address = *((uint64*)(fTargetBlock->Data() + fSelectionStart));
if (fCurrentEndianMode == EndianModeBigEndian)
address = B_HOST_TO_BENDIAN_INT64(address);
else
address = B_HOST_TO_LENDIAN_INT64(address);
messageDeleter.SetTo(message);
message->AddUInt64("address", address);
BMenuItem* item = new(std::nothrow) BMenuItem("Inspect", message);
if (item == NULL)
return;
messageDeleter.Detach();
itemDeleter.SetTo(item);
if (!menu->AddItem(item))
return;
item->SetTarget(Looper());
itemDeleter.Detach();
}
message = new(std::nothrow) BMessage(B_COPY);
if (message == NULL)
return;
messageDeleter.SetTo(message);
item = new(std::nothrow) BMenuItem("Copy", message);
if (item == NULL)
return;
messageDeleter.Detach();
itemDeleter.SetTo(item);
if (!menu->AddItem(item))
return;
item->SetTarget(this);
itemDeleter.Detach();
menuDeleter.Detach();
BPoint screenWhere(point);
ConvertToScreen(&screenWhere);
BRect mouseRect(screenWhere, screenWhere);
mouseRect.InsetBy(-4.0, -4.0);
menu->Go(screenWhere, true, false, mouseRect, true);
}
void
MemoryView::_GetNextHexBlock(char* buffer, int32 bufferSize,
const char* address)
{
switch(fHexMode) {
case HexMode8BitInt:
{
snprintf(buffer, bufferSize, "%02" B_PRIx8,
*((const uint8*)address));
break;
}
case HexMode16BitInt:
{
uint16 data = *((const uint16*)address);
switch(fCurrentEndianMode)
{
case EndianModeBigEndian:
{
data = B_HOST_TO_BENDIAN_INT16(data);
}
break;
case EndianModeLittleEndian:
{
data = B_HOST_TO_LENDIAN_INT16(data);
}
break;
}
snprintf(buffer, bufferSize, "%04" B_PRIx16,
data);
break;
}
case HexMode32BitInt:
{
uint32 data = *((const uint32*)address);
switch(fCurrentEndianMode)
{
case EndianModeBigEndian:
{
data = B_HOST_TO_BENDIAN_INT32(data);
}
break;
case EndianModeLittleEndian:
{
data = B_HOST_TO_LENDIAN_INT32(data);
}
break;
}
snprintf(buffer, bufferSize, "%08" B_PRIx32,
data);
break;
}
case HexMode64BitInt:
{
uint64 data = *((const uint64*)address);
switch(fCurrentEndianMode)
{
case EndianModeBigEndian:
{
data = B_HOST_TO_BENDIAN_INT64(data);
}
break;
case EndianModeLittleEndian:
{
data = B_HOST_TO_LENDIAN_INT64(data);
}
break;
}
snprintf(buffer, bufferSize, "%0*" B_PRIx64,
16, data);
break;
}
}
}
void
PackageWriter::_WriteAttributeValue(const AttributeValue& value, uint8 encoding)
{
switch (value.type) {
case B_HPKG_ATTRIBUTE_TYPE_INT:
case B_HPKG_ATTRIBUTE_TYPE_UINT:
{
uint64 intValue = value.type == B_HPKG_ATTRIBUTE_TYPE_INT
? (uint64)value.signedInt : value.unsignedInt;
switch (encoding) {
case B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT:
_Write<uint8>((uint8)intValue);
break;
case B_HPKG_ATTRIBUTE_ENCODING_INT_16_BIT:
_Write<uint16>(
B_HOST_TO_BENDIAN_INT16((uint16)intValue));
break;
case B_HPKG_ATTRIBUTE_ENCODING_INT_32_BIT:
_Write<uint32>(
B_HOST_TO_BENDIAN_INT32((uint32)intValue));
break;
case B_HPKG_ATTRIBUTE_ENCODING_INT_64_BIT:
_Write<uint64>(
B_HOST_TO_BENDIAN_INT64((uint64)intValue));
break;
default:
{
fprintf(stderr, "_WriteAttributeValue(): invalid "
"encoding %d for int value type %d\n", encoding,
value.type);
throw status_t(B_BAD_VALUE);
}
}
break;
}
case B_HPKG_ATTRIBUTE_TYPE_STRING:
{
if (encoding == B_HPKG_ATTRIBUTE_ENCODING_STRING_TABLE)
_WriteUnsignedLEB128(value.string->index);
else
_WriteString(value.string->string);
break;
}
case B_HPKG_ATTRIBUTE_TYPE_RAW:
{
_WriteUnsignedLEB128(value.data.size);
if (encoding == B_HPKG_ATTRIBUTE_ENCODING_RAW_HEAP)
_WriteUnsignedLEB128(value.data.offset);
else
fDataWriter->WriteDataThrows(value.data.raw, value.data.size);
break;
}
default:
fprintf(stderr, "_WriteAttributeValue(): invalid value type: "
"%d\n", value.type);
throw status_t(B_BAD_VALUE);
}
}
status_t
BNetBuffer::AppendUint64(uint64 data)
{
uint64 be_data = B_HOST_TO_BENDIAN_INT64(data);
return AppendData((const void*)&be_data, sizeof(uint64));
}
/*! Universal read/write function */
static status_t
read_write(scsi_periph_device_info *device, scsi_ccb *request,
io_operation *operation, uint64 offset, size_t originalNumBlocks,
physical_entry* vecs, size_t vecCount, bool isWrite,
size_t* _bytesTransferred)
{
uint32 blockSize = device->block_size;
size_t numBlocks = originalNumBlocks;
uint32 pos = offset;
err_res res;
int retries = 0;
do {
size_t numBytes;
bool isReadWrite10 = false;
request->flags = isWrite ? SCSI_DIR_OUT : SCSI_DIR_IN;
// io_operations are generated by a DMAResource and thus contain DMA
// safe physical vectors
if (operation != NULL)
request->flags |= SCSI_DMA_SAFE;
// make sure we avoid 10 byte commands if they aren't supported
if (!device->rw10_enabled || device->preferred_ccb_size == 6) {
// restricting transfer is OK - the block manager will
// take care of transferring the rest
if (numBlocks > 0x100)
numBlocks = 0x100;
// no way to break the 21 bit address limit
if (offset > 0x200000)
return B_BAD_VALUE;
// don't allow transfer cross the 24 bit address limit
// (I'm not sure whether this is allowed, but this way we
// are sure to not ask for trouble)
if (offset < 0x100000)
numBlocks = min_c(numBlocks, 0x100000 - pos);
}
numBytes = numBlocks * blockSize;
if (numBlocks != originalNumBlocks)
panic("I/O operation would need to be cut.");
request->data = NULL;
request->sg_list = vecs;
request->data_length = numBytes;
request->sg_count = vecCount;
request->io_operation = operation;
request->sort = pos;
request->timeout = device->std_timeout;
// see whether daemon instructed us to post an ordered command;
// reset flag after read
SHOW_FLOW(3, "flag=%x, next_tag=%x, ordered: %s",
(int)request->flags, (int)device->next_tag_action,
(request->flags & SCSI_ORDERED_QTAG) != 0 ? "yes" : "no");
// use shortest commands whenever possible
if (offset + numBlocks < 0x200000LL && numBlocks <= 0x100) {
scsi_cmd_rw_6 *cmd = (scsi_cmd_rw_6 *)request->cdb;
isReadWrite10 = false;
memset(cmd, 0, sizeof(*cmd));
cmd->opcode = isWrite ? SCSI_OP_WRITE_6 : SCSI_OP_READ_6;
cmd->high_lba = (pos >> 16) & 0x1f;
cmd->mid_lba = (pos >> 8) & 0xff;
cmd->low_lba = pos & 0xff;
cmd->length = numBlocks;
request->cdb_length = sizeof(*cmd);
} else if (offset + numBlocks < 0x100000000LL && numBlocks <= 0x10000) {
scsi_cmd_rw_10 *cmd = (scsi_cmd_rw_10 *)request->cdb;
isReadWrite10 = true;
memset(cmd, 0, sizeof(*cmd));
cmd->opcode = isWrite ? SCSI_OP_WRITE_10 : SCSI_OP_READ_10;
cmd->relative_address = 0;
cmd->force_unit_access = 0;
cmd->disable_page_out = 0;
cmd->lba = B_HOST_TO_BENDIAN_INT32(pos);
cmd->length = B_HOST_TO_BENDIAN_INT16(numBlocks);
request->cdb_length = sizeof(*cmd);
} else if (offset + numBlocks < 0x100000000LL && numBlocks <= 0x10000000) {
scsi_cmd_rw_12 *cmd = (scsi_cmd_rw_12 *)request->cdb;
memset(cmd, 0, sizeof(*cmd));
cmd->opcode = isWrite ? SCSI_OP_WRITE_12 : SCSI_OP_READ_12;
cmd->relative_address = 0;
cmd->force_unit_access = 0;
cmd->disable_page_out = 0;
cmd->lba = B_HOST_TO_BENDIAN_INT32(pos);
cmd->length = B_HOST_TO_BENDIAN_INT32(numBlocks);
request->cdb_length = sizeof(*cmd);
} else {
scsi_cmd_rw_16 *cmd = (scsi_cmd_rw_16 *)request->cdb;
memset(cmd, 0, sizeof(*cmd));
cmd->opcode = isWrite ? SCSI_OP_WRITE_16 : SCSI_OP_READ_16;
cmd->force_unit_access_non_volatile = 0;
cmd->force_unit_access = 0;
cmd->disable_page_out = 0;
cmd->lba = B_HOST_TO_BENDIAN_INT64(offset);
cmd->length = B_HOST_TO_BENDIAN_INT32(numBlocks);
request->cdb_length = sizeof(*cmd);
}
// TODO: last chance to detect errors that occured during concurrent accesses
//status_t status = handle->pending_error;
//if (status != B_OK)
// return status;
device->scsi->async_io(request);
acquire_sem(request->completion_sem);
// ask generic peripheral layer what to do now
res = periph_check_error(device, request);
// TODO: bytes might have been transferred even in the error case!
switch (res.action) {
case err_act_ok:
*_bytesTransferred = numBytes - request->data_resid;
break;
case err_act_start:
res = periph_send_start_stop(device, request, 1,
device->removable);
if (res.action == err_act_ok)
res.action = err_act_retry;
break;
case err_act_invalid_req:
// if this was a 10 byte command, the device probably doesn't
// support them, so disable them and retry
if (isReadWrite10) {
atomic_and(&device->rw10_enabled, 0);
res.action = err_act_retry;
} else
res.action = err_act_fail;
break;
}
} while ((res.action == err_act_retry && retries++ < 3)
status_t Flap::AddInt64(int64 value) {
int64 v = B_HOST_TO_BENDIAN_INT64(value);
return AddRawData((uchar *)&v, sizeof(value));
};
