小编mic*_*ael的帖子

我希望下面的问题不会太长。但除此之外，我无法通过问题和我想要的来解释：

从如何使用 importlib 从任意来源导入模块中学习？（我昨天的问题）我为新文件类型 (.xxx) 编写了一个特定的加载程序。（实际上 xxx 是 pyc 的加密版本，以防止代码被盗）。

我只想为新文件类型“xxx”添加一个导入挂钩，而不会以任何方式影响其他类型（.py、.pyc、.pyd）。

现在，加载器是ModuleLoader，继承自mportlib.machinery.SourcelessFileLoader.

使用sys.path_hooksloader 应添加一个钩子：

myFinder = importlib.machinery.FileFinder
loader_details = (ModuleLoader, ['.xxx'])
sys.path_hooks.append(myFinder.path_hook(loader_details))

注意：这是通过调用激活一次 modloader.activateLoader()

加载名为test（这是一个test.xxx）的模块后，我得到：

myFinder = importlib.machinery.FileFinder
loader_details = (ModuleLoader, ['.xxx'])
sys.path_hooks.append(myFinder.path_hook(loader_details))

但是，当我sys.path_hooks在添加钩子之前删除内容时：

sys.path_hooks = []
sys.path.insert(0, '.') # current directory
sys.path_hooks.append(myFinder.path_hook(loader_details))

有用：

>>> modloader.activateLoader()
>>> import test
using xxx class

in xxxLoader exec_module
in xxxLoader get_code: .\test.xxx
ANALYZING ...

GENERATE …

在使用可变参数模板时，我遇到了：

template <class... Ts> struct tuple {};

template <class T, class... Ts>
struct tuple<T, Ts...> : tuple<Ts...> 
{
    tuple(T t, Ts... ts) : tuple<Ts...>(ts...), tail(t) {}

    T tail;
};

我只想学会理解这里发生了什么：我们可以通过以下方式实例化这样的元组

tuple<int, double, const char*, const char*, const char*> myTuple(1234, 33.444, "I", "like", "C++");

但不是：

tuple myTuple2(1234, 33.444, "I", "like", "C++");

为什么编译器不能从给定类型列表中自动推断类型？

如果我做

template <class T>
void swap(T& first, T& second) {
   T aux = first;
   first = second;
   second = aux;
}

...
...

swap<int>(a, b);
swap(a, b);

两种变体都是可能的。这对于可变参数模板参数是不可能的吗？C++ 用于推断类型的规则是什么？

我必须在基于Linux的固件上为嵌入式系统组件实现基于Python的Web服务器：

class WebServer(http.server.HTTPServer)
...
...

要启用ssl连接，将在服务器中通过以下方式创建ssl上下文：

self.ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
self.ssl_context.load_cert_chain(certfile=cert, keyfile=key)
self.ssl_context.verify_mode = ssl.CERT_REQUIRED
self.ssl_context.load_verify_locations(verifyCert)

注意：cert是证书的文件路径，keyfile是私钥的路径。

根据请求，将调用get_request方法：

def get_request(self):
    request = self.socket.accept()
    if self.ssl_context:
        req_socket, addr = request
        connstream = self.ssl_context.wrap_socket(req_socket, server_side=True)
        return connstream, addr
    else:
        return request

wrap_socket方法用于将原始套接字包装到ssl套接字中，而将其返回。这就是提供ssl连接的全部。

现在的问题是：

该解决方案是第一个实施方案，并不安全。我们被迫使用给定的硬件安全模块（HSM）创建和存储证书和私钥。任何私钥都是完全隐藏的，永远不会离开模块。所有密码原语必须直接在模块内执行。HSM的接口是PKCS＃11，为此存在供应商提供的动态中间件库。

如何在python下使用ssl上下文设置模块而不是原始ssl？我已经知道，ssl基于openSSL，为此存在PKCS＃11引擎（libarary opensc-pkcs11.so）。供应商的中间件提供了PKCS＃11 API。

