python调用C语言程序的实现过程

1、为什么要调用C程序

     python语言的优点很多，当然也有缺点，由于是解释形脚本语言，所以它的执行程序的效率没有C语言快，操作系统硬件相关的操作接口程序都是C程序接口，所以对于一些特殊的应用与操作就要调用C语言程序来实现。

2、调用方法

     python调用C语言可以使用ctypes模块来实现，ctypes模块可以直接加载c语言的动态库文件，window系统下是.dll文件， linux系统下是.so文件。本文通过一个示例来实现python调用c程序的过程，同时使用python语言对要调用的c程序进行二次封装而变成python程序。

3. ctypes的使用

（1）C语言中基础的数据类型
　　这部分的使用比较简单，直接使用ctypes内置的方法创建对象即可，ctypes提供的方法和C语言对应的数据类型如下表：当在python调用c程序时向c程序中要传入相对应的数据类型时使用。

 

 （2）使用方法：

# -*- coding: utf-8 -*-
from ctypes import *

# 字符,仅接受one character bytes, bytearray or integer
char_type = c_char(b"a")
# 字节
byte_type = c_char(1)
# 字符串
string_type = c_wchar_p("abc")
# 整型
int_type = c_int(2)
# 直接打印输出的是对象信息，获取值需要使用value方法
print(char_type, byte_type, int_type)
print(char_type.value, byte_type.value, string_type.value, int_type.value)

输出：

 

2）数组类型
　　数组的创建和C语言的类似，给定数据类型和长度即可，如下：

# 数组
# 定义类型
char_array = c_char * 3
# 初始化
char_array_obj = char_array(b"a", b"b", 2)
# 打印只能打印数组对象的信息
print(char_array_obj)
# 打印值通过value方法
print(char_array_obj.value)

输出：

也可以在创建的时候直接进行初始化，如下：

int_array = (c_int * 3)(1, 2, 3)
for i in int_array:
    print(i)

char_array_2 = (c_char * 3)(1, 2, 3)
print(char_array_2.value)

输出：

这里需要注意，通过value方法获取值只适用于字符数组，其他类型如print(int_array.value)的使用会报错：

（3）指针类型
　　ctypes提供了pointer()和POINTER()两种方法创建指针，区别在于：

• pointer()用于将对象转化为指针，如下：

# 指针类型
int_obj = c_int(3)
int_p = pointer(int_obj)
print(int_p)
# 使用contents方法访问指针
print(int_p.contents)
# 获取指针指向的值
print(int_p[0])

输出：

• POINTER()用于定义某个类型的指针，如下：

# 指针类型
int_p = POINTER(c_int)
# 实例化
int_obj = c_int(4)
int_p_obj = int_p(int_obj)
print(int_p_obj)
print(int_p_obj.contents)
print(int_p_obj[0])

输出：

如果弄错了初始化的方式会报错，POINTER()如下：

# 指针类型
int_p = POINTER(c_int)
# 实例化
int_obj = c_int(4)
int_p_obj = POINTER(int_obj)

报错：

pointer()如下：

# 指针类型
int_p = pointer(c_int)

报错：

• 创建空指针的方式

null_ptr = POINTER(c_int)()
print(bool(null_ptr))

输出：

• 指针类型的转换
  ctypes提供cast()方法将一个ctypes实例转换为指向另一个ctypes数据类型的指针，cast()接受两个参数，一个是ctypes对象，它是或可以转换成某种类型的指针，另一个是ctypes指针类型。它返回第二个参数的一个实例，该实例引用与第一个参数相同的内存块。

int_p = pointer(c_int(4))
print(int_p)

char_p_type = POINTER(c_char)
print(char_p_type)

cast_type = cast(int_p, char_p_type)
print(cast_type)

输出：

（4）结构体类型
　　结构体类型的实现，结构和联合必须派生自ctypes模块中定义的结构和联合基类。每个子类必须 定义一个_fields_属性，_fields_必须是一个二元组列表，包含字段名和字段类型。_pack_属性 决定结构体的字节对齐方式，默认是4字节对齐，创建时使用_pack_=1可以指定1字节对齐。比如初始化student_t的方法如下，特别需要注意的是字段名不能和python关键字重名，不然会报错：

# -*- coding: utf-8 -*-
from ctypes import *

# 学生信息如下
stu_info = [("class", "A"),
            ("grade", 90),
            ("array", [1, 2, 3]),
            ("point", 4)]

# 创建结构提类
class Student(Structure):
    _fields_ = [("class", c_char),
            ("grade", c_int),
            ("array", c_long * 3),
            ("point", POINTER(c_int))]

print("sizeof Student: ", sizeof(Student))

# 实例化
long_array = c_long * 3
long_array_obj = long_array(1, 2, 3)
int_p = pointer(c_int(4))
stu_info_value = [c_char(b"A"), c_int(90), long_array_obj, int_p]

stu_obj = Student(*stu_info_value)
# 这样打印报错，因为字段名和python关键字class重名了，这是需要特别注意的点
# print("stu info:", stu_obj.class, stu_obj.grade, stu_obj.array[0], stu_obj.point[0])
print("stu info:", stu_obj.grade, stu_obj.array[0], stu_obj.point[0])

