首页 / C++ / C++检测句柄的权限

C++检测句柄的权限

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++检测句柄的权限，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8137字，纯文字阅读大概需要12分钟。

内容图文

主要是依靠NtQueryObject函数，其中需要传入ObjectBasicInformation参数

PUBLIC_OBJECT_BASIC_INFORMATION结构包含可用于对象的全部信息的子集。

typedef struct _PUBLIC_OBJECT_BASIC_INFORMATION {
  ULONG       Attributes;
  ACCESS_MASK GrantedAccess; //指定一个掩码，该掩码代表对对象的授予访问权限
  ULONG       HandleCount;
  ULONG       PointerCount;
  ULONG       Reserved[10];
} PUBLIC_OBJECT_BASIC_INFORMATION, *PPUBLIC_OBJECT_BASIC_INFORMATION;

Demo:

#include <iostream>
#include <string>

#include <Windows.h>
#include <TlHelp32.h>
#include <Psapi.h>
#include <Shlwapi.h>

usingnamespace std;

#pragma comment(lib, "shlwapi.lib")
#pragma comment(lib, "psapi.lib")

#pragma region NT Structures

#define NT_SUCCESS(x) ((x) >= 0)
#define STATUS_INFO_LENGTH_MISMATCH 0xc0000004

#define SystemHandleInformation 16
#define ObjectBasicInformation 0
#define ObjectNameInformation 1
#define ObjectTypeInformation 2

typedef struct _PUBLIC_OBJECT_BASIC_INFORMATION {
    ULONG Attributes;
    ACCESS_MASK GrantedAccess;
    ULONG HandleCount;
    ULONG PointerCount;
    ULONG Reserved[10];    // reserved for internal use
} PUBLIC_OBJECT_BASIC_INFORMATION, *PPUBLIC_OBJECT_BASIC_INFORMATION;

typedef NTSTATUS(NTAPI *_NtQuerySystemInformation)(
    ULONG SystemInformationClass,
    PVOID SystemInformation,
    ULONG SystemInformationLength,
    PULONG ReturnLength
    );
typedef NTSTATUS(NTAPI *_NtDuplicateObject)(
    HANDLE SourceProcessHandle,
    HANDLE SourceHandle,
    HANDLE TargetProcessHandle,
    PHANDLE TargetHandle,
    ACCESS_MASK DesiredAccess,
    ULONG Attributes,
    ULONG Options
    );
typedef NTSTATUS(NTAPI *_NtQueryObject)(
    HANDLE ObjectHandle,
    ULONG ObjectInformationClass,
    PVOID ObjectInformation,
    ULONG ObjectInformationLength,
    PULONG ReturnLength
    );