不幸的是，我没有计划如何将PKCS＃11引擎集成到python的ssl / openSSL中，以及如何将所有东西捆绑在一起。甚至有可能透明地使用PKCS＃11代替本机实现，如果是，如何从python激活它？而且，由于它们不再作为普通文件可用，我将如何传递参数“ certfile”和“ keyfile”？实际上，我无法直接访问私钥。HSM中只有用于操作对象的基于URL的对象引用。

PyKCS11可以代替ssl吗？

我只需要知道解决此类问题的基本路径即可。我可以自己找到所有详细信息。

使用importlib，“元路径查找器”（通过sys.meta_path遍历发现）和“路径条目查找器”（通过sys.path_hooks遍历发现）有什么区别？

第一种类型在导入开始时被调用，但是第二种类型何时使用？两者都返回规格对象吗？

我要实现自定义导入，可以从* .py或* .pyc以外的其他来源（例如，从流）导入模块。如何才能做到这一点？

假设我想传递一个通过std::bind引用 funktion 创建的函数对象：

void myCallback(int i, int j)
{
    std::cout << "toCall , i=" << i << " j=" << j;
}

void worker(std::function<void(int)> & callback)
{
    callback(111);
}

int main(int argc, char** argv)
{
    auto foo = std::bind(myCallback, std::placeholders::_1, 222);
    worker(foo);
}

这不能编译

严重性代码说明项目文件行抑制状态错误 C2664 'void worker(std::function &)': 无法将参数 1 从 'std::_Binder &,int>' 转换为 'std::function &' asn1test_1 D:.. ...\asn1test_1.....cpp 302

然而，按值传递是有效的：

void worker(std::function<void(int)> callback)
{
    callback(111);
}

当我避免使用“ auto”并改为使用

std::function<void(int)> foo = std::bind(myCallback, std::placeholders::_1, 222);

它既可以通过引用传递，也可以通过值传递。 …

我正在尝试在 Windows 7 下设置 openSSL 以使用供应商特定的安全模块。

我从供应商那里得到了一个 PKCS#11 API dll（比如说vendor.dll）。PKCS#11引擎已根据https://github.com/OpenSC/libp11创建

如链接中所述，为了测试，我开始

openssl 引擎 pkcs11 -t

但得到：

D:\Gateway\openSSL\Win32\Release>openssl engine pkcs11 -t
11020:error:25078067:DSO support routines:WIN32_LOAD:could not load the shared library:.\crypto\dso\dso_win32.c:179:filename(\usr\local\ssl\lib\engines\pkcs11.dll)
11020:error:25070067:DSO support routines:DSO_load:could not load the shared library:.\crypto\dso\dso_lib.c:233:
11020:error:260B6084:engine routines:DYNAMIC_LOAD:dso not found:.\crypto\engine\eng_dyn.c:467:
11020:error:2606A074:engine routines:ENGINE_by_id:no such engine:.\crypto\engine\eng_list.c:390:id=pkcs11

配置文件是：

[engine_section]
pkcs11 = pkcs11_section

[pkcs11_section]
engine_id = pkcs11
dynamic_path = D:\Gateway\libp11\libp11-master\src\pkcs11.dll
MODULE_PATH = D:\Gateway\driver\smgw\Win32\vendor.dll
init = 0

它尝试在 unix 目录 \usr\local 中查找 dll... 看来，动态路径的内容根本没有被评估，因为我可以在那里指定任何内容，我总是收到上面的错误消息。

我究竟做错了什么？

我根据https://docs.python.org/3.3/extending/extending.html在C中实现了一个python扩展模块

现在我想在该模块中有整数常量,所以我做了:

module= PyModule_Create(&myModuleDef);
...
PyModule_AddIntConstant(module, "VAR1",1);
PyModule_AddIntConstant(module, "VAR2",2);
...
return module;

这有效.但我可以修改python中的"常量",比如