输出：

如果把_pack_改为1，则输出：

（5）嵌套结构体
　　嵌套结构体的使用需要创建基础结构体的类型，然后将基础结构体的类型作为嵌套结构体 的成员，注意基础结构体所属字段的字段类型是基础结构体的类名，如下：

# 创建类型, nest_stu字段的类型为基础结构体的类名
class NestStudent(Structure):
    _fields_ = [("rank", c_char),
                ("nest_stu", Student)]

# 实例化
nest_stu_info_list = [c_char(b"M"), stu_obj]
nest_stu_obj = NestStudent(*nest_stu_info_list)

print("nest stu info: ", nest_stu_obj.rank, "basic stu info: ", nest_stu_obj.nest_stu.grade)

输出：

（6）结构体数组
　　结构体数组与普通数组的创建类似，需要提前创建结构体的类型，然后使用struct type * array_length 的方法创建数组。

# 结构体数组
# 创建结构体数组类型
stu_array = Student * 2
# 用Student类的对象实例化结构体数组
stu_array_obj = stu_array(stu_obj, stu_obj)

# 增加结构体数组成员
class NestStudent(Structure):
    _fields_ = [("rank", c_char),
                ("nest_stu", Student),
                ("strct_array", Student * 2)]

# 实例化
nest_stu_info_list = [c_char(b"M"), stu_obj, stu_array_obj]
nest_stu_obj = NestStudent(*nest_stu_info_list)

# 打印结构体数组第二个索引的grade字段的信息
print("stu struct array info: ", nest_stu_obj.strct_array[1].grade, nest_stu_obj.strct_array[1].array[0])

输出：

（7）结构体指针
　　首先创建结构体，然后使用ctype的指针方法包装为指针。

# 结构体指针
# # 创建结构体数组类型
stu_array = Student * 2
# # 用Student类的对象实例化结构体数组
stu_array_obj = stu_array(stu_obj, stu_obj)
# 曾接结构体指针成员,注意使用类型初始化指针是POINTER()
class NestStudent(Structure):
    _fields_ = [("rank", c_char),
                ("nest_stu", Student),
                ("strct_array", Student * 2),
                ("strct_point", POINTER(Student))]

# 实例化,对Student的对象包装为指针使用pointer()
nest_stu_info_list = [c_char(b"M"), stu_obj, stu_array_obj, pointer(stu_obj)]
nest_stu_obj = NestStudent(*nest_stu_info_list)

# 结构体指针指向Student的对象
print("stu struct point info: ", nest_stu_obj.strct_point.contents)
# 访问Student对象的成员
print("stu struct point info: ", nest_stu_obj.strct_point.contents.grade)

输出：

（8）结构体指针数组
　　创建结构体指针数组的顺序为先创建结构体，然后包装为指针，最后再创建数组，用结构体指针去实例化数组。

# 结构体指针数组
# 创建结构体数组类型
stu_array = Student * 2
# # 用Student类的对象实例化结构体数组
stu_array_obj = stu_array(stu_obj, stu_obj)
# 创建结构体指针数组
stu_p_array = POINTER(Student) * 2
# 使用pointer()初始化
stu_p_array_obj = stu_p_array(pointer(stu_obj), pointer(stu_obj))
# 曾接结构体指针成员,注意使用类型初始化指针是POINTER()
class NestStudent(Structure):
    _fields_ = [("rank", c_char),
                ("nest_stu", Student),
                ("strct_array", Student * 2),
                ("strct_point", POINTER(Student)),
                ("strct_point_array", POINTER(Student) * 2)]

# 实例化,对Student的对象包装为指针使用pointer()
nest_stu_info_list = [c_char(b"M"), stu_obj, stu_array_obj, pointer(stu_obj), stu_p_array_obj]
nest_stu_obj = NestStudent(*nest_stu_info_list)

# 数组第二索引为结构体指针
print(nest_stu_obj.strct_point_array[1])
# 指针指向Student的对象
print(nest_stu_obj.strct_point_array[1].contents)
# Student对象的grade字段
print(nest_stu_obj.strct_point_array[1].contents.grade)

输出：

4、python调用C程序实操 

     本文的操作全部基于linux系统中进行。首先编写一个c程序文件Cpa.c，并且编译生成so文件。程序文件内容如下：

#include "CPa_CortexMx.h"

/*
   初始化
 in:  pCtx  a容器指针
      pKey  主密钥 8字节
      IV  IV 8字节
 out: pCtx
 return : 0 成功
          others 失败
*/
int  CPaIni(CPa_context  *pCtx, unsigned char *pIV, unsigned char *pKey )
{
    uint32_t i = 0;

    for(i = 0; i < 8; i++)
    {
        pCtx->iv[i] = pIV[i];
    }

    for(i = 0; i < RoundCPa; i++)
    {
        pCtx->sk[i] = i + pKey[i % 8];
    }

    return 0;
}

