驱动开发：通过应用堆实现多次通信

news2024/11/18 9:45:14

在前面的文章《驱动开发：运用MDL映射实现多次通信》LyShark教大家使用MDL的方式灵活的实现了内核态多次输出结构体的效果，但是此种方法并不推荐大家使用原因很简单首先内核空间比较宝贵，其次内核里面不能分配太大且每次传出的结构体最大不能超过1024个，而最终这些内存由于无法得到更好的释放从而导致坏堆的产生，这样的程序显然是无法在生产环境中使用的，如下LyShark将教大家通过在应用层申请空间来实现同等效果，此类传递方式也是多数ARK反内核工具中最常采用的一种。

与MDL映射相反，MDL多数处理流程在内核代码中，而应用层开堆复杂代码则在应用层，但内核层中同样还是需要使用指针，只是这里的指针仅仅只是保留基本要素即可，通过EnumProcess()模拟枚举进程操作，传入的是PPROCESS_INFO进程指针转换，将数据传入到PPROCESS_INFO直接返回进程计数器即可。

// -------------------------------------------------
// R3传输结构体
// -------------------------------------------------

// 进程指针转换
typedef struct
{
  DWORD PID;
  DWORD PPID;
}PROCESS_INFO, *PPROCESS_INFO;

// 数据存储指针
typedef struct
{
  ULONG_PTR nSize;
  PVOID BufferPtr;
}BufferPointer, *pBufferPointer;

// 模拟进程枚举
ULONG EnumProcess(PPROCESS_INFO pBuffer)
{
  ULONG nCount = 0;

  for (size_t i = 0; i < 10; i++)
  {
    pBuffer[i].PID = nCount * 2;
    pBuffer[i].PPID = nCount * 4;

    nCount = nCount + 1;
  }
  return nCount;
}

内核层核心代码： 内核代码中是如何通信的，首先从用户态接收pIoBuffer到分配的缓冲区数据，并转换为pBufferPointer结构，ProbeForWrite用于检查地址是否可写入，接着会调用EnumProcess()注意传入的其实是应用层的指针，枚举进程结束后，将进程数量nCount通过*(PULONG)pIrp->AssociatedIrp.SystemBuffer = (ULONG)nCount回传给应用层，至此内核中仅仅回传了一个长度，其他的都写入到了应用层中。

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

pBufferPointer pinp = (pBufferPointer)pIoBuffer;

__try
{
  DbgPrint("缓冲区长度: %d \n", pinp->nSize);
  DbgPrint("缓冲区基地址: %p \n", pinp->BufferPtr);

  // 检查地址是否可写入
  ProbeForWrite(pinp->BufferPtr, pinp->nSize, 1);

  ULONG nCount = EnumProcess((PPROCESS_INFO)pinp->BufferPtr);
  DbgPrint("进程计数 = %d \n", nCount);
  if (nCount > 0)
  {
    // 将进程数返回给用户
    *(PULONG)pIrp->AssociatedIrp.SystemBuffer = (ULONG)nCount;
    status = STATUS_SUCCESS;
  }
}
__except (1)
{
  status = GetExceptionCode();
  DbgPrint("IOCTL_GET_EPROCESS %x \n", status);
}

// 返回通信状态
status = STATUS_SUCCESS;
break;

应用层核心代码： 通信的重点在于应用层，首先定义BufferPointer用于存放缓冲区头部指针，定义PPROCESS_INFO则是用于后期将数据放入该容器内，函数HeapAlloc分配一段堆空间，并HEAP_ZERO_MEMORY将该堆空间全部填空，将这一段初始化后的空间放入到pInput.BufferPtr缓冲区内，并计算出长度放入到pInput.nSize缓冲区内，一切准备就绪之后，再通过DriveControl.IoControl将BufferPointer结构传输至内核中，而bRet则是用于接收返回长度的变量。