typedef struct _UNICODE_STRING
{
    USHORT Length;
    USHORT MaximumLength;
    PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

typedef struct _SYSTEM_HANDLE
{
    ULONG ProcessId;
    BYTE ObjectTypeNumber;
    BYTE Flags;
    USHORT Handle;
    PVOID Object;
    ACCESS_MASK GrantedAccess;
} SYSTEM_HANDLE, *PSYSTEM_HANDLE;

typedef struct _SYSTEM_HANDLE_INFORMATION
{
    ULONG HandleCount;
    SYSTEM_HANDLE Handles[1];
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;

typedef enum _POOL_TYPE
{
    NonPagedPool,
    PagedPool,
    NonPagedPoolMustSucceed,
    DontUseThisType,
    NonPagedPoolCacheAligned,
    PagedPoolCacheAligned,
    NonPagedPoolCacheAlignedMustS
} POOL_TYPE, *PPOOL_TYPE;

typedef struct _OBJECT_TYPE_INFORMATION
{
    UNICODE_STRING Name;
    ULONG TotalNumberOfObjects;
    ULONG TotalNumberOfHandles;
    ULONG TotalPagedPoolUsage;
    ULONG TotalNonPagedPoolUsage;
    ULONG TotalNamePoolUsage;
    ULONG TotalHandleTableUsage;
    ULONG HighWaterNumberOfObjects;
    ULONG HighWaterNumberOfHandles;
    ULONG HighWaterPagedPoolUsage;
    ULONG HighWaterNonPagedPoolUsage;
    ULONG HighWaterNamePoolUsage;
    ULONG HighWaterHandleTableUsage;
    ULONG InvalidAttributes;
    GENERIC_MAPPING GenericMapping;
    ULONG ValidAccess;
    BOOLEAN SecurityRequired;
    BOOLEAN MaintainHandleCount;
    USHORT MaintainTypeList;
    POOL_TYPE PoolType;
    ULONG PagedPoolUsage;
    ULONG NonPagedPoolUsage;
} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;

#pragma endregion

// for getting an address of a procedure in memory.PVOID GetLibraryProcAddress(PSTR LibraryName, PSTR ProcName)
{
    return GetProcAddress(GetModuleHandleA(LibraryName), ProcName);
}

DWORD FindProcessId(const std::string processName)
{
    PROCESSENTRY32 processInfo;
    processInfo.dwSize = sizeof(processInfo);

    HANDLE processSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    if (processSnapshot == INVALID_HANDLE_VALUE)
        return0;

    Process32First(processSnapshot, &processInfo);
    if (!processName.compare(processInfo.szExeFile))
    {
        CloseHandle(processSnapshot);
        return processInfo.th32ProcessID;
    }

    while (Process32Next(processSnapshot, &processInfo))
    {
        if (!processName.compare(processInfo.szExeFile))
        {
            CloseHandle(processSnapshot);
            return processInfo.th32ProcessID;
        }
    }

    CloseHandle(processSnapshot);
    return0;
}


int main()
{
    while (1)
    {
    /*    string input;
        cout << "Please enter a name of a process: ";
        cin >> input;*/

        DWORD pid  = 0;
        _NtQuerySystemInformation NtQuerySystemInformation =
            (_NtQuerySystemInformation)GetLibraryProcAddress(const_cast<char*>("ntdll.dll"), const_cast<char*>("NtQuerySystemInformation"));
        _NtDuplicateObject NtDuplicateObject =
            (_NtDuplicateObject)GetLibraryProcAddress(const_cast<char*>("ntdll.dll"), const_cast<char*>("NtDuplicateObject"));
        _NtQueryObject NtQueryObject =
            (_NtQueryObject)GetLibraryProcAddress(const_cast<char*>("ntdll.dll"), const_cast<char*>("NtQueryObject"));

        NTSTATUS status;
        PSYSTEM_HANDLE_INFORMATION handleInfo;
        ULONG handleInfoSize = 0x10000;
        HANDLE processHandle;
        ULONG i;

        processHandle = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);

        handleInfo = (PSYSTEM_HANDLE_INFORMATION)malloc(handleInfoSize);

        while ((status = NtQuerySystemInformation(SystemHandleInformation, handleInfo, handleInfoSize, NULL)) == STATUS_INFO_LENGTH_MISMATCH)
            handleInfo = (PSYSTEM_HANDLE_INFORMATION)realloc(handleInfo, handleInfoSize *= 2);

        for (i = 0; i < handleInfo->HandleCount; i++)
        {
            SYSTEM_HANDLE handle = handleInfo->Handles[i];
            HANDLE dupHandle = NULL;
            POBJECT_TYPE_INFORMATION objectTypeInfo;
            PVOID objectNameInfo;
            UNICODE_STRING objectName;
            ULONG returnLength;

            /*if (handle.ProcessId != pid)
                continue;*/

            NT_SUCCESS(NtDuplicateObject(processHandle, (HANDLE)handle.Handle, GetCurrentProcess(), &dupHandle, 0, 0, 0));
            PUBLIC_OBJECT_BASIC_INFORMATION pb;
            STARTUPINFO si;
            PROCESS_INFORMATION pi;
            ZeroMemory(&pb, sizeof(pb));

            ZeroMemory(&si, sizeof(si));
            si.cb = sizeof(si);
            ZeroMemory(&pi, sizeof(pi));
            CreateProcess(NULL, const_cast<char*>("C:\\WINDOWS\\system32\\calc.exe"), NULL, NULL, FALSE, CREATE_BREAKAWAY_FROM_JOB, NULL, NULL, &si, &pi);

            objectTypeInfo = (POBJECT_TYPE_INFORMATION)malloc(0x1000);
            NTSTATUS err_1 = NtQueryObject(pi.hProcess, ObjectBasicInformation, &pb, sizeof(pb), NULL);

            DWORD access = pb.GrantedAccess;
            if (handle.GrantedAccess == 0x0012019f)
            {
                std::free(objectTypeInfo);
                CloseHandle(dupHandle);
                continue;
            }


            objectNameInfo = malloc(0x1000);



            if (!NT_SUCCESS(NtQueryObject(pi.hProcess, ObjectNameInformation, objectNameInfo, 0x1000, &returnLength)))
            {
                objectNameInfo = realloc(objectNameInfo, returnLength);
                if (!NT_SUCCESS(NtQueryObject(
                    dupHandle,
                    ObjectNameInformation,
                    objectNameInfo,
                    returnLength,
                    NULL
                )))
                {
                    std::free(objectTypeInfo);
                    std::free(objectNameInfo);
                    CloseHandle(dupHandle);
                    continue;
                }
            }
            objectName = *(PUNICODE_STRING)objectNameInfo;
            wstring ObjectBuffer = objectTypeInfo->Name.Buffer;

            // We are only interested about handles to files & processesif (ObjectBuffer.find(L"File") != wstring::npos || ObjectBuffer.find(L"Process") != wstring::npos)
            {

                HANDLE CurrentProcess = GetCurrentProcess();
                HANDLE procHandle = OpenProcess(PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, handle.ProcessId);

                HANDLE DuplicatedHandle = 0;

                // Duplicating the handle, now we can do basically anything with it.if (DuplicateHandle(procHandle, (HANDLE)handle.Handle, CurrentProcess, &DuplicatedHandle, 0, false, DUPLICATE_SAME_ACCESS))
                {
                    WCHAR NameBlock[256];
                    wstring block = NameBlock;
                    K32GetProcessImageFileNameW(DuplicatedHandle, NameBlock, 256);

                    PathStripPathW(NameBlock);
                    wcout << L"Handle to " << ObjectBuffer << ": " << NameBlock << " Id: " << GetProcessId(DuplicatedHandle) << endl;
                }
            }
            std::free(objectTypeInfo);
            std::free(objectNameInfo);
            CloseHandle(dupHandle);
        }

        std::free(handleInfo);
        CloseHandle(processHandle);
        cin.get();
    }
    return0;
}

大部分用不到，只需要关注NtQueryObject部分就行了。这个demo是测试createprocess获得的句柄权限，结果是pb.GrantedAccess = 0x1FFFFF，代表有全部权限，这与文档中说的是一样的

The handle returned by the CreateProcess function has PROCESS_ALL_ACCESS access to the process object. When you call the OpenProcess function, the system checks the requested access rights against the DACL in the process‘s security descriptor. When you call the GetCurrentProcess function, the system returns a pseudohandle with the maximum access that the DACL allows to the caller.

参考： https://docs.microsoft.com/en-us/windows/win32/procthread/process-security-and-access-rights

原文：https://www.cnblogs.com/strive-sun/p/12408299.html

内容总结

以上是互联网集市为您收集整理的C++检测句柄的权限全部内容，希望文章能够帮你解决C++检测句柄的权限所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1225981.html

来源：【匿名】

【上一篇】C++ 重载、重写、重定义【下一篇】c++有个库什么的吗?

更多 ►

【C++检测句柄的权限】教程文章相关的互联网学习教程文章

C++检测句柄的权限【代码】

主要是依靠NtQueryObject函数，其中需要传入ObjectBasicInformation参数PUBLIC_OBJECT_BASIC_INFORMATION结构包含可用于对象的全部信息的子集。typedef struct _PUBLIC_OBJECT_BASIC_INFORMATION {ULONG Attributes;ACCESS_MASK GrantedAccess; //指定一个掩码，该掩码代表对对象的授予访问权限ULONG HandleCount;ULONG PointerCount;ULONG Reserved[10]; } PUBLIC_OBJECT_BASIC_INFORMATION, *PPUBLIC_OB...

C++中封装和继承的访问权限【代码】

众所周知，C++面向对象的三大特性为：封装，继承和多态。下面我们就先对封装做一些简单的了解。封装是通过C++中的类来完成的，类是一种将抽象转换为用户定义类型的工具。类的定义如下：class circle {public: //成员变量int m_L;int m_H;public: //成员函数（方法）double get_Square(){return m_L*m_H;} } 在上面的代码中，我们定义了一个 "circle" 类，主要包含三个部分：成员变量，成员方法和访问控制（public, protect, priv...

【贪玩巴斯】c++核心编程，你需要敲出这些程序！（二）{ c++中函数默认参数、占位参数、函数重载、类和对象中的封装、权限} //2021-04-11

// // main.cpp // _day2 // // Created by AchesonD16 贪玩巴斯 on 2021/4/6. // 一、函数提高 1、函数默认参数 /* //函数默认参数 //在 c++ 中，函数的形参列表中的形参是可以有默认值的 //语法：返回值类型函数名（参数 = 默认值） // {} #include<iostream> using namespace std; int func(int a, int b = 10, int c = 10) { return a + b + c; } //1.如果某个位置参数有默认值，那么从这...

mysql-win7系统安装VC++时候提示无权限操作dll文件？

mysqlphpwampserver 微软官网下载的，先是普通用户登录的，先安装2012版的提示无权限操作dll文件，启用administrator用户，安装还是提示无权限！下个2015版的什么都不提示到最后来个安装失败！谁指导一下，我想装wampserver，总是提示缺少dll文件？

C++中关于public、protect、private的访问权限控制【代码】【图】

转载：https://blog.csdn.net/ycf74514/article/details/49053041 目录 C++中关于public、protect、private的访问权限控制 1 一：成员的访问权限 1 1: public访问权限 1 2：protected访问权限 1 3：private访问权限 3 总结：public在任何地方都能访问，protected只能在派生类中访问， private只能在友元中访问。 4 二：继承的访问权限控制 4 1：public继承 4 2：protected继承 5 3：private继承 7 总结：继承修饰符，就像是一种筛子...

C++继承权限和继承方式【代码】

C++继承的一般语法为： class 派生类名:［继承方式］基类名{ 派生类新增加的成员 }; 继承方式限定了基类成员在派生类中的访问权限，包括 public（公有的）、private（私有的）和 protected（受保护的）。此项是可选项，如果不写，默认为 private（成员变量和成员函数默认也是 private）。现在我们知道，public、protected、private 三个关键字除了可以修饰类的成员，还可以指定继承方式。 public、protected、private 修饰类...

C++类成员的访问权限以及类的封装【代码】

C++类成员的访问权限以及类的封装访问权限 c++中提供了三种成员访问限定符： public:公有 private:私有 protected:受保护Java、C# 程序员注意，C++ 中的 public、private、protected 只能修饰类的成员，不能修饰类，C++中的类没有共有私有之分。在类的内部（定义类的代码内部），无论成员被声明为 public、protected 还是 private，都是可以互相访问的，没有访问权限的限制。在类的外部（定义类的代码之外），只能通过对象访问成...

c++类和对象之封装及访问权限【代码】

c++的三大特性：封装、继承、多态 c++认为万物皆为对象，对象上有其属性和行为封装的意义封装是c++面向对象的三大特征之一封装的意义： 1、将属性和行为作为一个整体，表现生活中的事物 2、将属性和行为加以权限控制封装意义一：在设计类的时候，属性和行为表现事物语法： class 类名{ 访问权限；属性/行为}; 类中的属性和行为我们统一称为成员//属性：成员属性成员变量//行为：成员函数成员方法案例：设计一个圆类，...

CCF CSP 201612-3权限查询（c++100）【代码】【图】

CCF CSP 201612-3权限查询按题意模拟，一层层嵌套，有注释 #include<iostream> #include<map> #include<string> #include<algorithm> using namespace std; map<string,int>category,cy; map<string,map<string, int> >role; map<string,map<string, int> >user; int main(){int n;cin>>n;//存储权限 for(int i = 0; i < n; i++){string s;cin>>s;int f = -1;//分有权限和无权限两种 if((f = s.find(':'))!=-1){int num = 0;for(in...

浅谈借助指针突破C++类访问权限【代码】【图】

浅谈借助指针突破C++类访问权限有以下代码： #include <iostream> using namespace std; class A { public:A(int a, int b, int c):m_a(a),m_b(b),m_c(c) {}; private:int m_a;int m_b;int m_c; };int main() {A obj(1, 2, 3);int a = obj.m_a; //Compile ErrorA* p = new A(5, 6, 7,);int b= p->m_b; //Compile Errorreturn 0; }? 上面代码编译不通过，由类的访问权限可知，private对象不可直接访问。但这只是语法层面的不可访...

从本地控制台应用程序从C/C++LI DLL调用C#库时,无法授予最小权限请求

这个问题从Assembly does not allow partially trusted callers when using a custom resolver开始感谢该问题的解决方案,我现在可以从本地控制台应用程序调用网络共享上的C#库(不更改CasPol) 我现在需要采取下一步,即从另一个与C#Library位于网络上相同文件夹中的混合C/C++LI DLL调用C#库. C/C++LI DLL将由本地控制台应用程序调用. 我在上面使用相同的自定义处理程序(即有证据),当从本地控制台应用程序调用C#库时,它可以正常工作....

C++的继承权限

原文来自于：https://www.cnblogs.com/2018shawn/p/10648408.html 公式：继承成员对外的访问属性 = Max{继承方式，父类成员访问级别}； 1.如果子类从父类继承时使用的继承限定符是public，那么(1)父类的public成员成为子类的public成员，允许类以外的代码访问这些成员；(2)父类的private成员仍旧是父类的private成员，子类成员不可以访问这些成员；(3)父类的protected成员成为子类的protected成员，只允许子类成员访问； 2.如果子...

C++突破private访问权限的黑科技

如何突破class的private属性限制——试图破坏class的封装性，有点“逆天而行”的感觉。方法1. 添加友元函数#include<iostream> using namespace std;class X { private:int m_Age;public:X() : m_Age(1){}template<typename T>void Func(const T &t){}const int GetValue(){return m_Age;}friend void Func(X* xPtr); };void Func(X* xPtr) {xPtr->m_Age = 2; }int main() {X x;cout << x.GetValue() << endl;// 输出1Func(&x);co...

c++/c再学习：C++中public、protect、private的访问权限控制【代码】

C++中public、protect、private的访问权限控制访问权限一个类的public成员变量、成员函数，可以通过类的成员函数、类的实例变量进行访问一个类的protected成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。一个类的private成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。访问权限demo #include <iostream>class ReferencePeris...

C++之内部类（内部类就是外部类的友元类，单向友元。只是内部类比友元类多了一点权限）

1. 内部类的概念如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。即说：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。 2. 内部类可以定义在外部类的public、protected、private都是可以的。 ...

首页 / C++ / C++检测句柄的权限

C++检测句柄的权限

内容导读

内容图文

内容总结

内容备注

内容手机端

【C++检测句柄的权限】教程文章相关的互联网学习教程文章

权限 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程