/*
    加密
 in:  pCtx     a容器指针
      pData    待加密数据指针
      DataLen  待加密数据长度
 out: pCipher    密文
      *CipherLen 密文长度
 return : >0  密文长度
          others 失败
*/
int  CPa_Encrypt(CPa_context *pCtx, unsigned char *pData, unsigned int  DataLen,unsigned char *pCipher,unsigned int *CipherLen)
{
    uint32_t i = 0;

    for(i = 0; i < DataLen; i++)
    {
        pCipher[i] = pData[i] + pCtx->sk[i%sizeof(pCtx->sk)];

    }
    *CipherLen = DataLen;

    return 0;
}

    头文件中定义结构体，如下：

#ifndef _H_CPA_CORTEXMx_
#define _H_CPA_CORTEXMx_
#include <stdio.h>
#include <stdint.h>


#ifndef u8i
#define  u8i unsigned char
#endif

#ifndef u32i
#define  u32i uint32_t
#endif


#define RoundCPa 24



typedef struct
{
    u32i  sk[RoundCPa];
    unsigned char iv[8];

}
CPa_context;

/*
1。 更新密钥
 in:  pCtx  a容器指针
      pKey  主密钥 8字节
 out: pCtx  a容器中的轮密钥
 return : null
*/
void UpdateRk(CPa_context  *pCtx,unsigned char *pKey);
/*
2。 更新IV
 in:  pCtx  a容器指针
      IV  IV 8字节
 out: pCtx  a容器中的IV
 return : null
*/
void UpdateIV(CPa_context  *pCtx,unsigned char *pIV);

/*
4。 初始化
 in:  pCtx  a容器指针
      pKey  主密钥 8字节
      IV  IV 8字节
 out: pCtx
 return : 0 成功
          others 失败
*/
int  CPaIni(CPa_context  *pCtx, unsigned char *pIV, unsigned char *pKey );
/*
4。 加密
 in:  pCtx     a容器指针
      pData    待加密数据指针
      DataLen  待加密数据长度
 out: pCipher    密文
      *CipherLen 密文长度
 return : >0  密文长度
          others 失败
*/
int  CPa_Encrypt(CPa_context *pCtx, unsigned char *pData, unsigned int  DataLen,unsigned char *pCipher,unsigned int *CipherLen);
/*
4。 解密
 in:  pCtx     a容器指针
      pCipher  待解密数据指针
      CipherLen  待解密数据长度
 out: pData    解密数据指针
      *DataLen 解密数据长度
 return : >0  解密数据长度
          others 失败
*/
#define  CPa_Decrypt CPa_Encrypt


#endif

      把Cpa.c, CPa_CortexMx.h文件放在linux系统下进行编译，即执行命令gcc -o CPa.so -shared -fPIC CPa.c -I ./ 

     可以看到生成了CPa.so文件。下面需要编写PyCpa.py文件来对加密库进行调用。

      通过Cpa.c文件中可以知，调用其中的函数CPaIni(CPa_context  *pCtx, unsigned char *pIV, unsigned char *pKey )，需要输入结构体指针和2个字符数组指针，因些在python程序中要定义对应的数据类型， 字符数组对应的python中的数据结构是bytes类型的，结构体pCtx要使用ctypes中结构体来定义出来。

      CPa_context  结构体中包含有24个长度的整形数组和8个长度的字符数据。因些python中要使用定义同样结构的类来表示。代码如下，定义出来。

#define the CPa context struct
class CPa_context(Structure):
    _fields_ = [
    ("sk", c_uint * 24),
    ("iv", c_char * 8)
    ]

     结构体指针可以通过pointer取类CPa_context来获取，

#实例化一个类，表示一个结构体
cpa = CPa_context()
#取指针
pcpa = pointer(cpa)

      解决了数据类型的对应关系后，剩下的就是对c程序进行python封装了，即定义一个类，类中完成初始化和相关c程序的调用程序接口。如下代码所示。

# /usr/bin/python3.8
from ctypes import *
import ctypes

#define the CPa context struct
class CPa_context(Structure):
    _fields_ = [
    ("sk", c_uint * 24),
    ("iv", c_char * 8)
    ]


#封装一下c语言的加密库的接口为python程序接口
class CPa_python:
    def __init__(self, iv, key):
        self.cpa_so = ctypes.cdll.LoadLibrary("./CPa.so")
        self.cpa = CPa_context()
        self.pcpa = pointer(self.cpa)
        self.cpa_so.CPaIni(self.pcpa, iv, key)
    #encrypt data
    def cpa_encrypt(self, input):
        out_num = c_uint(0)
        pout_num = pointer(out_num)
        self.cpa_so.CPa_Encrypt(self.pcpa, input, len(input), input, pout_num)
        return input
    #decrypt data
    def cpa_decrypt(self, input):
        out_num = c_uint(0)
        pout_num = pointer(out_num)
        self.cpa_so.CPa_Encrypt(self.pcpa, input, len(input), input, pout_num)
        return input


#实例化一个CPa python类
cpa_python = CPa_python(bytes([1,1,1,1,0,0,0,0]), bytes([2,3,4,5,6,7,8,9]))
print("encrypt data",cpa_python.cpa_encrypt(bytes([1,2,3,4,5])))

     到这里已经对C程序函数完成了封装，执行一下程序可以看到输出结果。