当收到数据后，通过(PPROCESS_INFO)pInput.BufferPtr强制转换为指针类型，并依次pProcessInfo[i]读出每一个节点的元素，最后是调用HeapFree释放掉这段堆空间。至于输出就很简单了vectorProcess[x].PID循环容器元素即可。

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

// 应用层数据结构体数据
BOOL bRet = FALSE;
BufferPointer pInput = { 0 };
PPROCESS_INFO pProcessInfo = NULL;

// 分配堆空间
pInput.BufferPtr = (PVOID)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PROCESS_INFO) * 1000);
pInput.nSize = sizeof(PROCESS_INFO) * 1000;

ULONG nRet = 0;

if (pInput.BufferPtr)
{
  bRet = DriveControl.IoControl(IOCTL_IO_R3StructAll, &pInput, sizeof(BufferPointer), &nRet, sizeof(ULONG), 0);
}

std::cout << "返回结构体数量: " << nRet << std::endl;

if (bRet && nRet > 0)
{
  pProcessInfo = (PPROCESS_INFO)pInput.BufferPtr;
  std::vector<PROCESS_INFO> vectorProcess;

  for (ULONG i = 0; i < nRet; i++)
  {
    vectorProcess.push_back(pProcessInfo[i]);
  }

  // 释放空间
  bRet = HeapFree(GetProcessHeap(), 0, pInput.BufferPtr);
  std::cout << "释放状态: " << bRet << std::endl;

  // 输出容器内的进程ID列表
  for (int x = 0; x < nRet; x++)
  {
    std::cout << "PID: " << vectorProcess[x].PID << " PPID: " << vectorProcess[x].PPID << std::endl;
  }
}

// 关闭符号链接句柄
CloseHandle(DriveControl.m_hDriver);

如上就是内核层与应用层的部分代码功能分析，接下来我将完整代码分享出来，大家可以自行测试效果。

驱动程序WinDDK.sys完整代码；

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#define _CRT_SECURE_NO_WARNINGS
#include <ntifs.h>
#include <windef.h>

// 定义符号链接，一般来说修改为驱动的名字即可
#define DEVICE_NAME        L"\\Device\\WinDDK"
#define LINK_NAME          L"\\DosDevices\\WinDDK"
#define LINK_GLOBAL_NAME   L"\\DosDevices\\Global\\WinDDK"

// 定义驱动功能号和名字，提供接口给应用程序调用
#define IOCTL_IO_R3StructAll    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x806, METHOD_BUFFERED, FILE_ANY_ACCESS)

// 保存一段非分页内存,用于给全局变量使用
#define FILE_DEVICE_EXTENSION 4096

// -------------------------------------------------
// R3传输结构体
// -------------------------------------------------

// 进程指针转换
typedef struct
{
	DWORD PID;
	DWORD PPID;
}PROCESS_INFO, *PPROCESS_INFO;

// 数据存储指针
typedef struct
{
	ULONG_PTR nSize;
	PVOID BufferPtr;
}BufferPointer, *pBufferPointer;

// 模拟进程枚举
ULONG EnumProcess(PPROCESS_INFO pBuffer)
{
	ULONG nCount = 0;

	for (size_t i = 0; i < 10; i++)
	{
		pBuffer[i].PID = nCount * 2;
		pBuffer[i].PPID = nCount * 4;

		nCount = nCount + 1;
	}
	return nCount;
}

// 驱动绑定默认派遣函数
NTSTATUS DefaultDispatch(PDEVICE_OBJECT _pDeviceObject, PIRP _pIrp)
{
	_pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
	_pIrp->IoStatus.Information = 0;
	IoCompleteRequest(_pIrp, IO_NO_INCREMENT);
	return _pIrp->IoStatus.Status;
}