import myModule
myModule.VAR1 = 10

我试图重载__setattr__,但在赋值时不调用此函数.

有解决方案吗？

在 Linux（Ubuntu 平台）设备上，我使用一个文件来保存关键任务数据。

有时（大约 10,000 个案例中发生一次），文件会因不明原因而损坏。特别是，文件被截断（而不是一些 kbyte，它只有大约 100 个字节）。

现在，按照软件的顺序

1. 文件被打开，
2. 修改和
3. 关闭。

紧接着，文件可能会再次打开 (4)，并且正在执行其他操作。

到目前为止，我还没有注意到fflush（被调用fclose）不会写入文件系统，而只会写入中间缓冲区。可能是因为 3) 和 4) 之间的时间太短，并且 2) 的更改尚未写入磁盘，所以当我用 4) 重新打开时，我得到一个截断的文件，当它再次关闭时会导致永久丢失那些数据？

fsync()在这种情况下我应该在每次文件写入后使用吗？

停电需要考虑什么？数据损坏不太可能与断电有关。

我有一个服务器应用程序来接受来自一组大约 10000 个客户端（实际上是具有 GPRS 接口的现场设备）的 TCP 连接。

接受连接的部分是这样的：

public async System.Threading.Tasks.Task AcceptConnections()
{
    _listenerProxy.StartListen();
    var taskList = new List<System.Threading.Tasks.Task>();
    var application = _configManager.Configuration.GetSection("application");
    var maxTasks = int.Parse(application["MaxTasksPerListener"]);
    while (true)
    {
        if (taskList.Count > maxTasks)
        {
            _logger.Info($"Waiting for handling task to be completed {_listenerProxy.Port}.");
            await System.Threading.Tasks.Task.WhenAny(taskList.ToArray()).ConfigureAwait(false);
            taskList.RemoveAll(t => t.IsCompleted); // at least one task affected, but maybe more
        }
        _logger.Info($"Waiting for client to be accepted on port {_listenerProxy.Port}.");
        (var readStream, var writeStream, var sourceIP, var sourcePort) = await _listenerProxy.AcceptClient().ConfigureAwait(false);
        _logger.Info($"Client accepted …

问题的答案

如何在 PKCS#11 模块上使用私钥而不是 perivate 密钥文件在 OpenSSL 中进行相互身份验证？

非常清楚地解释了使用存储在智能卡或 HSM（硬件安全模块）上而不是普通文件上的私钥建立 SSL 连接所需的步骤。其实我想用python做同样的事情，但首先我必须了解背后的原理。所以暂时忘记python：

假设密钥已经存在于 HSM 上的“SecureToken”下。所以

1. 我首先必须从引擎加载私钥：

   EVP_PKEY* key = ENGINE_load_private_key(e, "SecureToken", NULL, &cb_data);

2. 然后必须打电话

   SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);

现在，我有一个带有 PKCS#11 接口的 HSM，我可以将其作为 openSSL 引擎加载。慢慢地我对原理有了更好的了解，但是，私钥如何离开模块仍然是个谜：为了将私钥始终保存在模块内，这就是我完全使用 HSM 的原因。

具体来说：我从 1) 中调用的返回值中返回什么作为“键”？我无法想象密钥内容是从 HSM 中读出的，因为 PKCS#11 甚至不支持此操作。我还能得到什么？它只是有关HSM 中密钥的元信息而不是密钥本身吗？并且 SSL_CTX * ctx 稍后如何知道，该“密钥”将如何使用？

鉴于 PKCS#11 引擎已正确加载，这是否意味着任何 RSA 函数都会与存储在上下文中的“元密钥信息”一起自动委托给 HSM ？

请确认这个假设或让我知道我错在哪里。

无论如何，我发现了 EVP_PKEY 是什么：

    struct evp_pkey_st {
        int type;
        int save_type;
        int references;
        const EVP_PKEY_ASN1_METHOD *ameth;
        ENGINE *engine;
        union …