C++ 调用Python3

作为一种胶水语言,Python 能够很容易地调用 C 、 C++ 等语言,也能够通过其他语言调用 Python 的模块。

Python 提供了 C++ 库,使得开发者能很方便地从 C++ 程序中调用 Python 模块。

具体操作可以参考: 官方文档

在调用Python模块时需要如下步骤:

  1. 初始化Python调用环境
  2. 加载对应的Python模块
  3. 加载对应的Python函数
  4. 将参数转化为Python元组类型
  5. 调用Python函数并传入参数元组
  6. 获取返回值
  7. 根据Python函数的定义解析返回值

初始化

在调用Python模块时需要首先包含Python.h头文件,这个头文件一般在安装的Python目录中的 include文件中,所在VS中首先需要将这个路径加入到项目中

包含完成之后可能会抱一个错误:找不到 inttypes.h文件,在个错误在Windows平台上很常见,如果报这个错误,需要去网上下载对应的inttypes.h文件然后放入到对应的目录中即可,我这放到VC的include目录中

在包含这些文件完成之后可能还会抱一个错误,未找到Python36_d.lib 在Python环境中确实找不到这个文件,这个时候可以修改pyconfig.h文件,将这个lib改为python36.lib,具体操作请参考这个链接: https://blog.csdn.net/Chris_zhangrx/article/details/78947526

还有一点要注意,下载的Python环境必须的与目标程序的类型相同,比如你在VS 中新建一个Win32项目,在引用Python环境的时候就需要引用32位版本的Python

这些准备工作做完后在调用Python前先调用Py_Initialize 函数来初始化Python环境,之后我们可以调用Py_IsInitialized来检测Python环境是否初始化成功
下面是一个初始化Python环境的例子

1
2
3
4
5
6
BOOL Init()
{
Py_Initialize();

return Py_IsInitialized();
}

调用Python模块

调用Python模块可以简单的调用Python语句也可以调用Python模块中的函数。

简单调用Python语句

针对简单的Python语句(就好像我们在Python的交互式环境中输入的一条语句那样),可以直接调用 PyRun_SimpleString 函数来执行, 这个函数需要一个Python语句的ANSI字符串作为参数,返回int型的值。如果为0表示执行成功否则为失败

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void ChangePyWorkPath(LPCTSTR lpWorkPath)
{
TCHAR szWorkPath[MAX_PATH + 64] = _T("");
StringCchCopy(szWorkPath, MAX_PATH + 64, _T("sys.path.append(\""));
StringCchCat(szWorkPath, MAX_PATH + 64, lpWorkPath);
StringCchCat(szWorkPath, MAX_PATH + 64, _T("\")"));

PyRun_SimpleString("import sys");
USES_CONVERSION;

int nRet = PyRun_SimpleString(T2A(szWorkPath));
if (nRet != 0)
{
return;
}
}

这个函数主要用来将传入的路径加入到当前Python的执行环境中,以便可以很方便的导入我们的自定义模块
函数首先通过字符串拼接的方式组织了一个 “sys.path.append(‘path’)” 这样的字符串,其中path是我们传进来的参数,然后调用PyRun_SimpleString执行Python的”import sys”语句来导入sys模块,接着执行之前拼接的语句,将对应路径加入到Python环境中

调用Python模块中的函数

调用Python模块中的函数需要执行之前说的2~7的步骤

  1. 加载Python模块(自定义模块)

    加载Python的模块需要调用 PyImport_ImportModule 这个函数需要传入一个模块的名称作为参数,注意:这里需要传入的是模块的名称也就是py文件的名称,不能带.py后缀。

    这个函数会返回一个Python对象的指针,在C++中表示为PyObject。这里返回模块的对象指针

  2. 然后调用 PyObject_GetAttrString 函数来加载对应的Python模块中的方法,这个函数需要两个参数,第一个是之前获取到的对应模块的指针,第二个参数是函数名称的ANSI字符串。这个函数会返回一个对应Python函数的对象指针。后面需要利用这个指针来调用Python函数

    获取到函数的指针之后我们可以调用 PyCallable_Check 来检测一下对应的对象是否可以被调用,如果能被调用这个函数会返回true否则返回false

  3. 接着就是传入参数了,Python中函数的参数以元组的方式传入的,所以这里需要先将要传入的参数转化为元组,然后调用 PyObject_CallObject 函数来执行对应的Python函数。这个函数需要两个参数第一个是上面Python函数对象的指针,第二个参数是需要传入Python函数中的参数组成的元组。函数会返回Python的元组对象,这个元组就是Python函数的返回值

  4. 获取到返回值之后就是解析参数了,我们可以使用对应的函数将Python元组转化为C++中的变量
  5. 最后需要调用 Py_DECREF 来解除Python对象的引用,以便Python的垃圾回收器能正常的回收这些对象的内存