// 驱动卸载的处理例程
VOID DriverUnload(PDRIVER_OBJECT pDriverObj)
{
	if (pDriverObj->DeviceObject)
	{
		UNICODE_STRING strLink;

		// 删除符号连接和设备
		RtlInitUnicodeString(&strLink, LINK_NAME);
		IoDeleteSymbolicLink(&strLink);
		IoDeleteDevice(pDriverObj->DeviceObject);
		DbgPrint("[kernel] # 驱动已卸载 \n");
	}
}

// IRP_MJ_CREATE 对应的处理例程，一般不用管它
NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	DbgPrint("[kernel] # 驱动处理例程载入 \n");
	pIrp->IoStatus.Status = STATUS_SUCCESS;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}

// IRP_MJ_CLOSE 对应的处理例程，一般不用管它
NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	DbgPrint("[kernel] # 关闭派遣 \n");
	pIrp->IoStatus.Status = STATUS_SUCCESS;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}

// IRP_MJ_DEVICE_CONTROL 对应的处理例程，驱动最重要的函数
NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
	NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
	PIO_STACK_LOCATION pIrpStack;
	ULONG uIoControlCode;
	PVOID pIoBuffer;
	ULONG uInSize;
	ULONG uOutSize;

	// 获得IRP里的关键数据
	pIrpStack = IoGetCurrentIrpStackLocation(pIrp);

	// 获取控制码
	uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;

	// 输入和输出的缓冲区（DeviceIoControl的InBuffer和OutBuffer都是它）
	pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;

	// EXE发送传入数据的BUFFER长度（DeviceIoControl的nInBufferSize）
	uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;

	// EXE接收传出数据的BUFFER长度（DeviceIoControl的nOutBufferSize）
	uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;

	// 对不同控制信号的处理流程
	switch (uIoControlCode)
	{
	// 测试R3传输多次结构体
	case IOCTL_IO_R3StructAll:
	{
		pBufferPointer pinp = (pBufferPointer)pIoBuffer;

		__try
		{
			DbgPrint("[lyshark] 缓冲区长度: %d \n", pinp->nSize);
			DbgPrint("[lyshark] 缓冲区基地址: %p \n", pinp->BufferPtr);

			// 检查地址是否可写入
			ProbeForWrite(pinp->BufferPtr, pinp->nSize, 1);

			ULONG nCount = EnumProcess((PPROCESS_INFO)pinp->BufferPtr);
			DbgPrint("[lyshark.com] 进程计数 = %d \n", nCount);
			if (nCount > 0)
			{
				// 将进程数返回给用户
				*(PULONG)pIrp->AssociatedIrp.SystemBuffer = (ULONG)nCount;
				status = STATUS_SUCCESS;
			}
		}
		__except (1)
		{
			status = GetExceptionCode();
			DbgPrint("IOCTL_GET_EPROCESS %x \n", status);
		}

		// 返回通信状态
		status = STATUS_SUCCESS;
		break;
	}
	}

	// 设定DeviceIoControl的*lpBytesReturned的值（如果通信失败则返回0长度）
	if (status == STATUS_SUCCESS)
	{
		pIrp->IoStatus.Information = uOutSize;
	}
	else
	{
		pIrp->IoStatus.Information = 0;
	}

	// 设定DeviceIoControl的返回值是成功还是失败
	pIrp->IoStatus.Status = status;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
	return status;
}

