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; } }