NTSTATUS myfgetws(__inout PWCHAR pInputBuffer, __in ULONGLONG inputBufferSize, __out PULONGLONG pStrSize){
NTSTATUS status = STATUS_UNSUCCESSFUL;
ULONG maxWcharCount = (ULONG)inputBufferSize / sizeof(WCHAR);
if (!pInputBuffer || !inputBufferSize || !pStrSize)
return STATUS_INVALID_PARAMETER;
*pStrSize = 0;
fflush(stdin);
fgetws(pInputBuffer, maxWcharCount, stdin);
fflush(stdin);
status = RtlStringCbLengthW(pInputBuffer, maxWcharCount * sizeof(WCHAR), pStrSize);
if (status)
return status;
///Eliminate 0x0A char if there is one in buffer
if (0x0A == pInputBuffer[*pStrSize / sizeof(WCHAR) - 1]){
pInputBuffer[*pStrSize / sizeof(WCHAR) - 1] = 0x0;
return STATUS_SUCCESS;
}
*pStrSize += sizeof(UNICODE_NULL);
return STATUS_SUCCESS;
}
void
AFSDumpTraceFiles()
{
NTSTATUS ntStatus = STATUS_SUCCESS;
HANDLE hDirectory = NULL;
OBJECT_ATTRIBUTES stObjectAttribs;
IO_STATUS_BLOCK stIoStatus;
LARGE_INTEGER liTime, liLocalTime;
TIME_FIELDS timeFields;
ULONG ulBytesWritten = 0;
HANDLE hDumpFile = NULL;
ULONG ulBytesProcessed, ulCopyLength;
LARGE_INTEGER liOffset;
ULONG ulDumpLength = 0;
BOOLEAN bSetEvent = FALSE;
__Enter
{
AFSAcquireShared( &AFSDbgLogLock,
TRUE);
ulDumpLength = AFSDbgBufferLength - AFSDbgLogRemainingLength;
AFSReleaseResource( &AFSDbgLogLock);
if( AFSDumpFileLocation.Length == 0 ||
AFSDumpFileLocation.Buffer == NULL ||
AFSDbgBufferLength == 0 ||
ulDumpLength == 0 ||
AFSDumpFileName.MaximumLength == 0 ||
AFSDumpFileName.Buffer == NULL ||
AFSDumpBuffer == NULL)
{
try_return( ntStatus);
}
//
// Go open the cache file
//
InitializeObjectAttributes( &stObjectAttribs,
&AFSDumpFileLocation,
OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
NULL,
NULL);
ntStatus = ZwCreateFile( &hDirectory,
GENERIC_READ | GENERIC_WRITE,
&stObjectAttribs,
&stIoStatus,
NULL,
0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_OPEN,
FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
if( !NT_SUCCESS( ntStatus))
{
try_return( ntStatus);
}
ntStatus = KeWaitForSingleObject( &AFSDumpFileEvent,
Executive,
KernelMode,
FALSE,
NULL);
if( !NT_SUCCESS( ntStatus))
{
try_return( ntStatus);
}
bSetEvent = TRUE;
AFSDumpFileName.Length = 0;
RtlZeroMemory( AFSDumpFileName.Buffer,
AFSDumpFileName.MaximumLength);
KeQuerySystemTime( &liTime);
ExSystemTimeToLocalTime( &liTime,
&liLocalTime);
RtlTimeToTimeFields( &liLocalTime,
&timeFields);
ntStatus = RtlStringCchPrintfW( AFSDumpFileName.Buffer,
AFSDumpFileName.MaximumLength/sizeof( WCHAR),
L"AFSDumpFile %d.%d.%d %d.%d.%d.log",
timeFields.Month,
timeFields.Day,
timeFields.Year,
timeFields.Hour,
timeFields.Minute,
timeFields.Second);
if( !NT_SUCCESS( ntStatus))
{
try_return( ntStatus);
}
RtlStringCbLengthW( AFSDumpFileName.Buffer,
AFSDumpFileName.MaximumLength,
(size_t *)&ulBytesWritten);
AFSDumpFileName.Length = (USHORT)ulBytesWritten;
InitializeObjectAttributes( &stObjectAttribs,
&AFSDumpFileName,
OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
hDirectory,
NULL);
ntStatus = ZwCreateFile( &hDumpFile,
GENERIC_READ | GENERIC_WRITE,
&stObjectAttribs,
&stIoStatus,
NULL,
0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_CREATE,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
if( !NT_SUCCESS( ntStatus))
{
try_return( ntStatus);
}
//
// Write out the trace buffer
//
liOffset.QuadPart = 0;
ulBytesProcessed = 0;
while( ulBytesProcessed < ulDumpLength)
{
ulCopyLength = AFSDumpBufferLength;
if( ulCopyLength > ulDumpLength - ulBytesProcessed)
{
ulCopyLength = ulDumpLength - ulBytesProcessed;
}
RtlCopyMemory( AFSDumpBuffer,
(void *)((char *)AFSDbgBuffer + ulBytesProcessed),
ulCopyLength);
ntStatus = ZwWriteFile( hDumpFile,
NULL,
NULL,
NULL,
&stIoStatus,
AFSDumpBuffer,
ulCopyLength,
&liOffset,
NULL);
if( !NT_SUCCESS( ntStatus))
{
break;
}
liOffset.QuadPart += ulCopyLength;
ulBytesProcessed += ulCopyLength;
}
try_exit:
if( hDumpFile != NULL)
{
ZwClose( hDumpFile);
}
if( hDirectory != NULL)
{
ZwClose( hDirectory);
}
if( bSetEvent)
{
KeSetEvent( &AFSDumpFileEvent,
0,
FALSE);
}
}
return;
}
_Use_decl_annotations_
NTSTATUS
SimBattQueryInformation (
PVOID Context,
ULONG BatteryTag,
BATTERY_QUERY_INFORMATION_LEVEL Level,
LONG AtRate,
PVOID Buffer,
ULONG BufferLength,
PULONG ReturnedLength
)
/*++
Routine Description:
Called by the class driver to retrieve battery information
The battery class driver will serialize all requests it issues to
the miniport for a given battery.
Return invalid parameter when a request for a specific level of information
can't be handled. This is defined in the battery class spec.
Arguments:
Context - Supplies the miniport context value for battery
BatteryTag - Supplies the tag of current battery
Level - Supplies the type of information required
AtRate - Supplies the rate of drain for the BatteryEstimatedTime level
Buffer - Supplies a pointer to a buffer to place the information
BufferLength - Supplies the length in bytes of the buffer
ReturnedLength - Supplies the length in bytes of the returned data
Return Value:
Success if there is a battery currently installed, else no such device.
--*/
{
PSIMBATT_FDO_DATA DevExt;
ULONG ResultValue;
PVOID ReturnBuffer;
size_t ReturnBufferLength;
NTSTATUS Status;
UNREFERENCED_PARAMETER(AtRate);
DebugEnter();
PAGED_CODE();
DevExt = (PSIMBATT_FDO_DATA)Context;
WdfWaitLockAcquire(DevExt->StateLock, NULL);
if (BatteryTag != DevExt->BatteryTag) {
Status = STATUS_NO_SUCH_DEVICE;
goto QueryInformationEnd;
}
//
// Determine the value of the information being queried for and return it.
// In a real battery, this would require hardware/firmware accesses. The
// simulated battery fakes this by storing the data to be returned in
// memory.
//
ReturnBuffer = NULL;
ReturnBufferLength = 0;
DebugPrint(SIMBATT_INFO, "Query for information level 0x%x\n", Level);
Status = STATUS_INVALID_DEVICE_REQUEST;
switch (Level) {
case BatteryInformation:
ReturnBuffer = &DevExt->State.BatteryInfo;
ReturnBufferLength = sizeof(BATTERY_INFORMATION);
Status = STATUS_SUCCESS;
break;
case BatteryEstimatedTime:
if (DevExt->State.EstimatedTime == SIMBATT_RATE_CALCULATE) {
if (AtRate == 0) {
AtRate = DevExt->State.BatteryStatus.Rate;
}
if (AtRate < 0) {
ResultValue = (3600 * DevExt->State.BatteryStatus.Capacity) /
(-AtRate);
} else {
ResultValue = BATTERY_UNKNOWN_TIME;
}
} else {
ResultValue = DevExt->State.EstimatedTime;
}
ReturnBuffer = &ResultValue;
ReturnBufferLength = sizeof(ResultValue);
Status = STATUS_SUCCESS;
break;
case BatteryUniqueID:
ReturnBuffer = DevExt->State.UniqueId;
Status = RtlStringCbLengthW(DevExt->State.UniqueId,
sizeof(DevExt->State.UniqueId),
&ReturnBufferLength);
ReturnBufferLength += sizeof(WCHAR);
break;
case BatteryManufactureName:
ReturnBuffer = DevExt->State.ManufacturerName;
Status = RtlStringCbLengthW(DevExt->State.ManufacturerName,
sizeof(DevExt->State.ManufacturerName),
&ReturnBufferLength);
ReturnBufferLength += sizeof(WCHAR);
break;
case BatteryDeviceName:
ReturnBuffer = DevExt->State.DeviceName;
Status = RtlStringCbLengthW(DevExt->State.DeviceName,
sizeof(DevExt->State.DeviceName),
&ReturnBufferLength);
ReturnBufferLength += sizeof(WCHAR);
break;
case BatterySerialNumber:
ReturnBuffer = DevExt->State.SerialNumber;
Status = RtlStringCbLengthW(DevExt->State.SerialNumber,
sizeof(DevExt->State.SerialNumber),
&ReturnBufferLength);
ReturnBufferLength += sizeof(WCHAR);
break;
case BatteryManufactureDate:
if (DevExt->State.ManufactureDate.Day != 0) {
ReturnBuffer = &DevExt->State.ManufactureDate;
ReturnBufferLength = sizeof(BATTERY_MANUFACTURE_DATE);
Status = STATUS_SUCCESS;
}
break;
case BatteryGranularityInformation:
if (DevExt->State.GranularityCount > 0) {
ReturnBuffer = DevExt->State.GranularityScale;
ReturnBufferLength = DevExt->State.GranularityCount *
sizeof(BATTERY_REPORTING_SCALE);
Status = STATUS_SUCCESS;
}
break;
case BatteryTemperature:
ReturnBuffer = &DevExt->State.Temperature;
ReturnBufferLength = sizeof(ULONG);
Status = STATUS_SUCCESS;
break;
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
NT_ASSERT(((ReturnBufferLength == 0) && (ReturnBuffer == NULL)) ||
((ReturnBufferLength > 0) && (ReturnBuffer != NULL)));
if (NT_SUCCESS(Status)) {
*ReturnedLength = (ULONG)ReturnBufferLength;
if (ReturnBuffer != NULL) {
if ((Buffer == NULL) || (BufferLength < ReturnBufferLength)) {
Status = STATUS_BUFFER_TOO_SMALL;
} else {
memcpy(Buffer, ReturnBuffer, ReturnBufferLength);
}
}
} else {
*ReturnedLength = 0;
}
QueryInformationEnd:
WdfWaitLockRelease(DevExt->StateLock);
DebugExitStatus(Status);
return Status;
}
NTSTATUS
FileDiskInitializeLogicalUnit(
__in PNDAS_LOGICALUNIT_DESCRIPTOR LogicalUnitDescriptor,
__in PNDAS_LOGICALUNIT_EXTENSION LogicalUnitExtension)
{
NTSTATUS status;
PFILEDISK_EXTENSION fileDiskExtension;
PFILEDISK_DESCRIPTOR fileDiskDescriptor;
size_t dataFilePathLength;
BOOLEAN newDataFileCreated;
PAGED_CODE();
fileDiskExtension = FileDiskGetExtension(LogicalUnitExtension);
if (sizeof(NDAS_LOGICALUNIT_DESCRIPTOR) != LogicalUnitDescriptor->Version)
{
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_FATAL,
"LogicalUnitDescriptor version is invalid. Version=%d, Expected=%d\n",
LogicalUnitDescriptor->Version,
sizeof(NDAS_LOGICALUNIT_DESCRIPTOR));
return STATUS_INVALID_PARAMETER;
}
if (LogicalUnitDescriptor->Size < FIELD_OFFSET(FILEDISK_DESCRIPTOR, FilePath))
{
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_FATAL,
"FileDiskDescriptor Size is invalid. Size=%d, Expected=%d\n",
LogicalUnitDescriptor->Size,
sizeof(FILEDISK_DESCRIPTOR));
return STATUS_INVALID_PARAMETER;
}
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_FATAL,
"Initializing FileDisk Logical Unit\n");
fileDiskDescriptor = (PFILEDISK_DESCRIPTOR) LogicalUnitDescriptor;
fileDiskExtension->FileDiskFlags = fileDiskDescriptor->FileDiskFlags;
status = RtlStringCbLengthW(
fileDiskDescriptor->FilePath,
LogicalUnitDescriptor->Size - FIELD_OFFSET(FILEDISK_DESCRIPTOR, FilePath),
&dataFilePathLength);
if (!NT_SUCCESS(status))
{
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_FATAL,
"FileDiskDescriptor FilePath length is invalid. Status=%08X\n",
status);
return status;
}
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_INFORMATION,
"FilePath=%ws\n", fileDiskDescriptor->FilePath);
dataFilePathLength += sizeof(WCHAR); // additional NULL
fileDiskExtension->FilePath.Buffer = (PWSTR) ExAllocatePoolWithTag(
NonPagedPool,
dataFilePathLength,
FILEDISK_EXT_TAG);
if (NULL == fileDiskExtension->FilePath.Buffer)
{
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_WARNING,
"Memory allocation failed for data file path (%d bytes).\n",
dataFilePathLength);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlCopyMemory(
fileDiskExtension->FilePath.Buffer,
fileDiskDescriptor->FilePath,
dataFilePathLength);
fileDiskExtension->FilePath.Length = dataFilePathLength - sizeof(WCHAR);
fileDiskExtension->FilePath.MaximumLength = (USHORT)dataFilePathLength;
fileDiskExtension->LogicalUnitAddress = LogicalUnitDescriptor->Address.Address;
fileDiskExtension->LogicalBlockAddress.QuadPart = fileDiskDescriptor->LogicalBlockAddress.QuadPart;
fileDiskExtension->BytesPerBlock = fileDiskDescriptor->BytesPerBlock;
fileDiskExtension->ThreadShouldStop = FALSE;
KeInitializeEvent(
&fileDiskExtension->ThreadNotificationEvent,
NotificationEvent,
FALSE);
KeInitializeEvent(
&fileDiskExtension->ThreadCompleteEvent,
NotificationEvent,
FALSE);
FileDiskInitializeIoScsiCapabilities(fileDiskExtension);
FileDiskInitializeInquiryData(fileDiskExtension);
fileDiskExtension->StorageBusType = BusTypeScsi;
fileDiskExtension->StorageBusMajorVersion = 2;
fileDiskExtension->StorageBusMinorVersion = 0;
status = FileDiskCreateDataFile(
fileDiskExtension,
&fileDiskExtension->FilePath,
&newDataFileCreated);
if (!NT_SUCCESS(status))
{
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_WARNING,
"FileDiskCreateDataFile failed, Status=%08X\n",
status);
goto error1;
}
//
// For Windows 2000, PsCreateSystemThread should be called
// from the system process context.
//
if (IoIsWdmVersionAvailable(0x01, 0x20))
{
FileDiskCreateThreadWorkItemRoutine(NULL, fileDiskExtension);
}
else
{
PIO_WORKITEM workItem;
workItem = NdasPortExAllocateWorkItem(LogicalUnitExtension);
if (NULL == workItem)
{
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_WARNING,
"NdasPortExAllocateWorkItem failed with out of resource error.\n");
status = STATUS_INSUFFICIENT_RESOURCES;
goto error2;
}
IoQueueWorkItem(
workItem,
FileDiskCreateThreadWorkItemRoutine,
DelayedWorkQueue,
fileDiskExtension);
KeWaitForSingleObject(
&fileDiskExtension->ThreadCompleteEvent,
Executive,
KernelMode,
FALSE,
NULL);
IoFreeWorkItem(workItem);
}
if (!NT_SUCCESS(fileDiskExtension->ThreadStatus))
{
status = fileDiskExtension->ThreadStatus;
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_INFORMATION,
"FileDisk file creation failed, Status=%08X\n",
status);
goto error3;
}
NdasPortTrace(FILEDISK_INIT, TRACE_LEVEL_INFORMATION,
"FileDisk created successfully at LogicalUnitAddress=%08X.\n",
fileDiskExtension->LogicalUnitAddress);
return STATUS_SUCCESS;
error3:
error2:
FileDiskCloseDataFile(fileDiskExtension);
if (newDataFileCreated)
{
FileDiskDeleteDataFile(&fileDiskExtension->FilePath);
}
error1:
ExFreePoolWithTag(
fileDiskExtension->FilePath.Buffer,
FILEDISK_EXT_TAG);
fileDiskExtension->FilePath.Buffer = NULL;
fileDiskExtension->FilePath.Length = 0;
fileDiskExtension->FilePath.MaximumLength = 0;
return status;
}
BOOLEAN YtCheckPassword(
const WCHAR *Password,
size_t PasswordLength)
{
UCHAR Message_Digest[SHA1HashSize];
//Вычисляем хэш пароля
NTSTATUS status = YtCryptoComputeDigest(
(const BYTE *)Password,
PasswordLength * sizeof(WCHAR),
Message_Digest);
if (!NT_SUCCESS(status))
{
DebugPrint(("YtCheckPassword: YtCryptoComputeDigest failed.\n"));
return FALSE;
}
//Если хэш уже получен, то просто его сравниваем
if (HashInitialized)
{
if (RtlCompareMemory(Message_Digest, PasswordHash, SHA1HashSize) == SHA1HashSize)
{
return TRUE;
}
else
{
DebugPrint(("YtCheckPassword: hashes (init-d) are not equal.\n"));
return FALSE;
}
}
UCHAR ComputerID[YTDRV_COMPUTER_ID_SIZE]; //Идентификатор компьютера
//Получаем идентификатор компьютера
if (!YtGetComputerIdentifier(ComputerID))
{
return TRUE;
}
PDEVICE_OBJECT DeviceObject = YtDriverObject->DeviceObject;
//Проходим по всем устройствам драйвера
while (DeviceObject)
{
YtDeviceType *DeviceType = (YtDeviceType *)DeviceObject->DeviceExtension;
//Если тип устройства - не фильтр, то пропускаем
if (*DeviceType != ytFilterDevice)
{
DeviceObject = DeviceObject->NextDevice;
continue;
}
YT_DISK_CONFIG DiskConfig; //Структура конфига
//Читаем конфиг
if (!YtReadConfig(DeviceObject, &DiskConfig))
{
DeviceObject = DeviceObject->NextDevice;
continue;
}
//Сравниваем идентификатор компьютера в конфиге с текущим
//Если устройство не от этого компьютера - игнорируем
if (RtlCompareMemory(ComputerID, DiskConfig.ComputerID, YTDRV_COMPUTER_ID_SIZE) != YTDRV_COMPUTER_ID_SIZE)
{
DeviceObject = DeviceObject->NextDevice;
continue;
}
//Сохраняем хэш из конфига в глобальной переменной, чтобы потом не читать его заново
RtlCopyMemory(PasswordHash, DiskConfig.PasswordDigest, SHA1HashSize);
HashInitialized = TRUE;
DebugPrint(("YtCheckPassword: password hash loaded;.\n"));
//Сравниваем хэш пароля с правильных хэшем
if (RtlCompareMemory(Message_Digest, DiskConfig.PasswordDigest, SHA1HashSize) == SHA1HashSize)
{
return TRUE;
}
else
{
DebugPrint(("YtCheckPassword: hashes are not equal.\n"));
return FALSE;
}
}
size_t defPasswordBytesCount;
//Если не найдено ни одного подходящего устройства, то вычисляем хэш пароля по умолчанию
RtlStringCbLengthW(
YTDRV_DEFAULT_PASSWORD,
(YT_MAX_PWD_LEN + 1) * sizeof(WCHAR),
&defPasswordBytesCount);
status = YtCryptoComputeDigest(
(const BYTE *)YTDRV_DEFAULT_PASSWORD,
defPasswordBytesCount,
PasswordHash);
if (!NT_SUCCESS(status))
{
DebugPrint(("YtCheckPassword: YtCryptoComputeDigest of default password failed.\n"));
return FALSE;
}
HashInitialized = TRUE;
//Сверяем хэш пароля с хэшем пароля по умолчанию
if (RtlCompareMemory(Message_Digest, PasswordHash, SHA1HashSize) == SHA1HashSize)
{
return TRUE;
}
else
{
DebugPrint(("YtCheckPassword: hash against default password is not equal.\n"));
return FALSE;
}
}