// 驱动的初始化工作
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
	NTSTATUS status = STATUS_SUCCESS;
	UNICODE_STRING ustrLinkName;
	UNICODE_STRING ustrDevName;
	PDEVICE_OBJECT pDevObj;

	// 初始化其他派遣
	for (ULONG i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
	{
		// DbgPrint("初始化派遣: %d \n", i);
		pDriverObj->MajorFunction[i] = DefaultDispatch;
	}

	// 设置分发函数和卸载例程
	pDriverObj->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
	pDriverObj->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
	pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
	pDriverObj->DriverUnload = DriverUnload;

	// 创建一个设备
	RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);

	// FILE_DEVICE_EXTENSION 创建设备时，指定设备扩展内存的大小，传一个值进去，就会给设备分配一块非页面内存。
	status = IoCreateDevice(pDriverObj, sizeof(FILE_DEVICE_EXTENSION), &ustrDevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDevObj);
	if (!NT_SUCCESS(status))
	{
		return status;
	}

	// 判断支持的WDM版本，其实这个已经不需要了，纯属WIN9X和WINNT并存时代的残留物
	if (IoIsWdmVersionAvailable(1, 0x10))
	{
		RtlInitUnicodeString(&ustrLinkName, LINK_GLOBAL_NAME);
	}
	else
	{
		RtlInitUnicodeString(&ustrLinkName, LINK_NAME);
	}

	// 创建符号连接
	status = IoCreateSymbolicLink(&ustrLinkName, &ustrDevName);
	if (!NT_SUCCESS(status))
	{
		DbgPrint("创建符号链接失败 \n");
		IoDeleteDevice(pDevObj);
		return status;
	}
	DbgPrint("[hello LyShark.com] # 驱动初始化完毕 \n");

	// 返回加载驱动的状态（如果返回失败，驱动讲被清除出内核空间）
	return STATUS_SUCCESS;
}

应用层客户端程序lyshark.exe完整代码；

// 署名权
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com

#include <iostream>
#include <Windows.h>
#include <vector>

#pragma comment(lib,"user32.lib")
#pragma comment(lib,"advapi32.lib")

// 定义驱动功能号和名字，提供接口给应用程序调用
#define IOCTL_IO_R3StructAll    0x806

class cDrvCtrl
{
public:
	cDrvCtrl()
	{
		m_pSysPath = NULL;
		m_pServiceName = NULL;
		m_pDisplayName = NULL;
		m_hSCManager = NULL;
		m_hService = NULL;
		m_hDriver = INVALID_HANDLE_VALUE;
	}
	~cDrvCtrl()
	{
		CloseServiceHandle(m_hService);
		CloseServiceHandle(m_hSCManager);
		CloseHandle(m_hDriver);
	}

	// 安装驱动
	BOOL Install(PCHAR pSysPath, PCHAR pServiceName, PCHAR pDisplayName)
	{
		m_pSysPath = pSysPath;
		m_pServiceName = pServiceName;
		m_pDisplayName = pDisplayName;
		m_hSCManager = OpenSCManagerA(NULL, NULL, SC_MANAGER_ALL_ACCESS);
		if (NULL == m_hSCManager)
		{
			m_dwLastError = GetLastError();
			return FALSE;
		}
		m_hService = CreateServiceA(m_hSCManager, m_pServiceName, m_pDisplayName,
			SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
			m_pSysPath, NULL, NULL, NULL, NULL, NULL);
		if (NULL == m_hService)
		{
			m_dwLastError = GetLastError();
			if (ERROR_SERVICE_EXISTS == m_dwLastError)
			{
				m_hService = OpenServiceA(m_hSCManager, m_pServiceName, SERVICE_ALL_ACCESS);
				if (NULL == m_hService)
				{
					CloseServiceHandle(m_hSCManager);
					return FALSE;
				}
			}
			else
			{
				CloseServiceHandle(m_hSCManager);
				return FALSE;
			}
		}
		return TRUE;
	}

	// 启动驱动
	BOOL Start()
	{
		if (!StartServiceA(m_hService, NULL, NULL))
		{
			m_dwLastError = GetLastError();
			return FALSE;
		}
		return TRUE;
	}

	// 关闭驱动
	BOOL Stop()
	{
		SERVICE_STATUS ss;
		GetSvcHandle(m_pServiceName);
		if (!ControlService(m_hService, SERVICE_CONTROL_STOP, &ss))
		{
			m_dwLastError = GetLastError();
			return FALSE;
		}
		return TRUE;
	}