下面是一个传入空参数的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void GetModuleInformation(IN LPCTSTR lpPyFileName, OUT LPTSTR lpVulName, OUT long& level)
{
USES_CONVERSION;

PyObject *pModule = PyImport_ImportModule(T2A(lpPyFileName)); //加载模块
if (NULL == pModule)
{
g_OutputString(_T("加载模块[%s]失败"), lpPyFileName);
goto __CLEAN_UP;
}

PyObject *pGetInformationFunc = PyObject_GetAttrString(pModule, "getInformation"); // 加载模块中的函数
if (NULL == pGetInformationFunc || !PyCallable_Check(pGetInformationFunc))
{
g_OutputString(_T("加载函数[%s]失败"), _T("getInformation"));
goto __CLEAN_UP;
}

PyObject *PyResult = PyObject_CallObject(pGetInformationFunc, NULL);
if (NULL != PyResult)
{
PyObject *pVulNameObj = PyTuple_GetItem(PyResult, 0);
PyObject *pVulLevelObj = PyTuple_GetItem(PyResult, 1);

//获取漏洞的名称信息
int nStrSize = 0;
LPTSTR pVulName = PyUnicode_AsWideCharString(pVulNameObj, &nStrSize);
StringCchCopy(lpVulName, MAX_PATH, pVulName);
PyMem_Free(pVulName);

//获取漏洞的危险等级
level = PyLong_AsLong(pVulLevelObj);

Py_DECREF(pVulNameObj);
Py_DECREF(pVulLevelObj);
}

//解除Python对象的引用, 以便Python进行垃圾回收
__CLEAN_UP:
Py_DECREF(pModule);
Py_DECREF(pGetInformationFunc);
Py_DECREF(PyResult);

}

在示例中调用了一个叫 getInformation 的函数,这个函数的定义如下:

1
2
def getInformation():
return "测试脚本", 1

下面是一个需要传入参数的函数调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
BOOL CallScanMethod(IN LPPYTHON_MODULES_DATA pPyModule, IN LPCTSTR lpUrl, IN LPCTSTR lpRequestMethod, OUT LPTSTR lpHasVulUrl, int BuffSize)
{
USES_CONVERSION;
//加载模块
PyObject* pModule = PyImport_ImportModule(T2A(pPyModule->szModuleName));
if (NULL == pModule)
{
g_OutputString(_T("加载模块[%s]失败!!!"), pPyModule->szModuleName);
return FALSE;
}

//加载模块
PyObject *pyScanMethod = PyObject_GetAttrString(pModule, "startScan");
if (NULL == pyScanMethod || !PyCallable_Check(pyScanMethod))
{
Py_DECREF(pModule);
g_OutputString(_T("加载函数[%s]失败!!!"), _T("startScan"));
return FALSE;
}

//加载参数
PyObject* pArgs = Py_BuildValue("ss", T2A(lpUrl), T2A(lpRequestMethod));

PyObject *pRes = PyObject_CallObject(pyScanMethod, pArgs);
Py_DECREF(pArgs);

if (NULL == pRes)
{
g_OutputString(_T("调用函数[%s]失败!!!!"), _T("startScan"));
return FALSE;
}

//如果是元组,那么Python脚本返回的是两个参数,证明发现漏洞
if (PyTuple_Check(pRes))
{
PyObject* pHasVul = PyTuple_GetItem(pRes, 0);
long bHasVul = PyLong_AsLong(pHasVul);
Py_DECREF(pHasVul);

if (bHasVul != 0)
{
PyObject* pyUrl = PyTuple_GetItem(pRes, 1);
int nSize = 0;
LPWSTR pszUrl = PyUnicode_AsWideCharString(pyUrl, &nSize);
Py_DECREF(pyUrl);

StringCchCopy(lpHasVulUrl, BuffSize, pszUrl);
PyMem_Free(pszUrl);

return TRUE;
}
}

Py_DECREF(pRes);
return FALSE;
}

