diff options
| author | k clair <kclair@riseup.net> | 2012-10-09 12:13:13 -0700 |
|---|---|---|
| committer | k clair <kclair@riseup.net> | 2012-10-09 12:13:13 -0700 |
| commit | 7ebbbaaeef0ded0f39b8bf863ee7fd324b19c9f9 (patch) | |
| tree | 0f18e1f7b54df0b1daee3297b12954905cc6f0d8 | |
Add source files for python-gnutls version 1.1.9
35 files changed, 5194 insertions, 0 deletions
diff --git a/python-gnutls-1.1.9.tar.gz b/python-gnutls-1.1.9.tar.gz Binary files differnew file mode 100644 index 0000000..2afcb86 --- /dev/null +++ b/python-gnutls-1.1.9.tar.gz diff --git a/python-gnutls-1.1.9/ChangeLog b/python-gnutls-1.1.9/ChangeLog new file mode 100644 index 0000000..a6c9459 --- /dev/null +++ b/python-gnutls-1.1.9/ChangeLog @@ -0,0 +1,97 @@ +Changes in version 1.1.9 +------------------------ + + * Made loseConnection signature match the corresponding one from twisted + * Bumped debian standards version to 3.8.2 + * Fixed lintian warning about missing misc:Depends dependency + +Changes in version 1.1.8 +------------------------ + + * Workaround for changed tcp.Server.__init__ signature in twisted 8.2.0 + * Fixed DeprecationWarning when running with python2.6 or newer + +Changes in version 1.1.7 +------------------------ + + * Updated debian build dependency to libgnutls-dev 2.4.1 or newer + * Use the default python interpreter instead of /usr/bin/python in + example, test and setup scripts + * Improved detection of gnutls libraries by using libgnutls-config + * Fixed gnutls library location for Mac OSX installations + +Changes in version 1.1.6 +------------------------ + + * Require libgnutls version 2.4.1 or higher. + +Changes in version 1.1.5 +------------------------ + + * Added server name extension support. + * Fixed 64-bit issues with size_t and ssize_t. + * Require libgnutls version 2.2.2 or higher. + +Changes in version 1.1.4 +------------------------ + + * Better integration with twisted. The TLSClient and TLSServer + classes now declare that they implement ISSLTransport. + +Changes in version 1.1.3 +------------------------ + + * Better version headers for changelog entries. + * Check if C module initialization failed. + +Changes in version 1.1.2 +------------------------ + + * Added LICENSE file and updated copyright notices to reference it. + * Only included the relevant examples in the source distribution. + * Avoid multiple splits on name/value pairs in X509Name. + +Changes in version 1.1.1 +------------------------ + + * Removed a circular reference manifesting on handshake failures. + +Changes in version 1.1.0 +------------------------ + + * Send TLS bye if the client session peer certificate verification fails + * Based CertificateError on GNUTLSError and added 4 new certificate related + exceptions derived from it. + * Added the ability to send TLS alerts based on certain error conditions + Using this mechanism a python exception related to GNUTLS can be mapped + to a TLS alert and sent to the peer which will map it back to the original + python exception, making it possible to transfer error conditions and + raise their corresponding exception on the other side that becomes this + way aware of the errors that occured in the peer. Currently this is used + to map certificate related exceptions into TLS alerts and back to python + exceptions on the other side. + * Send a TLS alert before closing a connection as a result of an error in + the twisted interface. + * Preserve closing reason while sending the close alerts. + * Pass the proper exception when a client connection fails. + * Improved some exception messages related to certificate errors. + * Added the ability to specify the certificate name to use in exceptions + raised by certificate checking methods, which helps improve the clarity + of the error messages. + * Set transport on protocol after the TCP connection is made, because we + may call connectionLost without calling connectionMade if TLS negociation + fails (which in turn will call connectionLost on the protocol). + * Added _closeWriteConnection to handle half closed connections. + +Changes in version 1.0.2 +------------------------ + + * Avoid the need to handle bye timeouts in the twisted interface by not + waiting for the bye notification acknowledgement as we do not use the + TCP connection anymore after closing the TLS session. + +Changes in version 1.0.1 +------------------------ + + * Fixed typo in internal class name in the twisted interface + diff --git a/python-gnutls-1.1.9/LICENSE b/python-gnutls-1.1.9/LICENSE new file mode 100644 index 0000000..a84c968 --- /dev/null +++ b/python-gnutls-1.1.9/LICENSE @@ -0,0 +1,20 @@ + +Copyright (C) 2006-2007 +AG Projects +Dan Pascu +Mircea Amarascu + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this library; if not, write to the Free Software Foundation, +Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. + diff --git a/python-gnutls-1.1.9/MANIFEST.in b/python-gnutls-1.1.9/MANIFEST.in new file mode 100644 index 0000000..e45dfeb --- /dev/null +++ b/python-gnutls-1.1.9/MANIFEST.in @@ -0,0 +1,3 @@ +recursive-include examples README crypto.py client.py server.py twisted-*.py +recursive-include examples certs/*.pem certs/valid.* certs/revoked.* +include MANIFEST.in LICENSE ChangeLog Makefile build_inplace diff --git a/python-gnutls-1.1.9/Makefile b/python-gnutls-1.1.9/Makefile new file mode 100644 index 0000000..9f01426 --- /dev/null +++ b/python-gnutls-1.1.9/Makefile @@ -0,0 +1,35 @@ + +export PYTHONPATH = $(PWD) + +HEADER_FILES = /usr/include/gnutls/gnutls.h /usr/include/gnutls/x509.h /usr/include/gnutls/openpgp.h /usr/include/gnutls/extra.h + +LIBRARIES = -lgnutls -lgnutls-extra + +all: gnutls-library + +gnutls-library: gnutls.xml + mv gnutls/library/__init__.py gnutls/library/__init__.py.tmp + touch gnutls/library/__init__.py + xml2py gnutls.xml -o gnutls/library/constants.py -v -kde -r ".*[Tt][Ll][Ss].*" + xml2py gnutls.xml -o gnutls/library/types.py -v -kst -r ".*[Tt][Ll][Ss].*" -m gnutls.library.constants + xml2py gnutls.xml -o gnutls/library/functions.py -v -kf -r ".*[Tt][Ll][Ss].*" $(LIBRARIES) -m gnutls.library.types -m gnutls.library.constants + mv gnutls/library/__init__.py.tmp gnutls/library/__init__.py + @echo "Fixing wrong argument types" + @CALLBACKS=`grep FUNCTYPE gnutls/library/types.py | cut -f 1 -d' '`; \ + cp gnutls/library/functions.py gnutls/library/functions.py.bak; \ + for cb in $$CALLBACKS; do \ + sed -i -r "s/POINTER\($$cb\)/$$cb/g" gnutls/library/functions.py; \ + done + @echo "Fixing 64 bit architecture issues" + @cp gnutls/library/types.py gnutls/library/types.py.bak; \ + sed -i -r "s/size_t = c_uint/size_t = c_size_t/g" gnutls/library/types.py; \ + sed -i -r "s/__ssize_t = c_int/__ssize_t = c_long/g" gnutls/library/types.py + +gnutls.xml: $(HEADER_FILES) + h2xml $(HEADER_FILES) -o gnutls.xml -q -c + +clean:: + rm -rf *~ gnutls.xml gnutls/__init__.pyc + (cd gnutls/library; rm -rf *.pyc constants.py types.py functions.py functions.py.bak) + +.PHONY: gnutls-library clean diff --git a/python-gnutls-1.1.9/PKG-INFO b/python-gnutls-1.1.9/PKG-INFO new file mode 100644 index 0000000..39109f3 --- /dev/null +++ b/python-gnutls-1.1.9/PKG-INFO @@ -0,0 +1,33 @@ +Metadata-Version: 1.0 +Name: python-gnutls +Version: 1.1.9 +Summary: Python wrapper for the GNUTLS library +Home-page: http://ag-projects.com/ +Author: Dan Pascu +Author-email: dan@ag-projects.com +License: LGPL +Download-URL: http://cheeseshop.python.org/pypi/python-gnutls/1.1.9 +Description: This package provides a high level object oriented wrapper around libgnutls, + as well as low level bindings to the GNUTLS types and functions via ctypes. + The high level wrapper hides the details of accessing the GNUTLS library via + ctypes behind a set of classes that encapsulate GNUTLS sessions, certificates + and credentials and expose them to python applications using a simple API. + + The package also includes a Twisted interface that has seamless intergration + with Twisted, providing connectTLS and listenTLS methods on the Twisted + reactor once imported (the methods are automatically attached to the reactor + by simply importing the GNUTLS Twisted interface module). + + The high level wrapper is written using the GNUTLS library bindings that are + made available via ctypes. This makes the wrapper very powerful and flexible + as it has direct access to all the GNUTLS internals and is also very easy to + extend without any need to write C code or recompile anything. + + +Platform: Platform Independent +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Topic :: Software Development :: Libraries :: Python Modules diff --git a/python-gnutls-1.1.9/README b/python-gnutls-1.1.9/README new file mode 100644 index 0000000..ef1052a --- /dev/null +++ b/python-gnutls-1.1.9/README @@ -0,0 +1,19 @@ + +Python wrapper for the GNUTLS library + +This package provides a high level object oriented wrapper around libgnutls, +as well as low level bindings to the GNUTLS types and functions via ctypes. +The high level wrapper hides the details of accessing the GNUTLS library via +ctypes behind a set of classes that encapsulate GNUTLS sessions, certificates +and credentials and expose them to python applications using a simple API. + +The package also includes a Twisted interface that has seamless intergration +with Twisted, providing connectTLS and listenTLS methods on the Twisted +reactor once imported (the methods are automatically attached to the reactor +by simply importing the GNUTLS Twisted interface module). + +The high level wrapper is written using the GNUTLS library bindings that are +made available via ctypes. This makes the wrapper very powerful and flexible +as it has direct access to all the GNUTLS internals and is also very easy to +extend without any need to write C code or recompile anything. + diff --git a/python-gnutls-1.1.9/build_inplace b/python-gnutls-1.1.9/build_inplace new file mode 100755 index 0000000..06748a0 --- /dev/null +++ b/python-gnutls-1.1.9/build_inplace @@ -0,0 +1,5 @@ +#!/bin/sh + +python setup.py build_ext --inplace +python setup.py clean + diff --git a/python-gnutls-1.1.9/examples/README b/python-gnutls-1.1.9/examples/README new file mode 100644 index 0000000..343359f --- /dev/null +++ b/python-gnutls-1.1.9/examples/README @@ -0,0 +1,21 @@ + +This directory holds some examples of using python-gnutls. + +- An example of writing a synchronous client and server using the + ClientSession and ServerSession classes from python-gnutls is + given in client.py and server.py + +- An example of writing an asynchronous client and server using the + python-gnutls twisted interface is given in twisted-client.py and + twisted-server.py + +- An example of working with X509 certificates and their attributes + as well as using a CRL to check their revocation is in crypto.py + + + +To run the examples without installing python-gnutls, run the following +command prior to trying the examples (after python-gnutls was built): + +export PYTHONPATH=/path/to/python-gnutls + diff --git a/python-gnutls-1.1.9/examples/certs/ca.pem b/python-gnutls-1.1.9/examples/certs/ca.pem new file mode 100644 index 0000000..6b81c20 --- /dev/null +++ b/python-gnutls-1.1.9/examples/certs/ca.pem @@ -0,0 +1,42 @@ +-----BEGIN CERTIFICATE----- +MIIHcTCCBVmgAwIBAgIJAPV2qch7qoEZMA0GCSqGSIb3DQEBBQUAMIGrMQswCQYD +VQQGEwJOTDEWMBQGA1UECBMNTm9vcmQtSG9vbGFuZDEQMA4GA1UEBxMHSGFhcmxl +bTEUMBIGA1UEChMLQUcgUHJvamVjdHMxFDASBgNVBAsTC0RldmVsb3BtZW50MSAw +HgYDVQQDExdBRyBQcm9qZWN0cyBEZXZlbG9wbWVudDEkMCIGCSqGSIb3DQEJARYV +ZGV2ZWxAYWctcHJvamVjdHMuY29tMB4XDTA3MDQwMzEyMTAwOFoXDTI3MDMyOTEy +MTAwOFowgasxCzAJBgNVBAYTAk5MMRYwFAYDVQQIEw1Ob29yZC1Ib29sYW5kMRAw +DgYDVQQHEwdIYWFybGVtMRQwEgYDVQQKEwtBRyBQcm9qZWN0czEUMBIGA1UECxML +RGV2ZWxvcG1lbnQxIDAeBgNVBAMTF0FHIFByb2plY3RzIERldmVsb3BtZW50MSQw +IgYJKoZIhvcNAQkBFhVkZXZlbEBhZy1wcm9qZWN0cy5jb20wggIiMA0GCSqGSIb3 +DQEBAQUAA4ICDwAwggIKAoICAQC1OQihc1t/UTcwZCEcz74t8nmzw6osCW7depcR +lPt7KCzamvBu+l/h5j5ONP3SJARCyoVcimMwgjB8NJGBkXCv8AOg4VXkxyfVI8/f +wm5STPZc2zg5ByPCxyrOn/QBtd787moSk8xfO59qHDfyGnhYOvLIJnwZFoXcnO6/ +KKd9RljiEI7+aG0uziYRoqzn1EC9UswAPkUOz/YwwBCvquoH+1IeYQyOxzAfkzAc +lf7mw8sHgl9F//jFgUUa+tV3oj/ZSgzEA5PtbT4uh8LZlaTDDjfgghFfTF2wKf3u +yMQWQ3kfnkaBEklRrx5hOPFoeqmnNwJGPxXWPoi6T/B+hNTtzpX1IzNTpz4AD+Vm +s2iFRc3CZvKSpq/+QvylPElWUXD5haPzjv7TFyvAvn7bIOjs8czhqD3ten9RbMBa +0AvQxr4m7KqeuOs0QdeiB74bf0FYWtIjleDJn84yFTQao7zCUEnXk+ib5dvBYGkR +j1gxNUzmmbrDb000i+mEE19hpcJ1zHOitBVoe/uECUo9Lvbf+jlRBHm+XM24POUk +cQD6TT37Z4gv7sVbjC3IljxZzxMxuC/gfkVygxmuDRFzIdwOWlbn1X/YhyrLGhBw +nkfw3Z+fuHHKwBaov16Sc7eZSEgrzkG0KtmeOjfxeVNFVwhcTXeIRbUw1Be/AeZA +DgfrFwIDAQABo4IBlDCCAZAwHQYDVR0OBBYEFJZ3T8wlA7XLQzOn1573ogHDCDj6 +MIHgBgNVHSMEgdgwgdWAFJZ3T8wlA7XLQzOn1573ogHDCDj6oYGxpIGuMIGrMQsw +CQYDVQQGEwJOTDEWMBQGA1UECBMNTm9vcmQtSG9vbGFuZDEQMA4GA1UEBxMHSGFh +cmxlbTEUMBIGA1UEChMLQUcgUHJvamVjdHMxFDASBgNVBAsTC0RldmVsb3BtZW50 +MSAwHgYDVQQDExdBRyBQcm9qZWN0cyBEZXZlbG9wbWVudDEkMCIGCSqGSIb3DQEJ +ARYVZGV2ZWxAYWctcHJvamVjdHMuY29tggkA9XapyHuqgRkwDwYDVR0TAQH/BAUw +AwEB/zARBglghkgBhvhCAQEEBAMCAQYwCQYDVR0SBAIwADArBglghkgBhvhCAQ0E +HhYcVGlueUNBIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAgBgNVHREEGTAXgRVkZXZl +bEBhZy1wcm9qZWN0cy5jb20wDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBBQUA +A4ICAQBkd1PtA3yYKZKtZz2xx3movWISQXsa6IfYxwlZGdL72catyuilcVCsPAD7 +UqUDRp/EyKZe2xN8vQm9yIBfA8fCnI/0nvSKpuPgYDOCKufesUiOkPVtVeOshXsC +QWQilM7o8oDpqCaZ84y853gdGMJaNMjctc7GzFOWJf7Bon2dYMWm/1muCWuBUMBq +PUJG5OaYrGU1E/pWntdqIFS9b+89q+tUd5OiGlz8OuXB7m0gtprj2VA+3lAc8QqZ +3FVCojhOLPKpe417BfgmHHA7233/5ARhmqVoEa791GpYFK/dV4tVLZcPxRF5+9QH +skSa80IVDOBqCZsBHb59DCnlZieG3CC3s7ddtPzwJ3zX3eBLnZ1EKMquSbEvAvI+ +tpdGSKHRXEZ/3M5b0FyKgBd+MBMExyupPTY+Fkhp1BkuCu6jH6OTBGqkFWU+9Onq +q79g3jYa3kqJFeK/k8L6Akl8jb8yX18hZIs2JiIZfmB3911OU6/rFWt/BRLLLYk/ +RfGa/BtMaSVFzXNTcUE9odCr6Y4DF801lXr6npn19/llPHGArAvyZ7MsrLNcgXKv +dIg/KCqHxd9ZhdW9p5ySfn0xw9j7F1KA6G0qRMQAOFbkVcCkJgyYIjtTSqTmL7IO +jd/OMQHcE/Tjx+zTGHGE+lqLdOG3JmyPtu5Baz490jIyxkkD3Q== +-----END CERTIFICATE----- diff --git a/python-gnutls-1.1.9/examples/certs/crl.pem b/python-gnutls-1.1.9/examples/certs/crl.pem new file mode 100644 index 0000000..d1eb221 --- /dev/null +++ b/python-gnutls-1.1.9/examples/certs/crl.pem @@ -0,0 +1,19 @@ +-----BEGIN X509 CRL----- +MIIDGjCCAQICAQEwDQYJKoZIhvcNAQEFBQAwgasxCzAJBgNVBAYTAk5MMRYwFAYD +VQQIEw1Ob29yZC1Ib29sYW5kMRAwDgYDVQQHEwdIYWFybGVtMRQwEgYDVQQKEwtB +RyBQcm9qZWN0czEUMBIGA1UECxMLRGV2ZWxvcG1lbnQxIDAeBgNVBAMTF0FHIFBy +b2plY3RzIERldmVsb3BtZW50MSQwIgYJKoZIhvcNAQkBFhVkZXZlbEBhZy1wcm9q +ZWN0cy5jb20XDTA3MDQwMzEyMjMwNFoXDTE3MDMzMTEyMjMwNFowIjAgAgECFw0w +NzA0MDMxMjIxNTlaMAwwCgYDVR0VBAMKAQEwDQYJKoZIhvcNAQEFBQADggIBAIoF +8pCAPnWt1kpao/TXkR80/ZOyrdKRAyo+hYejUJw41lxsWey4NUEwbWp9pnCWsL3s +DMrLt948PRzIqMhI/9zXhl4+ipuuWSTJAb4usMh3CG0vJsexzE1e8SMAnoJdE3Fu +5M2xCmd8loCaq3/oA05Ovv8Kc1KwTBiJUNQNvVEMhw9Wsn3mrFk2mWNlLa0vnANI +DlO9HFZJOrw0ipco03ACDxTGGQiNxw6Yjw+OCqMaV3AAE9GvE8VXy3PgeaDgvffM +9e71+6TC5j6S0S5c8P83NQpAAbYatQh5/McPd8b8o9ailj/rGt1krYxiLSUb12NE +yy6EmybdLJmat9nvMAlpbxtzdRQdX0E9aDQaK4J388OkMiT6P83ykEKT7qCloEk6 +vkAebqCexA/dqv+7+AsNe+h18iHB+aZxv0xU3NS1Te4X902AUj2n4UGtiOUELMgJ +leEN8Nh5R9a8/OsXQVLqqeMg6QmTjP3Y1PYNv4GSnJNAYMhEUPz19tC0E5kR4cLQ +Y7csgROnfo5EX7byeQK1PjSGTMOP5KMgdH1YpxSg43uuTk12ZJEqKYeIXa50KYCA +6OurC+2fOWQQogRnRlx94lOInfKeTlN7F09sMjBzIA+m9sKahKsZ00rHxuvcjP/e +ZN+qO9H56VmfcOefMRLRPSPwuwtQdR3udI/QyL4D +-----END X509 CRL----- diff --git a/python-gnutls-1.1.9/examples/certs/revoked.crt b/python-gnutls-1.1.9/examples/certs/revoked.crt new file mode 100644 index 0000000..d41bd3a --- /dev/null +++ b/python-gnutls-1.1.9/examples/certs/revoked.crt @@ -0,0 +1,34 @@ +-----BEGIN CERTIFICATE----- +MIIF4DCCA8igAwIBAgIBAjANBgkqhkiG9w0BAQUFADCBqzELMAkGA1UEBhMCTkwx +FjAUBgNVBAgTDU5vb3JkLUhvb2xhbmQxEDAOBgNVBAcTB0hhYXJsZW0xFDASBgNV +BAoTC0FHIFByb2plY3RzMRQwEgYDVQQLEwtEZXZlbG9wbWVudDEgMB4GA1UEAxMX +QUcgUHJvamVjdHMgRGV2ZWxvcG1lbnQxJDAiBgkqhkiG9w0BCQEWFWRldmVsQGFn +LXByb2plY3RzLmNvbTAeFw0wNzA0MDMxMjExMzFaFw0xNzAzMzExMjExMzFaMIGm +MQswCQYDVQQGEwJOTDEWMBQGA1UECBMNTm9vcmQtSG9vbGFuZDEQMA4GA1UEBxMH +SGFhcmxlbTEUMBIGA1UEChMLQUcgUHJvamVjdHMxFDASBgNVBAsTC0RldmVsb3Bt +ZW50MRwwGgYDVQQDExNSZXZva2VkIGNlcnRpZmljYXRlMSMwIQYJKoZIhvcNAQkB +FhR0ZXN0QGFnLXByb2plY3RzLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkC +gYEA+2k1ZYLmqLlogixTwVfZUw4WvfWjWXfTH0MJx4WynG7Oc7iLUw9KOCJaxOY+ +utE2etfRlVj4/SQ5JjgmkXuHfuaKpXXpWz7+na+YZqTcMs1cajGQ8sfdzQYKTlKw +vyHjAxDPCxG7HtXubiwkqqimABpD4leloT/cQNBfmNGCGU0CAwEAAaOCAZQwggGQ +MAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgZAMCsGCWCGSAGG+EIBDQQeFhxU +aW55Q0EgR2VuZXJhdGVkIENlcnRpZmljYXRlMB0GA1UdDgQWBBSuCSZulRupp+T6 +AuKl/0OYvpPBbzCB4AYDVR0jBIHYMIHVgBSWd0/MJQO1y0Mzp9ee96IBwwg4+qGB +saSBrjCBqzELMAkGA1UEBhMCTkwxFjAUBgNVBAgTDU5vb3JkLUhvb2xhbmQxEDAO +BgNVBAcTB0hhYXJsZW0xFDASBgNVBAoTC0FHIFByb2plY3RzMRQwEgYDVQQLEwtE +ZXZlbG9wbWVudDEgMB4GA1UEAxMXQUcgUHJvamVjdHMgRGV2ZWxvcG1lbnQxJDAi +BgkqhkiG9w0BCQEWFWRldmVsQGFnLXByb2plY3RzLmNvbYIJAPV2qch7qoEZMCAG +A1UdEgQZMBeBFWRldmVsQGFnLXByb2plY3RzLmNvbTAfBgNVHREEGDAWgRR0ZXN0 +QGFnLXByb2plY3RzLmNvbTANBgkqhkiG9w0BAQUFAAOCAgEApOy1uTOLlzZX4aMg +hy+k7ginbqRWLgZNSvgbUAs1oIiLxB5DnWr7+S6eOw6ao4xaXAUdffL0RjlI30DQ +hS/nWbHGePG65E2qFIPjnielEORrp5xI5mYbz221Khs9A51r/UIUzCPcRgKzZmpH +K2o0YApw61JWIl7LCsnoBPfOexe5GPJBVJDvOkdrqL/DdH8YrMyPpbawe/q5yh+5 +aYvwdKr9q6RL+WatOXKh4vQ1kcB8g7RGsAG8i2+hUGHTpyE2sJzNnsf/jGYeqPv/ +lTXjWOgKpdoIwjOetwpY0PXnnV4UESTQ9HA54pIv7wrB+Jfj38wD9DTk4YVlKcVc +nSJpNpZvj336G8fdypUOufGLH9KuYMOMv/6KA79gAicFbOsbzbZwDnZ5+zDqZMTx +F/k8+X+ofArJrva0jw8xe6LAwmxwRLVfurVZU1edqCh8LD+oV84V4wlJGYcMDqi5 +EaIXA0oOn1pUQEhnv/yTL6OH/N8BtpyC055Uw/rrU4N/N1umlV1ePdGh6ntyECSY +T8ZAziBUyzdkE3EpHuR15Dx0u3ah7uEBKejxUUYWs2mlEO5nxQCuGrtMSkv5+Y8g +duOXKuAGfQXMOBO8njGEwfInHKEQeeiPeZZMXjm3yuY/zyMSdI7wDgmvZzJhKtuK +4eds2Jp+RGmYDlNnq1ZazlAz3kc= +-----END CERTIFICATE----- diff --git a/python-gnutls-1.1.9/examples/certs/revoked.key b/python-gnutls-1.1.9/examples/certs/revoked.key new file mode 100644 index 0000000..f223826 --- /dev/null +++ b/python-gnutls-1.1.9/examples/certs/revoked.key @@ -0,0 +1,15 @@ +-----BEGIN RSA PRIVATE KEY----- +MIICXgIBAAKBgQD7aTVlguaouWiCLFPBV9lTDha99aNZd9MfQwnHhbKcbs5zuItT +D0o4IlrE5j660TZ619GVWPj9JDkmOCaRe4d+5oqldelbPv6dr5hmpNwyzVxqMZDy +x93NBgpOUrC/IeMDEM8LEbse1e5uLCSqqKYAGkPiV6WhP9xA0F+Y0YIZTQIDAQAB +AoGBANKqwjehjK5tTollo3krp8vUznG2134szhgwEI3EFnrGzvBg/z5GXabUAsNj +O8VHciNVnSVMPLfCFrFT892MaWffkEYwkyrkX+VUZYlRoMeNE/xT4BzPFchHg1rw +I8rwFRWZumHB0AhKzg7N015/cxNar2aIKtU5m833NrN9K3vxAkEA/7yFJLsAuPHT +scqPMXQ0XW/7P74lSFYHtbLOihVr/4myzLqpwuUvL55q1Ixi4AF/UHZ29pLilbDQ +jQIKfT6K9wJBAPurjBJ8E0unfg+UYhx7/ws718uiDqJ7E0nC37RTOO+qyqZF4687 +B0yOIt/MbwDRUQttArLoNIv+nSs7yvzCiNsCQQDEZWjyzlI9tinXTjItzoowf8E6 +MLK9HKSLG6iWTuFDu+H+bBPXQt67+TMdzDpawYuepXuy3Rb50nI2+CxKBu/9AkEA +8/SOizyK18M8h42mrUXlLNaNkG8/EHGNeOrWPs6NWoWMezE0TCBEKwl89MQOthQx +I4pAG3zLswjVAZusYOeSEQJAdHhBRhk8EHgo/rMITeL0sGRH3nT82oPOJIPLDoDQ +1T8aRVTvTtSsBXSadBw+cwmfgl2Z5GCmAmFoRS6bZqZCHQ== +-----END RSA PRIVATE KEY----- diff --git a/python-gnutls-1.1.9/examples/certs/valid.crt b/python-gnutls-1.1.9/examples/certs/valid.crt new file mode 100644 index 0000000..10a3066 --- /dev/null +++ b/python-gnutls-1.1.9/examples/certs/valid.crt @@ -0,0 +1,34 @@ +-----BEGIN CERTIFICATE----- +MIIF3jCCA8agAwIBAgIBATANBgkqhkiG9w0BAQUFADCBqzELMAkGA1UEBhMCTkwx +FjAUBgNVBAgTDU5vb3JkLUhvb2xhbmQxEDAOBgNVBAcTB0hhYXJsZW0xFDASBgNV +BAoTC0FHIFByb2plY3RzMRQwEgYDVQQLEwtEZXZlbG9wbWVudDEgMB4GA1UEAxMX +QUcgUHJvamVjdHMgRGV2ZWxvcG1lbnQxJDAiBgkqhkiG9w0BCQEWFWRldmVsQGFn +LXByb2plY3RzLmNvbTAeFw0wNzA0MDMxMjEwNTFaFw0xNzAzMzExMjEwNTFaMIGk +MQswCQYDVQQGEwJOTDEWMBQGA1UECBMNTm9vcmQtSG9vbGFuZDEQMA4GA1UEBxMH +SGFhcmxlbTEUMBIGA1UEChMLQUcgUHJvamVjdHMxFDASBgNVBAsTC0RldmVsb3Bt +ZW50MRowGAYDVQQDExFWYWxpZCBjZXJ0aWZpY2F0ZTEjMCEGCSqGSIb3DQEJARYU +dGVzdEBhZy1wcm9qZWN0cy5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB +AKYb9BLca4J3yszyRaMC+zvJKheOsROYFN9wIc+EAFO5RUFEFRQ/Ahfw2AmY+1bn +S5K7tMV8J54coHI0ROohskTEXKx1iF+67Krezf3tfUY0zGPhTGaXJ2OkReAmZQvj +a4IhWxBTQBFq1bbpDpOy/DJ24nBEgJoPTULfqGx5IVoJAgMBAAGjggGUMIIBkDAJ +BgNVHRMEAjAAMBEGCWCGSAGG+EIBAQQEAwIGQDArBglghkgBhvhCAQ0EHhYcVGlu +eUNBIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUDN4YV9HDpJrHcbzV +8Ayu0Lymh2AwgeAGA1UdIwSB2DCB1YAUlndPzCUDtctDM6fXnveiAcMIOPqhgbGk +ga4wgasxCzAJBgNVBAYTAk5MMRYwFAYDVQQIEw1Ob29yZC1Ib29sYW5kMRAwDgYD +VQQHEwdIYWFybGVtMRQwEgYDVQQKEwtBRyBQcm9qZWN0czEUMBIGA1UECxMLRGV2 +ZWxvcG1lbnQxIDAeBgNVBAMTF0FHIFByb2plY3RzIERldmVsb3BtZW50MSQwIgYJ +KoZIhvcNAQkBFhVkZXZlbEBhZy1wcm9qZWN0cy5jb22CCQD1dqnIe6qBGTAgBgNV +HRIEGTAXgRVkZXZlbEBhZy1wcm9qZWN0cy5jb20wHwYDVR0RBBgwFoEUdGVzdEBh +Zy1wcm9qZWN0cy5jb20wDQYJKoZIhvcNAQEFBQADggIBABCal7eKH7K5UmMt2CRh +xjLdpLfo2d83dCSvAerabfyLYuSE4qg4pP6x1P3vBGFVuMc504AF+TwZIOLWQ47U +b0NbzNi49NGPKjCUsjZiAhGE9SBjiac2xZXUW7UytkVlboyeqKn3Tc9rMT+THd/y +wJj5Nqz2vcAcJ1LSpKs/c+NFE3KX+gdaiQtkgUZfkGBz2N6gvXn6r6w1sY/j8Gdw +wuVXHv2pbM2zkhUFIFJbuT/3AEQlM2sqk7fVEHlm9cLOtzHsoBVo0pnSw/8mcl5J +Z6oss51eR8zLVBhU3XrKTbammHv8uZ2vawRKuUR2Ot2RfINAPdwiW6r61ugBj/ux +HGTmY8uO1Zx8dpNS/cC+HtjTKqD2zaBa6dX+6USf+4jgrVismMGAtUCX7IlwjNYV +/p5TiwovA5p+xC2KWb9d0vTr8pGHV6vyDaE5Ba0jLfEjkT6b4MbZmWanUDUkYHuy +P31NTgUPrIiU83bKfBlQZbS5YsyspdJQBzuGuon68Bw/ULpfERdRlipeTpkDhUn3 +gAAS0iLwgPybw8d9/d16nKPCdtSjDBvOUmMLPc0FqggvSGeFkkDn5hiN6eJ4DgTA +Ze5X9kpc57dV2SvA1eqPCkmA8pZfPWaJtwf5AiiOzhGUAAx4+4hXyRWULIJXNCcD +175SpToDKAei7ZSJfaiqPU/T +-----END CERTIFICATE----- diff --git a/python-gnutls-1.1.9/examples/certs/valid.key b/python-gnutls-1.1.9/examples/certs/valid.key new file mode 100644 index 0000000..694caed --- /dev/null +++ b/python-gnutls-1.1.9/examples/certs/valid.key @@ -0,0 +1,15 @@ +-----BEGIN RSA PRIVATE KEY----- +MIICWwIBAAKBgQCmG/QS3GuCd8rM8kWjAvs7ySoXjrETmBTfcCHPhABTuUVBRBUU +PwIX8NgJmPtW50uSu7TFfCeeHKByNETqIbJExFysdYhfuuyq3s397X1GNMxj4Uxm +lydjpEXgJmUL42uCIVsQU0ARatW26Q6TsvwyduJwRICaD01C36hseSFaCQIDAQAB +AoGAC6qs8uIuXuSBBvIBOBjOgn13il4IS+MDnEno5gVUbIz3s0TP4jMmt32//rSS ++qCWK0EpyjEVK0LBdiP7ryIcviC3EMU33SErqSPdpJN/UOYePn5CX45d30OyDL/J +1ai4AsQbG9twe5cOJae8ZLa76O4Q82MTxN2agrSoV41lcu0CQQDZID9NbHioGBPE +cgwzwgTAWXc+sdHKsEJERxCPGyqChuFwFjgTdl0MQms3mclAOUq/23j6XYHkjG7o +YS3FcBaTAkEAw9lnMKN5kF3/9xxZxmr62qm6RlgvpdgW4zs9m7SVGSq7fio07i4z +a/5RGC0Tr/WzfjHD1+SyUEXmT1DMl7eycwJAQUX2gdoYM8B5QNdgX7b2IrVCqfBf +N2XhphEPI1ZxYygVYdLsLL2qn2LgRKjQ3aPbmu3p4qp1wDWPqgB8+BwITQJAP1nA +fkQy21b8qCM8iukp8bc7MOvvpbarWJ9eA1K7c+OVuG7Qpka9jW47LxXNq3pPsD9K +uTgZ0ct6fyeEtoLOLwJAM1Eeopu3wSkNbf2p4TbhePc5ASZRR2c1GZZQE4GIYamB +yEk53aQ5MDpHLffWdWI7vZ449s/AHwrN6txlu/+VTQ== +-----END RSA PRIVATE KEY----- diff --git a/python-gnutls-1.1.9/examples/client.py b/python-gnutls-1.1.9/examples/client.py new file mode 100755 index 0000000..c6e4208 --- /dev/null +++ b/python-gnutls-1.1.9/examples/client.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python + +"""Synchronous client using python-gnutls""" + +import sys +import os +import socket + +from gnutls.crypto import * +from gnutls.connection import * + +script_path = os.path.realpath(os.path.dirname(sys.argv[0])) +certs_path = os.path.join(script_path, 'certs') + +cert = X509Certificate(open(certs_path + '/valid.crt').read()) +key = X509PrivateKey(open(certs_path + '/valid.key').read()) +ca = X509Certificate(open(certs_path + '/ca.pem').read()) +crl = X509CRL(open(certs_path + '/crl.pem').read()) +cred = X509Credentials(cert, key) + +sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) +session = ClientSession(sock, cred) + +session.connect(('localhost', 10000)) +session.handshake() +session.send("test\r\n") +buf = session.recv(1024) +print 'Received: ', buf.rstrip() +session.bye() +session.shutdown() +session.close() + diff --git a/python-gnutls-1.1.9/examples/crypto.py b/python-gnutls-1.1.9/examples/crypto.py new file mode 100755 index 0000000..cbb29c9 --- /dev/null +++ b/python-gnutls-1.1.9/examples/crypto.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python + +"""Cryptographic examples using python-gnutls""" + +import sys +import os +import time + +from gnutls.crypto import * + +script_path = os.path.realpath(os.path.dirname(sys.argv[0])) +certs_path = os.path.join(script_path, 'certs') + +cert = X509Certificate(open(certs_path + '/valid.crt').read()) +crl = X509CRL(open(certs_path + '/crl.pem').read()) + +print '' + +print 'CRL certs/crl.pem:' +print '------------------' +print 'CRL issuer:' +print ' CN = %s' % crl.issuer.CN # or crl.issuer.common_name +print ' O = %s' % crl.issuer.O # or crl.issuer.organization +print ' OU = %s' % crl.issuer.OU # or crl.issuer.organization_unit +print ' C = %s' % crl.issuer.C # or crl.issuer.country +print ' ST = %s' % crl.issuer.ST # or crl.issuer.state +print ' L = %s' % crl.issuer.L # or crl.issuer.locality +print ' EMAIL = %s' % crl.issuer.EMAIL # or crl.issuer.email +print 'CRL version:', crl.version +print 'CRL count: ', crl.count +print '' + +print 'Certificate certs/valid.crt:' +print '----------------------------' +print 'Cert subject:' +print ' CN = %s' % cert.subject.CN # or cert.subject.common_name +print ' O = %s' % cert.subject.O # or cert.subject.organization +print ' OU = %s' % cert.subject.OU # or cert.subject.organization_unit +print ' C = %s' % cert.subject.C # or cert.subject.country +print ' ST = %s' % cert.subject.ST # or cert.subject.state +print ' L = %s' % cert.subject.L # or cert.subject.locality +print ' EMAIL = %s' % cert.subject.EMAIL # or cert.subject.email +print 'Cert issuer:' +print ' CN = %s' % cert.issuer.CN # or cert.issuer.common_name +print ' O = %s' % cert.issuer.O # or cert.issuer.organization +print ' OU = %s' % cert.issuer.OU # or cert.issuer.organization_unit +print ' C = %s' % cert.issuer.C # or cert.issuer.country +print ' ST = %s' % cert.issuer.ST # or cert.issuer.state +print ' L = %s' % cert.issuer.L # or cert.issuer.locality +print ' EMAIL = %s' % cert.issuer.EMAIL # or cert.issuer.email +print 'Cert serial: ', cert.serial_number +print 'Cert version: ', cert.version +print 'Cert activation:', time.ctime(cert.activation_time) +print 'Cert expiration:', time.ctime(cert.expiration_time) +print 'Cert is revoked:', crl.is_revoked(cert) +print '' + +cert = X509Certificate(open(certs_path + '/revoked.crt').read()) + +print 'Certificate certs/revoked.crt:' +print '------------------------------' +print 'Cert subject:' +print ' CN = %s' % cert.subject.common_name # here we use long names +print ' O = %s' % cert.subject.organization +print ' OU = %s' % cert.subject.organization_unit +print ' C = %s' % cert.subject.country +print ' ST = %s' % cert.subject.state +print ' L = %s' % cert.subject.locality +print ' EMAIL = %s' % cert.subject.email +print 'Cert issuer:' +print ' CN = %s' % cert.issuer.common_name +print ' O = %s' % cert.issuer.organization +print ' OU = %s' % cert.issuer.organization_unit +print ' C = %s' % cert.issuer.country +print ' ST = %s' % cert.issuer.state +print ' L = %s' % cert.issuer.locality +print ' EMAIL = %s' % cert.issuer.email +print 'Cert serial: ', cert.serial_number +print 'Cert version: ', cert.version +print 'Cert activation:', time.ctime(cert.activation_time) +print 'Cert expiration:', time.ctime(cert.expiration_time) +print 'Cert is revoked:', crl.is_revoked(cert) +print '' + diff --git a/python-gnutls-1.1.9/examples/server.py b/python-gnutls-1.1.9/examples/server.py new file mode 100755 index 0000000..e7d744d --- /dev/null +++ b/python-gnutls-1.1.9/examples/server.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python + +"""Synchronous server using python-gnutls""" + +import sys +import os +import socket + +from gnutls.crypto import * +from gnutls.connection import * + +script_path = os.path.realpath(os.path.dirname(sys.argv[0])) +certs_path = os.path.join(script_path, 'certs') + +cert = X509Certificate(open(certs_path + '/valid.crt').read()) +key = X509PrivateKey(open(certs_path + '/valid.key').read()) +ca = X509Certificate(open(certs_path + '/ca.pem').read()) +crl = X509CRL(open(certs_path + '/crl.pem').read()) +cred = X509Credentials(cert, key, [ca], [crl]) + +sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) +sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) +ssf = ServerSessionFactory(sock, cred) +ssf.bind(('0.0.0.0', 10000)) +ssf.listen(100) + +while True: + session, address = ssf.accept() + try: + session.handshake() + peer_cert = session.peer_certificate + try: + peer_name = peer_cert.subject + except AttributeError: + peer_name = 'Unknown' + print '\nNew connection from:', peer_name + print 'Protocol: ', session.protocol + print 'KX algorithm: ', session.kx_algorithm + print 'Cipher: ', session.cipher + print 'MAC algorithm:', session.mac_algorithm + print 'Compression: ', session.compression + session.verify_peer() + cred.check_certificate(peer_cert, cert_name='peer certificate') + except Exception, e: + print 'Handshake failed:', e + session.bye() + else: + while True: + try: + buf = session.recv(1024) + if buf == 0 or buf == '': + print "Peer has closed the session" + break + else: + if buf.strip().lower() == 'quit': + print "Got quit command, closing connection" + session.bye() + break + session.send(buf) + except Exception, e: + print "Error in reception: ", e + break + session.shutdown() + session.close() diff --git a/python-gnutls-1.1.9/examples/twisted-client.py b/python-gnutls-1.1.9/examples/twisted-client.py new file mode 100755 index 0000000..0bcb8ca --- /dev/null +++ b/python-gnutls-1.1.9/examples/twisted-client.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python + +"""Asynchronous client using Twisted with GNUTLS""" + +import sys +import os + +from twisted.internet.protocol import ClientFactory +from twisted.protocols.basic import LineOnlyReceiver +from twisted.internet import reactor + +from gnutls.constants import * +from gnutls.crypto import * +from gnutls.errors import * +from gnutls.interfaces.twisted import X509Credentials + +class EchoProtocol(LineOnlyReceiver): + + def connectionMade(self): + self.sendLine('echo') + + def lineReceived(self, line): + print 'received: ', line + self.transport.loseConnection() + + def connectionLost(self, reason): + reactor.stop() + +class EchoFactory(ClientFactory): + protocol = EchoProtocol + + def clientConnectionFailed(self, connector, err): + print err.value + reactor.stop() + + +script_path = os.path.realpath(os.path.dirname(sys.argv[0])) +certs_path = os.path.join(script_path, 'certs') + +cert = X509Certificate(open(certs_path + '/valid.crt').read()) +key = X509PrivateKey(open(certs_path + '/valid.key').read()) +ca = X509Certificate(open(certs_path + '/ca.pem').read()) +crl = X509CRL(open(certs_path + '/crl.pem').read()) +cred = X509Credentials(cert, key, [ca]) +cred.verify_peer = True + +reactor.connectTLS('localhost', 10000, EchoFactory(), cred) +reactor.run() + diff --git a/python-gnutls-1.1.9/examples/twisted-server.py b/python-gnutls-1.1.9/examples/twisted-server.py new file mode 100755 index 0000000..67e14e6 --- /dev/null +++ b/python-gnutls-1.1.9/examples/twisted-server.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python + +"""Asynchronous server using Twisted with GNUTLS""" + +import sys +import os + +from twisted.internet.protocol import Factory +from twisted.protocols.basic import LineOnlyReceiver +from twisted.internet.error import CannotListenError, ConnectionDone +from twisted.internet import reactor + +from gnutls.constants import * +from gnutls.crypto import * +from gnutls.errors import * +from gnutls.interfaces.twisted import X509Credentials + +class EchoProtocol(LineOnlyReceiver): + + def connectionMade(self): + session = self.transport.socket + try: + peer_name = session.peer_certificate.subject + except AttributeError: + peer_name = 'Unknown' + print '\nNew connection from:', peer_name + print 'Protocol: ', session.protocol + print 'KX algorithm: ', session.kx_algorithm + print 'Cipher: ', session.cipher + print 'MAC algorithm:', session.mac_algorithm + print 'Compression: ', session.compression + + def lineReceived(self, line): + if line == 'quit': + self.transport.loseConnection() + return + self.sendLine(line) + + def connectionLost(self, reason): + if reason.type != ConnectionDone: + print "Connection was lost:", str(reason.value) + +class EchoFactory(Factory): + protocol = EchoProtocol + +script_path = os.path.realpath(os.path.dirname(sys.argv[0])) +certs_path = os.path.join(script_path, 'certs') + +cert = X509Certificate(open(certs_path + '/valid.crt').read()) +key = X509PrivateKey(open(certs_path + '/valid.key').read()) +ca = X509Certificate(open(certs_path + '/ca.pem').read()) +crl = X509CRL(open(certs_path + '/crl.pem').read()) +cred = X509Credentials(cert, key, [ca], [crl]) +cred.verify_peer = True +cred.session_params.compressions = (COMP_LZO, COMP_DEFLATE, COMP_NULL) + +reactor.listenTLS(10000, EchoFactory(), cred) +reactor.run() + diff --git a/python-gnutls-1.1.9/gnutls/__init__.py b/python-gnutls-1.1.9/gnutls/__init__.py new file mode 100644 index 0000000..c72f309 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/__init__.py @@ -0,0 +1,5 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# + +__version__ = '1.1.9' + diff --git a/python-gnutls-1.1.9/gnutls/connection.py b/python-gnutls-1.1.9/gnutls/connection.py new file mode 100644 index 0000000..5990bd4 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/connection.py @@ -0,0 +1,500 @@ +# Copyright (C) 2007-2008 AG Projects. See LICENSE for details. +# + +"""GNUTLS connection support""" + +__all__ = ['X509Credentials', 'ClientSession', 'ServerSession', 'ServerSessionFactory'] + +from time import time +from socket import SHUT_RDWR as SOCKET_SHUT_RDWR + +from _ctypes import PyObj_FromPtr +from ctypes import * + +from gnutls.validators import * +from gnutls.constants import * +from gnutls.crypto import * +from gnutls.errors import * + +from gnutls.library.constants import GNUTLS_SERVER, GNUTLS_CLIENT, GNUTLS_CRT_X509 +from gnutls.library.constants import GNUTLS_CERT_INVALID, GNUTLS_CERT_REVOKED, GNUTLS_CERT_INSECURE_ALGORITHM +from gnutls.library.constants import GNUTLS_CERT_SIGNER_NOT_FOUND, GNUTLS_CERT_SIGNER_NOT_CA +from gnutls.library.constants import GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE +from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY +from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED +from gnutls.library.constants import GNUTLS_NAME_DNS +from gnutls.library.types import gnutls_certificate_credentials_t, gnutls_session_t, gnutls_x509_crt_t +from gnutls.library.types import gnutls_certificate_server_retrieve_function +from gnutls.library.functions import * + + +@gnutls_certificate_server_retrieve_function +def _retrieve_server_certificate(c_session, retr_st): + session = PyObj_FromPtr(gnutls_session_get_ptr(c_session)) + identity = session.credentials.select_server_identity(session) + retr_st.contents.type = GNUTLS_CRT_X509 + retr_st.contents.deinit_all = 0 + if identity is None: + retr_st.contents.ncerts = 0 + else: + retr_st.contents.ncerts = 1 + retr_st.contents.cert.x509.contents = identity.cert._c_object + retr_st.contents.key.x509 = identity.key._c_object + return 0 + + +class _ServerNameIdentities(dict): + """Used internally by X509Credentials to map server names to X509 identities for the server name extension""" + def __init__(self, identities): + dict.__init__(self) + for identity in identities: + self.add(identity) + def add(self, identity): + for name in identity.cert.alternative_names.dns: + self[name.lower()] = identity + for ip in identity.cert.alternative_names.ip: + self[ip] = identity + subject = identity.cert.subject + if subject.CN is not None: + self[subject.CN.lower()] = identity + def get(self, server_name, default=None): + server_name = server_name.lower() + if server_name in self: + return self[server_name] + for name in (n for n in self if n.startswith('*.')): + suffix = name[1:] + if server_name.endswith(suffix) and '.' not in server_name[:-len(suffix)]: + return self[name] + return default + + +class X509Credentials(object): + DH_BITS = 1024 + RSA_BITS = 1024 + + dh_params = None + rsa_params = None + + def __new__(cls, *args, **kwargs): + c_object = gnutls_certificate_credentials_t() + gnutls_certificate_allocate_credentials(byref(c_object)) + instance = object.__new__(cls) + instance.__deinit = gnutls_certificate_free_credentials + instance._c_object = c_object + return instance + + @method_args((X509Certificate, none), (X509PrivateKey, none), list_of(X509Certificate), list_of(X509CRL), list_of(X509Identity)) + def __init__(self, cert=None, key=None, trusted=[], crl_list=[], identities=[]): + """Credentials contain a X509 certificate, a private key, a list of trusted CAs and a list of CRLs (all optional). + An optional list of additional X509 identities can be specified for applications that need more that one identity""" + if cert and key: + gnutls_certificate_set_x509_key(self._c_object, byref(cert._c_object), 1, key._c_object) + elif (cert, key) != (None, None): + raise ValueError("Specify neither or both the certificate and private key") + gnutls_certificate_server_set_retrieve_function(self._c_object, _retrieve_server_certificate) + self._max_depth = 5 + self._max_bits = 8200 + self._type = CRED_CERTIFICATE + self._cert = cert + self._key = key + self._identities = tuple(identities) + self._trusted = () + self.add_trusted(trusted) + self.crl_list = crl_list + self.server_name_identities = _ServerNameIdentities(identities) + if cert and key: + self.server_name_identities.add(X509Identity(cert, key)) + self.session_params = SessionParams(self._type) + + def __del__(self): + self.__deinit(self._c_object) + + # Methods to alter the credentials at runtime + + @method_args(list_of(X509Certificate)) + def add_trusted(self, trusted): + size = len(trusted) + if size > 0: + ca_list = (gnutls_x509_crt_t * size)(*[cert._c_object for cert in trusted]) + gnutls_certificate_set_x509_trust(self._c_object, cast(byref(ca_list), POINTER(gnutls_x509_crt_t)), size) + self._trusted = self._trusted + tuple(trusted) + + def generate_dh_params(self, bits=DH_BITS): + reference = self.dh_params ## keep a reference to preserve it until replaced + X509Credentials.dh_params = DHParams(bits) + del reference + + def generate_rsa_params(self, bits=RSA_BITS): + reference = self.rsa_params ## keep a reference to preserve it until replaced + X509Credentials.rsa_params = RSAParams(bits) + del reference + + # Properties + + @property + def cert(self): + return self._cert + + @property + def key(self): + return self._key + + @property + def identities(self): + return self._identities + + @property + def trusted(self): + return self._trusted + + def _get_crl_list(self): + return self._crl_list + @method_args(list_of(X509CRL)) + def _set_crl_list(self, crl_list): + self._crl_list = tuple(crl_list) + crl_list = property(_get_crl_list, _set_crl_list) + del _get_crl_list, _set_crl_list + + def _get_max_verify_length(self): + return self._max_depth + @method_args(int) + def _set_max_verify_length(self, max_depth): + gnutls_certificate_set_verify_limits(self._c_object, self._max_bits, max_depth) + self._max_depth = max_depth + max_verify_length = property(_get_max_verify_length, _set_max_verify_length) + del _get_max_verify_length, _set_max_verify_length + + def _get_max_verify_bits(self): + return self._max_bits + @method_args(int) + def _set_max_verify_bits(self, max_bits): + gnutls_certificate_set_verify_limits(self._c_object, max_bits, self._max_depth) + self._max_bits = max_bits + max_verify_bits = property(_get_max_verify_bits, _set_max_verify_bits) + del _get_max_verify_bits, _set_max_verify_bits + + # Methods to select and validate certificates + + def check_certificate(self, cert, cert_name='certificate'): + """Verify activation, expiration and revocation for the given certificate""" + now = time() + if cert.activation_time > now: + raise CertificateExpiredError("%s is not yet activated" % cert_name) + if cert.expiration_time < now: + raise CertificateExpiredError("%s has expired" % cert_name) + for crl in self.crl_list: + crl.check_revocation(cert, cert_name=cert_name) + + def select_server_identity(self, session): + """Select which identity the server will use for a given session. The default selection algorithm uses + the server name extension. A subclass can overwrite it if a different selection algorithm is desired.""" + server_name = session.server_name + if server_name is not None: + return self.server_name_identities.get(server_name) + elif self.cert and self.key: + return self ## since we have the cert and key attributes we can behave like a X509Identity + else: + return None + + +class SessionParams(object): + _default_kx_algorithms = { + CRED_CERTIFICATE: (KX_RSA, KX_DHE_DSS, KX_DHE_RSA), + CRED_ANON: (KX_ANON_DH,)} + _all_kx_algorithms = { + CRED_CERTIFICATE: set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT)), + CRED_ANON: set((KX_ANON_DH,))} + + def __new__(cls, credentials_type): + if credentials_type not in cls._default_kx_algorithms: + raise TypeError("Unknown credentials type: %r" % credentials_type) + return object.__new__(cls) + + def __init__(self, credentials_type): + self._credentials_type = credentials_type + self._protocols = (PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3) + self._kx_algorithms = self._default_kx_algorithms[credentials_type] + self._ciphers = (CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128) + self._mac_algorithms = (MAC_SHA1, MAC_MD5, MAC_RMD160) + self._compressions = (COMP_NULL,) + + def _get_protocols(self): + return self._protocols + def _set_protocols(self, protocols): + self._protocols = ProtocolListValidator(protocols) + protocols = property(_get_protocols, _set_protocols) + del _get_protocols, _set_protocols + + def _get_kx_algorithms(self): + return self._kx_algorithms + def _set_kx_algorithms(self, algorithms): + cred_type = self._credentials_type + algorithms = KeyExchangeListValidator(algorithms) + invalid = set(algorithms) - self._all_kx_algorithms[cred_type] + if invalid: + raise ValueError("Cannot specify %r with %r credentials" % (list(invalid), cred_type)) + self._kx_algorithms = algorithms + kx_algorithms = property(_get_kx_algorithms, _set_kx_algorithms) + del _get_kx_algorithms, _set_kx_algorithms + + def _get_ciphers(self): + return self._ciphers + def _set_ciphers(self, ciphers): + self._ciphers = CipherListValidator(ciphers) + ciphers = property(_get_ciphers, _set_ciphers) + del _get_ciphers, _set_ciphers + + def _get_mac_algorithms(self): + return self._mac_algorithms + def _set_mac_algorithms(self, algorithms): + self._mac_algorithms = MACListValidator(algorithms) + mac_algorithms = property(_get_mac_algorithms, _set_mac_algorithms) + del _get_mac_algorithms, _set_mac_algorithms + + def _get_compressions(self): + return self._compressions + def _set_compressions(self, compressions): + self._compressions = CompressionListValidator(compressions) + compressions = property(_get_compressions, _set_compressions) + del _get_compressions, _set_compressions + + +class Session(object): + """Abstract class representing a TLS session created from a TCP socket + and a Credentials object.""" + + session_type = None ## placeholder for GNUTLS_SERVER or GNUTLS_CLIENT as defined by subclass + + def __new__(cls, *args, **kwargs): + if cls is Session: + raise RuntimeError("Session cannot be instantiated directly") + instance = object.__new__(cls) + instance.__deinit = gnutls_deinit + instance._c_object = gnutls_session_t() + return instance + + def __init__(self, socket, credentials): + gnutls_init(byref(self._c_object), self.session_type) + ## Store a pointer to self on the C session + gnutls_session_set_ptr(self._c_object, id(self)) + # gnutls_dh_set_prime_bits(session, DH_BITS)? + gnutls_transport_set_ptr(self._c_object, socket.fileno()) + gnutls_handshake_set_private_extensions(self._c_object, 1) + self.socket = socket + self.credentials = credentials + self._update_params() + + def __del__(self): + self.__deinit(self._c_object) + + def __getattr__(self, name): + ## Generic wrapper for the underlying socket methods and attributes. + return getattr(self.socket, name) + + # Session properties + + def _get_credentials(self): + return self._credentials + @method_args(X509Credentials) + def _set_credentials(self, credentials): + ## Release all credentials, otherwise gnutls will only release an existing credential of + ## the same type as the one being set and we can end up with multiple credentials in C. + gnutls_credentials_clear(self._c_object) + gnutls_credentials_set(self._c_object, credentials._type, cast(credentials._c_object, c_void_p)) + self._credentials = credentials + credentials = property(_get_credentials, _set_credentials) + del _get_credentials, _set_credentials + + @property + def protocol(self): + return gnutls_protocol_get_name(gnutls_protocol_get_version(self._c_object)) + + @property + def kx_algorithm(self): + return gnutls_kx_get_name(gnutls_kx_get(self._c_object)) + + @property + def cipher(self): + return gnutls_cipher_get_name(gnutls_cipher_get(self._c_object)) + + @property + def mac_algorithm(self): + return gnutls_mac_get_name(gnutls_mac_get(self._c_object)) + + @property + def compression(self): + return gnutls_compression_get_name(gnutls_compression_get(self._c_object)) + + @property + def peer_certificate(self): + if gnutls_certificate_type_get(self._c_object) != GNUTLS_CRT_X509: + return None + list_size = c_uint() + cert_list = gnutls_certificate_get_peers(self._c_object, byref(list_size)) + if list_size.value == 0: + return None + cert = cert_list[0] + return X509Certificate(string_at(cert.data, cert.size), X509_FMT_DER) + + # Status checking after an operation was interrupted (these properties are + # only useful to check after an operation was interrupted, otherwise their + # value is meaningless). + + @property + def interrupted_while_writing(self): + """True if an operation was interrupted while writing""" + return gnutls_record_get_direction(self._c_object)==1 + + @property + def interrupted_while_reading(self): + """True if an operation was interrupted while reading""" + return gnutls_record_get_direction(self._c_object)==0 + + # Session methods + + def _update_params(self): + """Update the priorities of the session params using the credentials.""" + def c_priority_list(priorities): + size = len(priorities) + 1 + return (c_int * size)(*priorities) + session_params = self.credentials.session_params + # protocol order in the priority list is irrelevant (it always uses newer protocols first) + # the protocol list only specifies what protocols are to be enabled. + gnutls_protocol_set_priority(self._c_object, c_priority_list(session_params.protocols)) + gnutls_kx_set_priority(self._c_object, c_priority_list(session_params.kx_algorithms)) + gnutls_cipher_set_priority(self._c_object, c_priority_list(session_params.ciphers)) + gnutls_mac_set_priority(self._c_object, c_priority_list(session_params.mac_algorithms)) + gnutls_compression_set_priority(self._c_object, c_priority_list(session_params.compressions)) + + def handshake(self): + gnutls_handshake(self._c_object) + + #@method_args((basestring, buffer)) + def send(self, data): + data = str(data) + return gnutls_record_send(self._c_object, data, len(data)) + + def sendall(self, data): + size = len(data) + while size > 0: + sent = self.send(data[-size:]) + size -= sent + + def recv(self, limit): + data = create_string_buffer(limit) + size = gnutls_record_recv(self._c_object, data, limit) + return data[:size] + + def send_alert(self, exception): + alertdict = { + CertificateError: GNUTLS_A_BAD_CERTIFICATE, + CertificateAuthorityError: GNUTLS_A_UNKNOWN_CA, + CertificateSecurityError: GNUTLS_A_INSUFFICIENT_SECURITY, + CertificateExpiredError: GNUTLS_A_CERTIFICATE_EXPIRED, + CertificateRevokedError: GNUTLS_A_CERTIFICATE_REVOKED} + alert = alertdict.get(exception.__class__) + if alert: + gnutls_alert_send(self._c_object, GNUTLS_AL_FATAL, alert) + + @method_args(one_of(SHUT_RDWR, SHUT_WR)) + def bye(self, how=SHUT_RDWR): + gnutls_bye(self._c_object, how) + + def shutdown(self, how=SOCKET_SHUT_RDWR): + self.socket.shutdown(how) + + def close(self): + self.socket.close() + + def verify_peer(self): + status = c_uint() + gnutls_certificate_verify_peers2(self._c_object, byref(status)) + status = status.value + if status & GNUTLS_CERT_INVALID: + raise CertificateError("peer certificate is invalid") + elif status & GNUTLS_CERT_SIGNER_NOT_FOUND: + raise CertificateAuthorityError("peer certificate signer not found") + elif status & GNUTLS_CERT_SIGNER_NOT_CA: + raise CertificateAuthorityError("peer certificate signer is not a CA") + elif status & GNUTLS_CERT_INSECURE_ALGORITHM: + raise CertificateSecurityError("peer certificate uses an insecure algorithm") + elif status & GNUTLS_CERT_REVOKED: + raise CertificateRevokedError("peer certificate was revoked") + + +class ClientSession(Session): + session_type = GNUTLS_CLIENT + + def __init__(self, socket, credentials, server_name=None): + Session.__init__(self, socket, credentials) + self._server_name = None + if server_name is not None: + self.server_name = server_name + + def _get_server_name(self): + return self._server_name + @method_args(str) + def _set_server_name(self, server_name): + gnutls_server_name_set(self._c_object, GNUTLS_NAME_DNS, c_char_p(server_name), len(server_name)) + self._server_name = server_name + server_name = property(_get_server_name, _set_server_name) + del _get_server_name, _set_server_name + + +class ServerSession(Session): + session_type = GNUTLS_SERVER + + def __init__(self, socket, credentials): + Session.__init__(self, socket, credentials) + gnutls_certificate_server_set_request(self._c_object, CERT_REQUEST) + + @property + def server_name(self): + data_length = c_size_t(256) + data = create_string_buffer(data_length.value) + hostname_type = c_uint() + for i in xrange(2**16): + try: + gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i) + except RequestedDataNotAvailable: + break + except MemoryError: + data_length.value += 1 ## one extra byte for the terminating 0 + data = create_string_buffer(data_length.value) + gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i) + if hostname_type.value != GNUTLS_NAME_DNS: + continue + return data.value + return None + + +class ServerSessionFactory(object): + + def __init__(self, socket, credentials, session_class=ServerSession): + if not issubclass(session_class, ServerSession): + raise TypeError, "session_class must be a subclass of ServerSession" + self.socket = socket + self.credentials = credentials + self.session_class = session_class + + def __getattr__(self, name): + ## Generic wrapper for the underlying socket methods and attributes + return getattr(self.socket, name) + + def bind(self, address): + self.socket.bind(address) + + def listen(self, backlog): + self.socket.listen(backlog) + + def accept(self): + new_sock, address = self.socket.accept() + session = self.session_class(new_sock, self.credentials) + return (session, address) + + def shutdown(self, how=SOCKET_SHUT_RDWR): + self.socket.shutdown(how) + + def close(self): + self.socket.close() + diff --git a/python-gnutls-1.1.9/gnutls/constants.py b/python-gnutls-1.1.9/gnutls/constants.py new file mode 100644 index 0000000..4637a16 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/constants.py @@ -0,0 +1,54 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# + +"""GNUTLS constants""" + +__all__ = [ + ## GNUTLS session protocols + 'PROTO_TLS1_1', 'PROTO_TLS1_0', 'PROTO_SSL3', + + ## Key exchange algorithms + 'KX_RSA', 'KX_DHE_DSS', 'KX_DHE_RSA', 'KX_RSA_EXPORT', 'KX_ANON_DH', + + ## Ciphers + 'CIPHER_AES_128_CBC', 'CIPHER_3DES_CBC', 'CIPHER_ARCFOUR_128', 'CIPHER_AES_256_CBC', 'CIPHER_DES_CBC', + + ## MAC algorithms + 'MAC_SHA1', 'MAC_MD5', 'MAC_RMD160', + + ## Compressions + 'COMP_DEFLATE', 'COMP_LZO', 'COMP_NULL', + + ## Credential types + 'CRED_CERTIFICATE', 'CRED_ANON', + + ## X509 certificate/private key formats + 'X509_FMT_DER', 'X509_FMT_PEM', + + ## Miscellaneous + 'CERT_REQUEST', 'CERT_REQUIRE', 'SHUT_RDWR', 'SHUT_WR' +] + +__name_map__ = { + 'PROTO_TLS1_1': 'TLS1_1', 'PROTO_TLS1_0': 'TLS1_0', 'PROTO_SSL3': 'SSL3', + 'CRED_CERTIFICATE': 'CRD_CERTIFICATE', 'CRED_ANON': 'CRD_ANON' +} + + +from gnutls.library import constants + +class GNUTLSConstant(int): + def __new__(cls, name): + gnutls_name = 'GNUTLS_' + __name_map__.get(name, name) + instance = int.__new__(cls, getattr(constants, gnutls_name)) + instance.name = name + return instance + def __repr__(self): + return self.name + +## Generate all exported constants +code = '\n'.join(["%s = GNUTLSConstant('%s')" % (name, name) for name in __all__]) +exec code in locals(), globals() +del code, name + +del constants diff --git a/python-gnutls-1.1.9/gnutls/crypto.py b/python-gnutls-1.1.9/gnutls/crypto.py new file mode 100644 index 0000000..d330144 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/crypto.py @@ -0,0 +1,317 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# + +"""GNUTLS crypto support""" + +__all__ = ['X509Name', 'X509Certificate', 'X509PrivateKey', 'X509Identity', 'X509CRL', 'DHParams', 'RSAParams'] + +import re +from ctypes import * + +from gnutls.validators import method_args, one_of +from gnutls.constants import X509_FMT_DER, X509_FMT_PEM +from gnutls.errors import * + +from gnutls.library.constants import GNUTLS_SAN_DNSNAME, GNUTLS_SAN_RFC822NAME, GNUTLS_SAN_URI +from gnutls.library.constants import GNUTLS_SAN_IPADDRESS, GNUTLS_SAN_OTHERNAME, GNUTLS_SAN_DN +from gnutls.library.constants import GNUTLS_E_SHORT_MEMORY_BUFFER +from gnutls.library.types import * +from gnutls.library.functions import * + + +class X509NameMeta(type): + long_names = {'country': 'C', + 'state': 'ST', + 'locality': 'L', + 'common_name': 'CN', + 'organization': 'O', + 'organization_unit': 'OU', + 'email': 'EMAIL'} + def __new__(cls, name, bases, dic): + instance = type.__new__(cls, name, bases, dic) + instance.ids = X509NameMeta.long_names.values() + for long_name, short_name in X509NameMeta.long_names.items(): + ## Map a long_name property to the short_name attribute + cls.add_property(instance, long_name, short_name) + return instance + def add_property(instance, name, short_name): + setattr(instance, name, property(lambda self: getattr(self, short_name, None))) + + +class X509Name(str): + __metaclass__ = X509NameMeta + + def __init__(self, dname): + str.__init__(self) + pairs = [x.replace('\,', ',') for x in re.split(r'(?<!\\),\s*', dname)] + for pair in pairs: + try: + name, value = pair.split('=', 1) + except ValueError: + raise ValueError("Invalid X509 distinguished name: %s" % dname) + str.__setattr__(self, name, value) + for name in X509Name.ids: + if not hasattr(self, name): + str.__setattr__(self, name, None) + def __setattr__(self, name, value): + if name in X509Name.ids: + raise AttributeError("can't set attribute") + str.__setattr__(self, name, value) + + +class AlternativeNames(object): + __slots__ = {'dns': GNUTLS_SAN_DNSNAME, 'email': GNUTLS_SAN_RFC822NAME, 'uri': GNUTLS_SAN_URI, + 'ip': GNUTLS_SAN_IPADDRESS, 'other': GNUTLS_SAN_OTHERNAME, 'dn': GNUTLS_SAN_DN} + def __init__(self, names): + object.__init__(self) + for name, key in self.__slots__.iteritems(): + setattr(self, name, tuple(names.get(key, ()))) + + +class X509Certificate(object): + + def __new__(cls, *args, **kwargs): + instance = object.__new__(cls) + instance.__deinit = gnutls_x509_crt_deinit + instance._c_object = gnutls_x509_crt_t() + instance._alternative_names = None + return instance + + @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER)) + def __init__(self, buf, format=X509_FMT_PEM): + gnutls_x509_crt_init(byref(self._c_object)) + data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf))) + gnutls_x509_crt_import(self._c_object, byref(data), format) + + def __del__(self): + self.__deinit(self._c_object) + + @property + def subject(self): + size = c_size_t(256) + dname = create_string_buffer(size.value) + try: + gnutls_x509_crt_get_dn(self._c_object, dname, byref(size)) + except MemoryError: + dname = create_string_buffer(size.value) + gnutls_x509_crt_get_dn(self._c_object, dname, byref(size)) + return X509Name(dname.value) + + @property + def issuer(self): + size = c_size_t(256) + dname = create_string_buffer(size.value) + try: + gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size)) + except MemoryError: + dname = create_string_buffer(size.value) + gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size)) + return X509Name(dname.value) + + @property + def alternative_names(self): + if self._alternative_names is not None: + return self._alternative_names + names = {} + size = c_size_t(256) + alt_name = create_string_buffer(size.value) + for i in xrange(65536): + try: + name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None) + except RequestedDataNotAvailable: + break + except MemoryError: + alt_name = create_string_buffer(size.value) + name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None) + names.setdefault(name_type, []).append(alt_name.value) + self._alternative_names = AlternativeNames(names) + return self._alternative_names + + @property + def serial_number(self): + size = c_size_t(1) + serial = c_ulong() + try: + gnutls_x509_crt_get_serial(self._c_object, cast(byref(serial), c_void_p), byref(size)) + except MemoryError: + import struct, sys + serial = create_string_buffer(size.value * sizeof(c_void_p)) + gnutls_x509_crt_get_serial(self._c_object, cast(serial, c_void_p), byref(size)) + pad = size.value * sizeof(c_void_p) - len(serial.value) + format = '@%dL' % size.value + numbers = list(struct.unpack(format, serial.value + pad*'\x00')) + if sys.byteorder == 'little': + numbers.reverse() + number = 0 + offset = sizeof(c_void_p) * 8 + for n in numbers: + number = (number<<offset) + n + return number + else: + return serial.value + + @property + def activation_time(self): + return gnutls_x509_crt_get_activation_time(self._c_object) + + @property + def expiration_time(self): + return gnutls_x509_crt_get_expiration_time(self._c_object) + + @property + def version(self): + return gnutls_x509_crt_get_version(self._c_object) + + #@method_args(X509Certificate) + def has_issuer(self, issuer): + """Return True if the certificate was issued by the given issuer, False otherwise.""" + if not isinstance(issuer, X509Certificate): + raise TypeError("issuer must be an X509Certificate object") + return bool(gnutls_x509_crt_check_issuer(self._c_object, issuer._c_object)) + + @method_args(str) + def has_hostname(self, hostname): + """Return True if the hostname matches the DNSName/IPAddress subject alternative name extension + of this certificate, False otherwise.""" + ## For details see http://www.ietf.org/rfc/rfc2459.txt, section 4.2.1.7 Subject Alternative Name + return bool(gnutls_x509_crt_check_hostname(self._c_object, hostname)) + + def check_issuer(self, issuer): + """Raise CertificateError if certificate was not issued by the given issuer""" + if not self.has_issuer(issuer): + raise CertificateError("certificate issuer doesn't match") + + def check_hostname(self, hostname): + """Raise CertificateError if the certificate DNSName/IPAddress subject alternative name extension + doesn't match the given hostname""" + if not self.has_hostname(hostname): + raise CertificateError("certificate doesn't match hostname") + + +class X509PrivateKey(object): + def __new__(cls, *args, **kwargs): + instance = object.__new__(cls) + instance.__deinit = gnutls_x509_privkey_deinit + instance._c_object = gnutls_x509_privkey_t() + return instance + + @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER)) + def __init__(self, buf, format=X509_FMT_PEM): + gnutls_x509_privkey_init(byref(self._c_object)) + data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf))) + gnutls_x509_privkey_import(self._c_object, byref(data), format) + + def __del__(self): + self.__deinit(self._c_object) + + +class X509Identity(object): + """A X509 identity represents a X509 certificate and private key pair""" + + __slots__ = ('cert', 'key') + + @method_args(X509Certificate, X509PrivateKey) + def __init__(self, cert, key): + self.cert = cert + self.key = key + + def __setattr__(self, name, value): + if name in self.__slots__ and hasattr(self, name): + raise AttributeError("can't set attribute") + object.__setattr__(self, name, value) + + def __delattr__(self, name): + if name in self.__slots__: + raise AttributeError("can't delete attribute") + object.__delattr__(self, name) + + +class X509CRL(object): + def __new__(cls, *args, **kwargs): + instance = object.__new__(cls) + instance.__deinit = gnutls_x509_crl_deinit + instance._c_object = gnutls_x509_crl_t() + return instance + + @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER)) + def __init__(self, buf, format=X509_FMT_PEM): + gnutls_x509_crl_init(byref(self._c_object)) + data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf))) + gnutls_x509_crl_import(self._c_object, byref(data), format) + + def __del__(self): + self.__deinit(self._c_object) + + @property + def count(self): + return gnutls_x509_crl_get_crt_count(self._c_object) + + @property + def version(self): + return gnutls_x509_crl_get_version(self._c_object) + + @property + def issuer(self): + size = c_size_t(256) + dname = create_string_buffer(size.value) + try: + gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size)) + except MemoryError: + dname = create_string_buffer(size.value) + gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size)) + return X509Name(dname.value) + + @method_args(X509Certificate) + def is_revoked(self, cert): + """Return True if certificate is revoked, False otherwise""" + return bool(gnutls_x509_crt_check_revocation(cert._c_object, byref(self._c_object), 1)) + + def check_revocation(self, cert, cert_name='certificate'): + """Raise CertificateRevokedError if the given certificate is revoked""" + if self.is_revoked(cert): + raise CertificateRevokedError("%s was revoked" % cert_name) + + +class DHParams(object): + def __new__(cls, *args, **kwargs): + instance = object.__new__(cls) + instance.__deinit = gnutls_dh_params_deinit + instance._c_object = gnutls_dh_params_t() + return instance + + @method_args(int) + def __init__(self, bits=1024): + gnutls_dh_params_init(byref(self._c_object)) + gnutls_dh_params_generate2(self._c_object, bits) + + def __get__(self, obj, type_=None): + return self._c_object + + def __set__(self, obj, value): + raise AttributeError("Read-only attribute") + + def __del__(self): + self.__deinit(self._c_object) + + +class RSAParams(object): + def __new__(cls, *args, **kwargs): + instance = object.__new__(cls) + instance.__deinit = gnutls_rsa_params_deinit + instance._c_object = gnutls_rsa_params_t() + return instance + + @method_args(int) + def __init__(self, bits=1024): + gnutls_rsa_params_init(byref(self._c_object)) + gnutls_rsa_params_generate2(self._c_object, bits) + + def __get__(self, obj, type_=None): + return self._c_object + + def __set__(self, obj, value): + raise AttributeError("Read-only attribute") + + def __del__(self): + self.__deinit(self._c_object) + diff --git a/python-gnutls-1.1.9/gnutls/errors.py b/python-gnutls-1.1.9/gnutls/errors.py new file mode 100644 index 0000000..592ba1d --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/errors.py @@ -0,0 +1,22 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# + +"""GNUTLS errors""" + +__all__ = ['Error', 'GNUTLSError', 'OperationWouldBlock', 'OperationInterrupted', + 'CertificateError', 'CertificateAuthorityError', 'CertificateSecurityError', + 'CertificateExpiredError', 'CertificateRevokedError', 'RequestedDataNotAvailable'] + +class Error(Exception): pass + +class GNUTLSError(Error): pass +class OperationWouldBlock(GNUTLSError): pass +class OperationInterrupted(GNUTLSError): pass + +class CertificateError(GNUTLSError): pass +class CertificateAuthorityError(CertificateError): pass +class CertificateSecurityError(CertificateError): pass +class CertificateExpiredError(CertificateError): pass +class CertificateRevokedError(CertificateError): pass + +class RequestedDataNotAvailable(GNUTLSError): pass diff --git a/python-gnutls-1.1.9/gnutls/interfaces/__init__.py b/python-gnutls-1.1.9/gnutls/interfaces/__init__.py new file mode 100644 index 0000000..dc64199 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/interfaces/__init__.py @@ -0,0 +1,2 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# diff --git a/python-gnutls-1.1.9/gnutls/interfaces/twisted/__init__.py b/python-gnutls-1.1.9/gnutls/interfaces/twisted/__init__.py new file mode 100644 index 0000000..cee60bf --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/interfaces/twisted/__init__.py @@ -0,0 +1,372 @@ +# Copyright (C) 2007-2008 AG Projects. See LICENSE for details. +# + +"""GNUTLS Twisted interface""" + +__all__ = ['X509Credentials', 'connectTLS', 'listenTLS'] + +import socket +from time import time +from errno import EWOULDBLOCK, EINTR + +from twisted.python import failure +from twisted.internet import main, base, interfaces, address, tcp, error +from twisted.internet.protocol import BaseProtocol + +from zope.interface import implements, implementsOnly, implementedBy + +from gnutls.connection import ClientSession, ServerSession, ServerSessionFactory +from gnutls.connection import X509Credentials as _X509Credentials +from gnutls.constants import SHUT_RDWR, SHUT_WR +from gnutls.errors import * + + +class KeepRunning: + """Return this class from a recurrent function to indicate that it should keep running""" + pass + +class RecurrentCall(object): + """Execute a function repeatedly at the given interval, until signaled to stop""" + def __init__(self, period, func, *args, **kwargs): + from twisted.internet import reactor + self.func = func + self.args = args + self.kwargs = kwargs + self.period = period + self.now = None + self.next = None + self.callid = reactor.callLater(period, self) + def __call__(self): + from twisted.internet import reactor + self.callid = None + if self.now is None: + self.now = time() + self.next = self.now + self.period + else: + self.now, self.next = self.next, self.next + self.period + result = self.func(*self.args, **self.kwargs) + if result is KeepRunning: + delay = max(self.next-time(), 0) + self.callid = reactor.callLater(delay, self) + def cancel(self): + if self.callid is not None: + try: + self.callid.cancel() + except ValueError: + pass + self.callid = None + + +class CertificateOK: pass + +class X509Credentials(_X509Credentials): + """A Twisted enhanced X509Credentials""" + verify_peer = False + verify_period = None + + def verify_callback(self, peer_cert, preverify_status=None): + """Verifies the peer certificate and raises an exception if it cannot be accepted""" + if isinstance(preverify_status, Exception): + raise preverify_status + self.check_certificate(peer_cert, cert_name='peer certificate') + + +class TLSMixin: + """TLS specific functionality common to both clients and servers""" + + def getPeerCertificate(self): + return self.socket.peer_certificate + + def doRead(self): + try: + return tcp.Connection.doRead(self) + except (OperationWouldBlock, OperationInterrupted): + return + except GNUTLSError, e: + return e + + def writeSomeData(self, data): + try: + return tcp.Connection.writeSomeData(self, data) + except OperationInterrupted: + return self.writeSomeData(data) + except OperationWouldBlock: + return 0 + except GNUTLSError, e: + return e + + def _sendCloseReason(self, reason): + try: + self.socket.send_alert(reason) + except OperationInterrupted: + self._sendCloseReason(reason) + + def _sendCloseAlert(self, how=SHUT_RDWR): + try: + self.socket.bye(how) + except OperationInterrupted: + self._sendCloseAlert(how) + + def closeTLSSession(self, reason): + try: + self._sendCloseReason(reason) + self._sendCloseAlert(SHUT_RDWR) + except Exception, e: + pass + + def _postLoseConnection(self): + self.closeTLSSession(self._close_reason) + return self._close_reason + + def endTLSWrite(self): + self.stopWriting() + try: + self._sendCloseAlert(SHUT_WR) + except OperationWouldBlock, e: + if self.socket.interrupted_while_writing: + self.startWriting() + return + except Exception, e: + return e + del self.doWrite + + def _closeWriteConnection(self): + self.doWrite = self.endTLSWrite + result = self.endTLSWrite() + if isinstance(result, Exception): + return result + return tcp.Connection._closeWriteConnection(self) + + +class TLSClient(TLSMixin, tcp.Client): + """Add TLS capabilities to a TCP client""" + + implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Client) if i != interfaces.ITLSTransport]) + + def __init__(self, host, port, bindAddress, credentials, connector, reactor=None, server_name=None): + self.credentials = credentials + self.server_name = server_name + self.__watchdog = None + tcp.Client.__init__(self, host, port, bindAddress, connector, reactor) + + def createInternetSocket(self): + sock = tcp.Client.createInternetSocket(self) + return ClientSession(sock, self.credentials, self.server_name) + + def _recurrentVerify(self): + if not self.connected or self.disconnecting: + return + try: + self.credentials.verify_callback(self.socket.peer_certificate) + except Exception, e: + self.loseConnection(e) + return + else: + return KeepRunning + + def _verifyPeer(self): + session = self.socket + credentials = self.credentials + if not credentials.verify_peer: + return + try: + session.verify_peer() + except Exception, e: + preverify_status = e + else: + preverify_status = CertificateOK + + credentials.verify_callback(session.peer_certificate, preverify_status) + + if credentials.verify_period > 0: + self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify) + + def doHandshake(self): + self.stopWriting() + try: + self.socket.handshake() + except (OperationWouldBlock, OperationInterrupted): + if self.socket.interrupted_while_writing: + self.startWriting() + return + except GNUTLSError, e: + del self.doRead + self.failIfNotConnected(err = e) + return + + ## reset any references to the old doRead + del self.doRead + self.stopReading() + + try: + self._verifyPeer() + except GNUTLSError, e: + self.closeTLSSession(e) + self.failIfNotConnected(err = e) + return + except Exception, e: + self.closeTLSSession(e) + self.failIfNotConnected(err = error.getConnectError(str(e))) + return + + ## TLS handshake (including certificate verification) finished succesfully + tcp.Client._connectDone(self) + + def startTLS(self): + self.doRead = self.doHandshake + self.startReading() + self.doHandshake() + + def _connectDone(self): + self.startTLS() + + def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)): + reason = failure.Failure(reason) # accept python exceptions too + self._close_reason = reason.value + tcp.Client.loseConnection(self, reason) + + def connectionLost(self, reason): + if self.__watchdog is not None: + self.__watchdog.cancel() + self.__watchdog = None + tcp.Client.connectionLost(self, reason) + + +class TLSConnector(base.BaseConnector): + def __init__(self, host, port, factory, credentials, timeout, bindAddress, reactor=None, server_name=None): + self.host = host + self.port = port + self.bindAddress = bindAddress + self.credentials = credentials + self.server_name = server_name + base.BaseConnector.__init__(self, factory, timeout, reactor) + + def _makeTransport(self): + return TLSClient(self.host, self.port, self.bindAddress, self.credentials, self, self.reactor, self.server_name) + + +class TLSServer(TLSMixin, tcp.Server): + """Add TLS capabilities to a TCP server""" + + #implements(interfaces.ISSLTransport) + implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Server) if i != interfaces.ITLSTransport]) + + def __init__(self, sock, protocol, client, server, sessionno, *args, **kw): + self.__watchdog = None + self.credentials = server.credentials + tcp.Server.__init__(self, sock, protocol, client, server, sessionno, *args, **kw) + + def _recurrentVerify(self): + if not self.connected or self.disconnecting: + return + try: + self.credentials.verify_callback(self.socket.peer_certificate) + except Exception, e: + self.loseConnection(e) + return + else: + return KeepRunning + + def _verifyPeer(self): + session = self.socket + credentials = self.credentials + if not credentials.verify_peer: + return + try: + session.verify_peer() + except Exception, e: + preverify_status = e + else: + preverify_status = CertificateOK + + credentials.verify_callback(session.peer_certificate, preverify_status) + + if credentials.verify_period > 0: + self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify) + + def doHandshake(self): + self.stopWriting() + try: + self.socket.handshake() + except (OperationWouldBlock, OperationInterrupted): + if self.socket.interrupted_while_writing: + self.startWriting() + return + except GNUTLSError, e: + del self.doRead + return e + + ## reset any references to the old doRead + del self.doRead + self.stopReading() + self.startReading() + + try: + self._verifyPeer() + except Exception, e: + self.loseConnection(e) + return + + ## TLS handshake (including certificate verification) finished succesfully + + del self.protocol.makeConnection + self.protocol.makeConnection(self) + + def startTLS(self): + self.doRead = self.doHandshake + self.startReading() + + def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)): + reason = failure.Failure(reason) # accept python exceptions too + self._close_reason = reason.value + tcp.Server.loseConnection(self, reason) + + def connectionLost(self, reason): + if self.__watchdog is not None: + self.__watchdog.cancel() + self.__watchdog = None + tcp.Server.connectionLost(self, reason) + + +class TLSPort(tcp.Port): + """Add TLS capabilities to a TCP port""" + + transport = TLSServer + + def __init__(self, port, factory, credentials, backlog=50, interface='', reactor=None): + tcp.Port.__init__(self, port, factory, backlog, interface, reactor) + self.credentials = credentials + + def createInternetSocket(self): + sock = tcp.Port.createInternetSocket(self) + return ServerSessionFactory(sock, self.credentials, ServerSession) + + def _preMakeConnection(self, transport): + transport.protocol.makeConnection = lambda *args: None + transport.protocol.transport = transport ## because we may call connectionLost without connectionMade + transport.startTLS() + return tcp.Port._preMakeConnection(self, transport) + + +def connectTLS(reactor, host, port, factory, credentials, timeout=30, bindAddress=None, server_name=None): + c = TLSConnector(host, port, factory, credentials, timeout, bindAddress, reactor, server_name) + c.connect() + return c + + +def listenTLS(reactor, port, factory, credentials, backlog=50, interface=''): + p = TLSPort(port, factory, credentials, backlog, interface, reactor) + p.startListening() + return p + +## Add the connectTLS and listenTLS methods to the reactor + +import new +from twisted.internet.posixbase import PosixReactorBase + +method = new.instancemethod(connectTLS, None, PosixReactorBase) +setattr(PosixReactorBase, 'connectTLS', method) + +method = new.instancemethod(listenTLS, None, PosixReactorBase) +setattr(PosixReactorBase, 'listenTLS', method) + diff --git a/python-gnutls-1.1.9/gnutls/library/__init__.py b/python-gnutls-1.1.9/gnutls/library/__init__.py new file mode 100644 index 0000000..494460f --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/library/__init__.py @@ -0,0 +1,17 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# + +from gnutls.library import _gnutls_init +from gnutls.library import constants +from gnutls.library import types +from gnutls.library import errors +from gnutls.library import functions + +__need_version__ = '2.4.1' + +if functions.gnutls_check_version(__need_version__) is None: + version = functions.gnutls_check_version(None) + raise RuntimeError("Found GNUTLS library version %s, but at least version %s is required" % (version, __need_version__)) +if functions.gnutls_extra_check_version(__need_version__) is None: + version = functions.gnutls_extra_check_version(None) + raise RuntimeError("Found GNUTLS extra library version %s, but at least version %s is required" % (version, __need_version__)) diff --git a/python-gnutls-1.1.9/gnutls/library/_gnutls_init.c b/python-gnutls-1.1.9/gnutls/library/_gnutls_init.c new file mode 100644 index 0000000..ff9156c --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/library/_gnutls_init.c @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2007 AG Projects. See LICENSE for details. + * Author: Dan Pascu <dan@ag-projects.com> + * + * GNUTLS library initializations. + * + */ + +#include <Python.h> + +#include <gnutls/gnutls.h> +#include <gnutls/extra.h> +#include <gcrypt.h> +#include <errno.h> +#include <pthread.h> + +// Use POSIX threads for libgcrypt locking +GCRY_THREAD_OPTION_PTHREAD_IMPL; + +// List of functions defined in the module +static PyMethodDef gnutls_methods[] = { + {NULL, NULL} // sentinel +}; + +PyDoc_STRVAR(module_doc, +"This module does behind the scenes GNUTLS initializations, like for example\n" +"enabling thread safety in the gcrypt library and calling the GNUTLS global\n" +"initialization functions."); + +// Initialization function for the module (must be called init_gnutls_init) +PyMODINIT_FUNC +init_gnutls_init(void) +{ + PyObject *m; + + m = Py_InitModule3("_gnutls_init", gnutls_methods, module_doc); + if (m == NULL) + return; + + // Enable thread safety for the posix threads library. + // This must be done before calling gnutls_global_init(). + gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread); + + gnutls_global_init(); + gnutls_global_init_extra(); +} + diff --git a/python-gnutls-1.1.9/gnutls/library/constants.py b/python-gnutls-1.1.9/gnutls/library/constants.py new file mode 100644 index 0000000..43c82d3 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/library/constants.py @@ -0,0 +1,648 @@ +from ctypes import * + +STRING = c_char_p + + +GNUTLS_CRD_IA = 5 +GNUTLS_CERT_REQUIRE = 2 +GNUTLS_PKCS_USE_PKCS12_3DES = 2 +GNUTLS_CRD_CERTIFICATE = 1 +GNUTLS_HANDSHAKE_SERVER_HELLO_DONE = 14 +GNUTLS_SIGN_RSA_RMD160 = 5 +GNUTLS_PKCS_PLAIN = 1 +GNUTLS_A_UNKNOWN_CA = 48 +GNUTLS_CRT_PRINT_ONELINE = 1 +GNUTLS_PKCS_USE_PKCS12_ARCFOUR = 4 +GNUTLS_A_UNKNOWN_PSK_IDENTITY = 115 +GNUTLS_CRT_X509 = 1 +GNUTLS_KX_DHE_PSK = 10 +GNUTLS_PARAMS_RSA_EXPORT = 1 +GNUTLS_DIG_NULL = 1 +GNUTLS_KX_PSK = 9 +GNUTLS_CIPHER_RC2_40_CBC = 90 +GNUTLS_AL_WARNING = 1 +GNUTLS_DIG_SHA256 = 6 +GNUTLS_CERT_INSECURE_ALGORITHM = 256 +GNUTLS_SIGN_RSA_MD2 = 4 +GNUTLS_CRT_PRINT_UNSIGNED_FULL = 2 +GNUTLS_PK_DSA = 2 +GNUTLS_A_UNRECOGNIZED_NAME = 112 +GNUTLS_A_INNER_APPLICATION_FAILURE = 208 +GNUTLS_VERIFY_DO_NOT_ALLOW_SAME = 4 +GNUTLS_CIPHER_AES_128_CBC = 4 +GNUTLS_CRT_PRINT_FULL = 0 +GNUTLS_PKCS_USE_PBES2_3DES = 16 +GNUTLS_SSL3 = 1 +GNUTLS_SAN_OTHERNAME_XMPP = 1000 +GNUTLS_DIG_SHA384 = 7 +GNUTLS_MAC_UNKNOWN = 0 +GNUTLS_A_CERTIFICATE_UNOBTAINABLE = 111 +GNUTLS_OPENPGP_CERT_FINGERPRINT = 1 +GNUTLS_SIGN_RSA_SHA512 = 8 +GNUTLS_A_DECRYPT_ERROR = 51 +GNUTLS_SAN_DN = 6 +GNUTLS_SAN_DNSNAME = 1 +GNUTLS_CRT_UNKNOWN = 0 +GNUTLS_SERVER = 1 +GNUTLS_CIPHER_NULL = 1 +GNUTLS_CIPHER_DES_CBC = 91 +GNUTLS_A_USER_CANCELED = 90 +GNUTLS_TLS1_1 = 3 +GNUTLS_CRT_OPENPGP = 2 +GNUTLS_SHUT_WR = 1 +GNUTLS_KX_ANON_DH = 4 +GNUTLS_A_EXPORT_RESTRICTION = 60 +GNUTLS_HANDSHAKE_FINISHED = 20 +GNUTLS_KX_UNKNOWN = 0 +GNUTLS_MAC_NULL = 1 +GNUTLS_SAN_IPADDRESS = 4 +GNUTLS_HANDSHAKE_CLIENT_HELLO = 1 +GNUTLS_CRD_ANON = 2 +GNUTLS_SHUT_RDWR = 0 +GNUTLS_A_SSL3_NO_CERTIFICATE = 41 +GNUTLS_COMP_NULL = 1 +GNUTLS_TLS1_2 = 4 +GNUTLS_IA_APPLICATION_PAYLOAD = 0 +GNUTLS_SIGN_RSA_SHA224 = 9 +GNUTLS_HANDSHAKE_CERTIFICATE_PKT = 11 +GNUTLS_DIG_MD2 = 5 +GNUTLS_PK_RSA = 1 +GNUTLS_CIPHER_CAMELLIA_256_CBC = 8 +GNUTLS_HANDSHAKE_SUPPLEMENTAL = 23 +GNUTLS_SIGN_UNKNOWN = 0 +GNUTLS_PARAMS_DH = 2 +GNUTLS_PK_UNKNOWN = 0 +GNUTLS_A_INSUFFICIENT_SECURITY = 71 +GNUTLS_DIG_SHA512 = 8 +GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0 +GNUTLS_KX_RSA = 1 +GNUTLS_SIGN_RSA_SHA384 = 7 +GNUTLS_A_RECORD_OVERFLOW = 22 +GNUTLS_KX_DHE_RSA = 3 +GNUTLS_COMP_LZO = 3 +GNUTLS_CERT_IGNORE = 0 +GNUTLS_SIGN_RSA_SHA1 = 1 +GNUTLS_A_ILLEGAL_PARAMETER = 47 +GNUTLS_A_NO_RENEGOTIATION = 100 +GNUTLS_A_PROTOCOL_VERSION = 70 +GNUTLS_A_DECOMPRESSION_FAILURE = 30 +GNUTLS_A_CERTIFICATE_REVOKED = 44 +GNUTLS_CIPHER_AES_256_CBC = 5 +GNUTLS_A_INTERNAL_ERROR = 80 +GNUTLS_HANDSHAKE_HELLO_REQUEST = 0 +GNUTLS_X509_FMT_DER = 0 +GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST = 13 +GNUTLS_HANDSHAKE_SERVER_HELLO = 2 +GNUTLS_A_HANDSHAKE_FAILURE = 40 +GNUTLS_DIG_MD5 = 2 +GNUTLS_SIGN_RSA_MD5 = 3 +GNUTLS_MAC_SHA256 = 6 +GNUTLS_OPENPGP_CERT = 0 +GNUTLS_CERT_SIGNER_NOT_CA = 128 +GNUTLS_AL_FATAL = 2 +GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2 = 16 +GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT = 2 +GNUTLS_CIPHER_3DES_CBC = 3 +GNUTLS_A_DECRYPTION_FAILED = 21 +GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE = 16 +GNUTLS_SAN_RFC822NAME = 2 +GNUTLS_CRD_PSK = 4 +GNUTLS_OPENPGP_FMT_RAW = 0 +GNUTLS_CERT_SIGNER_NOT_FOUND = 64 +GNUTLS_A_UNSUPPORTED_EXTENSION = 110 +GNUTLS_DIG_SHA1 = 3 +GNUTLS_DIG_RMD160 = 4 +GNUTLS_A_CLOSE_NOTIFY = 0 +GNUTLS_KX_SRP_RSA = 7 +GNUTLS_MAC_MD5 = 2 +GNUTLS_IA_FINAL_PHASE_FINISHED = 2 +GNUTLS_A_UNSUPPORTED_CERTIFICATE = 43 +GNUTLS_COMP_UNKNOWN = 0 +GNUTLS_PKCS_USE_PKCS12_RC2_40 = 8 +GNUTLS_CIPHER_UNKNOWN = 0 +GNUTLS_PSK_KEY_HEX = 1 +GNUTLS_KX_SRP_DSS = 8 +GNUTLS_MAC_SHA384 = 7 +GNUTLS_SAN_URI = 3 +GNUTLS_X509_FMT_PEM = 1 +GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED = 1 +GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY = 15 +GNUTLS_A_DECODE_ERROR = 50 +GNUTLS_MAC_SHA1 = 3 +GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE = 12 +GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED = 1 +GNUTLS_A_CERTIFICATE_UNKNOWN = 46 +GNUTLS_OPENPGP_FMT_BASE64 = 1 +GNUTLS_CLIENT = 2 +GNUTLS_PSK_KEY_RAW = 0 +GNUTLS_A_UNEXPECTED_MESSAGE = 10 +GNUTLS_CERT_INVALID = 2 +GNUTLS_CRD_SRP = 3 +GNUTLS_A_BAD_RECORD_MAC = 20 +GNUTLS_MAC_RMD160 = 4 +GNUTLS_DIG_SHA224 = 9 +GNUTLS_TLS1_0 = 2 +GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5 = 32 +GNUTLS_KX_SRP = 5 +GNUTLS_A_CERTIFICATE_EXPIRED = 45 +GNUTLS_MAC_MD2 = 5 +GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT = 8 +GNUTLS_A_ACCESS_DENIED = 49 +GNUTLS_VERIFY_DISABLE_CA_SIGN = 1 +GNUTLS_CIPHER_ARCFOUR_40 = 6 +GNUTLS_A_BAD_CERTIFICATE = 42 +GNUTLS_CERT_REVOKED = 32 +GNUTLS_CERT_REQUEST = 1 +GNUTLS_MAC_SHA512 = 8 +GNUTLS_SAN_OTHERNAME = 5 +GNUTLS_VERSION_UNKNOWN = 255 +GNUTLS_KX_RSA_EXPORT = 6 +GNUTLS_CIPHER_CAMELLIA_128_CBC = 7 +GNUTLS_COMP_DEFLATE = 2 +GNUTLS_NAME_DNS = 1 +GNUTLS_SIGN_DSA_SHA1 = 2 +GNUTLS_A_INNER_APPLICATION_VERIFICATION = 209 +GNUTLS_CIPHER_ARCFOUR_128 = 2 +GNUTLS_KX_DHE_DSS = 2 +GNUTLS_SIGN_RSA_SHA256 = 6 +GNUTLS_E_UNKNOWN_PK_ALGORITHM = -80 # Variable c_int +TLS_MASTER_SIZE = 48 # Variable c_int +LIBGNUTLS_VERSION_NUMBER = 132097 # Variable c_int +GNUTLS_E_FATAL_ALERT_RECEIVED = -12 # Variable c_int +GNUTLS_E_LARGE_PACKET = -7 # Variable c_int +GNUTLS_E_ASN1_DER_OVERFLOW = -77 # Variable c_int +GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY = -203 # Variable c_int +GNUTLS_E_SHORT_MEMORY_BUFFER = -51 # Variable c_int +GNUTLS_E_UNKNOWN_ALGORITHM = -105 # Variable c_int +GNUTLS_MAX_SESSION_ID = 32 # Variable c_int +GNUTLS_E_OPENPGP_GETKEY_FAILED = -88 # Variable c_int +GNUTLS_E_REHANDSHAKE = -37 # Variable c_int +GNUTLS_E_ASN1_VALUE_NOT_FOUND = -70 # Variable c_int +GNUTLS_E_SUCCESS = 0 # Variable c_int +GNUTLS_E_ASN1_SYNTAX_ERROR = -76 # Variable c_int +GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE = '1.3.6.1.5.5.7.9.5' # Variable STRING +GNUTLS_E_RECORD_LIMIT_REACHED = -39 # Variable c_int +GNUTLS_E_WARNING_IA_FPHF_RECEIVED = -103 # Variable c_int +GNUTLS_OID_X520_DN_QUALIFIER = '2.5.4.46' # Variable STRING +GNUTLS_OID_X520_GIVEN_NAME = '2.5.4.42' # Variable STRING +LIBGNUTLS_VERSION_MINOR = 4 # Variable c_int +GNUTLS_E_ASN1_ELEMENT_NOT_FOUND = -67 # Variable c_int +GNUTLS_E_CRYPTO_ALREADY_REGISTERED = -209 # Variable c_int +GNUTLS_E_KEY_USAGE_VIOLATION = -48 # Variable c_int +GNUTLS_E_WARNING_IA_IPHF_RECEIVED = -102 # Variable c_int +GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM = -3 # Variable c_int +GNUTLS_E_PK_DECRYPTION_FAILED = -45 # Variable c_int +GNUTLS_CRL_REASON_CA_COMPROMISE = 32 # Variable c_int +GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE = -98 # Variable c_int +GNUTLS_E_DECRYPTION_FAILED = -24 # Variable c_int +GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE = -97 # Variable c_int +GNUTLS_KP_OCSP_SIGNING = '1.3.6.1.5.5.7.3.9' # Variable STRING +GNUTLS_E_PK_SIGN_FAILED = -46 # Variable c_int +GNUTLS_E_ASN1_TAG_IMPLICIT = -74 # Variable c_int +GNUTLS_E_INIT_LIBEXTRA = -82 # Variable c_int +GNUTLS_KP_TLS_WWW_SERVER = '1.3.6.1.5.5.7.3.1' # Variable STRING +GNUTLS_E_OPENPGP_KEYRING_ERROR = -204 # Variable c_int +GNUTLS_E_MEMORY_ERROR = -25 # Variable c_int +GNUTLS_E_MAC_VERIFY_FAILED = -100 # Variable c_int +GNUTLS_E_NO_TEMPORARY_DH_PARAMS = -93 # Variable c_int +GNUTLS_KEY_NON_REPUDIATION = 64 # Variable c_int +GNUTLS_MAX_ALGORITHM_NUM = 16 # Variable c_int +GNUTLS_OID_X520_COUNTRY_NAME = '2.5.4.6' # Variable STRING +GNUTLS_E_WARNING_ALERT_RECEIVED = -16 # Variable c_int +GNUTLS_E_OPENPGP_UID_REVOKED = -79 # Variable c_int +GNUTLS_E_PUSH_ERROR = -53 # Variable c_int +GNUTLS_KEY_KEY_CERT_SIGN = 4 # Variable c_int +GNUTLS_E_GOT_APPLICATION_DATA = -38 # Variable c_int +GNUTLS_E_BASE64_DECODING_ERROR = -34 # Variable c_int +GNUTLS_E_PULL_ERROR = -54 # Variable c_int +GNUTLS_E_COMPRESSION_FAILED = -27 # Variable c_int +GNUTLS_E_ASN1_DER_ERROR = -69 # Variable c_int +GNUTLS_KEY_DECIPHER_ONLY = 32768 # Variable c_int +GNUTLS_E_DECOMPRESSION_FAILED = -26 # Variable c_int +LIBGNUTLS_VERSION_MAJOR = 2 # Variable c_int +GNUTLS_E_NO_CIPHER_SUITES = -87 # Variable c_int +GNUTLS_KEY_KEY_ENCIPHERMENT = 32 # Variable c_int +GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR = -207 # Variable c_int +GNUTLS_E_ASN1_TYPE_ANY_ERROR = -75 # Variable c_int +GNUTLS_OID_LDAP_UID = '0.9.2342.19200300.100.1.1' # Variable STRING +GNUTLS_KEY_DATA_ENCIPHERMENT = 16 # Variable c_int +GNUTLS_E_X509_UNSUPPORTED_OID = -205 # Variable c_int +GNUTLS_E_NO_CERTIFICATE_FOUND = -49 # Variable c_int +GNUTLS_E_UNIMPLEMENTED_FEATURE = -1250 # Variable c_int +GNUTLS_E_UNSUPPORTED_VERSION_PACKET = -8 # Variable c_int +GNUTLS_E_FILE_ERROR = -64 # Variable c_int +GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN = 1 # Variable c_int +LIBGNUTLS_VERSION = '2.4.1' # Variable STRING +GNUTLS_CRL_REASON_AFFILIATION_CHANGED = 16 # Variable c_int +GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME = '2.5.4.11' # Variable STRING +GNUTLS_OID_X520_COMMON_NAME = '2.5.4.3' # Variable STRING +GNUTLS_E_HASH_FAILED = -33 # Variable c_int +GNUTLS_E_PKCS1_WRONG_PAD = -57 # Variable c_int +GNUTLS_OID_X520_GENERATION_QUALIFIER = '2.5.4.44' # Variable STRING +GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY = -202 # Variable c_int +GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION = -47 # Variable c_int +GNUTLS_OID_X520_PSEUDONYM = '2.5.4.65' # Variable STRING +GNUTLS_E_NO_COMPRESSION_ALGORITHMS = -86 # Variable c_int +GNUTLS_E_UNEXPECTED_PACKET_LENGTH = -9 # Variable c_int +GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY = -202 # Variable c_int +GNUTLS_E_MPI_PRINT_FAILED = -35 # Variable c_int +GNUTLS_E_INVALID_PASSWORD = -99 # Variable c_int +GNUTLS_E_CERTIFICATE_KEY_MISMATCH = -60 # Variable c_int +GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME = '2.5.4.8' # Variable STRING +GNUTLS_E_INSUFFICIENT_CREDENTIALS = -32 # Variable c_int +GNUTLS_OID_X520_SURNAME = '2.5.4.4' # Variable STRING +GNUTLS_E_X509_UNKNOWN_SAN = -62 # Variable c_int +GNUTLS_KEY_CRL_SIGN = 2 # Variable c_int +GNUTLS_E_PK_SIG_VERIFY_FAILED = -89 # Variable c_int +GNUTLS_E_BASE64_ENCODING_ERROR = -201 # Variable c_int +GNUTLS_E_ASN1_VALUE_NOT_VALID = -72 # Variable c_int +GNUTLS_OID_X520_TITLE = '2.5.4.12' # Variable STRING +GNUTLS_E_ENCRYPTION_FAILED = -40 # Variable c_int +GNUTLS_OID_PKCS9_EMAIL = '1.2.840.113549.1.9.1' # Variable STRING +GNUTLS_KP_ANY = '2.5.29.37.0' # Variable STRING +GNUTLS_CRL_REASON_UNUSED = 128 # Variable c_int +GNUTLS_E_OPENPGP_SUBKEY_ERROR = -208 # Variable c_int +GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER = -55 # Variable c_int +GNUTLS_E_EXPIRED = -29 # Variable c_int +GNUTLS_E_DB_ERROR = -30 # Variable c_int +GNUTLS_E_UNWANTED_ALGORITHM = -22 # Variable c_int +GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP = '1.3.6.1.5.5.7.9.4' # Variable STRING +GNUTLS_E_APPLICATION_ERROR_MIN = -65500 # Variable c_int +GNUTLS_E_INVALID_REQUEST = -50 # Variable c_int +GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND = -68 # Variable c_int +GNUTLS_OID_X520_INITIALS = '2.5.4.43' # Variable STRING +GNUTLS_E_ASN1_TAG_ERROR = -73 # Variable c_int +GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE = -95 # Variable c_int +GNUTLS_KP_EMAIL_PROTECTION = '1.3.6.1.5.5.7.3.4' # Variable STRING +GNUTLS_CRL_REASON_CESSATION_OF_OPERATION = 4 # Variable c_int +GNUTLS_E_IA_VERIFY_FAILED = -104 # Variable c_int +GNUTLS_KP_TIME_STAMPING = '1.3.6.1.5.5.7.3.8' # Variable STRING +GNUTLS_E_INTERNAL_ERROR = -59 # Variable c_int +GNUTLS_E_LZO_INIT_FAILED = -85 # Variable c_int +GNUTLS_CRL_REASON_CERTIFICATE_HOLD = 2 # Variable c_int +GNUTLS_OID_X520_ORGANIZATION_NAME = '2.5.4.10' # Variable STRING +GNUTLS_CRL_REASON_KEY_COMPROMISE = 64 # Variable c_int +GNUTLS_OID_PKIX_GENDER = '1.3.6.1.5.5.7.9.3' # Variable STRING +GNUTLS_E_APPLICATION_ERROR_MAX = -65000 # Variable c_int +GNUTLS_E_SRP_PWD_PARSING_ERROR = -91 # Variable c_int +GNUTLS_E_NO_TEMPORARY_RSA_PARAMS = -84 # Variable c_int +GNUTLS_OID_PKIX_PLACE_OF_BIRTH = '1.3.6.1.5.5.7.9.2' # Variable STRING +GNUTLS_E_LIBRARY_VERSION_MISMATCH = -83 # Variable c_int +GNUTLS_KEY_DIGITAL_SIGNATURE = 128 # Variable c_int +GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET = -19 # Variable c_int +GNUTLS_E_ASN1_GENERIC_ERROR = -71 # Variable c_int +GNUTLS_E_ILLEGAL_SRP_USERNAME = -90 # Variable c_int +_GNUTLS_GCC_VERSION = 40301 # Variable c_int +GNUTLS_E_AGAIN = -28 # Variable c_int +GNUTLS_E_DH_PRIME_UNACCEPTABLE = -63 # Variable c_int +GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE = -61 # Variable c_int +GNUTLS_E_UNKNOWN_CIPHER_SUITE = -21 # Variable c_int +GNUTLS_E_CONSTRAINT_ERROR = -101 # Variable c_int +GNUTLS_E_UNEXPECTED_PACKET = -15 # Variable c_int +TLS_RANDOM_SIZE = 32 # Variable c_int +LIBGNUTLS_VERSION_PATCH = 1 # Variable c_int +GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION = -58 # Variable c_int +GNUTLS_E_INVALID_SESSION = -10 # Variable c_int +GNUTLS_KEY_KEY_AGREEMENT = 8 # Variable c_int +GNUTLS_E_ERROR_IN_FINISHED_PACKET = -18 # Variable c_int +GNUTLS_KEY_ENCIPHER_ONLY = 1 # Variable c_int +GNUTLS_E_UNKNOWN_CIPHER_TYPE = -6 # Variable c_int +GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE = -56 # Variable c_int +GNUTLS_CRL_REASON_AA_COMPROMISE = 32768 # Variable c_int +GNUTLS_E_CERTIFICATE_ERROR = -43 # Variable c_int +GNUTLS_E_TOO_MANY_EMPTY_PACKETS = -78 # Variable c_int +GNUTLS_OID_PKIX_DATE_OF_BIRTH = '1.3.6.1.5.5.7.9.1' # Variable STRING +GNUTLS_E_PK_ENCRYPTION_FAILED = -44 # Variable c_int +GNUTLS_OID_LDAP_DC = '0.9.2342.19200300.100.1.25' # Variable STRING +GNUTLS_KP_TLS_WWW_CLIENT = '1.3.6.1.5.5.7.3.2' # Variable STRING +GNUTLS_E_MPI_SCAN_FAILED = -23 # Variable c_int +GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED = -94 # Variable c_int +GNUTLS_E_SRP_PWD_ERROR = -31 # Variable c_int +GNUTLS_CRL_REASON_SUPERSEEDED = 8 # Variable c_int +GNUTLS_E_INTERRUPTED = -52 # Variable c_int +GNUTLS_OID_X520_LOCALITY_NAME = '2.5.4.7' # Variable STRING +GNUTLS_E_UNKNOWN_HASH_ALGORITHM = -96 # Variable c_int +GNUTLS_E_RANDOM_FAILED = -206 # Variable c_int +GNUTLS_E_HANDSHAKE_TOO_LARGE = -210 # Variable c_int +GNUTLS_KP_CODE_SIGNING = '1.3.6.1.5.5.7.3.3' # Variable STRING + +# values for enumeration 'gnutls_ia_apptype_t' +gnutls_ia_apptype_t = c_int # enum + +# values for enumeration 'gnutls_cipher_algorithm_t' +gnutls_cipher_algorithm_t = c_int # enum + +# values for enumeration 'gnutls_kx_algorithm_t' +gnutls_kx_algorithm_t = c_int # enum + +# values for enumeration 'gnutls_params_type_t' +gnutls_params_type_t = c_int # enum + +# values for enumeration 'gnutls_credentials_type_t' +gnutls_credentials_type_t = c_int # enum + +# values for enumeration 'gnutls_mac_algorithm_t' +gnutls_mac_algorithm_t = c_int # enum + +# values for enumeration 'gnutls_digest_algorithm_t' +gnutls_digest_algorithm_t = c_int # enum + +# values for enumeration 'gnutls_compression_method_t' +gnutls_compression_method_t = c_int # enum + +# values for enumeration 'gnutls_connection_end_t' +gnutls_connection_end_t = c_int # enum + +# values for enumeration 'gnutls_alert_level_t' +gnutls_alert_level_t = c_int # enum + +# values for enumeration 'gnutls_alert_description_t' +gnutls_alert_description_t = c_int # enum + +# values for enumeration 'gnutls_handshake_description_t' +gnutls_handshake_description_t = c_int # enum + +# values for enumeration 'gnutls_certificate_status_t' +gnutls_certificate_status_t = c_int # enum + +# values for enumeration 'gnutls_certificate_request_t' +gnutls_certificate_request_t = c_int # enum + +# values for enumeration 'gnutls_openpgp_crt_status_t' +gnutls_openpgp_crt_status_t = c_int # enum + +# values for enumeration 'gnutls_close_request_t' +gnutls_close_request_t = c_int # enum + +# values for enumeration 'gnutls_protocol_t' +gnutls_protocol_t = c_int # enum + +# values for enumeration 'gnutls_certificate_type_t' +gnutls_certificate_type_t = c_int # enum + +# values for enumeration 'gnutls_x509_crt_fmt_t' +gnutls_x509_crt_fmt_t = c_int # enum + +# values for enumeration 'gnutls_certificate_print_formats' +gnutls_certificate_print_formats = c_int # enum + +# values for enumeration 'gnutls_pk_algorithm_t' +gnutls_pk_algorithm_t = c_int # enum + +# values for enumeration 'gnutls_sign_algorithm_t' +gnutls_sign_algorithm_t = c_int # enum + +# values for enumeration 'gnutls_server_name_type_t' +gnutls_server_name_type_t = c_int # enum + +# values for enumeration 'gnutls_supplemental_data_format_type_t' +gnutls_supplemental_data_format_type_t = c_int # enum + +# values for enumeration 'gnutls_psk_key_flags' +gnutls_psk_key_flags = c_int # enum + +# values for enumeration 'gnutls_x509_subject_alt_name_t' +gnutls_x509_subject_alt_name_t = c_int # enum + +# values for enumeration 'gnutls_openpgp_crt_fmt' +gnutls_openpgp_crt_fmt = c_int # enum + +# values for enumeration 'gnutls_certificate_import_flags' +gnutls_certificate_import_flags = c_int # enum + +# values for enumeration 'gnutls_certificate_verify_flags' +gnutls_certificate_verify_flags = c_int # enum + +# values for enumeration 'gnutls_pkcs_encrypt_flags_t' +gnutls_pkcs_encrypt_flags_t = c_int # enum +__all__ = ['GNUTLS_PKCS_USE_PKCS12_ARCFOUR', + 'GNUTLS_HANDSHAKE_CLIENT_HELLO', + 'GNUTLS_E_ASN1_DER_OVERFLOW', + 'GNUTLS_CERT_INSECURE_ALGORITHM', + 'GNUTLS_E_WARNING_ALERT_RECEIVED', + 'GNUTLS_E_OPENPGP_GETKEY_FAILED', 'GNUTLS_KX_UNKNOWN', + 'GNUTLS_E_SUCCESS', 'GNUTLS_CRT_PRINT_UNSIGNED_FULL', + 'GNUTLS_DIG_NULL', 'GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND', + 'GNUTLS_CIPHER_UNKNOWN', 'GNUTLS_KX_SRP_DSS', + 'GNUTLS_A_UNSUPPORTED_EXTENSION', + 'GNUTLS_E_WARNING_IA_IPHF_RECEIVED', + 'GNUTLS_CRL_REASON_CA_COMPROMISE', + 'GNUTLS_E_LZO_INIT_FAILED', 'gnutls_pkcs_encrypt_flags_t', + 'GNUTLS_PKCS_USE_PKCS12_RC2_40', + 'GNUTLS_A_CERTIFICATE_UNKNOWN', + 'GNUTLS_E_MAC_VERIFY_FAILED', 'GNUTLS_OPENPGP_CERT', + 'GNUTLS_E_NO_TEMPORARY_DH_PARAMS', + 'GNUTLS_E_OPENPGP_UID_REVOKED', 'GNUTLS_KX_DHE_RSA', + 'GNUTLS_E_PUSH_ERROR', 'GNUTLS_CRT_OPENPGP', + 'GNUTLS_E_PULL_ERROR', 'GNUTLS_E_CONSTRAINT_ERROR', + 'GNUTLS_KEY_DECIPHER_ONLY', + 'GNUTLS_HANDSHAKE_HELLO_REQUEST', + 'gnutls_certificate_verify_flags', 'GNUTLS_E_FILE_ERROR', + 'GNUTLS_E_ASN1_TYPE_ANY_ERROR', 'GNUTLS_CERT_REVOKED', + 'GNUTLS_E_NO_CERTIFICATE_FOUND', 'GNUTLS_SIGN_RSA_MD5', + 'GNUTLS_E_DECOMPRESSION_FAILED', 'GNUTLS_DIG_MD5', + 'GNUTLS_DIG_MD2', 'GNUTLS_A_HANDSHAKE_FAILURE', + 'GNUTLS_E_ASN1_VALUE_NOT_FOUND', + 'GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT', + 'GNUTLS_E_PKCS1_WRONG_PAD', 'gnutls_params_type_t', + 'GNUTLS_E_BASE64_DECODING_ERROR', + 'GNUTLS_CIPHER_ARCFOUR_128', 'GNUTLS_X509_FMT_PEM', + 'GNUTLS_E_CERTIFICATE_KEY_MISMATCH', + 'GNUTLS_SIGN_RSA_SHA1', 'GNUTLS_DIG_SHA256', + 'GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST', + 'LIBGNUTLS_VERSION', 'GNUTLS_OID_X520_TITLE', + 'GNUTLS_MAC_SHA256', 'GNUTLS_E_DB_ERROR', + 'GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP', + 'GNUTLS_SIGN_UNKNOWN', 'GNUTLS_DIG_SHA512', + 'gnutls_x509_subject_alt_name_t', 'GNUTLS_AL_FATAL', + 'GNUTLS_E_IA_VERIFY_FAILED', 'gnutls_certificate_type_t', + 'GNUTLS_MAC_RMD160', 'GNUTLS_SIGN_RSA_SHA256', + 'GNUTLS_CRT_PRINT_FULL', + 'GNUTLS_E_LIBRARY_VERSION_MISMATCH', + 'gnutls_pk_algorithm_t', 'GNUTLS_HANDSHAKE_SUPPLEMENTAL', + 'GNUTLS_A_UNEXPECTED_MESSAGE', + 'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5', + 'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2', + 'GNUTLS_E_UNEXPECTED_PACKET', 'GNUTLS_A_UNKNOWN_CA', + 'gnutls_certificate_import_flags', + 'LIBGNUTLS_VERSION_PATCH', + 'GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION', + 'GNUTLS_SIGN_RSA_SHA512', 'GNUTLS_PKCS_USE_PBES2_3DES', + 'GNUTLS_KEY_KEY_AGREEMENT', + 'GNUTLS_E_DH_PRIME_UNACCEPTABLE', + 'GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY', + 'gnutls_cipher_algorithm_t', + 'GNUTLS_IA_FINAL_PHASE_FINISHED', 'GNUTLS_SAN_DNSNAME', + 'GNUTLS_E_PK_ENCRYPTION_FAILED', + 'GNUTLS_E_MPI_SCAN_FAILED', + 'GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED', + 'GNUTLS_E_SRP_PWD_ERROR', 'gnutls_mac_algorithm_t', + 'GNUTLS_PARAMS_RSA_EXPORT', 'GNUTLS_PSK_KEY_RAW', + 'GNUTLS_E_UNKNOWN_HASH_ALGORITHM', + 'GNUTLS_E_RANDOM_FAILED', 'GNUTLS_E_HANDSHAKE_TOO_LARGE', + 'GNUTLS_A_NO_RENEGOTIATION', 'TLS_MASTER_SIZE', + 'GNUTLS_E_FATAL_ALERT_RECEIVED', 'GNUTLS_E_LARGE_PACKET', + 'GNUTLS_MAX_SESSION_ID', + 'GNUTLS_A_INNER_APPLICATION_FAILURE', + 'GNUTLS_E_RECORD_LIMIT_REACHED', + 'GNUTLS_E_ASN1_ELEMENT_NOT_FOUND', + 'GNUTLS_HANDSHAKE_CERTIFICATE_PKT', + 'GNUTLS_A_INSUFFICIENT_SECURITY', + 'GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM', + 'GNUTLS_A_DECODE_ERROR', + 'GNUTLS_A_INNER_APPLICATION_VERIFICATION', + 'GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE', 'GNUTLS_PK_RSA', + 'GNUTLS_CRD_CERTIFICATE', 'GNUTLS_MAC_MD5', + 'GNUTLS_MAC_MD2', 'GNUTLS_E_ASN1_TAG_IMPLICIT', + 'GNUTLS_E_OPENPGP_KEYRING_ERROR', 'GNUTLS_SAN_OTHERNAME', + 'GNUTLS_SAN_IPADDRESS', 'gnutls_compression_method_t', + 'GNUTLS_SAN_DN', 'GNUTLS_COMP_NULL', + 'GNUTLS_A_CERTIFICATE_EXPIRED', + 'GNUTLS_OPENPGP_CERT_FINGERPRINT', + 'GNUTLS_KEY_DATA_ENCIPHERMENT', 'GNUTLS_X509_FMT_DER', + 'GNUTLS_CIPHER_AES_256_CBC', 'gnutls_sign_algorithm_t', + 'GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN', 'GNUTLS_SHUT_WR', + 'GNUTLS_KX_DHE_PSK', 'GNUTLS_CLIENT', 'GNUTLS_DIG_SHA384', + 'GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION', + 'GNUTLS_E_UNKNOWN_CIPHER_TYPE', + 'GNUTLS_E_MPI_PRINT_FAILED', 'GNUTLS_E_INVALID_PASSWORD', + 'GNUTLS_CIPHER_3DES_CBC', 'gnutls_credentials_type_t', + 'GNUTLS_SIGN_DSA_SHA1', 'GNUTLS_KEY_CRL_SIGN', + 'GNUTLS_E_BASE64_ENCODING_ERROR', 'GNUTLS_A_CLOSE_NOTIFY', + 'GNUTLS_OID_PKCS9_EMAIL', 'GNUTLS_CRL_REASON_UNUSED', + 'GNUTLS_E_UNKNOWN_PK_ALGORITHM', 'GNUTLS_CERT_INVALID', + 'GNUTLS_E_APPLICATION_ERROR_MIN', + 'GNUTLS_HANDSHAKE_SERVER_HELLO_DONE', + 'GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED', + 'GNUTLS_SAN_URI', 'GNUTLS_A_UNSUPPORTED_CERTIFICATE', + 'GNUTLS_E_ASN1_TAG_ERROR', 'GNUTLS_E_INTERNAL_ERROR', + 'GNUTLS_CRL_REASON_CERTIFICATE_HOLD', + 'gnutls_certificate_status_t', 'GNUTLS_OID_PKIX_GENDER', + 'GNUTLS_E_SRP_PWD_PARSING_ERROR', 'GNUTLS_MAC_SHA384', + 'GNUTLS_COMP_DEFLATE', 'GNUTLS_E_ASN1_VALUE_NOT_VALID', + 'GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED', + 'GNUTLS_COMP_UNKNOWN', + 'GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET', + 'GNUTLS_CIPHER_CAMELLIA_256_CBC', + 'GNUTLS_CERT_SIGNER_NOT_FOUND', + 'GNUTLS_A_PROTOCOL_VERSION', 'GNUTLS_E_AGAIN', + 'GNUTLS_CIPHER_NULL', 'GNUTLS_KEY_ENCIPHER_ONLY', + 'GNUTLS_NAME_DNS', 'GNUTLS_E_UNKNOWN_CIPHER_SUITE', + 'gnutls_certificate_request_t', + 'GNUTLS_CERT_SIGNER_NOT_CA', 'GNUTLS_A_USER_CANCELED', + 'GNUTLS_E_PK_SIGN_FAILED', + 'GNUTLS_E_ERROR_IN_FINISHED_PACKET', + 'GNUTLS_CRL_REASON_AA_COMPROMISE', 'GNUTLS_MAC_SHA1', + 'GNUTLS_CRD_ANON', 'GNUTLS_HANDSHAKE_SERVER_HELLO', + 'GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE', + 'GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY', + 'gnutls_ia_apptype_t', '_GNUTLS_GCC_VERSION', + 'GNUTLS_CRL_REASON_SUPERSEEDED', + 'gnutls_digest_algorithm_t', 'GNUTLS_A_DECRYPTION_FAILED', + 'GNUTLS_MAC_NULL', 'GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE', + 'GNUTLS_E_ASN1_DER_ERROR', 'GNUTLS_PSK_KEY_HEX', + 'GNUTLS_E_UNKNOWN_ALGORITHM', 'GNUTLS_DIG_SHA1', + 'GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY', + 'GNUTLS_E_ASN1_SYNTAX_ERROR', + 'GNUTLS_E_WARNING_IA_FPHF_RECEIVED', + 'GNUTLS_OID_X520_DN_QUALIFIER', + 'GNUTLS_E_NO_CIPHER_SUITES', 'GNUTLS_KX_SRP', + 'GNUTLS_E_CRYPTO_ALREADY_REGISTERED', + 'GNUTLS_HANDSHAKE_FINISHED', 'GNUTLS_DIG_RMD160', + 'gnutls_openpgp_crt_status_t', 'GNUTLS_KEY_KEY_CERT_SIGN', + 'GNUTLS_CRD_SRP', 'GNUTLS_E_DECRYPTION_FAILED', + 'GNUTLS_KX_SRP_RSA', 'gnutls_protocol_t', + 'gnutls_openpgp_crt_fmt', 'GNUTLS_IA_APPLICATION_PAYLOAD', + 'GNUTLS_SIGN_RSA_MD2', 'GNUTLS_A_CERTIFICATE_UNOBTAINABLE', + 'GNUTLS_CIPHER_DES_CBC', 'GNUTLS_A_RECORD_OVERFLOW', + 'GNUTLS_KX_DHE_DSS', 'GNUTLS_KEY_KEY_ENCIPHERMENT', + 'GNUTLS_OID_LDAP_UID', 'GNUTLS_E_X509_UNSUPPORTED_OID', + 'GNUTLS_VERIFY_DO_NOT_ALLOW_SAME', + 'GNUTLS_E_UNIMPLEMENTED_FEATURE', 'GNUTLS_A_DECRYPT_ERROR', + 'GNUTLS_TLS1_2', 'GNUTLS_TLS1_0', 'GNUTLS_TLS1_1', + 'GNUTLS_CRL_REASON_AFFILIATION_CHANGED', + 'GNUTLS_OPENPGP_FMT_RAW', + 'GNUTLS_OID_X520_GENERATION_QUALIFIER', + 'GNUTLS_OID_X520_PSEUDONYM', + 'GNUTLS_A_DECOMPRESSION_FAILURE', + 'GNUTLS_E_NO_COMPRESSION_ALGORITHMS', + 'GNUTLS_E_UNEXPECTED_PACKET_LENGTH', 'GNUTLS_PK_UNKNOWN', + 'GNUTLS_E_COMPRESSION_FAILED', + 'GNUTLS_KEY_NON_REPUDIATION', 'GNUTLS_A_ACCESS_DENIED', + 'GNUTLS_E_INSUFFICIENT_CREDENTIALS', + 'gnutls_kx_algorithm_t', 'GNUTLS_OID_X520_COMMON_NAME', + 'GNUTLS_OID_PKIX_PLACE_OF_BIRTH', + 'GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME', + 'GNUTLS_VERIFY_DISABLE_CA_SIGN', + 'GNUTLS_SAN_OTHERNAME_XMPP', 'GNUTLS_E_INVALID_REQUEST', + 'GNUTLS_SSL3', 'GNUTLS_KP_TIME_STAMPING', + 'GNUTLS_A_SSL3_NO_CERTIFICATE', + 'GNUTLS_CRL_REASON_KEY_COMPROMISE', + 'GNUTLS_E_APPLICATION_ERROR_MAX', + 'GNUTLS_KEY_DIGITAL_SIGNATURE', + 'gnutls_supplemental_data_format_type_t', + 'gnutls_alert_description_t', + 'GNUTLS_A_CERTIFICATE_REVOKED', 'gnutls_alert_level_t', + 'gnutls_psk_key_flags', 'GNUTLS_A_BAD_CERTIFICATE', + 'GNUTLS_MAC_UNKNOWN', 'GNUTLS_A_UNRECOGNIZED_NAME', + 'TLS_RANDOM_SIZE', 'GNUTLS_E_INVALID_SESSION', + 'GNUTLS_PARAMS_DH', 'GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE', + 'gnutls_x509_crt_fmt_t', 'GNUTLS_KP_ANY', + 'GNUTLS_E_TOO_MANY_EMPTY_PACKETS', + 'GNUTLS_OID_PKIX_DATE_OF_BIRTH', + 'GNUTLS_OPENPGP_FMT_BASE64', + 'GNUTLS_E_NO_TEMPORARY_RSA_PARAMS', + 'GNUTLS_VERSION_UNKNOWN', 'GNUTLS_E_INTERRUPTED', + 'GNUTLS_COMP_LZO', 'GNUTLS_SERVER', 'GNUTLS_CRD_IA', + 'GNUTLS_DIG_SHA224', 'GNUTLS_KX_RSA', + 'LIBGNUTLS_VERSION_NUMBER', 'GNUTLS_CERT_IGNORE', + 'GNUTLS_CERT_REQUEST', 'GNUTLS_MAC_SHA512', + 'GNUTLS_E_SHORT_MEMORY_BUFFER', 'GNUTLS_SIGN_RSA_SHA224', + 'GNUTLS_E_REHANDSHAKE', 'gnutls_close_request_t', + 'GNUTLS_OID_X520_GIVEN_NAME', 'LIBGNUTLS_VERSION_MINOR', + 'gnutls_handshake_description_t', + 'GNUTLS_E_KEY_USAGE_VIOLATION', + 'GNUTLS_E_PK_DECRYPTION_FAILED', + 'GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE', 'GNUTLS_KX_PSK', + 'GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA', + 'GNUTLS_KP_OCSP_SIGNING', 'GNUTLS_A_UNKNOWN_PSK_IDENTITY', + 'GNUTLS_OID_X520_SURNAME', 'GNUTLS_E_MEMORY_ERROR', + 'GNUTLS_CERT_REQUIRE', 'GNUTLS_KX_ANON_DH', + 'GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT', + 'GNUTLS_MAX_ALGORITHM_NUM', 'GNUTLS_A_EXPORT_RESTRICTION', + 'GNUTLS_OID_X520_COUNTRY_NAME', 'GNUTLS_SHUT_RDWR', + 'GNUTLS_AL_WARNING', 'GNUTLS_E_GOT_APPLICATION_DATA', + 'LIBGNUTLS_VERSION_MAJOR', 'GNUTLS_CRT_UNKNOWN', + 'GNUTLS_E_UNSUPPORTED_VERSION_PACKET', + 'GNUTLS_KP_TLS_WWW_SERVER', + 'GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME', + 'GNUTLS_E_HASH_FAILED', + 'GNUTLS_OID_X520_ORGANIZATION_NAME', + 'gnutls_server_name_type_t', 'GNUTLS_E_ENCRYPTION_FAILED', + 'GNUTLS_E_X509_UNKNOWN_SAN', 'GNUTLS_CRD_PSK', + 'GNUTLS_E_PK_SIG_VERIFY_FAILED', 'GNUTLS_A_BAD_RECORD_MAC', + 'GNUTLS_KX_RSA_EXPORT', 'GNUTLS_E_OPENPGP_SUBKEY_ERROR', + 'GNUTLS_SIGN_RSA_SHA384', 'GNUTLS_CRT_X509', + 'GNUTLS_E_EXPIRED', 'GNUTLS_E_UNWANTED_ALGORITHM', + 'GNUTLS_SIGN_RSA_RMD160', 'GNUTLS_OID_X520_INITIALS', + 'GNUTLS_KP_EMAIL_PROTECTION', 'gnutls_connection_end_t', + 'GNUTLS_E_INIT_LIBEXTRA', 'GNUTLS_PKCS_PLAIN', + 'GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE', + 'GNUTLS_CRL_REASON_CESSATION_OF_OPERATION', + 'GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER', + 'GNUTLS_CIPHER_CAMELLIA_128_CBC', + 'GNUTLS_E_ASN1_GENERIC_ERROR', + 'GNUTLS_E_ILLEGAL_SRP_USERNAME', + 'GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE', 'GNUTLS_PK_DSA', + 'GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY', + 'GNUTLS_SAN_RFC822NAME', + 'GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR', + 'GNUTLS_PKCS_USE_PKCS12_3DES', 'GNUTLS_CIPHER_ARCFOUR_40', + 'GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE', + 'GNUTLS_CIPHER_RC2_40_CBC', 'GNUTLS_CIPHER_AES_128_CBC', + 'GNUTLS_OID_LDAP_DC', 'GNUTLS_KP_TLS_WWW_CLIENT', + 'GNUTLS_A_INTERNAL_ERROR', 'GNUTLS_A_ILLEGAL_PARAMETER', + 'gnutls_certificate_print_formats', + 'GNUTLS_OID_X520_LOCALITY_NAME', + 'GNUTLS_E_CERTIFICATE_ERROR', 'GNUTLS_CRT_PRINT_ONELINE', + 'GNUTLS_KP_CODE_SIGNING'] diff --git a/python-gnutls-1.1.9/gnutls/library/errors.py b/python-gnutls-1.1.9/gnutls/library/errors.py new file mode 100644 index 0000000..1e4dea7 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/library/errors.py @@ -0,0 +1,78 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# + +"""GNUTLS library errors""" + +from gnutls.errors import * +from gnutls.errors import __all__ + +from gnutls.library.constants import GNUTLS_E_AGAIN, GNUTLS_E_INTERRUPTED, GNUTLS_E_NO_CERTIFICATE_FOUND +from gnutls.library.constants import GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER +from gnutls.library.constants import GNUTLS_E_FATAL_ALERT_RECEIVED, GNUTLS_A_BAD_CERTIFICATE +from gnutls.library.constants import GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE +from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY +from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED +from gnutls.library.functions import gnutls_strerror, gnutls_alert_get + +class ErrorMessage(str): + def __new__(cls, code): + obj = str.__new__(cls, gnutls_strerror(code)) + obj.code = code + return obj + +# Check functions which return an integer status code (negative codes being errors) +# +def _check_status(retcode, function, args): + if retcode >= 0: + return retcode + elif retcode == -1: + from gnutls.library import functions + if function in (functions.gnutls_certificate_activation_time_peers, + functions.gnutls_x509_crt_get_activation_time, + functions.gnutls_openpgp_key_get_creation_time): + raise GNUTLSError("cannot retrieve activation time") + elif function in (functions.gnutls_certificate_expiration_time_peers, + functions.gnutls_x509_crt_get_expiration_time, + functions.gnutls_openpgp_key_get_expiration_time): + raise GNUTLSError("cannot retrieve expiration time") + elif function in (functions.gnutls_x509_crl_get_this_update, + functions.gnutls_x509_crl_get_next_update): + raise GNUTLSError("cannot retrieve CRL update time") + else: + raise GNUTLSError(ErrorMessage(retcode)) + elif retcode == GNUTLS_E_AGAIN: + raise OperationWouldBlock(gnutls_strerror(retcode)) + elif retcode == GNUTLS_E_INTERRUPTED: + raise OperationInterrupted(gnutls_strerror(retcode)) + elif retcode in (GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER): + raise MemoryError(ErrorMessage(retcode)) + elif retcode == GNUTLS_E_NO_CERTIFICATE_FOUND: + raise CertificateSecurityError(gnutls_strerror(retcode)) + elif retcode == GNUTLS_E_FATAL_ALERT_RECEIVED: + alertdict = { + GNUTLS_A_BAD_CERTIFICATE: (CertificateError, "peer rejected our certificate as invalid"), + GNUTLS_A_UNKNOWN_CA: (CertificateAuthorityError, "peer does not trust our certificate authority"), + GNUTLS_A_INSUFFICIENT_SECURITY: (CertificateSecurityError, "peer rejected us on insufficient security"), + GNUTLS_A_CERTIFICATE_EXPIRED: (CertificateExpiredError, "peer rejected our certificate as expired"), + GNUTLS_A_CERTIFICATE_REVOKED: (CertificateRevokedError, "peer rejected our certificate as revoked")} + alert = gnutls_alert_get(args[0]) + exception, reason = alertdict.get(alert, (GNUTLSError, ErrorMessage(retcode))) + raise exception(reason) + elif retcode == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE: + raise RequestedDataNotAvailable(gnutls_strerror(retcode)) + else: + raise GNUTLSError(ErrorMessage(retcode)) + +# Attach the error checking function to all functions returning integers +# +from gnutls.library import functions +from ctypes import c_int, c_long + +for func in functions.__dict__.values(): + if not hasattr(func, 'errcheck'): + continue ## not a function + if func.restype in (c_int, c_long): + func.errcheck = _check_status + +del c_int, c_long, func, functions + diff --git a/python-gnutls-1.1.9/gnutls/library/functions.py b/python-gnutls-1.1.9/gnutls/library/functions.py new file mode 100644 index 0000000..5ee3cab --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/library/functions.py @@ -0,0 +1,1836 @@ +from ctypes import * + +from gnutls.library.types import gnutls_ia_client_credentials_t +_libraries = {} +_libraries['libgnutls-extra.so.26'] = CDLL('libgnutls-extra.so.26') +from gnutls.library.types import gnutls_ia_server_credentials_t +from gnutls.library.types import gnutls_ia_avp_func +from gnutls.library.types import gnutls_session_t +from gnutls.library.types import size_t +STRING = c_char_p +from gnutls.library.types import ssize_t +from gnutls.library.constants import gnutls_pk_algorithm_t +_libraries['libgnutls.so.26'] = CDLL('libgnutls.so.26') +from gnutls.library.constants import gnutls_sign_algorithm_t +from gnutls.library.constants import gnutls_connection_end_t +from gnutls.library.constants import gnutls_close_request_t +from gnutls.library.constants import gnutls_alert_description_t +from gnutls.library.constants import gnutls_alert_level_t +from gnutls.library.constants import gnutls_cipher_algorithm_t +from gnutls.library.constants import gnutls_kx_algorithm_t +from gnutls.library.constants import gnutls_mac_algorithm_t +from gnutls.library.constants import gnutls_compression_method_t +from gnutls.library.constants import gnutls_certificate_type_t +from gnutls.library.constants import gnutls_protocol_t +from gnutls.library.constants import gnutls_handshake_description_t +from gnutls.library.constants import gnutls_server_name_type_t +from gnutls.library.constants import gnutls_supplemental_data_format_type_t +from gnutls.library.types import gnutls_priority_t +from gnutls.library.types import gnutls_datum_t +from gnutls.library.types import gnutls_db_retr_func +from gnutls.library.types import gnutls_db_remove_func +from gnutls.library.types import gnutls_db_store_func +from gnutls.library.types import gnutls_datum_t +from gnutls.library.types import gnutls_handshake_post_client_hello_func +from gnutls.library.constants import gnutls_credentials_type_t +from gnutls.library.types import gnutls_anon_server_credentials_t +from gnutls.library.types import gnutls_dh_params_t +from gnutls.library.types import gnutls_params_function +from gnutls.library.types import gnutls_anon_client_credentials_t +from gnutls.library.types import gnutls_certificate_credentials_t +from gnutls.library.types import gnutls_rsa_params_t +from gnutls.library.constants import gnutls_x509_crt_fmt_t +from gnutls.library.types import gnutls_x509_crt_t +from gnutls.library.types import gnutls_x509_privkey_t +from gnutls.library.types import gnutls_x509_crl_t +from gnutls.library.types import gnutls_openpgp_keyring_t +from gnutls.library.types import gnutls_alloc_function +from gnutls.library.types import gnutls_is_secure_function +from gnutls.library.types import gnutls_realloc_function +from gnutls.library.types import gnutls_free_function +from gnutls.library.types import gnutls_log_func +from gnutls.library.types import gnutls_transport_ptr_t +from gnutls.library.types import gnutls_push_func +from gnutls.library.types import gnutls_pull_func +from gnutls.library.constants import gnutls_openpgp_crt_status_t +from gnutls.library.constants import gnutls_digest_algorithm_t +from gnutls.library.types import gnutls_srp_client_credentials_t +from gnutls.library.types import gnutls_srp_server_credentials_t +from gnutls.library.types import gnutls_srp_server_credentials_function +from gnutls.library.types import gnutls_srp_client_credentials_function +from gnutls.library.types import gnutls_psk_client_credentials_t +from gnutls.library.constants import gnutls_psk_key_flags +from gnutls.library.types import gnutls_psk_server_credentials_t +from gnutls.library.types import gnutls_psk_server_credentials_function +from gnutls.library.types import gnutls_psk_client_credentials_function +from gnutls.library.types import gnutls_sign_func +from gnutls.library.types import gnutls_certificate_client_retrieve_function +from gnutls.library.types import gnutls_certificate_server_retrieve_function +from gnutls.library.constants import gnutls_certificate_request_t +from gnutls.library.types import gnutls_openpgp_crt_t +from gnutls.library.types import gnutls_openpgp_crt_fmt_t +from gnutls.library.types import gnutls_certificate_print_formats_t +from gnutls.library.types import gnutls_openpgp_privkey_t +from gnutls.library.types import gnutls_openpgp_recv_key_func +from gnutls.library.constants import gnutls_x509_subject_alt_name_t +from gnutls.library.types import gnutls_x509_dn_t +from gnutls.library.types import gnutls_x509_ava_st +from gnutls.library.types import gnutls_pkcs7_t +from gnutls.library.types import gnutls_x509_crq_t + + +gnutls_ia_free_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_client_credentials +gnutls_ia_free_client_credentials.restype = None +gnutls_ia_free_client_credentials.argtypes = [gnutls_ia_client_credentials_t] +gnutls_ia_allocate_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_client_credentials +gnutls_ia_allocate_client_credentials.restype = c_int +gnutls_ia_allocate_client_credentials.argtypes = [POINTER(gnutls_ia_client_credentials_t)] +gnutls_ia_free_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_server_credentials +gnutls_ia_free_server_credentials.restype = None +gnutls_ia_free_server_credentials.argtypes = [gnutls_ia_server_credentials_t] +gnutls_ia_allocate_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_server_credentials +gnutls_ia_allocate_server_credentials.restype = c_int +gnutls_ia_allocate_server_credentials.argtypes = [POINTER(gnutls_ia_server_credentials_t)] +gnutls_ia_set_client_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_function +gnutls_ia_set_client_avp_function.restype = None +gnutls_ia_set_client_avp_function.argtypes = [gnutls_ia_client_credentials_t, gnutls_ia_avp_func] +gnutls_ia_set_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_ptr +gnutls_ia_set_client_avp_ptr.restype = None +gnutls_ia_set_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t, c_void_p] +gnutls_ia_get_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_client_avp_ptr +gnutls_ia_get_client_avp_ptr.restype = c_void_p +gnutls_ia_get_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t] +gnutls_ia_set_server_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_function +gnutls_ia_set_server_avp_function.restype = None +gnutls_ia_set_server_avp_function.argtypes = [gnutls_ia_server_credentials_t, gnutls_ia_avp_func] +gnutls_ia_set_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_ptr +gnutls_ia_set_server_avp_ptr.restype = None +gnutls_ia_set_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t, c_void_p] +gnutls_ia_get_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_server_avp_ptr +gnutls_ia_get_server_avp_ptr.restype = c_void_p +gnutls_ia_get_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t] +gnutls_ia_handshake_p = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake_p +gnutls_ia_handshake_p.restype = c_int +gnutls_ia_handshake_p.argtypes = [gnutls_session_t] +gnutls_ia_handshake = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake +gnutls_ia_handshake.restype = c_int +gnutls_ia_handshake.argtypes = [gnutls_session_t] +gnutls_ia_permute_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_permute_inner_secret +gnutls_ia_permute_inner_secret.restype = c_int +gnutls_ia_permute_inner_secret.argtypes = [gnutls_session_t, size_t, STRING] +gnutls_ia_endphase_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_endphase_send +gnutls_ia_endphase_send.restype = c_int +gnutls_ia_endphase_send.argtypes = [gnutls_session_t, c_int] +gnutls_ia_verify_endphase = _libraries['libgnutls-extra.so.26'].gnutls_ia_verify_endphase +gnutls_ia_verify_endphase.restype = c_int +gnutls_ia_verify_endphase.argtypes = [gnutls_session_t, STRING] +gnutls_ia_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_send +gnutls_ia_send.restype = ssize_t +gnutls_ia_send.argtypes = [gnutls_session_t, STRING, size_t] +gnutls_ia_recv = _libraries['libgnutls-extra.so.26'].gnutls_ia_recv +gnutls_ia_recv.restype = ssize_t +gnutls_ia_recv.argtypes = [gnutls_session_t, STRING, size_t] +gnutls_ia_generate_challenge = _libraries['libgnutls-extra.so.26'].gnutls_ia_generate_challenge +gnutls_ia_generate_challenge.restype = c_int +gnutls_ia_generate_challenge.argtypes = [gnutls_session_t, size_t, STRING] +gnutls_ia_extract_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_extract_inner_secret +gnutls_ia_extract_inner_secret.restype = None +gnutls_ia_extract_inner_secret.argtypes = [gnutls_session_t, STRING] +gnutls_ia_enable = _libraries['libgnutls-extra.so.26'].gnutls_ia_enable +gnutls_ia_enable.restype = None +gnutls_ia_enable.argtypes = [gnutls_session_t, c_int] +gnutls_global_init_extra = _libraries['libgnutls-extra.so.26'].gnutls_global_init_extra +gnutls_global_init_extra.restype = c_int +gnutls_global_init_extra.argtypes = [] +gnutls_extra_check_version = _libraries['libgnutls-extra.so.26'].gnutls_extra_check_version +gnutls_extra_check_version.restype = STRING +gnutls_extra_check_version.argtypes = [STRING] +gnutls_pk_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_pk_algorithm_get_name +gnutls_pk_algorithm_get_name.restype = STRING +gnutls_pk_algorithm_get_name.argtypes = [gnutls_pk_algorithm_t] +gnutls_sign_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_sign_algorithm_get_name +gnutls_sign_algorithm_get_name.restype = STRING +gnutls_sign_algorithm_get_name.argtypes = [gnutls_sign_algorithm_t] +gnutls_init = _libraries['libgnutls.so.26'].gnutls_init +gnutls_init.restype = c_int +gnutls_init.argtypes = [POINTER(gnutls_session_t), gnutls_connection_end_t] +gnutls_deinit = _libraries['libgnutls.so.26'].gnutls_deinit +gnutls_deinit.restype = None +gnutls_deinit.argtypes = [gnutls_session_t] +gnutls_bye = _libraries['libgnutls.so.26'].gnutls_bye +gnutls_bye.restype = c_int +gnutls_bye.argtypes = [gnutls_session_t, gnutls_close_request_t] +gnutls_handshake = _libraries['libgnutls.so.26'].gnutls_handshake +gnutls_handshake.restype = c_int +gnutls_handshake.argtypes = [gnutls_session_t] +gnutls_rehandshake = _libraries['libgnutls.so.26'].gnutls_rehandshake +gnutls_rehandshake.restype = c_int +gnutls_rehandshake.argtypes = [gnutls_session_t] +gnutls_alert_get = _libraries['libgnutls.so.26'].gnutls_alert_get +gnutls_alert_get.restype = gnutls_alert_description_t +gnutls_alert_get.argtypes = [gnutls_session_t] +gnutls_alert_send = _libraries['libgnutls.so.26'].gnutls_alert_send +gnutls_alert_send.restype = c_int +gnutls_alert_send.argtypes = [gnutls_session_t, gnutls_alert_level_t, gnutls_alert_description_t] +gnutls_alert_send_appropriate = _libraries['libgnutls.so.26'].gnutls_alert_send_appropriate +gnutls_alert_send_appropriate.restype = c_int +gnutls_alert_send_appropriate.argtypes = [gnutls_session_t, c_int] +gnutls_alert_get_name = _libraries['libgnutls.so.26'].gnutls_alert_get_name +gnutls_alert_get_name.restype = STRING +gnutls_alert_get_name.argtypes = [gnutls_alert_description_t] +gnutls_cipher_get = _libraries['libgnutls.so.26'].gnutls_cipher_get +gnutls_cipher_get.restype = gnutls_cipher_algorithm_t +gnutls_cipher_get.argtypes = [gnutls_session_t] +gnutls_kx_get = _libraries['libgnutls.so.26'].gnutls_kx_get +gnutls_kx_get.restype = gnutls_kx_algorithm_t +gnutls_kx_get.argtypes = [gnutls_session_t] +gnutls_mac_get = _libraries['libgnutls.so.26'].gnutls_mac_get +gnutls_mac_get.restype = gnutls_mac_algorithm_t +gnutls_mac_get.argtypes = [gnutls_session_t] +gnutls_compression_get = _libraries['libgnutls.so.26'].gnutls_compression_get +gnutls_compression_get.restype = gnutls_compression_method_t +gnutls_compression_get.argtypes = [gnutls_session_t] +gnutls_certificate_type_get = _libraries['libgnutls.so.26'].gnutls_certificate_type_get +gnutls_certificate_type_get.restype = gnutls_certificate_type_t +gnutls_certificate_type_get.argtypes = [gnutls_session_t] +gnutls_cipher_get_key_size = _libraries['libgnutls.so.26'].gnutls_cipher_get_key_size +gnutls_cipher_get_key_size.restype = size_t +gnutls_cipher_get_key_size.argtypes = [gnutls_cipher_algorithm_t] +gnutls_mac_get_key_size = _libraries['libgnutls.so.26'].gnutls_mac_get_key_size +gnutls_mac_get_key_size.restype = size_t +gnutls_mac_get_key_size.argtypes = [gnutls_mac_algorithm_t] +gnutls_cipher_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_get_name +gnutls_cipher_get_name.restype = STRING +gnutls_cipher_get_name.argtypes = [gnutls_cipher_algorithm_t] +gnutls_mac_get_name = _libraries['libgnutls.so.26'].gnutls_mac_get_name +gnutls_mac_get_name.restype = STRING +gnutls_mac_get_name.argtypes = [gnutls_mac_algorithm_t] +gnutls_compression_get_name = _libraries['libgnutls.so.26'].gnutls_compression_get_name +gnutls_compression_get_name.restype = STRING +gnutls_compression_get_name.argtypes = [gnutls_compression_method_t] +gnutls_kx_get_name = _libraries['libgnutls.so.26'].gnutls_kx_get_name +gnutls_kx_get_name.restype = STRING +gnutls_kx_get_name.argtypes = [gnutls_kx_algorithm_t] +gnutls_certificate_type_get_name = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_name +gnutls_certificate_type_get_name.restype = STRING +gnutls_certificate_type_get_name.argtypes = [gnutls_certificate_type_t] +gnutls_mac_get_id = _libraries['libgnutls.so.26'].gnutls_mac_get_id +gnutls_mac_get_id.restype = gnutls_mac_algorithm_t +gnutls_mac_get_id.argtypes = [STRING] +gnutls_compression_get_id = _libraries['libgnutls.so.26'].gnutls_compression_get_id +gnutls_compression_get_id.restype = gnutls_compression_method_t +gnutls_compression_get_id.argtypes = [STRING] +gnutls_cipher_get_id = _libraries['libgnutls.so.26'].gnutls_cipher_get_id +gnutls_cipher_get_id.restype = gnutls_cipher_algorithm_t +gnutls_cipher_get_id.argtypes = [STRING] +gnutls_kx_get_id = _libraries['libgnutls.so.26'].gnutls_kx_get_id +gnutls_kx_get_id.restype = gnutls_kx_algorithm_t +gnutls_kx_get_id.argtypes = [STRING] +gnutls_protocol_get_id = _libraries['libgnutls.so.26'].gnutls_protocol_get_id +gnutls_protocol_get_id.restype = gnutls_protocol_t +gnutls_protocol_get_id.argtypes = [STRING] +gnutls_certificate_type_get_id = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_id +gnutls_certificate_type_get_id.restype = gnutls_certificate_type_t +gnutls_certificate_type_get_id.argtypes = [STRING] +gnutls_cipher_list = _libraries['libgnutls.so.26'].gnutls_cipher_list +gnutls_cipher_list.restype = POINTER(gnutls_cipher_algorithm_t) +gnutls_cipher_list.argtypes = [] +gnutls_mac_list = _libraries['libgnutls.so.26'].gnutls_mac_list +gnutls_mac_list.restype = POINTER(gnutls_mac_algorithm_t) +gnutls_mac_list.argtypes = [] +gnutls_compression_list = _libraries['libgnutls.so.26'].gnutls_compression_list +gnutls_compression_list.restype = POINTER(gnutls_compression_method_t) +gnutls_compression_list.argtypes = [] +gnutls_protocol_list = _libraries['libgnutls.so.26'].gnutls_protocol_list +gnutls_protocol_list.restype = POINTER(gnutls_protocol_t) +gnutls_protocol_list.argtypes = [] +gnutls_certificate_type_list = _libraries['libgnutls.so.26'].gnutls_certificate_type_list +gnutls_certificate_type_list.restype = POINTER(gnutls_certificate_type_t) +gnutls_certificate_type_list.argtypes = [] +gnutls_kx_list = _libraries['libgnutls.so.26'].gnutls_kx_list +gnutls_kx_list.restype = POINTER(gnutls_kx_algorithm_t) +gnutls_kx_list.argtypes = [] +gnutls_cipher_suite_info = _libraries['libgnutls.so.26'].gnutls_cipher_suite_info +gnutls_cipher_suite_info.restype = STRING +gnutls_cipher_suite_info.argtypes = [size_t, STRING, POINTER(gnutls_kx_algorithm_t), POINTER(gnutls_cipher_algorithm_t), POINTER(gnutls_mac_algorithm_t), POINTER(gnutls_protocol_t)] +gnutls_error_is_fatal = _libraries['libgnutls.so.26'].gnutls_error_is_fatal +gnutls_error_is_fatal.restype = c_int +gnutls_error_is_fatal.argtypes = [c_int] +gnutls_error_to_alert = _libraries['libgnutls.so.26'].gnutls_error_to_alert +gnutls_error_to_alert.restype = c_int +gnutls_error_to_alert.argtypes = [c_int, POINTER(c_int)] +gnutls_perror = _libraries['libgnutls.so.26'].gnutls_perror +gnutls_perror.restype = None +gnutls_perror.argtypes = [c_int] +gnutls_strerror = _libraries['libgnutls.so.26'].gnutls_strerror +gnutls_strerror.restype = STRING +gnutls_strerror.argtypes = [c_int] +gnutls_handshake_set_private_extensions = _libraries['libgnutls.so.26'].gnutls_handshake_set_private_extensions +gnutls_handshake_set_private_extensions.restype = None +gnutls_handshake_set_private_extensions.argtypes = [gnutls_session_t, c_int] +gnutls_handshake_get_last_out = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_out +gnutls_handshake_get_last_out.restype = gnutls_handshake_description_t +gnutls_handshake_get_last_out.argtypes = [gnutls_session_t] +gnutls_handshake_get_last_in = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_in +gnutls_handshake_get_last_in.restype = gnutls_handshake_description_t +gnutls_handshake_get_last_in.argtypes = [gnutls_session_t] +gnutls_record_send = _libraries['libgnutls.so.26'].gnutls_record_send +gnutls_record_send.restype = ssize_t +gnutls_record_send.argtypes = [gnutls_session_t, c_void_p, size_t] +gnutls_record_recv = _libraries['libgnutls.so.26'].gnutls_record_recv +gnutls_record_recv.restype = ssize_t +gnutls_record_recv.argtypes = [gnutls_session_t, c_void_p, size_t] +gnutls_session_enable_compatibility_mode = _libraries['libgnutls.so.26'].gnutls_session_enable_compatibility_mode +gnutls_session_enable_compatibility_mode.restype = None +gnutls_session_enable_compatibility_mode.argtypes = [gnutls_session_t] +gnutls_record_disable_padding = _libraries['libgnutls.so.26'].gnutls_record_disable_padding +gnutls_record_disable_padding.restype = None +gnutls_record_disable_padding.argtypes = [gnutls_session_t] +gnutls_record_get_direction = _libraries['libgnutls.so.26'].gnutls_record_get_direction +gnutls_record_get_direction.restype = c_int +gnutls_record_get_direction.argtypes = [gnutls_session_t] +gnutls_record_get_max_size = _libraries['libgnutls.so.26'].gnutls_record_get_max_size +gnutls_record_get_max_size.restype = size_t +gnutls_record_get_max_size.argtypes = [gnutls_session_t] +gnutls_record_set_max_size = _libraries['libgnutls.so.26'].gnutls_record_set_max_size +gnutls_record_set_max_size.restype = ssize_t +gnutls_record_set_max_size.argtypes = [gnutls_session_t, size_t] +gnutls_record_check_pending = _libraries['libgnutls.so.26'].gnutls_record_check_pending +gnutls_record_check_pending.restype = size_t +gnutls_record_check_pending.argtypes = [gnutls_session_t] +gnutls_prf = _libraries['libgnutls.so.26'].gnutls_prf +gnutls_prf.restype = c_int +gnutls_prf.argtypes = [gnutls_session_t, size_t, STRING, c_int, size_t, STRING, size_t, STRING] +gnutls_prf_raw = _libraries['libgnutls.so.26'].gnutls_prf_raw +gnutls_prf_raw.restype = c_int +gnutls_prf_raw.argtypes = [gnutls_session_t, size_t, STRING, size_t, STRING, size_t, STRING] +gnutls_server_name_set = _libraries['libgnutls.so.26'].gnutls_server_name_set +gnutls_server_name_set.restype = c_int +gnutls_server_name_set.argtypes = [gnutls_session_t, gnutls_server_name_type_t, c_void_p, size_t] +gnutls_server_name_get = _libraries['libgnutls.so.26'].gnutls_server_name_get +gnutls_server_name_get.restype = c_int +gnutls_server_name_get.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t), POINTER(c_uint), c_uint] +gnutls_supplemental_get_name = _libraries['libgnutls.so.26'].gnutls_supplemental_get_name +gnutls_supplemental_get_name.restype = STRING +gnutls_supplemental_get_name.argtypes = [gnutls_supplemental_data_format_type_t] +gnutls_cipher_set_priority = _libraries['libgnutls.so.26'].gnutls_cipher_set_priority +gnutls_cipher_set_priority.restype = c_int +gnutls_cipher_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)] +gnutls_mac_set_priority = _libraries['libgnutls.so.26'].gnutls_mac_set_priority +gnutls_mac_set_priority.restype = c_int +gnutls_mac_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)] +gnutls_compression_set_priority = _libraries['libgnutls.so.26'].gnutls_compression_set_priority +gnutls_compression_set_priority.restype = c_int +gnutls_compression_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)] +gnutls_kx_set_priority = _libraries['libgnutls.so.26'].gnutls_kx_set_priority +gnutls_kx_set_priority.restype = c_int +gnutls_kx_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)] +gnutls_protocol_set_priority = _libraries['libgnutls.so.26'].gnutls_protocol_set_priority +gnutls_protocol_set_priority.restype = c_int +gnutls_protocol_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)] +gnutls_certificate_type_set_priority = _libraries['libgnutls.so.26'].gnutls_certificate_type_set_priority +gnutls_certificate_type_set_priority.restype = c_int +gnutls_certificate_type_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)] +gnutls_priority_init = _libraries['libgnutls.so.26'].gnutls_priority_init +gnutls_priority_init.restype = c_int +gnutls_priority_init.argtypes = [POINTER(gnutls_priority_t), STRING, POINTER(STRING)] +gnutls_priority_deinit = _libraries['libgnutls.so.26'].gnutls_priority_deinit +gnutls_priority_deinit.restype = None +gnutls_priority_deinit.argtypes = [gnutls_priority_t] +gnutls_priority_set = _libraries['libgnutls.so.26'].gnutls_priority_set +gnutls_priority_set.restype = c_int +gnutls_priority_set.argtypes = [gnutls_session_t, gnutls_priority_t] +gnutls_priority_set_direct = _libraries['libgnutls.so.26'].gnutls_priority_set_direct +gnutls_priority_set_direct.restype = c_int +gnutls_priority_set_direct.argtypes = [gnutls_session_t, STRING, POINTER(STRING)] +gnutls_set_default_priority = _libraries['libgnutls.so.26'].gnutls_set_default_priority +gnutls_set_default_priority.restype = c_int +gnutls_set_default_priority.argtypes = [gnutls_session_t] +gnutls_set_default_export_priority = _libraries['libgnutls.so.26'].gnutls_set_default_export_priority +gnutls_set_default_export_priority.restype = c_int +gnutls_set_default_export_priority.argtypes = [gnutls_session_t] +gnutls_cipher_suite_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_suite_get_name +gnutls_cipher_suite_get_name.restype = STRING +gnutls_cipher_suite_get_name.argtypes = [gnutls_kx_algorithm_t, gnutls_cipher_algorithm_t, gnutls_mac_algorithm_t] +gnutls_protocol_get_version = _libraries['libgnutls.so.26'].gnutls_protocol_get_version +gnutls_protocol_get_version.restype = gnutls_protocol_t +gnutls_protocol_get_version.argtypes = [gnutls_session_t] +gnutls_protocol_get_name = _libraries['libgnutls.so.26'].gnutls_protocol_get_name +gnutls_protocol_get_name.restype = STRING +gnutls_protocol_get_name.argtypes = [gnutls_protocol_t] +gnutls_session_set_data = _libraries['libgnutls.so.26'].gnutls_session_set_data +gnutls_session_set_data.restype = c_int +gnutls_session_set_data.argtypes = [gnutls_session_t, c_void_p, size_t] +gnutls_session_get_data = _libraries['libgnutls.so.26'].gnutls_session_get_data +gnutls_session_get_data.restype = c_int +gnutls_session_get_data.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)] +gnutls_session_get_data2 = _libraries['libgnutls.so.26'].gnutls_session_get_data2 +gnutls_session_get_data2.restype = c_int +gnutls_session_get_data2.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)] +gnutls_session_get_id = _libraries['libgnutls.so.26'].gnutls_session_get_id +gnutls_session_get_id.restype = c_int +gnutls_session_get_id.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)] +gnutls_session_get_server_random = _libraries['libgnutls.so.26'].gnutls_session_get_server_random +gnutls_session_get_server_random.restype = c_void_p +gnutls_session_get_server_random.argtypes = [gnutls_session_t] +gnutls_session_get_client_random = _libraries['libgnutls.so.26'].gnutls_session_get_client_random +gnutls_session_get_client_random.restype = c_void_p +gnutls_session_get_client_random.argtypes = [gnutls_session_t] +gnutls_session_get_master_secret = _libraries['libgnutls.so.26'].gnutls_session_get_master_secret +gnutls_session_get_master_secret.restype = c_void_p +gnutls_session_get_master_secret.argtypes = [gnutls_session_t] +gnutls_session_is_resumed = _libraries['libgnutls.so.26'].gnutls_session_is_resumed +gnutls_session_is_resumed.restype = c_int +gnutls_session_is_resumed.argtypes = [gnutls_session_t] +gnutls_db_set_cache_expiration = _libraries['libgnutls.so.26'].gnutls_db_set_cache_expiration +gnutls_db_set_cache_expiration.restype = None +gnutls_db_set_cache_expiration.argtypes = [gnutls_session_t, c_int] +gnutls_db_remove_session = _libraries['libgnutls.so.26'].gnutls_db_remove_session +gnutls_db_remove_session.restype = None +gnutls_db_remove_session.argtypes = [gnutls_session_t] +gnutls_db_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_db_set_retrieve_function +gnutls_db_set_retrieve_function.restype = None +gnutls_db_set_retrieve_function.argtypes = [gnutls_session_t, gnutls_db_retr_func] +gnutls_db_set_remove_function = _libraries['libgnutls.so.26'].gnutls_db_set_remove_function +gnutls_db_set_remove_function.restype = None +gnutls_db_set_remove_function.argtypes = [gnutls_session_t, gnutls_db_remove_func] +gnutls_db_set_store_function = _libraries['libgnutls.so.26'].gnutls_db_set_store_function +gnutls_db_set_store_function.restype = None +gnutls_db_set_store_function.argtypes = [gnutls_session_t, gnutls_db_store_func] +gnutls_db_set_ptr = _libraries['libgnutls.so.26'].gnutls_db_set_ptr +gnutls_db_set_ptr.restype = None +gnutls_db_set_ptr.argtypes = [gnutls_session_t, c_void_p] +gnutls_db_get_ptr = _libraries['libgnutls.so.26'].gnutls_db_get_ptr +gnutls_db_get_ptr.restype = c_void_p +gnutls_db_get_ptr.argtypes = [gnutls_session_t] +gnutls_db_check_entry = _libraries['libgnutls.so.26'].gnutls_db_check_entry +gnutls_db_check_entry.restype = c_int +gnutls_db_check_entry.argtypes = [gnutls_session_t, gnutls_datum_t] +gnutls_handshake_set_post_client_hello_function = _libraries['libgnutls.so.26'].gnutls_handshake_set_post_client_hello_function +gnutls_handshake_set_post_client_hello_function.restype = None +gnutls_handshake_set_post_client_hello_function.argtypes = [gnutls_session_t, gnutls_handshake_post_client_hello_func] +gnutls_handshake_set_max_packet_length = _libraries['libgnutls.so.26'].gnutls_handshake_set_max_packet_length +gnutls_handshake_set_max_packet_length.restype = None +gnutls_handshake_set_max_packet_length.argtypes = [gnutls_session_t, size_t] +gnutls_check_version = _libraries['libgnutls.so.26'].gnutls_check_version +gnutls_check_version.restype = STRING +gnutls_check_version.argtypes = [STRING] +gnutls_credentials_clear = _libraries['libgnutls.so.26'].gnutls_credentials_clear +gnutls_credentials_clear.restype = None +gnutls_credentials_clear.argtypes = [gnutls_session_t] +gnutls_credentials_set = _libraries['libgnutls.so.26'].gnutls_credentials_set +gnutls_credentials_set.restype = c_int +gnutls_credentials_set.argtypes = [gnutls_session_t, gnutls_credentials_type_t, c_void_p] +gnutls_anon_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_server_credentials +gnutls_anon_free_server_credentials.restype = None +gnutls_anon_free_server_credentials.argtypes = [gnutls_anon_server_credentials_t] +gnutls_anon_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_server_credentials +gnutls_anon_allocate_server_credentials.restype = c_int +gnutls_anon_allocate_server_credentials.argtypes = [POINTER(gnutls_anon_server_credentials_t)] +gnutls_anon_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_anon_set_server_dh_params +gnutls_anon_set_server_dh_params.restype = None +gnutls_anon_set_server_dh_params.argtypes = [gnutls_anon_server_credentials_t, gnutls_dh_params_t] +gnutls_anon_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_server_params_function +gnutls_anon_set_server_params_function.restype = None +gnutls_anon_set_server_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function] +gnutls_anon_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_client_credentials +gnutls_anon_free_client_credentials.restype = None +gnutls_anon_free_client_credentials.argtypes = [gnutls_anon_client_credentials_t] +gnutls_anon_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_client_credentials +gnutls_anon_allocate_client_credentials.restype = c_int +gnutls_anon_allocate_client_credentials.argtypes = [POINTER(gnutls_anon_client_credentials_t)] +gnutls_certificate_free_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_free_credentials +gnutls_certificate_free_credentials.restype = None +gnutls_certificate_free_credentials.argtypes = [gnutls_certificate_credentials_t] +gnutls_certificate_allocate_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_allocate_credentials +gnutls_certificate_allocate_credentials.restype = c_int +gnutls_certificate_allocate_credentials.argtypes = [POINTER(gnutls_certificate_credentials_t)] +gnutls_certificate_free_keys = _libraries['libgnutls.so.26'].gnutls_certificate_free_keys +gnutls_certificate_free_keys.restype = None +gnutls_certificate_free_keys.argtypes = [gnutls_certificate_credentials_t] +gnutls_certificate_free_cas = _libraries['libgnutls.so.26'].gnutls_certificate_free_cas +gnutls_certificate_free_cas.restype = None +gnutls_certificate_free_cas.argtypes = [gnutls_certificate_credentials_t] +gnutls_certificate_free_ca_names = _libraries['libgnutls.so.26'].gnutls_certificate_free_ca_names +gnutls_certificate_free_ca_names.restype = None +gnutls_certificate_free_ca_names.argtypes = [gnutls_certificate_credentials_t] +gnutls_certificate_free_crls = _libraries['libgnutls.so.26'].gnutls_certificate_free_crls +gnutls_certificate_free_crls.restype = None +gnutls_certificate_free_crls.argtypes = [gnutls_certificate_credentials_t] +gnutls_certificate_set_dh_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_dh_params +gnutls_certificate_set_dh_params.restype = None +gnutls_certificate_set_dh_params.argtypes = [gnutls_certificate_credentials_t, gnutls_dh_params_t] +gnutls_certificate_set_rsa_export_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_rsa_export_params +gnutls_certificate_set_rsa_export_params.restype = None +gnutls_certificate_set_rsa_export_params.argtypes = [gnutls_certificate_credentials_t, gnutls_rsa_params_t] +gnutls_certificate_set_verify_flags = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_flags +gnutls_certificate_set_verify_flags.restype = None +gnutls_certificate_set_verify_flags.argtypes = [gnutls_certificate_credentials_t, c_uint] +gnutls_certificate_set_verify_limits = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_limits +gnutls_certificate_set_verify_limits.restype = None +gnutls_certificate_set_verify_limits.argtypes = [gnutls_certificate_credentials_t, c_uint, c_uint] +gnutls_certificate_set_x509_trust_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_file +gnutls_certificate_set_x509_trust_file.restype = c_int +gnutls_certificate_set_x509_trust_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t] +gnutls_certificate_set_x509_trust_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_mem +gnutls_certificate_set_x509_trust_mem.restype = c_int +gnutls_certificate_set_x509_trust_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_certificate_set_x509_crl_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_file +gnutls_certificate_set_x509_crl_file.restype = c_int +gnutls_certificate_set_x509_crl_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t] +gnutls_certificate_set_x509_crl_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_mem +gnutls_certificate_set_x509_crl_mem.restype = c_int +gnutls_certificate_set_x509_crl_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_certificate_set_x509_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_file +gnutls_certificate_set_x509_key_file.restype = c_int +gnutls_certificate_set_x509_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_x509_crt_fmt_t] +gnutls_certificate_set_x509_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_mem +gnutls_certificate_set_x509_key_mem.restype = c_int +gnutls_certificate_set_x509_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_certificate_send_x509_rdn_sequence = _libraries['libgnutls.so.26'].gnutls_certificate_send_x509_rdn_sequence +gnutls_certificate_send_x509_rdn_sequence.restype = None +gnutls_certificate_send_x509_rdn_sequence.argtypes = [gnutls_session_t, c_int] +gnutls_certificate_set_x509_simple_pkcs12_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_simple_pkcs12_file +gnutls_certificate_set_x509_simple_pkcs12_file.restype = c_int +gnutls_certificate_set_x509_simple_pkcs12_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t, STRING] +gnutls_certificate_set_x509_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key +gnutls_certificate_set_x509_key.restype = c_int +gnutls_certificate_set_x509_key.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int, gnutls_x509_privkey_t] +gnutls_certificate_set_x509_trust = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust +gnutls_certificate_set_x509_trust.restype = c_int +gnutls_certificate_set_x509_trust.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int] +gnutls_certificate_set_x509_crl = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl +gnutls_certificate_set_x509_crl.restype = c_int +gnutls_certificate_set_x509_crl.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crl_t), c_int] +gnutls_certificate_get_x509_cas = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_cas +gnutls_certificate_get_x509_cas.restype = None +gnutls_certificate_get_x509_cas.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crt_t)), POINTER(c_uint)] +gnutls_certificate_get_x509_crls = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_crls +gnutls_certificate_get_x509_crls.restype = None +gnutls_certificate_get_x509_crls.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crl_t)), POINTER(c_uint)] +gnutls_certificate_get_openpgp_keyring = _libraries['libgnutls.so.26'].gnutls_certificate_get_openpgp_keyring +gnutls_certificate_get_openpgp_keyring.restype = None +gnutls_certificate_get_openpgp_keyring.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_openpgp_keyring_t)] +gnutls_global_init = _libraries['libgnutls.so.26'].gnutls_global_init +gnutls_global_init.restype = c_int +gnutls_global_init.argtypes = [] +gnutls_global_deinit = _libraries['libgnutls.so.26'].gnutls_global_deinit +gnutls_global_deinit.restype = None +gnutls_global_deinit.argtypes = [] +gnutls_global_set_mem_functions = _libraries['libgnutls.so.26'].gnutls_global_set_mem_functions +gnutls_global_set_mem_functions.restype = None +gnutls_global_set_mem_functions.argtypes = [gnutls_alloc_function, gnutls_alloc_function, gnutls_is_secure_function, gnutls_realloc_function, gnutls_free_function] +gnutls_global_set_log_function = _libraries['libgnutls.so.26'].gnutls_global_set_log_function +gnutls_global_set_log_function.restype = None +gnutls_global_set_log_function.argtypes = [gnutls_log_func] +gnutls_global_set_log_level = _libraries['libgnutls.so.26'].gnutls_global_set_log_level +gnutls_global_set_log_level.restype = None +gnutls_global_set_log_level.argtypes = [c_int] +gnutls_dh_params_init = _libraries['libgnutls.so.26'].gnutls_dh_params_init +gnutls_dh_params_init.restype = c_int +gnutls_dh_params_init.argtypes = [POINTER(gnutls_dh_params_t)] +gnutls_dh_params_deinit = _libraries['libgnutls.so.26'].gnutls_dh_params_deinit +gnutls_dh_params_deinit.restype = None +gnutls_dh_params_deinit.argtypes = [gnutls_dh_params_t] +gnutls_dh_params_import_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_import_raw +gnutls_dh_params_import_raw.restype = c_int +gnutls_dh_params_import_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_dh_params_import_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_import_pkcs3 +gnutls_dh_params_import_pkcs3.restype = c_int +gnutls_dh_params_import_pkcs3.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_dh_params_generate2 = _libraries['libgnutls.so.26'].gnutls_dh_params_generate2 +gnutls_dh_params_generate2.restype = c_int +gnutls_dh_params_generate2.argtypes = [gnutls_dh_params_t, c_uint] +gnutls_dh_params_export_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_export_pkcs3 +gnutls_dh_params_export_pkcs3.restype = c_int +gnutls_dh_params_export_pkcs3.argtypes = [gnutls_dh_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)] +gnutls_dh_params_export_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_export_raw +gnutls_dh_params_export_raw.restype = c_int +gnutls_dh_params_export_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)] +gnutls_dh_params_cpy = _libraries['libgnutls.so.26'].gnutls_dh_params_cpy +gnutls_dh_params_cpy.restype = c_int +gnutls_dh_params_cpy.argtypes = [gnutls_dh_params_t, gnutls_dh_params_t] +gnutls_rsa_params_init = _libraries['libgnutls.so.26'].gnutls_rsa_params_init +gnutls_rsa_params_init.restype = c_int +gnutls_rsa_params_init.argtypes = [POINTER(gnutls_rsa_params_t)] +gnutls_rsa_params_deinit = _libraries['libgnutls.so.26'].gnutls_rsa_params_deinit +gnutls_rsa_params_deinit.restype = None +gnutls_rsa_params_deinit.argtypes = [gnutls_rsa_params_t] +gnutls_rsa_params_cpy = _libraries['libgnutls.so.26'].gnutls_rsa_params_cpy +gnutls_rsa_params_cpy.restype = c_int +gnutls_rsa_params_cpy.argtypes = [gnutls_rsa_params_t, gnutls_rsa_params_t] +gnutls_rsa_params_import_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_raw +gnutls_rsa_params_import_raw.restype = c_int +gnutls_rsa_params_import_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_rsa_params_generate2 = _libraries['libgnutls.so.26'].gnutls_rsa_params_generate2 +gnutls_rsa_params_generate2.restype = c_int +gnutls_rsa_params_generate2.argtypes = [gnutls_rsa_params_t, c_uint] +gnutls_rsa_params_export_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_raw +gnutls_rsa_params_export_raw.restype = c_int +gnutls_rsa_params_export_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)] +gnutls_rsa_params_export_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_pkcs1 +gnutls_rsa_params_export_pkcs1.restype = c_int +gnutls_rsa_params_export_pkcs1.argtypes = [gnutls_rsa_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)] +gnutls_rsa_params_import_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_pkcs1 +gnutls_rsa_params_import_pkcs1.restype = c_int +gnutls_rsa_params_import_pkcs1.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_transport_set_ptr = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr +gnutls_transport_set_ptr.restype = None +gnutls_transport_set_ptr.argtypes = [gnutls_session_t, gnutls_transport_ptr_t] +gnutls_transport_set_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr2 +gnutls_transport_set_ptr2.restype = None +gnutls_transport_set_ptr2.argtypes = [gnutls_session_t, gnutls_transport_ptr_t, gnutls_transport_ptr_t] +gnutls_transport_get_ptr = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr +gnutls_transport_get_ptr.restype = gnutls_transport_ptr_t +gnutls_transport_get_ptr.argtypes = [gnutls_session_t] +gnutls_transport_get_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr2 +gnutls_transport_get_ptr2.restype = None +gnutls_transport_get_ptr2.argtypes = [gnutls_session_t, POINTER(gnutls_transport_ptr_t), POINTER(gnutls_transport_ptr_t)] +gnutls_transport_set_lowat = _libraries['libgnutls.so.26'].gnutls_transport_set_lowat +gnutls_transport_set_lowat.restype = None +gnutls_transport_set_lowat.argtypes = [gnutls_session_t, c_int] +gnutls_transport_set_push_function = _libraries['libgnutls.so.26'].gnutls_transport_set_push_function +gnutls_transport_set_push_function.restype = None +gnutls_transport_set_push_function.argtypes = [gnutls_session_t, gnutls_push_func] +gnutls_transport_set_pull_function = _libraries['libgnutls.so.26'].gnutls_transport_set_pull_function +gnutls_transport_set_pull_function.restype = None +gnutls_transport_set_pull_function.argtypes = [gnutls_session_t, gnutls_pull_func] +gnutls_transport_set_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_errno +gnutls_transport_set_errno.restype = None +gnutls_transport_set_errno.argtypes = [gnutls_session_t, c_int] +gnutls_transport_set_global_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_global_errno +gnutls_transport_set_global_errno.restype = None +gnutls_transport_set_global_errno.argtypes = [c_int] +gnutls_session_set_ptr = _libraries['libgnutls.so.26'].gnutls_session_set_ptr +gnutls_session_set_ptr.restype = None +gnutls_session_set_ptr.argtypes = [gnutls_session_t, c_void_p] +gnutls_session_get_ptr = _libraries['libgnutls.so.26'].gnutls_session_get_ptr +gnutls_session_get_ptr.restype = c_void_p +gnutls_session_get_ptr.argtypes = [gnutls_session_t] +gnutls_openpgp_send_cert = _libraries['libgnutls.so.26'].gnutls_openpgp_send_cert +gnutls_openpgp_send_cert.restype = None +gnutls_openpgp_send_cert.argtypes = [gnutls_session_t, gnutls_openpgp_crt_status_t] +gnutls_fingerprint = _libraries['libgnutls.so.26'].gnutls_fingerprint +gnutls_fingerprint.restype = c_int +gnutls_fingerprint.argtypes = [gnutls_digest_algorithm_t, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)] +gnutls_srp_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_client_credentials +gnutls_srp_free_client_credentials.restype = None +gnutls_srp_free_client_credentials.argtypes = [gnutls_srp_client_credentials_t] +gnutls_srp_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_client_credentials +gnutls_srp_allocate_client_credentials.restype = c_int +gnutls_srp_allocate_client_credentials.argtypes = [POINTER(gnutls_srp_client_credentials_t)] +gnutls_srp_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials +gnutls_srp_set_client_credentials.restype = c_int +gnutls_srp_set_client_credentials.argtypes = [gnutls_srp_client_credentials_t, STRING, STRING] +gnutls_srp_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_server_credentials +gnutls_srp_free_server_credentials.restype = None +gnutls_srp_free_server_credentials.argtypes = [gnutls_srp_server_credentials_t] +gnutls_srp_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_server_credentials +gnutls_srp_allocate_server_credentials.restype = c_int +gnutls_srp_allocate_server_credentials.argtypes = [POINTER(gnutls_srp_server_credentials_t)] +gnutls_srp_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_file +gnutls_srp_set_server_credentials_file.restype = c_int +gnutls_srp_set_server_credentials_file.argtypes = [gnutls_srp_server_credentials_t, STRING, STRING] +gnutls_srp_server_get_username = _libraries['libgnutls.so.26'].gnutls_srp_server_get_username +gnutls_srp_server_get_username.restype = STRING +gnutls_srp_server_get_username.argtypes = [gnutls_session_t] +gnutls_srp_verifier = _libraries['libgnutls.so.26'].gnutls_srp_verifier +gnutls_srp_verifier.restype = c_int +gnutls_srp_verifier.argtypes = [STRING, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_srp_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_function +gnutls_srp_set_server_credentials_function.restype = None +gnutls_srp_set_server_credentials_function.argtypes = [gnutls_srp_server_credentials_t, gnutls_srp_server_credentials_function] +gnutls_srp_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials_function +gnutls_srp_set_client_credentials_function.restype = None +gnutls_srp_set_client_credentials_function.argtypes = [gnutls_srp_client_credentials_t, gnutls_srp_client_credentials_function] +gnutls_srp_base64_encode = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode +gnutls_srp_base64_encode.restype = c_int +gnutls_srp_base64_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)] +gnutls_srp_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode_alloc +gnutls_srp_base64_encode_alloc.restype = c_int +gnutls_srp_base64_encode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_srp_base64_decode = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode +gnutls_srp_base64_decode.restype = c_int +gnutls_srp_base64_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)] +gnutls_srp_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode_alloc +gnutls_srp_base64_decode_alloc.restype = c_int +gnutls_srp_base64_decode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_psk_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_client_credentials +gnutls_psk_free_client_credentials.restype = None +gnutls_psk_free_client_credentials.argtypes = [gnutls_psk_client_credentials_t] +gnutls_psk_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_client_credentials +gnutls_psk_allocate_client_credentials.restype = c_int +gnutls_psk_allocate_client_credentials.argtypes = [POINTER(gnutls_psk_client_credentials_t)] +gnutls_psk_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials +gnutls_psk_set_client_credentials.restype = c_int +gnutls_psk_set_client_credentials.argtypes = [gnutls_psk_client_credentials_t, STRING, POINTER(gnutls_datum_t), gnutls_psk_key_flags] +gnutls_psk_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_server_credentials +gnutls_psk_free_server_credentials.restype = None +gnutls_psk_free_server_credentials.argtypes = [gnutls_psk_server_credentials_t] +gnutls_psk_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_server_credentials +gnutls_psk_allocate_server_credentials.restype = c_int +gnutls_psk_allocate_server_credentials.argtypes = [POINTER(gnutls_psk_server_credentials_t)] +gnutls_psk_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_file +gnutls_psk_set_server_credentials_file.restype = c_int +gnutls_psk_set_server_credentials_file.argtypes = [gnutls_psk_server_credentials_t, STRING] +gnutls_psk_set_server_credentials_hint = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_hint +gnutls_psk_set_server_credentials_hint.restype = c_int +gnutls_psk_set_server_credentials_hint.argtypes = [gnutls_psk_server_credentials_t, STRING] +gnutls_psk_server_get_username = _libraries['libgnutls.so.26'].gnutls_psk_server_get_username +gnutls_psk_server_get_username.restype = STRING +gnutls_psk_server_get_username.argtypes = [gnutls_session_t] +gnutls_psk_client_get_hint = _libraries['libgnutls.so.26'].gnutls_psk_client_get_hint +gnutls_psk_client_get_hint.restype = STRING +gnutls_psk_client_get_hint.argtypes = [gnutls_session_t] +gnutls_psk_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_function +gnutls_psk_set_server_credentials_function.restype = None +gnutls_psk_set_server_credentials_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_psk_server_credentials_function] +gnutls_psk_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials_function +gnutls_psk_set_client_credentials_function.restype = None +gnutls_psk_set_client_credentials_function.argtypes = [gnutls_psk_client_credentials_t, gnutls_psk_client_credentials_function] +gnutls_hex_encode = _libraries['libgnutls.so.26'].gnutls_hex_encode +gnutls_hex_encode.restype = c_int +gnutls_hex_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)] +gnutls_hex_decode = _libraries['libgnutls.so.26'].gnutls_hex_decode +gnutls_hex_decode.restype = c_int +gnutls_hex_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)] +gnutls_psk_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_psk_set_server_dh_params +gnutls_psk_set_server_dh_params.restype = None +gnutls_psk_set_server_dh_params.argtypes = [gnutls_psk_server_credentials_t, gnutls_dh_params_t] +gnutls_psk_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_params_function +gnutls_psk_set_server_params_function.restype = None +gnutls_psk_set_server_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function] +gnutls_psk_netconf_derive_key = _libraries['libgnutls.so.26'].gnutls_psk_netconf_derive_key +gnutls_psk_netconf_derive_key.restype = c_int +gnutls_psk_netconf_derive_key.argtypes = [STRING, STRING, STRING, POINTER(gnutls_datum_t)] +gnutls_auth_get_type = _libraries['libgnutls.so.26'].gnutls_auth_get_type +gnutls_auth_get_type.restype = gnutls_credentials_type_t +gnutls_auth_get_type.argtypes = [gnutls_session_t] +gnutls_auth_server_get_type = _libraries['libgnutls.so.26'].gnutls_auth_server_get_type +gnutls_auth_server_get_type.restype = gnutls_credentials_type_t +gnutls_auth_server_get_type.argtypes = [gnutls_session_t] +gnutls_auth_client_get_type = _libraries['libgnutls.so.26'].gnutls_auth_client_get_type +gnutls_auth_client_get_type.restype = gnutls_credentials_type_t +gnutls_auth_client_get_type.argtypes = [gnutls_session_t] +gnutls_dh_set_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_set_prime_bits +gnutls_dh_set_prime_bits.restype = None +gnutls_dh_set_prime_bits.argtypes = [gnutls_session_t, c_uint] +gnutls_dh_get_secret_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_secret_bits +gnutls_dh_get_secret_bits.restype = c_int +gnutls_dh_get_secret_bits.argtypes = [gnutls_session_t] +gnutls_dh_get_peers_public_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_peers_public_bits +gnutls_dh_get_peers_public_bits.restype = c_int +gnutls_dh_get_peers_public_bits.argtypes = [gnutls_session_t] +gnutls_dh_get_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_prime_bits +gnutls_dh_get_prime_bits.restype = c_int +gnutls_dh_get_prime_bits.argtypes = [gnutls_session_t] +gnutls_dh_get_group = _libraries['libgnutls.so.26'].gnutls_dh_get_group +gnutls_dh_get_group.restype = c_int +gnutls_dh_get_group.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_dh_get_pubkey = _libraries['libgnutls.so.26'].gnutls_dh_get_pubkey +gnutls_dh_get_pubkey.restype = c_int +gnutls_dh_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)] +gnutls_rsa_export_get_pubkey = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_pubkey +gnutls_rsa_export_get_pubkey.restype = c_int +gnutls_rsa_export_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_rsa_export_get_modulus_bits = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_modulus_bits +gnutls_rsa_export_get_modulus_bits.restype = c_int +gnutls_rsa_export_get_modulus_bits.argtypes = [gnutls_session_t] +gnutls_sign_callback_set = _libraries['libgnutls.so.26'].gnutls_sign_callback_set +gnutls_sign_callback_set.restype = None +gnutls_sign_callback_set.argtypes = [gnutls_session_t, gnutls_sign_func, c_void_p] +gnutls_sign_callback_get = _libraries['libgnutls.so.26'].gnutls_sign_callback_get +gnutls_sign_callback_get.restype = gnutls_sign_func +gnutls_sign_callback_get.argtypes = [gnutls_session_t, POINTER(c_void_p)] +gnutls_certificate_client_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_client_set_retrieve_function +gnutls_certificate_client_set_retrieve_function.restype = None +gnutls_certificate_client_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_client_retrieve_function] +gnutls_certificate_server_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_retrieve_function +gnutls_certificate_server_set_retrieve_function.restype = None +gnutls_certificate_server_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_server_retrieve_function] +gnutls_certificate_server_set_request = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_request +gnutls_certificate_server_set_request.restype = None +gnutls_certificate_server_set_request.argtypes = [gnutls_session_t, gnutls_certificate_request_t] +gnutls_certificate_get_peers = _libraries['libgnutls.so.26'].gnutls_certificate_get_peers +gnutls_certificate_get_peers.restype = POINTER(gnutls_datum_t) +gnutls_certificate_get_peers.argtypes = [gnutls_session_t, POINTER(c_uint)] +gnutls_certificate_get_ours = _libraries['libgnutls.so.26'].gnutls_certificate_get_ours +gnutls_certificate_get_ours.restype = POINTER(gnutls_datum_t) +gnutls_certificate_get_ours.argtypes = [gnutls_session_t] +__time_t = c_long +time_t = __time_t +gnutls_certificate_activation_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_activation_time_peers +gnutls_certificate_activation_time_peers.restype = time_t +gnutls_certificate_activation_time_peers.argtypes = [gnutls_session_t] +gnutls_certificate_expiration_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_expiration_time_peers +gnutls_certificate_expiration_time_peers.restype = time_t +gnutls_certificate_expiration_time_peers.argtypes = [gnutls_session_t] +gnutls_certificate_client_get_request_status = _libraries['libgnutls.so.26'].gnutls_certificate_client_get_request_status +gnutls_certificate_client_get_request_status.restype = c_int +gnutls_certificate_client_get_request_status.argtypes = [gnutls_session_t] +gnutls_certificate_verify_peers2 = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers2 +gnutls_certificate_verify_peers2.restype = c_int +gnutls_certificate_verify_peers2.argtypes = [gnutls_session_t, POINTER(c_uint)] +gnutls_certificate_verify_peers = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers +gnutls_certificate_verify_peers.restype = c_int +gnutls_certificate_verify_peers.argtypes = [gnutls_session_t] +gnutls_pem_base64_encode = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode +gnutls_pem_base64_encode.restype = c_int +gnutls_pem_base64_encode.argtypes = [STRING, POINTER(gnutls_datum_t), STRING, POINTER(size_t)] +gnutls_pem_base64_decode = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode +gnutls_pem_base64_decode.restype = c_int +gnutls_pem_base64_decode.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(c_ubyte), POINTER(size_t)] +gnutls_pem_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode_alloc +gnutls_pem_base64_encode_alloc.restype = c_int +gnutls_pem_base64_encode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_pem_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode_alloc +gnutls_pem_base64_decode_alloc.restype = c_int +gnutls_pem_base64_decode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_certificate_set_params_function = _libraries['libgnutls.so.26'].gnutls_certificate_set_params_function +gnutls_certificate_set_params_function.restype = None +gnutls_certificate_set_params_function.argtypes = [gnutls_certificate_credentials_t, gnutls_params_function] +gnutls_anon_set_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_params_function +gnutls_anon_set_params_function.restype = None +gnutls_anon_set_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function] +gnutls_psk_set_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_params_function +gnutls_psk_set_params_function.restype = None +gnutls_psk_set_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function] +gnutls_hex2bin = _libraries['libgnutls.so.26'].gnutls_hex2bin +gnutls_hex2bin.restype = c_int +gnutls_hex2bin.argtypes = [STRING, size_t, STRING, POINTER(size_t)] +gnutls_openpgp_crt_init = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_init +gnutls_openpgp_crt_init.restype = c_int +gnutls_openpgp_crt_init.argtypes = [POINTER(gnutls_openpgp_crt_t)] +gnutls_openpgp_crt_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_deinit +gnutls_openpgp_crt_deinit.restype = None +gnutls_openpgp_crt_deinit.argtypes = [gnutls_openpgp_crt_t] +gnutls_openpgp_crt_import = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_import +gnutls_openpgp_crt_import.restype = c_int +gnutls_openpgp_crt_import.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t] +gnutls_openpgp_crt_export = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_export +gnutls_openpgp_crt_export.restype = c_int +gnutls_openpgp_crt_export.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_crt_fmt_t, c_void_p, POINTER(size_t)] +gnutls_openpgp_crt_print = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_print +gnutls_openpgp_crt_print.restype = c_int +gnutls_openpgp_crt_print.argtypes = [gnutls_openpgp_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)] +gnutls_openpgp_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_usage +gnutls_openpgp_crt_get_key_usage.restype = c_int +gnutls_openpgp_crt_get_key_usage.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)] +gnutls_openpgp_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_fingerprint +gnutls_openpgp_crt_get_fingerprint.restype = c_int +gnutls_openpgp_crt_get_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_void_p, POINTER(size_t)] +gnutls_openpgp_crt_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_fingerprint +gnutls_openpgp_crt_get_subkey_fingerprint.restype = c_int +gnutls_openpgp_crt_get_subkey_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_uint, c_void_p, POINTER(size_t)] +gnutls_openpgp_crt_get_name = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_name +gnutls_openpgp_crt_get_name.restype = c_int +gnutls_openpgp_crt_get_name.argtypes = [gnutls_openpgp_crt_t, c_int, STRING, POINTER(size_t)] +gnutls_openpgp_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_algorithm +gnutls_openpgp_crt_get_pk_algorithm.restype = gnutls_pk_algorithm_t +gnutls_openpgp_crt_get_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)] +gnutls_openpgp_crt_get_version = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_version +gnutls_openpgp_crt_get_version.restype = c_int +gnutls_openpgp_crt_get_version.argtypes = [gnutls_openpgp_crt_t] +gnutls_openpgp_crt_get_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_creation_time +gnutls_openpgp_crt_get_creation_time.restype = time_t +gnutls_openpgp_crt_get_creation_time.argtypes = [gnutls_openpgp_crt_t] +gnutls_openpgp_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_expiration_time +gnutls_openpgp_crt_get_expiration_time.restype = time_t +gnutls_openpgp_crt_get_expiration_time.argtypes = [gnutls_openpgp_crt_t] +gnutls_openpgp_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_id +gnutls_openpgp_crt_get_key_id.restype = c_int +gnutls_openpgp_crt_get_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)] +gnutls_openpgp_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_check_hostname +gnutls_openpgp_crt_check_hostname.restype = c_int +gnutls_openpgp_crt_check_hostname.argtypes = [gnutls_openpgp_crt_t, STRING] +gnutls_openpgp_crt_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_revoked_status +gnutls_openpgp_crt_get_revoked_status.restype = c_int +gnutls_openpgp_crt_get_revoked_status.argtypes = [gnutls_openpgp_crt_t] +gnutls_openpgp_crt_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_count +gnutls_openpgp_crt_get_subkey_count.restype = c_int +gnutls_openpgp_crt_get_subkey_count.argtypes = [gnutls_openpgp_crt_t] +gnutls_openpgp_crt_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_idx +gnutls_openpgp_crt_get_subkey_idx.restype = c_int +gnutls_openpgp_crt_get_subkey_idx.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)] +gnutls_openpgp_crt_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_revoked_status +gnutls_openpgp_crt_get_subkey_revoked_status.restype = c_int +gnutls_openpgp_crt_get_subkey_revoked_status.argtypes = [gnutls_openpgp_crt_t, c_uint] +gnutls_openpgp_crt_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_algorithm +gnutls_openpgp_crt_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t +gnutls_openpgp_crt_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)] +gnutls_openpgp_crt_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_creation_time +gnutls_openpgp_crt_get_subkey_creation_time.restype = time_t +gnutls_openpgp_crt_get_subkey_creation_time.argtypes = [gnutls_openpgp_crt_t, c_uint] +gnutls_openpgp_crt_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_expiration_time +gnutls_openpgp_crt_get_subkey_expiration_time.restype = time_t +gnutls_openpgp_crt_get_subkey_expiration_time.argtypes = [gnutls_openpgp_crt_t, c_uint] +gnutls_openpgp_crt_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_id +gnutls_openpgp_crt_get_subkey_id.restype = c_int +gnutls_openpgp_crt_get_subkey_id.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_ubyte)] +gnutls_openpgp_crt_get_subkey_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_usage +gnutls_openpgp_crt_get_subkey_usage.restype = c_int +gnutls_openpgp_crt_get_subkey_usage.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)] +gnutls_openpgp_crt_get_subkey_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_dsa_raw +gnutls_openpgp_crt_get_subkey_pk_dsa_raw.restype = c_int +gnutls_openpgp_crt_get_subkey_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_crt_get_subkey_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_rsa_raw +gnutls_openpgp_crt_get_subkey_pk_rsa_raw.restype = c_int +gnutls_openpgp_crt_get_subkey_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_dsa_raw +gnutls_openpgp_crt_get_pk_dsa_raw.restype = c_int +gnutls_openpgp_crt_get_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_rsa_raw +gnutls_openpgp_crt_get_pk_rsa_raw.restype = c_int +gnutls_openpgp_crt_get_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_crt_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_preferred_key_id +gnutls_openpgp_crt_get_preferred_key_id.restype = c_int +gnutls_openpgp_crt_get_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)] +gnutls_openpgp_crt_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_set_preferred_key_id +gnutls_openpgp_crt_set_preferred_key_id.restype = c_int +gnutls_openpgp_crt_set_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)] +gnutls_openpgp_privkey_init = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_init +gnutls_openpgp_privkey_init.restype = c_int +gnutls_openpgp_privkey_init.argtypes = [POINTER(gnutls_openpgp_privkey_t)] +gnutls_openpgp_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_deinit +gnutls_openpgp_privkey_deinit.restype = None +gnutls_openpgp_privkey_deinit.argtypes = [gnutls_openpgp_privkey_t] +gnutls_openpgp_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_pk_algorithm +gnutls_openpgp_privkey_get_pk_algorithm.restype = gnutls_pk_algorithm_t +gnutls_openpgp_privkey_get_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_uint)] +gnutls_openpgp_privkey_import = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_import +gnutls_openpgp_privkey_import.restype = c_int +gnutls_openpgp_privkey_import.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t, STRING, c_uint] +gnutls_openpgp_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_sign_hash +gnutls_openpgp_privkey_sign_hash.restype = c_int +gnutls_openpgp_privkey_sign_hash.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_privkey_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_fingerprint +gnutls_openpgp_privkey_get_fingerprint.restype = c_int +gnutls_openpgp_privkey_get_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_void_p, POINTER(size_t)] +gnutls_openpgp_privkey_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_fingerprint +gnutls_openpgp_privkey_get_subkey_fingerprint.restype = c_int +gnutls_openpgp_privkey_get_subkey_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_uint, c_void_p, POINTER(size_t)] +gnutls_openpgp_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_key_id +gnutls_openpgp_privkey_get_key_id.restype = c_int +gnutls_openpgp_privkey_get_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)] +gnutls_openpgp_privkey_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_count +gnutls_openpgp_privkey_get_subkey_count.restype = c_int +gnutls_openpgp_privkey_get_subkey_count.argtypes = [gnutls_openpgp_privkey_t] +gnutls_openpgp_privkey_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_idx +gnutls_openpgp_privkey_get_subkey_idx.restype = c_int +gnutls_openpgp_privkey_get_subkey_idx.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)] +gnutls_openpgp_privkey_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_revoked_status +gnutls_openpgp_privkey_get_subkey_revoked_status.restype = c_int +gnutls_openpgp_privkey_get_subkey_revoked_status.argtypes = [gnutls_openpgp_privkey_t, c_uint] +gnutls_openpgp_privkey_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_revoked_status +gnutls_openpgp_privkey_get_revoked_status.restype = c_int +gnutls_openpgp_privkey_get_revoked_status.argtypes = [gnutls_openpgp_privkey_t] +gnutls_openpgp_privkey_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_pk_algorithm +gnutls_openpgp_privkey_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t +gnutls_openpgp_privkey_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_uint)] +gnutls_openpgp_privkey_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_expiration_time +gnutls_openpgp_privkey_get_subkey_expiration_time.restype = time_t +gnutls_openpgp_privkey_get_subkey_expiration_time.argtypes = [gnutls_openpgp_privkey_t, c_uint] +gnutls_openpgp_privkey_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_id +gnutls_openpgp_privkey_get_subkey_id.restype = c_int +gnutls_openpgp_privkey_get_subkey_id.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_ubyte)] +gnutls_openpgp_privkey_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_creation_time +gnutls_openpgp_privkey_get_subkey_creation_time.restype = time_t +gnutls_openpgp_privkey_get_subkey_creation_time.argtypes = [gnutls_openpgp_privkey_t, c_uint] +gnutls_openpgp_privkey_export_subkey_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_dsa_raw +gnutls_openpgp_privkey_export_subkey_dsa_raw.restype = c_int +gnutls_openpgp_privkey_export_subkey_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_privkey_export_subkey_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_rsa_raw +gnutls_openpgp_privkey_export_subkey_rsa_raw.restype = c_int +gnutls_openpgp_privkey_export_subkey_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_dsa_raw +gnutls_openpgp_privkey_export_dsa_raw.restype = c_int +gnutls_openpgp_privkey_export_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_rsa_raw +gnutls_openpgp_privkey_export_rsa_raw.restype = c_int +gnutls_openpgp_privkey_export_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_openpgp_privkey_export = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export +gnutls_openpgp_privkey_export.restype = c_int +gnutls_openpgp_privkey_export.argtypes = [gnutls_openpgp_privkey_t, gnutls_openpgp_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)] +gnutls_openpgp_privkey_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_set_preferred_key_id +gnutls_openpgp_privkey_set_preferred_key_id.restype = c_int +gnutls_openpgp_privkey_set_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)] +gnutls_openpgp_privkey_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_preferred_key_id +gnutls_openpgp_privkey_get_preferred_key_id.restype = c_int +gnutls_openpgp_privkey_get_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)] +gnutls_openpgp_crt_get_auth_subkey = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_auth_subkey +gnutls_openpgp_crt_get_auth_subkey.restype = c_int +gnutls_openpgp_crt_get_auth_subkey.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte), c_uint] +gnutls_openpgp_keyring_init = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_init +gnutls_openpgp_keyring_init.restype = c_int +gnutls_openpgp_keyring_init.argtypes = [POINTER(gnutls_openpgp_keyring_t)] +gnutls_openpgp_keyring_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_deinit +gnutls_openpgp_keyring_deinit.restype = None +gnutls_openpgp_keyring_deinit.argtypes = [gnutls_openpgp_keyring_t] +gnutls_openpgp_keyring_import = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_import +gnutls_openpgp_keyring_import.restype = c_int +gnutls_openpgp_keyring_import.argtypes = [gnutls_openpgp_keyring_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t] +gnutls_openpgp_keyring_check_id = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_check_id +gnutls_openpgp_keyring_check_id.restype = c_int +gnutls_openpgp_keyring_check_id.argtypes = [gnutls_openpgp_keyring_t, POINTER(c_ubyte), c_uint] +gnutls_openpgp_crt_verify_ring = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_ring +gnutls_openpgp_crt_verify_ring.restype = c_int +gnutls_openpgp_crt_verify_ring.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_keyring_t, c_uint, POINTER(c_uint)] +gnutls_openpgp_crt_verify_self = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_self +gnutls_openpgp_crt_verify_self.restype = c_int +gnutls_openpgp_crt_verify_self.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)] +gnutls_openpgp_keyring_get_crt = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt +gnutls_openpgp_keyring_get_crt.restype = c_int +gnutls_openpgp_keyring_get_crt.argtypes = [gnutls_openpgp_keyring_t, c_uint, POINTER(gnutls_openpgp_crt_t)] +gnutls_openpgp_keyring_get_crt_count = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt_count +gnutls_openpgp_keyring_get_crt_count.restype = c_int +gnutls_openpgp_keyring_get_crt_count.argtypes = [gnutls_openpgp_keyring_t] +gnutls_openpgp_set_recv_key_function = _libraries['libgnutls.so.26'].gnutls_openpgp_set_recv_key_function +gnutls_openpgp_set_recv_key_function.restype = None +gnutls_openpgp_set_recv_key_function.argtypes = [gnutls_session_t, gnutls_openpgp_recv_key_func] +gnutls_certificate_set_openpgp_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key +gnutls_certificate_set_openpgp_key.restype = c_int +gnutls_certificate_set_openpgp_key.argtypes = [gnutls_certificate_credentials_t, gnutls_openpgp_crt_t, gnutls_openpgp_privkey_t] +gnutls_certificate_set_openpgp_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file +gnutls_certificate_set_openpgp_key_file.restype = c_int +gnutls_certificate_set_openpgp_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_openpgp_crt_fmt_t] +gnutls_certificate_set_openpgp_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem +gnutls_certificate_set_openpgp_key_mem.restype = c_int +gnutls_certificate_set_openpgp_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t] +gnutls_certificate_set_openpgp_key_file2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file2 +gnutls_certificate_set_openpgp_key_file2.restype = c_int +gnutls_certificate_set_openpgp_key_file2.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, STRING, gnutls_openpgp_crt_fmt_t] +gnutls_certificate_set_openpgp_key_mem2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem2 +gnutls_certificate_set_openpgp_key_mem2.restype = c_int +gnutls_certificate_set_openpgp_key_mem2.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), STRING, gnutls_openpgp_crt_fmt_t] +gnutls_certificate_set_openpgp_keyring_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_mem +gnutls_certificate_set_openpgp_keyring_mem.restype = c_int +gnutls_certificate_set_openpgp_keyring_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(c_ubyte), size_t, gnutls_openpgp_crt_fmt_t] +gnutls_certificate_set_openpgp_keyring_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_file +gnutls_certificate_set_openpgp_keyring_file.restype = c_int +gnutls_certificate_set_openpgp_keyring_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_openpgp_crt_fmt_t] +gnutls_x509_crt_init = _libraries['libgnutls.so.26'].gnutls_x509_crt_init +gnutls_x509_crt_init.restype = c_int +gnutls_x509_crt_init.argtypes = [POINTER(gnutls_x509_crt_t)] +gnutls_x509_crt_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crt_deinit +gnutls_x509_crt_deinit.restype = None +gnutls_x509_crt_deinit.argtypes = [gnutls_x509_crt_t] +gnutls_x509_crt_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_import +gnutls_x509_crt_import.restype = c_int +gnutls_x509_crt_import.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_x509_crt_list_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_import +gnutls_x509_crt_list_import.restype = c_int +gnutls_x509_crt_list_import.argtypes = [POINTER(gnutls_x509_crt_t), POINTER(c_uint), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, c_uint] +gnutls_x509_crt_export = _libraries['libgnutls.so.26'].gnutls_x509_crt_export +gnutls_x509_crt_export.restype = c_int +gnutls_x509_crt_export.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn +gnutls_x509_crt_get_issuer_dn.restype = c_int +gnutls_x509_crt_get_issuer_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)] +gnutls_x509_crt_get_issuer_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_oid +gnutls_x509_crt_get_issuer_dn_oid.restype = c_int +gnutls_x509_crt_get_issuer_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_by_oid +gnutls_x509_crt_get_issuer_dn_by_oid.restype = c_int +gnutls_x509_crt_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn +gnutls_x509_crt_get_dn.restype = c_int +gnutls_x509_crt_get_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)] +gnutls_x509_crt_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_oid +gnutls_x509_crt_get_dn_oid.restype = c_int +gnutls_x509_crt_get_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_by_oid +gnutls_x509_crt_get_dn_by_oid.restype = c_int +gnutls_x509_crt_get_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)] +gnutls_x509_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_hostname +gnutls_x509_crt_check_hostname.restype = c_int +gnutls_x509_crt_check_hostname.argtypes = [gnutls_x509_crt_t, STRING] +gnutls_x509_crt_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature_algorithm +gnutls_x509_crt_get_signature_algorithm.restype = c_int +gnutls_x509_crt_get_signature_algorithm.argtypes = [gnutls_x509_crt_t] +gnutls_x509_crt_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature +gnutls_x509_crt_get_signature.restype = c_int +gnutls_x509_crt_get_signature.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)] +gnutls_x509_crt_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_version +gnutls_x509_crt_get_version.restype = c_int +gnutls_x509_crt_get_version.argtypes = [gnutls_x509_crt_t] +gnutls_x509_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_id +gnutls_x509_crt_get_key_id.restype = c_int +gnutls_x509_crt_get_key_id.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(c_ubyte), POINTER(size_t)] +gnutls_x509_crt_set_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_authority_key_id +gnutls_x509_crt_set_authority_key_id.restype = c_int +gnutls_x509_crt_set_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t] +gnutls_x509_crt_get_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_authority_key_id +gnutls_x509_crt_get_authority_key_id.restype = c_int +gnutls_x509_crt_get_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)] +gnutls_x509_crt_get_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_key_id +gnutls_x509_crt_get_subject_key_id.restype = c_int +gnutls_x509_crt_get_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)] +gnutls_x509_crt_get_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_crl_dist_points +gnutls_x509_crt_get_crl_dist_points.restype = c_int +gnutls_x509_crt_get_crl_dist_points.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)] +gnutls_x509_crt_set_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crl_dist_points +gnutls_x509_crt_set_crl_dist_points.restype = c_int +gnutls_x509_crt_set_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, c_void_p, c_uint] +gnutls_x509_crt_cpy_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_cpy_crl_dist_points +gnutls_x509_crt_cpy_crl_dist_points.restype = c_int +gnutls_x509_crt_cpy_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t] +gnutls_x509_crt_get_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_activation_time +gnutls_x509_crt_get_activation_time.restype = time_t +gnutls_x509_crt_get_activation_time.argtypes = [gnutls_x509_crt_t] +gnutls_x509_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_expiration_time +gnutls_x509_crt_get_expiration_time.restype = time_t +gnutls_x509_crt_get_expiration_time.argtypes = [gnutls_x509_crt_t] +gnutls_x509_crt_get_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_serial +gnutls_x509_crt_get_serial.restype = c_int +gnutls_x509_crt_get_serial.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_algorithm +gnutls_x509_crt_get_pk_algorithm.restype = c_int +gnutls_x509_crt_get_pk_algorithm.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)] +gnutls_x509_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_rsa_raw +gnutls_x509_crt_get_pk_rsa_raw.restype = c_int +gnutls_x509_crt_get_pk_rsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_dsa_raw +gnutls_x509_crt_get_pk_dsa_raw.restype = c_int +gnutls_x509_crt_get_pk_dsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_crt_get_subject_alt_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name +gnutls_x509_crt_get_subject_alt_name.restype = c_int +gnutls_x509_crt_get_subject_alt_name.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint)] +gnutls_x509_crt_get_subject_alt_name2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name2 +gnutls_x509_crt_get_subject_alt_name2.restype = c_int +gnutls_x509_crt_get_subject_alt_name2.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)] +gnutls_x509_crt_get_subject_alt_othername_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_othername_oid +gnutls_x509_crt_get_subject_alt_othername_oid.restype = c_int +gnutls_x509_crt_get_subject_alt_othername_oid.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_ca_status +gnutls_x509_crt_get_ca_status.restype = c_int +gnutls_x509_crt_get_ca_status.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)] +gnutls_x509_crt_get_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_basic_constraints +gnutls_x509_crt_get_basic_constraints.restype = c_int +gnutls_x509_crt_get_basic_constraints.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(c_int)] +gnutls_x509_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_usage +gnutls_x509_crt_get_key_usage.restype = c_int +gnutls_x509_crt_get_key_usage.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_uint)] +gnutls_x509_crt_set_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_usage +gnutls_x509_crt_set_key_usage.restype = c_int +gnutls_x509_crt_set_key_usage.argtypes = [gnutls_x509_crt_t, c_uint] +gnutls_x509_crt_get_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_proxy +gnutls_x509_crt_get_proxy.restype = c_int +gnutls_x509_crt_get_proxy.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(STRING), POINTER(STRING), POINTER(size_t)] +gnutls_x509_dn_oid_known = _libraries['libgnutls.so.26'].gnutls_x509_dn_oid_known +gnutls_x509_dn_oid_known.restype = c_int +gnutls_x509_dn_oid_known.argtypes = [STRING] +gnutls_x509_crt_get_extension_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_oid +gnutls_x509_crt_get_extension_oid.restype = c_int +gnutls_x509_crt_get_extension_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_by_oid +gnutls_x509_crt_get_extension_by_oid.restype = c_int +gnutls_x509_crt_get_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)] +gnutls_x509_crt_get_extension_info = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_info +gnutls_x509_crt_get_extension_info.restype = c_int +gnutls_x509_crt_get_extension_info.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_int)] +gnutls_x509_crt_get_extension_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_data +gnutls_x509_crt_get_extension_data.restype = c_int +gnutls_x509_crt_get_extension_data.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)] +gnutls_x509_crt_set_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_extension_by_oid +gnutls_x509_crt_set_extension_by_oid.restype = c_int +gnutls_x509_crt_set_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_void_p, size_t, c_uint] +gnutls_x509_crt_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_dn_by_oid +gnutls_x509_crt_set_dn_by_oid.restype = c_int +gnutls_x509_crt_set_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint] +gnutls_x509_crt_set_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_issuer_dn_by_oid +gnutls_x509_crt_set_issuer_dn_by_oid.restype = c_int +gnutls_x509_crt_set_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint] +gnutls_x509_crt_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_version +gnutls_x509_crt_set_version.restype = c_int +gnutls_x509_crt_set_version.argtypes = [gnutls_x509_crt_t, c_uint] +gnutls_x509_crt_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key +gnutls_x509_crt_set_key.restype = c_int +gnutls_x509_crt_set_key.argtypes = [gnutls_x509_crt_t, gnutls_x509_privkey_t] +gnutls_x509_crt_set_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_ca_status +gnutls_x509_crt_set_ca_status.restype = c_int +gnutls_x509_crt_set_ca_status.argtypes = [gnutls_x509_crt_t, c_uint] +gnutls_x509_crt_set_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_basic_constraints +gnutls_x509_crt_set_basic_constraints.restype = c_int +gnutls_x509_crt_set_basic_constraints.argtypes = [gnutls_x509_crt_t, c_uint, c_int] +gnutls_x509_crt_set_subject_alternative_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_alternative_name +gnutls_x509_crt_set_subject_alternative_name.restype = c_int +gnutls_x509_crt_set_subject_alternative_name.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, STRING] +gnutls_x509_crt_sign = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign +gnutls_x509_crt_sign.restype = c_int +gnutls_x509_crt_sign.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t] +gnutls_x509_crt_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign2 +gnutls_x509_crt_sign2.restype = c_int +gnutls_x509_crt_sign2.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint] +gnutls_x509_crt_set_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_activation_time +gnutls_x509_crt_set_activation_time.restype = c_int +gnutls_x509_crt_set_activation_time.argtypes = [gnutls_x509_crt_t, time_t] +gnutls_x509_crt_set_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_expiration_time +gnutls_x509_crt_set_expiration_time.restype = c_int +gnutls_x509_crt_set_expiration_time.argtypes = [gnutls_x509_crt_t, time_t] +gnutls_x509_crt_set_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_serial +gnutls_x509_crt_set_serial.restype = c_int +gnutls_x509_crt_set_serial.argtypes = [gnutls_x509_crt_t, c_void_p, size_t] +gnutls_x509_crt_set_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_key_id +gnutls_x509_crt_set_subject_key_id.restype = c_int +gnutls_x509_crt_set_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t] +gnutls_x509_crt_set_proxy_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy_dn +gnutls_x509_crt_set_proxy_dn.restype = c_int +gnutls_x509_crt_set_proxy_dn.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, c_uint, c_void_p, c_uint] +gnutls_x509_crt_set_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy +gnutls_x509_crt_set_proxy.restype = c_int +gnutls_x509_crt_set_proxy.argtypes = [gnutls_x509_crt_t, c_int, STRING, STRING, size_t] +gnutls_x509_crt_print = _libraries['libgnutls.so.26'].gnutls_x509_crt_print +gnutls_x509_crt_print.restype = c_int +gnutls_x509_crt_print.argtypes = [gnutls_x509_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)] +gnutls_x509_crl_print = _libraries['libgnutls.so.26'].gnutls_x509_crl_print +gnutls_x509_crl_print.restype = c_int +gnutls_x509_crl_print.argtypes = [gnutls_x509_crl_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)] +gnutls_x509_crt_get_raw_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_issuer_dn +gnutls_x509_crt_get_raw_issuer_dn.restype = c_int +gnutls_x509_crt_get_raw_issuer_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)] +gnutls_x509_crt_get_raw_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_dn +gnutls_x509_crt_get_raw_dn.restype = c_int +gnutls_x509_crt_get_raw_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)] +gnutls_x509_rdn_get = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get +gnutls_x509_rdn_get.restype = c_int +gnutls_x509_rdn_get.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)] +gnutls_x509_rdn_get_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_oid +gnutls_x509_rdn_get_oid.restype = c_int +gnutls_x509_rdn_get_oid.argtypes = [POINTER(gnutls_datum_t), c_int, c_void_p, POINTER(size_t)] +gnutls_x509_rdn_get_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_by_oid +gnutls_x509_rdn_get_by_oid.restype = c_int +gnutls_x509_rdn_get_by_oid.argtypes = [POINTER(gnutls_datum_t), STRING, c_int, c_uint, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_subject = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject +gnutls_x509_crt_get_subject.restype = c_int +gnutls_x509_crt_get_subject.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)] +gnutls_x509_crt_get_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer +gnutls_x509_crt_get_issuer.restype = c_int +gnutls_x509_crt_get_issuer.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)] +gnutls_x509_dn_get_rdn_ava = _libraries['libgnutls.so.26'].gnutls_x509_dn_get_rdn_ava +gnutls_x509_dn_get_rdn_ava.restype = c_int +gnutls_x509_dn_get_rdn_ava.argtypes = [gnutls_x509_dn_t, c_int, c_int, POINTER(gnutls_x509_ava_st)] +gnutls_x509_dn_init = _libraries['libgnutls.so.26'].gnutls_x509_dn_init +gnutls_x509_dn_init.restype = c_int +gnutls_x509_dn_init.argtypes = [POINTER(gnutls_x509_dn_t)] +gnutls_x509_dn_import = _libraries['libgnutls.so.26'].gnutls_x509_dn_import +gnutls_x509_dn_import.restype = c_int +gnutls_x509_dn_import.argtypes = [gnutls_x509_dn_t, POINTER(gnutls_datum_t)] +gnutls_x509_dn_export = _libraries['libgnutls.so.26'].gnutls_x509_dn_export +gnutls_x509_dn_export.restype = c_int +gnutls_x509_dn_export.argtypes = [gnutls_x509_dn_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)] +gnutls_x509_dn_deinit = _libraries['libgnutls.so.26'].gnutls_x509_dn_deinit +gnutls_x509_dn_deinit.restype = None +gnutls_x509_dn_deinit.argtypes = [gnutls_x509_dn_t] +gnutls_x509_crl_init = _libraries['libgnutls.so.26'].gnutls_x509_crl_init +gnutls_x509_crl_init.restype = c_int +gnutls_x509_crl_init.argtypes = [POINTER(gnutls_x509_crl_t)] +gnutls_x509_crl_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crl_deinit +gnutls_x509_crl_deinit.restype = None +gnutls_x509_crl_deinit.argtypes = [gnutls_x509_crl_t] +gnutls_x509_crl_import = _libraries['libgnutls.so.26'].gnutls_x509_crl_import +gnutls_x509_crl_import.restype = c_int +gnutls_x509_crl_import.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_x509_crl_export = _libraries['libgnutls.so.26'].gnutls_x509_crl_export +gnutls_x509_crl_export.restype = c_int +gnutls_x509_crl_export.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)] +gnutls_x509_crl_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn +gnutls_x509_crl_get_issuer_dn.restype = c_int +gnutls_x509_crl_get_issuer_dn.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)] +gnutls_x509_crl_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn_by_oid +gnutls_x509_crl_get_issuer_dn_by_oid.restype = c_int +gnutls_x509_crl_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crl_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)] +gnutls_x509_crl_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_dn_oid +gnutls_x509_crl_get_dn_oid.restype = c_int +gnutls_x509_crl_get_dn_oid.argtypes = [gnutls_x509_crl_t, c_int, c_void_p, POINTER(size_t)] +gnutls_x509_crl_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature_algorithm +gnutls_x509_crl_get_signature_algorithm.restype = c_int +gnutls_x509_crl_get_signature_algorithm.argtypes = [gnutls_x509_crl_t] +gnutls_x509_crl_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature +gnutls_x509_crl_get_signature.restype = c_int +gnutls_x509_crl_get_signature.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)] +gnutls_x509_crl_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_version +gnutls_x509_crl_get_version.restype = c_int +gnutls_x509_crl_get_version.argtypes = [gnutls_x509_crl_t] +gnutls_x509_crl_get_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_this_update +gnutls_x509_crl_get_this_update.restype = time_t +gnutls_x509_crl_get_this_update.argtypes = [gnutls_x509_crl_t] +gnutls_x509_crl_get_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_next_update +gnutls_x509_crl_get_next_update.restype = time_t +gnutls_x509_crl_get_next_update.argtypes = [gnutls_x509_crl_t] +gnutls_x509_crl_get_crt_count = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_count +gnutls_x509_crl_get_crt_count.restype = c_int +gnutls_x509_crl_get_crt_count.argtypes = [gnutls_x509_crl_t] +gnutls_x509_crl_get_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_serial +gnutls_x509_crl_get_crt_serial.restype = c_int +gnutls_x509_crl_get_crt_serial.argtypes = [gnutls_x509_crl_t, c_int, POINTER(c_ubyte), POINTER(size_t), POINTER(time_t)] +gnutls_x509_crl_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crl_check_issuer +gnutls_x509_crl_check_issuer.restype = c_int +gnutls_x509_crl_check_issuer.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t] +gnutls_x509_crl_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_version +gnutls_x509_crl_set_version.restype = c_int +gnutls_x509_crl_set_version.argtypes = [gnutls_x509_crl_t, c_uint] +gnutls_x509_crl_sign = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign +gnutls_x509_crl_sign.restype = c_int +gnutls_x509_crl_sign.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t] +gnutls_x509_crl_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign2 +gnutls_x509_crl_sign2.restype = c_int +gnutls_x509_crl_sign2.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint] +gnutls_x509_crl_set_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_this_update +gnutls_x509_crl_set_this_update.restype = c_int +gnutls_x509_crl_set_this_update.argtypes = [gnutls_x509_crl_t, time_t] +gnutls_x509_crl_set_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_next_update +gnutls_x509_crl_set_next_update.restype = c_int +gnutls_x509_crl_set_next_update.argtypes = [gnutls_x509_crl_t, time_t] +gnutls_x509_crl_set_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt_serial +gnutls_x509_crl_set_crt_serial.restype = c_int +gnutls_x509_crl_set_crt_serial.argtypes = [gnutls_x509_crl_t, c_void_p, size_t, time_t] +gnutls_x509_crl_set_crt = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt +gnutls_x509_crl_set_crt.restype = c_int +gnutls_x509_crl_set_crt.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, time_t] +gnutls_pkcs7_init = _libraries['libgnutls.so.26'].gnutls_pkcs7_init +gnutls_pkcs7_init.restype = c_int +gnutls_pkcs7_init.argtypes = [POINTER(gnutls_pkcs7_t)] +gnutls_pkcs7_deinit = _libraries['libgnutls.so.26'].gnutls_pkcs7_deinit +gnutls_pkcs7_deinit.restype = None +gnutls_pkcs7_deinit.argtypes = [gnutls_pkcs7_t] +gnutls_pkcs7_import = _libraries['libgnutls.so.26'].gnutls_pkcs7_import +gnutls_pkcs7_import.restype = c_int +gnutls_pkcs7_import.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_pkcs7_export = _libraries['libgnutls.so.26'].gnutls_pkcs7_export +gnutls_pkcs7_export.restype = c_int +gnutls_pkcs7_export.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)] +gnutls_pkcs7_get_crt_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_count +gnutls_pkcs7_get_crt_count.restype = c_int +gnutls_pkcs7_get_crt_count.argtypes = [gnutls_pkcs7_t] +gnutls_pkcs7_get_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_raw +gnutls_pkcs7_get_crt_raw.restype = c_int +gnutls_pkcs7_get_crt_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)] +gnutls_pkcs7_set_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt_raw +gnutls_pkcs7_set_crt_raw.restype = c_int +gnutls_pkcs7_set_crt_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)] +gnutls_pkcs7_set_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt +gnutls_pkcs7_set_crt.restype = c_int +gnutls_pkcs7_set_crt.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_t] +gnutls_pkcs7_delete_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crt +gnutls_pkcs7_delete_crt.restype = c_int +gnutls_pkcs7_delete_crt.argtypes = [gnutls_pkcs7_t, c_int] +gnutls_pkcs7_get_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_raw +gnutls_pkcs7_get_crl_raw.restype = c_int +gnutls_pkcs7_get_crl_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)] +gnutls_pkcs7_get_crl_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_count +gnutls_pkcs7_get_crl_count.restype = c_int +gnutls_pkcs7_get_crl_count.argtypes = [gnutls_pkcs7_t] +gnutls_pkcs7_set_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl_raw +gnutls_pkcs7_set_crl_raw.restype = c_int +gnutls_pkcs7_set_crl_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)] +gnutls_pkcs7_set_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl +gnutls_pkcs7_set_crl.restype = c_int +gnutls_pkcs7_set_crl.argtypes = [gnutls_pkcs7_t, gnutls_x509_crl_t] +gnutls_pkcs7_delete_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crl +gnutls_pkcs7_delete_crl.restype = c_int +gnutls_pkcs7_delete_crl.argtypes = [gnutls_pkcs7_t, c_int] +gnutls_x509_crt_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_issuer +gnutls_x509_crt_check_issuer.restype = c_int +gnutls_x509_crt_check_issuer.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t] +gnutls_x509_crt_list_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_verify +gnutls_x509_crt_list_verify.restype = c_int +gnutls_x509_crt_list_verify.argtypes = [POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crl_t), c_int, c_uint, POINTER(c_uint)] +gnutls_x509_crt_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify +gnutls_x509_crt_verify.restype = c_int +gnutls_x509_crt_verify.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)] +gnutls_x509_crl_verify = _libraries['libgnutls.so.26'].gnutls_x509_crl_verify +gnutls_x509_crl_verify.restype = c_int +gnutls_x509_crl_verify.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)] +gnutls_x509_crt_check_revocation = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_revocation +gnutls_x509_crt_check_revocation.restype = c_int +gnutls_x509_crt_check_revocation.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crl_t), c_int] +gnutls_x509_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_fingerprint +gnutls_x509_crt_get_fingerprint.restype = c_int +gnutls_x509_crt_get_fingerprint.argtypes = [gnutls_x509_crt_t, gnutls_digest_algorithm_t, c_void_p, POINTER(size_t)] +gnutls_x509_crt_get_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_purpose_oid +gnutls_x509_crt_get_key_purpose_oid.restype = c_int +gnutls_x509_crt_get_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)] +gnutls_x509_crt_set_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_purpose_oid +gnutls_x509_crt_set_key_purpose_oid.restype = c_int +gnutls_x509_crt_set_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_void_p, c_uint] +gnutls_x509_privkey_init = _libraries['libgnutls.so.26'].gnutls_x509_privkey_init +gnutls_x509_privkey_init.restype = c_int +gnutls_x509_privkey_init.argtypes = [POINTER(gnutls_x509_privkey_t)] +gnutls_x509_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_x509_privkey_deinit +gnutls_x509_privkey_deinit.restype = None +gnutls_x509_privkey_deinit.argtypes = [gnutls_x509_privkey_t] +gnutls_x509_privkey_cpy = _libraries['libgnutls.so.26'].gnutls_x509_privkey_cpy +gnutls_x509_privkey_cpy.restype = c_int +gnutls_x509_privkey_cpy.argtypes = [gnutls_x509_privkey_t, gnutls_x509_privkey_t] +gnutls_x509_privkey_import = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import +gnutls_x509_privkey_import.restype = c_int +gnutls_x509_privkey_import.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_x509_privkey_import_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_pkcs8 +gnutls_x509_privkey_import_pkcs8.restype = c_int +gnutls_x509_privkey_import_pkcs8.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, STRING, c_uint] +gnutls_x509_privkey_import_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_rsa_raw +gnutls_x509_privkey_import_rsa_raw.restype = c_int +gnutls_x509_privkey_import_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_privkey_fix = _libraries['libgnutls.so.26'].gnutls_x509_privkey_fix +gnutls_x509_privkey_fix.restype = c_int +gnutls_x509_privkey_fix.argtypes = [gnutls_x509_privkey_t] +gnutls_x509_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_dsa_raw +gnutls_x509_privkey_export_dsa_raw.restype = c_int +gnutls_x509_privkey_export_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_privkey_import_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_dsa_raw +gnutls_x509_privkey_import_dsa_raw.restype = c_int +gnutls_x509_privkey_import_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_pk_algorithm +gnutls_x509_privkey_get_pk_algorithm.restype = c_int +gnutls_x509_privkey_get_pk_algorithm.argtypes = [gnutls_x509_privkey_t] +gnutls_x509_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_key_id +gnutls_x509_privkey_get_key_id.restype = c_int +gnutls_x509_privkey_get_key_id.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(c_ubyte), POINTER(size_t)] +gnutls_x509_privkey_generate = _libraries['libgnutls.so.26'].gnutls_x509_privkey_generate +gnutls_x509_privkey_generate.restype = c_int +gnutls_x509_privkey_generate.argtypes = [gnutls_x509_privkey_t, gnutls_pk_algorithm_t, c_uint, c_uint] +gnutls_x509_privkey_export = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export +gnutls_x509_privkey_export.restype = c_int +gnutls_x509_privkey_export.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)] +gnutls_x509_privkey_export_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_pkcs8 +gnutls_x509_privkey_export_pkcs8.restype = c_int +gnutls_x509_privkey_export_pkcs8.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)] +gnutls_x509_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_rsa_raw +gnutls_x509_privkey_export_rsa_raw.restype = c_int +gnutls_x509_privkey_export_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_privkey_sign_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_data +gnutls_x509_privkey_sign_data.restype = c_int +gnutls_x509_privkey_sign_data.argtypes = [gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)] +gnutls_x509_privkey_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_verify_data +gnutls_x509_privkey_verify_data.restype = c_int +gnutls_x509_privkey_verify_data.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_crt_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify_data +gnutls_x509_crt_verify_data.restype = c_int +gnutls_x509_crt_verify_data.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_hash +gnutls_x509_privkey_sign_hash.restype = c_int +gnutls_x509_privkey_sign_hash.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)] +gnutls_x509_crq_init = _libraries['libgnutls.so.26'].gnutls_x509_crq_init +gnutls_x509_crq_init.restype = c_int +gnutls_x509_crq_init.argtypes = [POINTER(gnutls_x509_crq_t)] +gnutls_x509_crq_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crq_deinit +gnutls_x509_crq_deinit.restype = None +gnutls_x509_crq_deinit.argtypes = [gnutls_x509_crq_t] +gnutls_x509_crq_import = _libraries['libgnutls.so.26'].gnutls_x509_crq_import +gnutls_x509_crq_import.restype = c_int +gnutls_x509_crq_import.argtypes = [gnutls_x509_crq_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t] +gnutls_x509_crq_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_pk_algorithm +gnutls_x509_crq_get_pk_algorithm.restype = c_int +gnutls_x509_crq_get_pk_algorithm.argtypes = [gnutls_x509_crq_t, POINTER(c_uint)] +gnutls_x509_crq_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn +gnutls_x509_crq_get_dn.restype = c_int +gnutls_x509_crq_get_dn.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)] +gnutls_x509_crq_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_oid +gnutls_x509_crq_get_dn_oid.restype = c_int +gnutls_x509_crq_get_dn_oid.argtypes = [gnutls_x509_crq_t, c_int, c_void_p, POINTER(size_t)] +gnutls_x509_crq_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_by_oid +gnutls_x509_crq_get_dn_by_oid.restype = c_int +gnutls_x509_crq_get_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)] +gnutls_x509_crq_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_dn_by_oid +gnutls_x509_crq_set_dn_by_oid.restype = c_int +gnutls_x509_crq_set_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_uint, c_void_p, c_uint] +gnutls_x509_crq_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_version +gnutls_x509_crq_set_version.restype = c_int +gnutls_x509_crq_set_version.argtypes = [gnutls_x509_crq_t, c_uint] +gnutls_x509_crq_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_key +gnutls_x509_crq_set_key.restype = c_int +gnutls_x509_crq_set_key.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t] +gnutls_x509_crq_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign2 +gnutls_x509_crq_sign2.restype = c_int +gnutls_x509_crq_sign2.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint] +gnutls_x509_crq_sign = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign +gnutls_x509_crq_sign.restype = c_int +gnutls_x509_crq_sign.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t] +gnutls_x509_crq_set_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_challenge_password +gnutls_x509_crq_set_challenge_password.restype = c_int +gnutls_x509_crq_set_challenge_password.argtypes = [gnutls_x509_crq_t, STRING] +gnutls_x509_crq_get_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_challenge_password +gnutls_x509_crq_get_challenge_password.restype = c_int +gnutls_x509_crq_get_challenge_password.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)] +gnutls_x509_crq_set_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_attribute_by_oid +gnutls_x509_crq_set_attribute_by_oid.restype = c_int +gnutls_x509_crq_set_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_void_p, size_t] +gnutls_x509_crq_get_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_attribute_by_oid +gnutls_x509_crq_get_attribute_by_oid.restype = c_int +gnutls_x509_crq_get_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_void_p, POINTER(size_t)] +gnutls_x509_crq_export = _libraries['libgnutls.so.26'].gnutls_x509_crq_export +gnutls_x509_crq_export.restype = c_int +gnutls_x509_crq_export.argtypes = [gnutls_x509_crq_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)] +gnutls_x509_crt_set_crq = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crq +gnutls_x509_crt_set_crq.restype = c_int +gnutls_x509_crt_set_crq.argtypes = [gnutls_x509_crt_t, gnutls_x509_crq_t] +__all__ = ['gnutls_ia_set_server_avp_ptr', + 'gnutls_openpgp_privkey_init', + 'gnutls_certificate_activation_time_peers', + 'gnutls_x509_crt_set_proxy_dn', + 'gnutls_db_set_remove_function', + 'gnutls_x509_crt_set_dn_by_oid', + 'gnutls_x509_crt_check_hostname', + 'gnutls_openpgp_keyring_get_crt', + 'gnutls_global_init_extra', + 'gnutls_srp_set_client_credentials_function', + 'gnutls_x509_crl_import', + 'gnutls_certificate_set_x509_trust_file', + 'gnutls_x509_crt_get_pk_rsa_raw', + 'gnutls_x509_privkey_export_rsa_raw', + 'gnutls_priority_set', 'gnutls_cipher_get', + 'gnutls_certificate_set_openpgp_keyring_mem', + 'gnutls_x509_crt_get_ca_status', + 'gnutls_cipher_get_key_size', + 'gnutls_certificate_set_x509_crl_file', + 'gnutls_x509_privkey_import_dsa_raw', + 'gnutls_x509_crq_init', 'gnutls_session_get_master_secret', + 'gnutls_x509_crq_get_challenge_password', '__time_t', + 'gnutls_x509_crt_get_pk_algorithm', + 'gnutls_x509_crt_set_crq', + 'gnutls_certificate_set_openpgp_key_mem2', + 'gnutls_certificate_free_keys', 'gnutls_srp_verifier', + 'gnutls_x509_crl_deinit', + 'gnutls_openpgp_crt_get_pk_dsa_raw', + 'gnutls_certificate_free_ca_names', 'gnutls_cipher_list', + 'gnutls_x509_crq_export', + 'gnutls_certificate_client_set_retrieve_function', + 'gnutls_x509_crl_get_crt_serial', + 'gnutls_pkcs7_get_crt_count', + 'gnutls_certificate_set_x509_trust', + 'gnutls_openpgp_crt_get_subkey_fingerprint', + 'gnutls_ia_handshake_p', + 'gnutls_openpgp_privkey_get_subkey_fingerprint', + 'gnutls_openpgp_keyring_import', 'gnutls_pkcs7_set_crl', + 'gnutls_x509_crq_get_pk_algorithm', + 'gnutls_pkcs7_set_crl_raw', + 'gnutls_certificate_set_verify_limits', + 'gnutls_x509_crt_get_authority_key_id', + 'gnutls_x509_crt_set_activation_time', 'gnutls_db_set_ptr', + 'gnutls_openpgp_crt_get_version', + 'gnutls_x509_crt_get_subject_key_id', + 'gnutls_credentials_clear', 'gnutls_x509_crt_get_key_id', + 'gnutls_x509_crt_init', 'gnutls_dh_params_generate2', + 'gnutls_pkcs7_delete_crt', + 'gnutls_x509_crt_get_subject_alt_name2', + 'gnutls_alert_get_name', + 'gnutls_x509_crt_set_authority_key_id', + 'gnutls_openpgp_crt_get_subkey_pk_rsa_raw', + 'gnutls_x509_crt_list_verify', 'gnutls_priority_init', + 'gnutls_openpgp_crt_get_expiration_time', + 'gnutls_x509_crl_set_version', + 'gnutls_certificate_set_openpgp_keyring_file', + 'gnutls_pem_base64_encode', + 'gnutls_handshake_set_max_packet_length', + 'gnutls_openpgp_privkey_get_subkey_expiration_time', + 'gnutls_x509_crq_set_dn_by_oid', 'gnutls_session_get_id', + 'gnutls_cipher_set_priority', + 'gnutls_openpgp_keyring_check_id', + 'gnutls_openpgp_keyring_deinit', + 'gnutls_srp_base64_encode_alloc', + 'gnutls_db_set_store_function', + 'gnutls_supplemental_get_name', + 'gnutls_handshake_get_last_out', + 'gnutls_x509_privkey_export_pkcs8', + 'gnutls_x509_privkey_deinit', 'gnutls_compression_get_id', + 'gnutls_openpgp_crt_get_subkey_idx', + 'gnutls_x509_privkey_import_rsa_raw', + 'gnutls_transport_set_errno', + 'gnutls_openpgp_privkey_get_subkey_revoked_status', + 'gnutls_x509_crt_get_issuer_dn', + 'gnutls_ia_get_server_avp_ptr', + 'gnutls_openpgp_keyring_get_crt_count', 'gnutls_ia_recv', + 'gnutls_x509_crt_get_pk_dsa_raw', 'gnutls_x509_crt_sign', + 'gnutls_certificate_verify_peers', + 'gnutls_srp_free_server_credentials', + 'gnutls_x509_crt_print', + 'gnutls_openpgp_privkey_export_subkey_dsa_raw', + 'gnutls_server_name_set', 'gnutls_kx_set_priority', + 'gnutls_transport_set_push_function', + 'gnutls_x509_crt_sign2', + 'gnutls_x509_crt_cpy_crl_dist_points', + 'gnutls_pem_base64_decode', 'gnutls_srp_base64_decode', + 'gnutls_openpgp_privkey_get_subkey_count', + 'gnutls_global_init', 'gnutls_x509_rdn_get_by_oid', + 'gnutls_dh_params_import_raw', + 'gnutls_global_set_mem_functions', + 'gnutls_x509_crt_set_key_usage', 'time_t', + 'gnutls_anon_set_server_params_function', + 'gnutls_mac_get_key_size', + 'gnutls_rsa_params_export_pkcs1', + 'gnutls_certificate_type_set_priority', + 'gnutls_x509_crt_get_issuer_dn_oid', + 'gnutls_dh_params_init', + 'gnutls_x509_crq_set_attribute_by_oid', + 'gnutls_certificate_expiration_time_peers', + 'gnutls_ia_endphase_send', + 'gnutls_psk_allocate_server_credentials', + 'gnutls_certificate_set_dh_params', 'gnutls_init', + 'gnutls_openpgp_privkey_get_subkey_pk_algorithm', + 'gnutls_x509_rdn_get_oid', 'gnutls_x509_crl_get_crt_count', + 'gnutls_perror', 'gnutls_x509_crl_get_dn_oid', + 'gnutls_certificate_get_peers', + 'gnutls_ia_set_server_avp_function', + 'gnutls_x509_crl_sign2', + 'gnutls_x509_crt_get_extension_oid', + 'gnutls_x509_crl_sign', 'gnutls_dh_get_pubkey', + 'gnutls_record_get_max_size', 'gnutls_x509_crt_get_dn_oid', + 'gnutls_x509_crt_get_extension_info', + 'gnutls_transport_get_ptr', 'gnutls_db_check_entry', + 'gnutls_ia_generate_challenge', + 'gnutls_certificate_server_set_retrieve_function', + 'gnutls_certificate_set_openpgp_key', + 'gnutls_srp_base64_encode', 'gnutls_db_get_ptr', + 'gnutls_pkcs7_export', 'gnutls_mac_set_priority', + 'gnutls_x509_crt_get_basic_constraints', + 'gnutls_x509_crt_get_subject_alt_othername_oid', + 'gnutls_cipher_get_id', 'gnutls_x509_crl_get_this_update', + 'gnutls_x509_dn_init', 'gnutls_openpgp_crt_import', + 'gnutls_certificate_set_x509_crl', + 'gnutls_rsa_export_get_modulus_bits', + 'gnutls_x509_crl_get_version', + 'gnutls_pkcs7_get_crl_count', 'gnutls_handshake', + 'gnutls_dh_get_group', 'gnutls_x509_crq_get_dn', + 'gnutls_pkcs7_deinit', 'gnutls_record_check_pending', + 'gnutls_protocol_get_name', + 'gnutls_openpgp_privkey_sign_hash', + 'gnutls_srp_set_server_credentials_file', + 'gnutls_pkcs7_delete_crl', 'gnutls_rsa_params_init', + 'gnutls_x509_crt_set_key_purpose_oid', 'gnutls_mac_get', + 'gnutls_record_get_direction', + 'gnutls_certificate_type_list', 'gnutls_session_get_ptr', + 'gnutls_psk_set_server_dh_params', + 'gnutls_x509_crt_get_raw_issuer_dn', + 'gnutls_x509_crt_get_raw_dn', 'gnutls_record_send', + 'gnutls_psk_allocate_client_credentials', + 'gnutls_certificate_set_x509_key', + 'gnutls_certificate_type_get_id', + 'gnutls_x509_privkey_export_dsa_raw', + 'gnutls_pk_algorithm_get_name', + 'gnutls_openpgp_crt_get_pk_algorithm', + 'gnutls_psk_free_client_credentials', + 'gnutls_openpgp_crt_check_hostname', + 'gnutls_handshake_set_post_client_hello_function', + 'gnutls_record_set_max_size', + 'gnutls_openpgp_crt_verify_ring', + 'gnutls_transport_set_ptr', 'gnutls_ia_set_client_avp_ptr', + 'gnutls_x509_privkey_generate', 'gnutls_db_remove_session', + 'gnutls_certificate_type_get_name', + 'gnutls_openpgp_crt_verify_self', + 'gnutls_x509_crq_get_dn_oid', 'gnutls_x509_dn_oid_known', + 'gnutls_openpgp_crt_print', 'gnutls_alert_send', + 'gnutls_x509_privkey_sign_data', + 'gnutls_x509_crt_get_extension_data', + 'gnutls_x509_crl_set_crt_serial', + 'gnutls_x509_crt_set_basic_constraints', + 'gnutls_credentials_set', 'gnutls_transport_set_ptr2', + 'gnutls_x509_crt_set_issuer_dn_by_oid', + 'gnutls_record_disable_padding', 'gnutls_prf_raw', + 'gnutls_anon_allocate_server_credentials', + 'gnutls_x509_crl_get_signature', + 'gnutls_x509_crl_check_issuer', 'gnutls_cipher_suite_info', + 'gnutls_x509_crt_get_issuer', + 'gnutls_certificate_set_params_function', + 'gnutls_openpgp_crt_get_subkey_id', + 'gnutls_psk_set_server_credentials_hint', + 'gnutls_sign_callback_set', + 'gnutls_x509_crt_check_revocation', + 'gnutls_openpgp_privkey_export', + 'gnutls_x509_crt_get_activation_time', 'gnutls_kx_list', + 'gnutls_x509_crt_get_subject_alt_name', + 'gnutls_openpgp_privkey_get_subkey_creation_time', + 'gnutls_x509_crt_get_dn_by_oid', 'gnutls_rsa_params_cpy', + 'gnutls_x509_crt_set_subject_key_id', + 'gnutls_check_version', + 'gnutls_certificate_client_get_request_status', + 'gnutls_prf', 'gnutls_srp_server_get_username', + 'gnutls_pem_base64_encode_alloc', + 'gnutls_certificate_set_openpgp_key_file2', + 'gnutls_openpgp_privkey_export_rsa_raw', + 'gnutls_certificate_set_openpgp_key_mem', + 'gnutls_openpgp_privkey_get_key_id', + 'gnutls_anon_free_client_credentials', + 'gnutls_transport_get_ptr2', + 'gnutls_ia_get_client_avp_ptr', 'gnutls_pkcs7_import', + 'gnutls_compression_get', + 'gnutls_x509_crl_get_signature_algorithm', + 'gnutls_openpgp_keyring_init', + 'gnutls_certificate_free_crls', + 'gnutls_transport_set_global_errno', 'gnutls_record_recv', + 'gnutls_certificate_type_get', + 'gnutls_auth_server_get_type', + 'gnutls_anon_set_params_function', + 'gnutls_openpgp_crt_deinit', 'gnutls_pkcs7_set_crt', + 'gnutls_rsa_params_export_raw', + 'gnutls_x509_dn_get_rdn_ava', 'gnutls_x509_crt_deinit', + 'gnutls_session_get_client_random', + 'gnutls_openpgp_set_recv_key_function', + 'gnutls_x509_crl_set_this_update', + 'gnutls_ia_free_client_credentials', + 'gnutls_protocol_get_version', 'gnutls_x509_crl_set_crt', + 'gnutls_fingerprint', 'gnutls_x509_dn_export', + 'gnutls_openpgp_privkey_import', 'gnutls_error_to_alert', + 'gnutls_x509_privkey_get_key_id', + 'gnutls_x509_crt_get_subject', 'gnutls_rsa_params_deinit', + 'gnutls_cipher_get_name', 'gnutls_ia_send', + 'gnutls_x509_crt_set_extension_by_oid', + 'gnutls_x509_privkey_get_pk_algorithm', + 'gnutls_hex_encode', 'gnutls_rsa_params_import_raw', + 'gnutls_mac_get_name', 'gnutls_psk_server_get_username', + 'gnutls_session_get_data2', 'gnutls_kx_get', + 'gnutls_openpgp_crt_get_preferred_key_id', + 'gnutls_certificate_get_x509_crls', + 'gnutls_x509_crq_set_version', 'gnutls_x509_privkey_cpy', + 'gnutls_openpgp_crt_get_subkey_revoked_status', + 'gnutls_priority_set_direct', 'gnutls_dh_get_secret_bits', + 'gnutls_x509_crt_get_expiration_time', 'gnutls_pkcs7_init', + 'gnutls_transport_set_pull_function', + 'gnutls_protocol_list', + 'gnutls_srp_set_client_credentials', + 'gnutls_x509_crt_get_key_purpose_oid', + 'gnutls_certificate_verify_peers2', + 'gnutls_srp_base64_decode_alloc', 'gnutls_x509_crq_sign', + 'gnutls_x509_privkey_init', 'gnutls_global_set_log_level', + 'gnutls_sign_callback_get', 'gnutls_x509_rdn_get', + 'gnutls_openpgp_privkey_set_preferred_key_id', + 'gnutls_certificate_free_credentials', + 'gnutls_x509_dn_deinit', + 'gnutls_certificate_set_rsa_export_params', + 'gnutls_x509_crt_get_serial', 'gnutls_x509_crq_import', + 'gnutls_x509_privkey_export', + 'gnutls_cipher_suite_get_name', + 'gnutls_ia_extract_inner_secret', + 'gnutls_x509_crt_get_version', 'gnutls_ia_enable', + 'gnutls_x509_crt_set_key', + 'gnutls_srp_free_client_credentials', 'gnutls_mac_list', + 'gnutls_dh_get_prime_bits', 'gnutls_certificate_free_cas', + 'gnutls_alert_get', 'gnutls_ia_permute_inner_secret', + 'gnutls_rehandshake', + 'gnutls_x509_crt_set_subject_alternative_name', + 'gnutls_psk_set_server_credentials_file', + 'gnutls_dh_set_prime_bits', 'gnutls_priority_deinit', + 'gnutls_x509_crt_set_version', + 'gnutls_dh_params_export_pkcs3', 'gnutls_x509_crq_deinit', + 'gnutls_x509_crt_get_fingerprint', + 'gnutls_extra_check_version', + 'gnutls_srp_allocate_client_credentials', + 'gnutls_x509_crl_get_issuer_dn_by_oid', + 'gnutls_pkcs7_get_crl_raw', + 'gnutls_x509_crt_set_expiration_time', + 'gnutls_compression_set_priority', + 'gnutls_openpgp_crt_get_subkey_count', + 'gnutls_openpgp_crt_get_key_usage', + 'gnutls_ia_allocate_server_credentials', + 'gnutls_ia_free_server_credentials', + 'gnutls_transport_set_lowat', + 'gnutls_x509_crt_set_crl_dist_points', + 'gnutls_compression_list', + 'gnutls_x509_privkey_import_pkcs8', + 'gnutls_session_enable_compatibility_mode', + 'gnutls_x509_crq_set_challenge_password', + 'gnutls_strerror', 'gnutls_x509_crt_get_dn', + 'gnutls_x509_crl_init', + 'gnutls_certificate_set_verify_flags', + 'gnutls_psk_free_server_credentials', + 'gnutls_openpgp_privkey_get_subkey_idx', + 'gnutls_ia_set_client_avp_function', + 'gnutls_openpgp_crt_get_subkey_creation_time', + 'gnutls_compression_get_name', 'gnutls_openpgp_crt_init', + 'gnutls_x509_crq_get_dn_by_oid', + 'gnutls_openpgp_privkey_get_pk_algorithm', + 'gnutls_certificate_set_x509_key_file', + 'gnutls_openpgp_crt_get_key_id', + 'gnutls_set_default_export_priority', + 'gnutls_x509_crl_print', 'gnutls_rsa_export_get_pubkey', + 'gnutls_x509_crq_set_key', + 'gnutls_x509_crt_get_signature_algorithm', + 'gnutls_openpgp_crt_get_name', + 'gnutls_openpgp_crt_get_subkey_pk_dsa_raw', + 'gnutls_x509_crl_get_issuer_dn', + 'gnutls_rsa_params_generate2', + 'gnutls_handshake_set_private_extensions', + 'gnutls_psk_set_client_credentials', + 'gnutls_server_name_get', + 'gnutls_openpgp_crt_get_subkey_usage', + 'gnutls_rsa_params_import_pkcs1', 'gnutls_session_set_ptr', + 'gnutls_bye', 'gnutls_auth_client_get_type', + 'gnutls_openpgp_privkey_export_subkey_rsa_raw', + 'gnutls_x509_crt_get_proxy', 'gnutls_kx_get_id', + 'gnutls_session_get_data', 'gnutls_x509_crt_list_import', + 'gnutls_pkcs7_get_crt_raw', + 'gnutls_openpgp_privkey_get_subkey_id', + 'gnutls_psk_set_server_credentials_function', + 'gnutls_srp_set_server_credentials_function', + 'gnutls_ia_verify_endphase', 'gnutls_error_is_fatal', + 'gnutls_x509_crt_verify_data', + 'gnutls_psk_netconf_derive_key', + 'gnutls_certificate_server_set_request', + 'gnutls_openpgp_privkey_get_fingerprint', + 'gnutls_dh_params_export_raw', + 'gnutls_protocol_set_priority', + 'gnutls_psk_set_client_credentials_function', + 'gnutls_set_default_priority', 'gnutls_hex2bin', + 'gnutls_dh_params_cpy', 'gnutls_ia_handshake', + 'gnutls_handshake_get_last_in', 'gnutls_protocol_get_id', + 'gnutls_x509_crq_get_attribute_by_oid', + 'gnutls_certificate_get_ours', + 'gnutls_anon_free_server_credentials', + 'gnutls_x509_crt_verify', 'gnutls_session_set_data', + 'gnutls_certificate_allocate_credentials', + 'gnutls_x509_crt_set_serial', 'gnutls_openpgp_send_cert', + 'gnutls_certificate_set_x509_key_mem', + 'gnutls_x509_crt_get_extension_by_oid', + 'gnutls_session_get_server_random', + 'gnutls_openpgp_privkey_get_revoked_status', + 'gnutls_dh_params_deinit', 'gnutls_mac_get_id', + 'gnutls_x509_crt_get_signature', 'gnutls_x509_crq_sign2', + 'gnutls_global_deinit', 'gnutls_sign_algorithm_get_name', + 'gnutls_anon_allocate_client_credentials', + 'gnutls_x509_crt_export', + 'gnutls_certificate_get_x509_cas', + 'gnutls_dh_params_import_pkcs3', 'gnutls_hex_decode', + 'gnutls_openpgp_crt_export', + 'gnutls_psk_set_params_function', + 'gnutls_x509_crt_check_issuer', + 'gnutls_x509_crl_set_next_update', + 'gnutls_ia_allocate_client_credentials', + 'gnutls_psk_client_get_hint', + 'gnutls_certificate_send_x509_rdn_sequence', + 'gnutls_alert_send_appropriate', + 'gnutls_anon_set_server_dh_params', + 'gnutls_openpgp_crt_get_revoked_status', + 'gnutls_openpgp_crt_get_subkey_pk_algorithm', + 'gnutls_openpgp_privkey_get_preferred_key_id', + 'gnutls_x509_privkey_sign_hash', 'gnutls_x509_crl_export', + 'gnutls_openpgp_privkey_deinit', + 'gnutls_pkcs7_set_crt_raw', 'gnutls_auth_get_type', + 'gnutls_certificate_get_openpgp_keyring', + 'gnutls_openpgp_privkey_export_dsa_raw', + 'gnutls_openpgp_crt_set_preferred_key_id', + 'gnutls_srp_allocate_server_credentials', + 'gnutls_dh_get_peers_public_bits', + 'gnutls_certificate_set_x509_crl_mem', + 'gnutls_x509_privkey_fix', 'gnutls_kx_get_name', + 'gnutls_psk_set_server_params_function', + 'gnutls_openpgp_crt_get_fingerprint', + 'gnutls_openpgp_crt_get_subkey_expiration_time', + 'gnutls_x509_dn_import', + 'gnutls_x509_crt_get_issuer_dn_by_oid', + 'gnutls_openpgp_crt_get_creation_time', + 'gnutls_openpgp_crt_get_pk_rsa_raw', + 'gnutls_session_is_resumed', 'gnutls_x509_crt_set_proxy', + 'gnutls_certificate_set_openpgp_key_file', + 'gnutls_certificate_set_x509_trust_mem', + 'gnutls_openpgp_crt_get_auth_subkey', + 'gnutls_x509_privkey_verify_data', 'gnutls_deinit', + 'gnutls_x509_crt_import', + 'gnutls_db_set_retrieve_function', + 'gnutls_x509_privkey_import', + 'gnutls_certificate_set_x509_simple_pkcs12_file', + 'gnutls_global_set_log_function', + 'gnutls_db_set_cache_expiration', + 'gnutls_x509_crt_set_ca_status', + 'gnutls_x509_crl_get_next_update', + 'gnutls_x509_crl_verify', 'gnutls_pem_base64_decode_alloc', + 'gnutls_x509_crt_get_key_usage', + 'gnutls_x509_crt_get_crl_dist_points'] diff --git a/python-gnutls-1.1.9/gnutls/library/types.py b/python-gnutls-1.1.9/gnutls/library/types.py new file mode 100644 index 0000000..0d878bb --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/library/types.py @@ -0,0 +1,248 @@ +from ctypes import * + +STRING = c_char_p +from gnutls.library.constants import gnutls_cipher_algorithm_t +from gnutls.library.constants import gnutls_certificate_print_formats +from gnutls.library.constants import gnutls_params_type_t +from gnutls.library.constants import gnutls_psk_key_flags +from gnutls.library.constants import gnutls_x509_subject_alt_name_t +from gnutls.library.constants import gnutls_certificate_type_t +from gnutls.library.constants import gnutls_pk_algorithm_t +from gnutls.library.constants import gnutls_openpgp_crt_fmt +from gnutls.library.constants import gnutls_certificate_import_flags +from gnutls.library.constants import gnutls_certificate_verify_flags +from gnutls.library.constants import gnutls_pkcs_encrypt_flags_t + + +class gnutls_session_int(Structure): + pass +gnutls_session_t = POINTER(gnutls_session_int) +size_t = c_size_t +gnutls_ia_avp_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, STRING, size_t, POINTER(STRING), POINTER(size_t)) +class gnutls_ia_server_credentials_st(Structure): + pass +gnutls_ia_server_credentials_st._fields_ = [ +] +gnutls_ia_server_credentials_t = POINTER(gnutls_ia_server_credentials_st) +class gnutls_ia_client_credentials_st(Structure): + pass +gnutls_ia_client_credentials_st._fields_ = [ +] +gnutls_ia_client_credentials_t = POINTER(gnutls_ia_client_credentials_st) +gnutls_certificate_print_formats_t = gnutls_certificate_print_formats +gnutls_transport_ptr_t = c_void_p +gnutls_session_int._fields_ = [ +] +class gnutls_dh_params_int(Structure): + pass +gnutls_dh_params_int._fields_ = [ +] +gnutls_dh_params_t = POINTER(gnutls_dh_params_int) +class gnutls_x509_privkey_int(Structure): + pass +gnutls_x509_privkey_int._fields_ = [ +] +gnutls_rsa_params_t = POINTER(gnutls_x509_privkey_int) +class gnutls_priority_st(Structure): + pass +gnutls_priority_st._fields_ = [ +] +gnutls_priority_t = POINTER(gnutls_priority_st) +class gnutls_datum_t(Structure): + pass +gnutls_datum_t._fields_ = [ + ('data', POINTER(c_ubyte)), + ('size', c_uint), +] +class gnutls_params_st(Structure): + pass +class params(Union): + pass +params._fields_ = [ + ('dh', gnutls_dh_params_t), + ('rsa_export', gnutls_rsa_params_t), +] +gnutls_params_st._fields_ = [ + ('type', gnutls_params_type_t), + ('params', params), + ('deinit', c_int), +] +gnutls_params_function = CFUNCTYPE(c_int, gnutls_session_t, gnutls_params_type_t, POINTER(gnutls_params_st)) +gnutls_oprfi_callback_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, size_t, POINTER(c_ubyte), POINTER(c_ubyte)) +gnutls_db_store_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t, gnutls_datum_t) +gnutls_db_remove_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t) +gnutls_db_retr_func = CFUNCTYPE(gnutls_datum_t, c_void_p, gnutls_datum_t) +gnutls_handshake_post_client_hello_func = CFUNCTYPE(c_int, gnutls_session_t) +class gnutls_certificate_credentials_st(Structure): + pass +gnutls_certificate_credentials_st._fields_ = [ +] +gnutls_certificate_credentials_t = POINTER(gnutls_certificate_credentials_st) +gnutls_certificate_server_credentials = gnutls_certificate_credentials_t +gnutls_certificate_client_credentials = gnutls_certificate_credentials_t +class gnutls_anon_server_credentials_st(Structure): + pass +gnutls_anon_server_credentials_st._fields_ = [ +] +gnutls_anon_server_credentials_t = POINTER(gnutls_anon_server_credentials_st) +class gnutls_anon_client_credentials_st(Structure): + pass +gnutls_anon_client_credentials_st._fields_ = [ +] +gnutls_anon_client_credentials_t = POINTER(gnutls_anon_client_credentials_st) +gnutls_x509_privkey_t = POINTER(gnutls_x509_privkey_int) +class gnutls_x509_crl_int(Structure): + pass +gnutls_x509_crl_int._fields_ = [ +] +gnutls_x509_crl_t = POINTER(gnutls_x509_crl_int) +class gnutls_x509_crt_int(Structure): + pass +gnutls_x509_crt_int._fields_ = [ +] +gnutls_x509_crt_t = POINTER(gnutls_x509_crt_int) +class gnutls_openpgp_keyring_int(Structure): + pass +gnutls_openpgp_keyring_int._fields_ = [ +] +gnutls_openpgp_keyring_t = POINTER(gnutls_openpgp_keyring_int) +gnutls_alloc_function = CFUNCTYPE(c_void_p, size_t) +gnutls_calloc_function = CFUNCTYPE(c_void_p, size_t, size_t) +gnutls_is_secure_function = CFUNCTYPE(c_int, c_void_p) +gnutls_free_function = CFUNCTYPE(None, c_void_p) +gnutls_realloc_function = CFUNCTYPE(c_void_p, c_void_p, size_t) +gnutls_log_func = CFUNCTYPE(None, c_int, STRING) +__ssize_t = c_long +ssize_t = __ssize_t +gnutls_pull_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t) +gnutls_push_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t) +class gnutls_srp_server_credentials_st(Structure): + pass +gnutls_srp_server_credentials_st._fields_ = [ +] +gnutls_srp_server_credentials_t = POINTER(gnutls_srp_server_credentials_st) +class gnutls_srp_client_credentials_st(Structure): + pass +gnutls_srp_client_credentials_st._fields_ = [ +] +gnutls_srp_client_credentials_t = POINTER(gnutls_srp_client_credentials_st) +gnutls_srp_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)) +gnutls_srp_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(STRING)) +class gnutls_psk_server_credentials_st(Structure): + pass +gnutls_psk_server_credentials_st._fields_ = [ +] +gnutls_psk_server_credentials_t = POINTER(gnutls_psk_server_credentials_st) +class gnutls_psk_client_credentials_st(Structure): + pass +gnutls_psk_client_credentials_st._fields_ = [ +] +gnutls_psk_client_credentials_t = POINTER(gnutls_psk_client_credentials_st) +gnutls_psk_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t)) +gnutls_psk_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(gnutls_datum_t)) +class gnutls_openpgp_crt_int(Structure): + pass +gnutls_openpgp_crt_int._fields_ = [ +] +gnutls_openpgp_crt_t = POINTER(gnutls_openpgp_crt_int) +class gnutls_openpgp_privkey_int(Structure): + pass +gnutls_openpgp_privkey_int._fields_ = [ +] +gnutls_openpgp_privkey_t = POINTER(gnutls_openpgp_privkey_int) +class gnutls_retr_st(Structure): + pass +class cert(Union): + pass +cert._fields_ = [ + ('x509', POINTER(gnutls_x509_crt_t)), + ('pgp', gnutls_openpgp_crt_t), +] +class key(Union): + pass +key._fields_ = [ + ('x509', gnutls_x509_privkey_t), + ('pgp', gnutls_openpgp_privkey_t), +] +gnutls_retr_st._fields_ = [ + ('type', gnutls_certificate_type_t), + ('cert', cert), + ('ncerts', c_uint), + ('key', key), + ('deinit_all', c_uint), +] +gnutls_certificate_client_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_datum_t), c_int, POINTER(gnutls_pk_algorithm_t), c_int, POINTER(gnutls_retr_st)) +gnutls_certificate_server_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_retr_st)) +gnutls_sign_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, gnutls_certificate_type_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)) +gnutls_openpgp_crt_fmt_t = gnutls_openpgp_crt_fmt +gnutls_openpgp_keyid_t = c_ubyte * 8 +gnutls_openpgp_recv_key_func = CFUNCTYPE(c_int, gnutls_session_t, POINTER(c_ubyte), c_uint, POINTER(gnutls_datum_t)) +gnutls_x509_dn_t = c_void_p +class gnutls_x509_ava_st(Structure): + pass +gnutls_x509_ava_st._fields_ = [ + ('oid', gnutls_datum_t), + ('value', gnutls_datum_t), + ('value_tag', c_ulong), +] +class gnutls_pkcs7_int(Structure): + pass +gnutls_pkcs7_int._fields_ = [ +] +gnutls_pkcs7_t = POINTER(gnutls_pkcs7_int) +class gnutls_x509_crq_int(Structure): + pass +gnutls_x509_crq_int._fields_ = [ +] +gnutls_x509_crq_t = POINTER(gnutls_x509_crq_int) +__all__ = ['key', 'gnutls_certificate_print_formats_t', + 'gnutls_session_int', 'gnutls_srp_server_credentials_st', + 'gnutls_oprfi_callback_func', '__ssize_t', + 'gnutls_transport_ptr_t', 'gnutls_pkcs7_int', + 'gnutls_psk_client_credentials_st', 'gnutls_priority_t', + 'gnutls_certificate_credentials_st', + 'gnutls_psk_server_credentials_t', 'gnutls_x509_crt_t', + 'gnutls_x509_privkey_t', 'gnutls_openpgp_keyring_t', + 'gnutls_x509_privkey_int', 'gnutls_push_func', + 'gnutls_x509_crq_int', 'gnutls_psk_server_credentials_st', + 'gnutls_openpgp_crt_t', + 'gnutls_certificate_client_credentials', 'size_t', + 'gnutls_ia_avp_func', 'gnutls_params_st', + 'gnutls_anon_client_credentials_t', 'gnutls_dh_params_t', + 'gnutls_anon_client_credentials_st', 'gnutls_sign_func', + 'gnutls_srp_server_credentials_function', 'cert', + 'gnutls_x509_crt_int', 'gnutls_realloc_function', + 'gnutls_srp_client_credentials_function', + 'gnutls_ia_server_credentials_st', + 'gnutls_srp_client_credentials_st', + 'gnutls_calloc_function', 'gnutls_priority_st', + 'gnutls_x509_crl_int', 'params', + 'gnutls_certificate_server_credentials', + 'gnutls_handshake_post_client_hello_func', + 'gnutls_session_t', + 'gnutls_psk_client_credentials_function', + 'gnutls_openpgp_privkey_int', 'gnutls_retr_st', + 'gnutls_is_secure_function', 'gnutls_db_retr_func', + 'gnutls_openpgp_keyring_int', + 'gnutls_srp_client_credentials_t', + 'gnutls_psk_client_credentials_t', + 'gnutls_anon_server_credentials_t', 'gnutls_dh_params_int', + 'gnutls_datum_t', 'gnutls_openpgp_crt_fmt_t', + 'gnutls_ia_server_credentials_t', 'gnutls_x509_ava_st', + 'gnutls_alloc_function', + 'gnutls_psk_server_credentials_function', + 'gnutls_anon_server_credentials_st', + 'gnutls_params_function', + 'gnutls_srp_server_credentials_t', + 'gnutls_openpgp_crt_int', 'gnutls_log_func', + 'gnutls_rsa_params_t', + 'gnutls_certificate_server_retrieve_function', + 'gnutls_x509_dn_t', 'gnutls_x509_crq_t', + 'gnutls_pull_func', 'gnutls_db_remove_func', + 'gnutls_ia_client_credentials_t', + 'gnutls_certificate_credentials_t', 'gnutls_pkcs7_t', + 'gnutls_ia_client_credentials_st', 'gnutls_db_store_func', + 'ssize_t', 'gnutls_openpgp_recv_key_func', + 'gnutls_openpgp_privkey_t', 'gnutls_openpgp_keyid_t', + 'gnutls_free_function', 'gnutls_x509_crl_t', + 'gnutls_certificate_client_retrieve_function'] diff --git a/python-gnutls-1.1.9/gnutls/validators.py b/python-gnutls-1.1.9/gnutls/validators.py new file mode 100644 index 0000000..11c29c3 --- /dev/null +++ b/python-gnutls-1.1.9/gnutls/validators.py @@ -0,0 +1,286 @@ +# Copyright (C) 2007 AG Projects. See LICENSE for details. +# + +"""GNUTLS data validators""" + +__all__ = ['function_args', 'method_args', 'none', 'ignore', 'list_of', 'one_of', 'ProtocolListValidator', + 'KeyExchangeListValidator', 'CipherListValidator', 'MACListValidator', 'CompressionListValidator'] + +from gnutls.constants import * + +# +# Priority list validators. They take a tuple or list on input and output a +# tuple with the same elements if they check valid, else raise an exception. +# + +class ProtocolListValidator(tuple): + _protocols = set((PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3)) + + def __new__(cls, arg): + if not isinstance(arg, (tuple, list)): + raise TypeError("Argument must be a tuple or list") + if not arg: + raise ValueError("Protocol list cannot be empty") + if not cls._protocols.issuperset(set(arg)): + raise ValueError("Got invalid protocol") + return tuple.__new__(cls, arg) + + +class KeyExchangeListValidator(tuple): + _algorithms = set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT, KX_ANON_DH)) + + def __new__(cls, arg): + if not isinstance(arg, (tuple, list)): + raise TypeError("Argument must be a tuple or list") + if not arg: + raise ValueError("Key exchange algorithm list cannot be empty") + if not cls._algorithms.issuperset(set(arg)): + raise ValueError("Got invalid key exchange algorithm") + return tuple.__new__(cls, arg) + + +class CipherListValidator(tuple): + _ciphers = set((CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128, CIPHER_AES_256_CBC, CIPHER_DES_CBC)) + + def __new__(cls, arg): + if not isinstance(arg, (tuple, list)): + raise TypeError("Argument must be a tuple or list") + if not arg: + raise ValueError("Cipher list cannot be empty") + if not cls._ciphers.issuperset(set(arg)): + raise ValueError("Got invalid cipher") + return tuple.__new__(cls, arg) + + +class MACListValidator(tuple): + _algorithms = set((MAC_SHA1, MAC_MD5, MAC_RMD160)) + + def __new__(cls, arg): + if not isinstance(arg, (tuple, list)): + raise TypeError("Argument must be a tuple or list") + if not arg: + raise ValueError("MAC algorithm list cannot be empty") + if not cls._algorithms.issuperset(set(arg)): + raise ValueError("Got invalid MAC algorithm") + return tuple.__new__(cls, arg) + + +class CompressionListValidator(tuple): + _compressions = set((COMP_DEFLATE, COMP_LZO, COMP_NULL)) + + def __new__(cls, arg): + if not isinstance(arg, (tuple, list)): + raise TypeError("Argument must be a tuple or list") + if not arg: + raise ValueError("Compression list cannot be empty") + if not cls._compressions.issuperset(set(arg)): + raise ValueError("Got invalid compression") + return tuple.__new__(cls, arg) + +# +# Argument validating +# + +# Helper functions (internal use) +# + +def isclass(obj): + return hasattr(obj, '__bases__') or isinstance(obj, type) + +# Internal validator classes +# + +class Validator(object): + _registered = [] + def __init__(self, typ): + self.type = typ + def check(self, value): + return False + @staticmethod + def can_validate(typ): + return False + @classmethod + def register(cls, validator): + cls._registered.append(validator) + @classmethod + def get(cls, typ): + for validator in cls._registered: + if validator.can_validate(typ): + return validator(typ) + else: + return None + @staticmethod + def join_names(names): + if type(names) in (tuple, list): + if len(names) <= 2: + return ' or '.join(names) + else: + return ' or '.join((', '.join(names[:-1]), names[-1])) + else: + return names + def _type_names(self): + if isinstance(self.type, tuple): + return self.join_names([t.__name__.replace('NoneType', 'None') for t in self.type]) + else: + return self.type.__name__.replace('NoneType', 'None') + @property + def name(self): + name = self._type_names() + if name.startswith('None'): + prefix = '' + elif name[0] in ('a', 'e', 'i', 'o', 'u'): + prefix = 'an ' + else: + prefix = 'a ' + return prefix + name + +class IgnoringValidator(Validator): + def __init__(self, typ): + self.type = none + def check(self, value): + return True + @staticmethod + def can_validate(obj): + return obj is ignore + +class TypeValidator(Validator): + def check(self, value): + return isinstance(value, self.type) + @staticmethod + def can_validate(obj): + return isclass(obj) + +class MultiTypeValidator(TypeValidator): + @staticmethod + def can_validate(obj): + return isinstance(obj, tuple) and not filter(lambda x: not isclass(x), obj) + +class OneOfValidator(Validator): + def __init__(self, typ): + self.type = typ.type + def check(self, value): + return value in self.type + @staticmethod + def can_validate(obj): + return isinstance(obj, one_of) + @property + def name(self): + return 'one of %s' % self.join_names(["`%r'" % e for e in self.type]) + +class ListOfValidator(Validator): + def __init__(self, typ): + self.type = typ.type + def check(self, value): + return isinstance(value, (tuple, list)) and not filter(lambda x: not isinstance(x, self.type), value) + @staticmethod + def can_validate(obj): + return isinstance(obj, list_of) + @property + def name(self): + return 'a list of %s' % self._type_names() + +class ComplexValidator(Validator): + def __init__(self, typ): + self.type = [Validator.get(x) for x in typ] + def check(self, value): + return bool(sum(t.check(value) for t in self.type)) + @staticmethod + def can_validate(obj): + return isinstance(obj, tuple) and not filter(lambda x: Validator.get(x) is None, obj) + @property + def name(self): + return self.join_names([x.name for x in self.type]) + +Validator.register(IgnoringValidator) +Validator.register(TypeValidator) +Validator.register(MultiTypeValidator) +Validator.register(OneOfValidator) +Validator.register(ListOfValidator) +Validator.register(ComplexValidator) + + +# Extra types to be used with argument validating decorators +# + +none = type(None) + +class one_of(object): + def __init__(self, *args): + if len(args) < 2: + raise ValueError("one_of must have at least 2 arguments") + self.type = args + +class list_of(object): + def __init__(self, *args): + if filter(lambda x: not isclass(x), args): + raise TypeError("list_of arguments must be types") + if len(args) == 1: + self.type = args[0] + else: + self.type = args + +ignore = type('ignore', (), {})() + + +# Helpers for writing well behaved decorators +# + +def decorator(func): + """A syntactic marker with no other effect than improving readability.""" + return func + +def preserve_signature(func): + """Preserve the original function signature and attributes in decorator wrappers.""" + from inspect import getargspec, formatargspec + from gnutls.constants import GNUTLSConstant + constants = [c for c in (getargspec(func)[3] or []) if isinstance(c, GNUTLSConstant)] + signature = formatargspec(*getargspec(func))[1:-1] + parameters = formatargspec(*getargspec(func), **{'formatvalue': lambda value: ""})[1:-1] + def fix_signature(wrapper): + if constants: + ## import the required GNUTLSConstants used as function default arguments + code = "from gnutls.constants import %s\n" % ', '.join(c.name for c in constants) + exec code in locals(), locals() + code = "def %s(%s): return wrapper(%s)\nnew_wrapper = %s\n" % (func.__name__, signature, parameters, func.__name__) + exec code in locals(), locals() + new_wrapper.__name__ = func.__name__ + new_wrapper.__doc__ = func.__doc__ + new_wrapper.__module__ = func.__module__ + new_wrapper.__dict__.update(func.__dict__) + return new_wrapper + return fix_signature + +# Argument validating decorators +# + +def _callable_args(*args, **kwargs): + """Internal function used by argument checking decorators""" + start = kwargs.get('_start', 0) + validators = [] + for i, arg in enumerate(args): + validator = Validator.get(arg) + if validator is None: + raise TypeError("unsupported type `%r' at position %d for argument checking decorator" % (arg, i+1)) + validators.append(validator) + def check_args_decorator(func): + @preserve_signature(func) + def check_args(*func_args): + pos = start + for validator in validators: + if not validator.check(func_args[pos]): + raise TypeError("argument %d must be %s" % (pos+1-start, validator.name)) + pos += 1 + return func(*func_args) + return check_args + return check_args_decorator + +@decorator +def method_args(*args): + """Check class or instance method arguments""" + return _callable_args(*args, **{'_start': 1}) + +@decorator +def function_args(*args): + """Check functions or staticmethod arguments""" + return _callable_args(*args) + diff --git a/python-gnutls-1.1.9/setup.py b/python-gnutls-1.1.9/setup.py new file mode 100755 index 0000000..e12da4e --- /dev/null +++ b/python-gnutls-1.1.9/setup.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python + +from distutils.core import setup, Extension +from gnutls import __version__ +import subprocess +import sys +import platform +import os + +# Get the title and description from README +import re +readme = open('README').read() +title, intro = re.findall(r'^\s*([^\n]+)\s+(.*)$', readme, re.DOTALL)[0] + +# Get GNUTLS library version and compile/link options +def get_options(): + GNUTLS_CONF = 'libgnutls-config' + GNUTLS_EXTRA_CONF = 'libgnutls-extra-config' + library_init = open('gnutls/library/__init__.py').read() + gnutls_version_req = [int(num) for num in re.findall(r"__need_version__ = '(\d)\.(\d)\.(\d)'", library_init)[0]] + try: + sub = subprocess.Popen([GNUTLS_CONF, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + except OSError: + # return some sane defaults if libgnutls-config is not available + return [], [], ['gcrypt', 'gnutls', 'gnutls-extra'] + sub.wait() + gnutls_version = [int(num) for num in sub.stdout.read().strip().split(".")] + # check the returned version number against the required version in the debian/control file + if not gnutls_version >= gnutls_version_req: + print 'python-gnutls requires version %d.%d.%d of libgnutls (found %d.%d.%d).' % tuple(gnutls_version_req + gnutls_version) + sys.exit() + sub = subprocess.Popen([GNUTLS_CONF, '--libs', '--cflags'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + sub.wait() + gnutls_options = re.findall('-(.*?)[\n ]', sub.stdout.read()) + sub = subprocess.Popen([GNUTLS_EXTRA_CONF, '--libs', '--cflags'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + sub.wait() + gnutls_extra_options = re.findall('-(.*?)[\n ]', sub.stdout.read()) + # filter out the unique options from the output of both scripts + include_dirs = list(set(option[1:] for option in gnutls_options + gnutls_extra_options if option.startswith('I'))) + library_dirs = list(set(option[1:] for option in gnutls_options + gnutls_extra_options if option.startswith('L'))) + libraries = list(set(option[1:] for option in gnutls_options + gnutls_extra_options if option.startswith('l'))) + # on OS-X, replace the library names in gnutls/library/functions.py and include the full path to it + if platform.system() == "Darwin": + functions_py = open('gnutls/library/functions.py').read() + if gnutls_options.index('lgnutls') > 0: + gnutls_dir = gnutls_options[gnutls_options.index('lgnutls') - 1] + if gnutls_dir.startswith('L'): + functions_py = re.sub(r"_libraries\['libgnutls.so.26'\] = CDLL\('.*?'\)", "_libraries['libgnutls.so.26'] = CDLL('%s')" % os.path.join(gnutls_dir[1:], 'libgnutls.26.dylib'), functions_py, 1) + if gnutls_extra_options.index('lgnutls-extra'): + gnutls_extra_dir = gnutls_extra_options[gnutls_extra_options.index('lgnutls-extra') - 1] + if gnutls_extra_dir.startswith('L'): + functions_py = re.sub(r"_libraries\['libgnutls-extra.so.26'\] = CDLL\('.*?'\)", "_libraries['libgnutls-extra.so.26'] = CDLL('%s')" % os.path.join(gnutls_extra_dir[1:], 'libgnutls-extra.26.dylib'), functions_py, 1) + open('gnutls/library/functions.py', 'w').write(functions_py) + return include_dirs, library_dirs, libraries + +include_dirs, library_dirs, libraries = get_options() + +setup(name = "python-gnutls", + version = __version__, + author = "Dan Pascu", + author_email = "dan@ag-projects.com", + url = "http://ag-projects.com/", + download_url = "http://cheeseshop.python.org/pypi/python-gnutls/%s" % __version__, + description = title, + long_description = intro, + license = "LGPL", + platforms = ["Platform Independent"], + classifiers = [ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers", + "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Topic :: Software Development :: Libraries :: Python Modules" + ], + packages = ['gnutls', 'gnutls.interfaces', 'gnutls.interfaces.twisted', 'gnutls.library'], + ext_modules = [Extension(name='gnutls.library._gnutls_init', + sources=['gnutls/library/_gnutls_init.c'], + include_dirs=include_dirs, + library_dirs=library_dirs, + libraries=libraries)]) + |