	// 移除驱动
	BOOL Remove()
	{
		GetSvcHandle(m_pServiceName);
		if (!DeleteService(m_hService))
		{
			m_dwLastError = GetLastError();
			return FALSE;
		}
		return TRUE;
	}

	// 打开驱动
	BOOL Open(PCHAR pLinkName)
	{
		if (m_hDriver != INVALID_HANDLE_VALUE)
			return TRUE;
		m_hDriver = CreateFileA(pLinkName, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
		if (m_hDriver != INVALID_HANDLE_VALUE)
			return TRUE;
		else
			return FALSE;
	}

	// 发送控制信号
	BOOL IoControl(DWORD dwIoCode, PVOID InBuff, DWORD InBuffLen, PVOID OutBuff, DWORD OutBuffLen, DWORD *RealRetBytes)
	{
		DWORD dw;
		BOOL b = DeviceIoControl(m_hDriver, CTL_CODE_GEN(dwIoCode), InBuff, InBuffLen, OutBuff, OutBuffLen, &dw, NULL);
		if (RealRetBytes)
			*RealRetBytes = dw;
		return b;
	}
private:

	// 获取服务句柄
	BOOL GetSvcHandle(PCHAR pServiceName)
	{
		m_pServiceName = pServiceName;
		m_hSCManager = OpenSCManagerA(NULL, NULL, SC_MANAGER_ALL_ACCESS);
		if (NULL == m_hSCManager)
		{
			m_dwLastError = GetLastError();
			return FALSE;
		}
		m_hService = OpenServiceA(m_hSCManager, m_pServiceName, SERVICE_ALL_ACCESS);
		if (NULL == m_hService)
		{
			CloseServiceHandle(m_hSCManager);
			return FALSE;
		}
		else
		{
			return TRUE;
		}
	}

	// 获取控制信号对应字符串
	DWORD CTL_CODE_GEN(DWORD lngFunction)
	{
		return (FILE_DEVICE_UNKNOWN * 65536) | (FILE_ANY_ACCESS * 16384) | (lngFunction * 4) | METHOD_BUFFERED;
	}

public:
	DWORD m_dwLastError;
	PCHAR m_pSysPath;
	PCHAR m_pServiceName;
	PCHAR m_pDisplayName;
	HANDLE m_hDriver;
	SC_HANDLE m_hSCManager;
	SC_HANDLE m_hService;
};

void GetAppPath(char *szCurFile)
{
	GetModuleFileNameA(0, szCurFile, MAX_PATH);
	for (SIZE_T i = strlen(szCurFile) - 1; i >= 0; i--)
	{
		if (szCurFile[i] == '\\')
		{
			szCurFile[i + 1] = '\0';
			break;
		}
	}
}

// -------------------------------------------------
// R3数据传递变量
// -------------------------------------------------
// 进程指针转换
typedef struct
{
	DWORD PID;
	DWORD PPID;
}PROCESS_INFO, *PPROCESS_INFO;

// 数据存储指针
typedef struct
{
	ULONG_PTR nSize;
	PVOID BufferPtr;
}BufferPointer, *pBufferPointer;

int main(int argc, char *argv[])
{
	cDrvCtrl DriveControl;

	// 设置驱动名称
	char szSysFile[MAX_PATH] = { 0 };
	char szSvcLnkName[] = "WinDDK";;
	GetAppPath(szSysFile);
	strcat(szSysFile, "WinDDK.sys");

	// 安装并启动驱动
	DriveControl.Install(szSysFile, szSvcLnkName, szSvcLnkName);
	DriveControl.Start();

	// 打开驱动的符号链接
	DriveControl.Open("\\\\.\\WinDDK");

	// 应用层数据结构体数据
	BOOL bRet = FALSE;
	BufferPointer pInput = { 0 };
	PPROCESS_INFO pProcessInfo = NULL;

	// 分配堆空间
	pInput.BufferPtr = (PVOID)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PROCESS_INFO) * 1000);
	pInput.nSize = sizeof(PROCESS_INFO) * 1000;

	ULONG nRet = 0;

	if (pInput.BufferPtr)
	{
		bRet = DriveControl.IoControl(IOCTL_IO_R3StructAll, &pInput, sizeof(BufferPointer), &nRet, sizeof(ULONG), 0);
	}

	std::cout << "[LyShark.com] 返回结构体数量: " << nRet << std::endl;

	if (bRet && nRet > 0)
	{
		pProcessInfo = (PPROCESS_INFO)pInput.BufferPtr;
		std::vector<PROCESS_INFO> vectorProcess;

		for (ULONG i = 0; i < nRet; i++)
		{
			vectorProcess.push_back(pProcessInfo[i]);
		}

		// 释放空间
		bRet = HeapFree(GetProcessHeap(), 0, pInput.BufferPtr);
		std::cout << "释放状态: " << bRet << std::endl;

		// 输出容器内的进程ID列表
		for (int x = 0; x < nRet; x++)
		{
			std::cout << "PID: " << vectorProcess[x].PID << " PPID: " << vectorProcess[x].PPID << std::endl;
		}
	}

	// 关闭符号链接句柄
	CloseHandle(DriveControl.m_hDriver);

	// 停止并卸载驱动
	DriveControl.Stop();
	DriveControl.Remove();

	system("pause");
	return 0;
}