对应的Python函数如下:

1
2
3
4
5
6
7
8
9
10
def startScan(url, method):
if(method == "GET"):
response = requests.get(url)
else:
response = requests.post(url)

if response.status_code == 200:
return True, url
else:
return False

C++数据类型与Python对象的相互转化

Python与C++结合的一个关键的内容就是C++与Python数据类型的相互转化,针对这个问题Python提供了一系列的函数。

这些函数的格式为PyXXX_AsXXX 或者PyXXX_FromXXX,一般带有As的是将Python对象转化为C++数据类型的,而带有From的是将C++对象转化为Python,Py前面的XXX表示的是Python中的数据类型。比如 PyUnicode_AsWideCharString 是将Python中的字符串转化为C++中宽字符,而 Pyunicode_FromWideChar 是将C++的字符串转化为Python中的字符串。这里需要注意一个问题就是Python3废除了在2中的普通的字符串,它将所有字符串都当做Unicode了,所以在调用3的时候需要将所有字符串转化为Unicode的形式而不是像之前那样转化为String。具体的转化类型请参考Python官方的说明。

上面介绍了基本数据类型的转化,除了这些Python中也有一些容器类型的数据,比如元组,字典等等。下面主要说说元组的操作。元组算是比较重要的操作,因为在调用函数的时候需要元组传参并且需要解析以便获取元组中的值。

  1. 创建Python的元组对象

    创建元组对象可以使用 PyTuple_New 来创建一个元组的对象,这个函数需要一个参数用来表示元组中对象的个数。

    之后需要创建对应的Python对象,可以使用前面说的那些转化函数来创建普通Python对象,然后调用 PyTuple_SetItem 来设置元组中数据的内容,函数需要三个参数,分别是元组对象的指针,元组中的索引和对应的数据

    示例:

    1
    2
    3
    4
    5
    PyObject* args = PyTuple_New(2);   // 2个参数
    PyObject* arg1 = PyInt_FromLong(4); // 参数一设为4
    PyObject* arg2 = PyInt_FromLong(3); // 参数二设为3
    PyTuple_SetItem(args, 0, arg1);
    PyTuple_SetItem(args, 1, arg2);

或者如果元组中都是简单数据类型,可以直接使用 PyObject* args = Py_BuildValue(4, 3); 这种方式来创建元组

  1. 解析元组

    Python 函数返回的是元组,在C++中需要进行对应的解析,我们可以使用 PyTuple_GetItem 来获取元组中的数据成员,这个函数返回PyObject 的指针,之后再使用对应的转化函数将Python对象转化成C++数据类型即可

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    PyObject *pVulNameObj = PyTuple_GetItem(PyResult, 0);
    PyObject *pVulLevelObj = PyTuple_GetItem(PyResult, 1);

    //获取漏洞的名称信息
    int nStrSize = 0;
    LPTSTR pVulName = PyUnicode_AsWideCharString(pVulNameObj, &nStrSize);
    StringCchCopy(lpVulName, MAX_PATH, pVulName);
    PyMem_Free(pVulName); //释放由PyUnicode_AsWideCharString分配出来的内存

    //获取漏洞的危险等级
    level = PyLong_AsLong(pVulLevelObj);

    //最后别忘了将Python对象解引用
    Py_DECREF(pVulNameObj);
    Py_DECREF(pVulLevelObj);
    Py_DECREF(PyResult);

Python中针对具体数据类型操作的函数一般是以Py开头,后面跟上具体的数据类型的名称,比如操作元组的PyTuple系列函数和操作列表的PyList系列函数,后面如果想操作对应的数据类型只需要去官网搜索对应的名称即可。

这些代码实例都是我之前写的一个Demo中的代码,Demo放到了Github上: PyScanner