手动编译这两个程序，将驱动签名后以管理员身份运行lyshark.exe客户端，此时屏幕中即可看到滚动输出效果，如此一来就实现了循环传递参数的目的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/543583.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

jvm之GC

jvm之GC

写在前面 本文一起看下GC相关的内容。 1&#xff1a;GC基础内容 1.1&#xff1a;为什么要有GC 内存资源的稀缺性&#xff0c;以及内存管理的复杂性&#xff0c;决定了需要有垃圾回收器这样的角色来帮助我们管理内存资源&#xff0c;避免手动管理带来的内存不能得到正常释放…
阅读更多...
普源DS1102Z-E示波器，100MHz带宽

普源DS1102Z-E示波器，100MHz带宽

DS1000Z-E系列数字示波器是RIGOL基于主流需求而设计的&#xff0c;电商专供款高性能经济型数字示波器,具备100MHz带宽和1GSa/s采样率&#xff0c;搭载RIGOL独创的UltraVision技术平台&#xff0c;更深的储存&#xff08;标配达24 Mpts&#xff09;&#xff0c;高达30,000 wfms/…
阅读更多...
解决基于kvm的win10虚拟机只识别2个cpu的问题

解决基于kvm的win10虚拟机只识别2个cpu的问题

在使用kvmqemu创建win10虚拟机的时候&#xff0c;发现尽管我在virt manager里面指定了72个vcpu&#xff0c;但是win10里面只识别2个cpu核心的现象。 如图所示&#xff1a; 虚拟系统管理器里面当时是这样设置的&#xff1a; 这个时候&#xff0c;对应的xml文件内&#xff0c;关…
阅读更多...
【深度学习】离线安装Python及相关第三方库

【深度学习】离线安装Python及相关第三方库

如果对方电脑无法联网。 那么需要在可以联网的电脑上进行如下操作&#xff0c;随后将整个文件包传输到对方电脑&#xff0c;实现环境配置。 Python 先给离线电脑安装Python初始环境 https://www.python.org/downloads/ 这里我选择下载了Python3.7.8 https://www.python.org…
阅读更多...
如何用python在微信公众号上添加自己的ChatGPT

如何用python在微信公众号上添加自己的ChatGPT

由于之前chatgpt的火热&#xff0c;现在很多微信公众号都接入了chatgpt的接口&#xff0c;来给自家公众号增添一丝乐趣&#xff0c;下面我以自己的经验&#xff0c;用python在微信公众上添加自己的chatGPT&#xff0c;先看下方成果图 三步曲 申请自己的公众号部署服务接入chat…
阅读更多...
如何用国产DBDesginer软件进行数据库建模设计？

如何用国产DBDesginer软件进行数据库建模设计？

我们在开发软件系统之前都需要进行数据结构的建模设计&#xff0c;传统的都是通过PowerDesiger等国外的软件或直接Excel来进行数据库表结构设计&#xff0c;今天来了解一下如何使用国产软件来进行数据库建模设计 1、首先是注册DBDesigner用户&#xff08; http://dbdesigner.n…
阅读更多...
用蹩脚英语在StackOverflow上飞奔:如何在一个RestApi接口中调用另一个RestApi文件接口发送上传文件请求

用蹩脚英语在StackOverflow上飞奔:如何在一个RestApi接口中调用另一个RestApi文件接口发送上传文件请求

上班摸鱼、下班干活&#xff0c;日常埋坑、加班填坑——这是我的搬砖&#xff0c;亦是在座的各位&#xff01; 昨天在StackOverflow上面闲逛&#xff0c;突然看到一个国际友人提出了一个问题&#xff0c;他发出了好久都没有人来回答&#xff0c;本着在下为人处世乐善好施、广结…
阅读更多...
视频flv怎么转换成mp4格式？

视频flv怎么转换成mp4格式？

视频flv怎么转换成mp4格式&#xff1f;关于视频格式转换这个问题&#xff0c;小编发现&#xff0c;就算不是从事视频编辑的朋友也有可能经常会遇到这种转换操作&#xff0c;为什么会这样呢&#xff1f;原因主要是因为视频格式的种类真的非常多&#xff0c;多到我们数不清&#…
阅读更多...
软件测试之自动化测试

软件测试之自动化测试

目录 一、初试自动化测试 1.自动化测试的分类&#xff08;简单了解&#xff09; 2.如何实施自动化单元测试 二、selenium 介绍&#xff08;重点内容&#xff09; 1.工作原理 2.Selenium 环境搭建 2.1 Chrome java 2.2 常见问题及解决方案 1.元素的定位 1.1 CSS 定位…
阅读更多...
sonarqube分析仓库

sonarqube分析仓库

sonarqube可以有多种方式分析仓库 使用GitlabCI 设置项目编码 添加环境变量 创建或修改配置文件 sonarqube-check:image: name: sonarsource/sonar-scanner-cli:latestentrypoint: [""]variables:SONAR_USER_HOME: "${CI_PROJECT_DIR}/.sonar" # Defi…
阅读更多...
GE H201Ci-1 单通道变压器控制单元

GE H201Ci-1 单通道变压器控制单元

HYDRAN 201Ci-1一个标准模拟输出通道控制器非隔离&#xff0c;跳线可配置为0-l mA 一个遥控电子控制器或4-20 mA&#xff08;最大输出10 V&#xff09;、0-1 V或0-10 V&#xff1b;0-2000 ppm范围 HYDRANR 201Ti智能变送器&#xff1b;它提供网络通信能力 第二个可选模拟输出加…
阅读更多...
基于Web的智慧产业园区3D可视化运营管理平台

基于Web的智慧产业园区3D可视化运营管理平台

改革开放以来&#xff0c;园区逐渐成为地区招商引资、储备人才的重要途径。我国社会、经济处于快速发展阶段&#xff0c;园区正向着智慧化、创、科技化转变。 建设背景 在人类的历史发展过程中&#xff0c;随着5G、人工智能、云计算、物联网、GIS等新一轮信息技术的迅速发展&…
阅读更多...
Jenkins流水线整合k8s实现代码自动集成和部署

Jenkins流水线整合k8s实现代码自动集成和部署

一、前置条件 1、安装好k8s集群 这里先要搭建好一个K8s集群&#xff0c;笔者这边就采用使用了一个一主一丛的k8s集群&#xff0c;k8s集群的版本使用1.19.5版本&#xff0c;服务器的配置&#xff1a;2核4G&#xff0c;操作系统: CentOS Linux release 7.9.2009 (Core) 主机名…
阅读更多...
Rabbitmq 下载与安装

Rabbitmq 下载与安装

文章目录 说明1、下载Erlan2、下载对应的rabbitmq 说明 Rabbitmq依赖于Erlan 对应版本查看&#xff1a;https://www.rabbitmq.com/which-erlang.html 这里版本使用&#xff1a; Rabbitmq 3.9.11 Erlan 24.1.7 1、下载Erlan https://www.erlang.org/patches/otp-24.1.7 安装完…
阅读更多...
matlab代码复现：室内定位、无线传感器网路定位、估计优化滤波等探讨及技术支持

matlab代码复现：室内定位、无线传感器网路定位、估计优化滤波等探讨及技术支持

室内外定位导航、无线传感器网路定位、估计优化滤波等探讨及技术支持 博主主要擅长以下几个方面&#xff0c;探讨、技术支持、代码复现等问题欢迎联系&#xff0c;也可以站内私信 weixin: ZB823618313&#xff08;备注来意&#xff09; 1. 估计\滤波\融合 1 各种参数估计算法…
阅读更多...
ChatGPT智能聊天系统1.0.3版本发布啦~

ChatGPT智能聊天系统1.0.3版本发布啦~

ChatGPT智能聊天系统1.0.3版本啦&#xff01;主要更新内容如下&#xff1a; 新增功能 获取微信昵称 支付宝支付 PC端允许退出登录 PC端创作和技能支持关键词搜索 分享记录添加今日分享统计 邀请记录添加今日邀请和今日发放统计 细节优化 模型对话框去掉快递发送功能 后…
阅读更多...
bioinformatics2022 | Sc2Mol+：使用VAE和Transformer的两阶段基于骨架的分子生成

bioinformatics2022 | Sc2Mol+：使用VAE和Transformer的两阶段基于骨架的分子生成

原文标题&#xff1a;Sc2Mol&#xff1a;a scaffold-based two-step molecule generator with variational autoencoder and transformer 论文地址&#xff1a;Sc2Mol: a scaffold-based two-step molecule generator with variational autoencoder and transformer | Bioinfo…
阅读更多...
3 分钟利用 FastGPT 和 Laf 将 ChatGPT 接入企业微信

3 分钟利用 FastGPT 和 Laf 将 ChatGPT 接入企业微信

原文链接&#xff1a;https://forum.laf.run/d/556 FastGPT 是一个超级&#x1f42e;&#x1f37a;的 ChatGPT 平台项目&#xff0c;功能非常强大&#xff1a; ✅ 集成了 ChatGPT、GPT4 和 Claude ✅ 可以使用任意文本来训练自己的知识库、文档库&#xff0c;而且知识库专有模…
阅读更多...
无人值守的IDC机房动环综合运维方案

无人值守的IDC机房动环综合运维方案

企业数字化转型以及5G、物联网、云计算、人工智能等新业态带动了数据中心的发展&#xff0c;在国家一体化大数据中心及“东数西算”节点布局的推动下&#xff0c;数据中心机房已成为各大企事业单位维持业务正常运营的重要组成部分&#xff0c;网络设备、系统、业务应用数量与日…
阅读更多...
16-01 云平台分类和思考

16-01 云平台分类和思考

云环境的分类 混合云 为什么选择混合云 混合云网络互联 入口层分流 CDN内容分发网络 CDN工作原理 Captcha图灵测试 SLB软件负载均衡器 SDN&#xff1a;软件定义网络网络层次&#xff1a;通用网络&#xff08;2-4层&#xff09;和HTTP&#xff08;5-7层&#xff09;多种实现…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023