././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9798453 pykcs11-1.5.20/0000755000175100017510000000000015246574336012557 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541146.592659 pykcs11-1.5.20/COPYING0000644000175100017510000004310315246574333013610 0ustar00runnerrunner GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541146.592659 pykcs11-1.5.20/Changes.txt0000644000175100017510000002370115246574333014670 0ustar00runnerrunnerHistory ======= 1.5.20 - September 2026, Ludovic Rousseau - fix C_Initialize() crash on Windows 1.5.19 - August 2026, Ludovic Rousseau - Add support of swig 4.5.0 - getMechanismList(): do not fail on unknown mechanisms - Remove use of deprecated CKA_SECONDARY_AUTH - test/reset_softHSM: - add support of Homebrew on arm64 - add some output traces - setup: Rename the project in lower case - Move source code in src/ - minor improvements 1.5.18 - August 2025, Ludovic Rousseau - add CKM_EXTRACT_KEY_FROM_KEY mechanism - add CKM_EDDSA and CK_EDDSA_PARAMS support - C_Initialize(): allow OS locking - PyKCS11.load() & .unload(): make the methods tread-safe - bugfix: store CKM_CONCATENATE_BASE_AND_KEY parameter in mechanism context - IsNum(): CKA_HW_FEATURE_TYPE is also a numeric value - improve support for multi-part encryption/decryption - fix some Python typing issues - Fix issue with vendor defined (CKM_VENDOR_DEFINED) mechanisms - fix/ignore all pylint warnings - use pytest for running tests - minor improvements 1.5.17 - October 2024, Ludovic Rousseau - Add AES in counter mode support (CKM_AES_CTR) - Add simple derivation mechanisms support (CMK_CONCATENATE_*) - Fix reference counting in PyKCS11Lib.load() - remove python 2 support from ckbytelist - minor improvements 1.5.16 - May 2024, Ludovic Rousseau - add support of CKA_MODIFIABLE and CKA_DESTROYABLE attributes - minor improvements 1.5.15 - April 2024, Ludovic Rousseau - fix problems when PYKCS11LIB has incorrect values - fix a problem with swig and "pip install ..." - minor improvements 1.5.14 - February 2024, Ludovic Rousseau - fix build using swig 4.2.0 1.5.13 - January 2024, Ludovic Rousseau - fix issue between Python 3.12 garbage collector and C_Finalize() - Modernize use of setup.py - Check swig is installed - remove unused files - minor improvements 1.5.12 - April 2023, Ludovic Rousseau - add setAttributeValue() - minor improvements 1.5.11 - Septembre 2022, Ludovic Rousseau - add deriveKey() with CKM_ECDH1_DERIVE and CK_ECDH1_DERIVE_PARAMS - support pSourceData in OAEP params - remove use of (deprecated) distutils - samples: port to Python 3 - fix code coverage generation 1.5.10 - December 2020, Ludovic Rousseau - Add CKH_* constants - CKA_HW_FEATURE_TYPE attribute value is a number - Makefile: use python3 by default - minor improvements 1.5.9 - July 2020, Ludovic Rousseau - call C_GetSlotList() with a NULL parameter to correctly initialize some PKCS#11 lib conforming to PKCS#11 version 2.40. 1.5.8 - May 2020, Ludovic Rousseau - CKA_ALWAYS_AUTHENTICATE is boolean - CKM_VENDOR_DEFINED_... . Fix name: use CKM_ instead of CKR_ prefix . Use an explicit hex prefix: CKM_VENDOR_DEFINED_0x45 - Add missing CKM_*, CKA_*, CKF_*, CKD_*, CKK_*, CKN_*, CKO_*, CKR_* from PKCS#11 v3.0 - fix test_asymetric.py for RSA_PSS_Mechanism 1.5.7 - December 2019, Ludovic Rousseau - add missing files in the .tar.gz 1.5.6 - December 2019, Ludovic Rousseau - AppVeyor: . generate bdist_wheel . add Python 3.7 and 3.8 - Sample events.py: add a -f/--full argument - Add support of CKM_AES_GCM mechanism - CPKCS11Lib::Load(): return different error codes - minor improvements 1.5.5 - April 2019, Ludovic Rousseau - fix source package generation 1.5.4 - April 2019, Ludovic Rousseau - getTokenInfo: replace NUL char by ' ' in utcTime - dumpit: . print hardwareVersion and firmwareVersion . print slot flags . move to next slot if token not present - add support of CKA_WRAP_TEMPLATE/CKA_UNWRAP_TEMPLATE - add samples for ECC key generation and use - move from distutils to setuptools - upload of wheels to pypi on "make dist" 1.5.3 - October 2018, Ludovic Rousseau - Do not fail when converting a UTF-8 string - Documentation: convert from Epydoc to Sphinx - some minor improvements 1.5.2 - April 2018, Ludovic Rousseau - Fix initPin() - add tests for initPin(), setPin(), initToken() 1.5.1 - March 2018, Ludovic Rousseau - Fix "pip install" 1.5.0 - March 2018, Ludovic Rousseau - Python 3: use strings instead of binary buffers for CK_UTF8CHAR PKCS#11 types. The behavior is now the same as with Python 2 - allow non string PIN values (binary PIN) for login(), initToken(), initPin(), setPin() - fix support of RSA PKCS PSS mechanism The mechanism object now uses a parameter "mechanism" instead of hard coding the mechanism value to CKM_RSA_PKCS_PSS. - add support of Python 2.7 on Windows - add AppVeyor configuration (automatic Windows builds) - ckbytelist: remove possibility to give a initial size - samples/getinfo: do not list the mechanisms by default - samples/events: . do not list the mechanisms by default . add support of pinpad readers - some minor improvements 1.4.4 - October 2017, Ludovic Rousseau - getAttributeValue(): handle CKR_ARGUMENTS_BAD error - seedRandom: fix the seed convertion - Add vendor errors support to PyKCS11Error - samples/getinfo & dumpit: list only slots with a token present by default - run_test: add support of OpenSC PKCS#11 spy - ckbytelist: update __repr__() - include tests files in the archive - dumpit: display the error if getAttributeValue() fails - some minor improvements 1.4.3 - June 2017, Ludovic Rousseau - Add support of CKM_RSA_PKCS_PSS mechanism - fix CKM_AES_CBC issue with Python 3 - add Unitary Tests (make tests) - add tox support (automate and standardize testing in Python) - add coverage support (measuring code coverage of Python programs) - add Travis-CI configuration (automatic build and tests) - some minor improvements 1.4.2 - May 2017, Ludovic Rousseau - Moved the project from https://bitbucket.org/PyKCS11/pykcs11 to https://github.com/LudovicRousseau/PyKCS11 - Makefile: use a better default value for PREFIX - Fix PyKCS11.__del__(): test that every module is accessible - getSlotList(): add optional tokenPresent parameter By default the method returns all the slots (like before the change). - Always call C_Initialize() in ::Load() to work with some bogus PKCS#11 library (like libCryptoki2 from Safenet Luna SA HSM) - LowLevel samples: use PYKCS11LIB environment variable - some minor improvements 1.4.1 - February 2017, Ludovic Rousseau - fix compilation under Python 3 - add rsa encryption sample program 1.4.0 - February 2017, Ludovic Rousseau - fix closeAllSessions() and move it Session to PKCS11Lib - add RSAOAEPMechanism to support RSA Encryption - add DigestSession which enables multi-part digesting - add Elliptic curve keypair generating mechanism - fix bug in Templates using booleans CK_TRUE/CK_FALSE Templates are used by generateKey(), generateKeyPair(), findObjects() createObject(), unwrapKey() - fix dumpit.py sample for Python 3 1.3.3 - November 2016, Ludovic Rousseau - PKCS#11 definitions: sync with Cryptoki version 2.40 . add missing CKM_* and CKP_* defines - Add generateKey() with default mechanism CKM_AES_KEY_GEN - Make sure the PyKCS11Lib is referenced as long as Session object is live - Fix OverflowError on Windows - Attribute CKA_WRAP_WITH_TRUSTED is bool - samples - dumpit: ask to enter the PIN on the pinpad if needed - getinfo & dumpit: add --slot= parameter - some minor improvements 1.3.2 - January 2016, Ludovic Rousseau - Add wrappers for C_Verify, C_WrapKey, C_UnwrapKey - PKCS#11 definitions: sync with Cryptoki version 2.30 - Generate CKM[CKM_VENDOR_DEFINED+x] values on the fly - Fix use of a pinpad reader CKF_PROTECTED_AUTHENTICATION_PATH - dumpit.py: lots of small fixes - Setup call make to build pykcs11_wrap.cpp using SWIG - Fix build on Windows - Small bugs fixed 1.3.1 - October 2015, Ludovic Rousseau - PKCS#11 definitions: sync with Cryptoki version 2.30 - Add user type CK_CONTEXT_SPECIFIC - Fixes #9, incorrect assignment of pParameter for CK_MECHANISMs. - CKA_DERIVE is a CK_BBOOL and not byte array - Add digest() and encrypt method to Session class - Add samples: - key-pair generation - key-pair generation + certificate import - printing public key modulus - computing signature - small bugs fixed 1.3.0 - July 2014, Ludovic Rousseau - add Python3 support 1.2.4 - April 2012, Ludovic Rousseau - improve epydoc documentation - add pinpad support in C_Login() using pin=None - add pinpad support in samples getinfo.py and dumpit.py - add createObject() 1.2.3 - December 2010, Ludovic Rousseau - Add new classes CK_SLOT_INFO, CK_INFO, CK_SESSION_INFO, CK_MECHANISM_INFO and CK_TOKEN_INFO instead of the low level ones to have a __repr__() method. It is now possible to just print an object of these classes and have a human readable version. - Add a new class CK_OBJECT_HANDLE() to replace the low level one and have a __repr__() method for objects returned by findObjects() - Move initToken() from class Session to class PyKCS11Lib and add a slot parameter. - Add generateKeyPair and destoryObject support in high level interface 1.2.2 - June 2010, Ludovic Rousseau - Debug low level C_GenerateRandom - Add seedRandom() and generateRandom() in the high level API 1.2.1 - November 2008, Ludovic Rousseau - Use src/opensc/pkcs11.h instead of src/rsaref/* files since the files from RSA are not free enough (no right to distribute modified versions for example) - improve samples/getinfo.py script - bug fixes 1.2.0 - August 2008, Ludovic Rousseau - add getMechanismList() and getMechanismInfo() - add Session().getSessionInfo() - bug fixes 1.1.1 - December 2006, Giuseppe Amato (Midori) - bug fixes 1.1.0 - August 2006, Ludovic Rousseau - Introduce high level API 1.0.2 - July 2006, Ludovic Rousseau - port to Unix (tested on GNU/Linux only) - explicit call to SWIG to generate the wrapper 1.0.1 - 2004 Giuseppe Amato (Midori) - first version - Windows only ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541146.592659 pykcs11-1.5.20/MANIFEST.in0000644000175100017510000000034215246574333014311 0ustar00runnerrunnerinclude src/* include src/opensc/* recursive-include samples *.py include Changes.txt include Makefile* include run_test.py include tox.ini include dev-requirements.txt include docs/* include COPYING include get_PYKCS11LIB.py ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541146.592659 pykcs11-1.5.20/Makefile0000644000175100017510000000233215246574333014214 0ustar00runnerrunner# give some default values ifeq (, $(PYTHON)) PYTHON=python3 endif COVERAGE ?= $(PYTHON) -m coverage build: $(PYTHON) -m build constants: $(PYTHON) generate_constants.py > constants.py mv constants.py src/PyKCS11/ install: $(PYTHON) -m pip install --editable . venv: rm -rf temp $(PYTHON) -m venv temp ./temp/bin/pip3 install -r dev-requirements.txt clean distclean: $(PYTHON) setup.py clean rm -f src/pykcs11_wrap.cpp rm -rf build rm -f *.pyc PyKCS11/*.pyc rm -f src/PyKCS11/LowLevel.py rm -f src/PyKCS11/_LowLevel* rm -f build-stamp rm -f test/*.pyc find . -name .DS_Store -exec rm {} \; src/pykcs11.i: src/opensc/pkcs11.h src/pkcs11lib.h src/pykcs11string.h src/ck_attribute_smart.h touch $@ pypi: clean rm -rf dist $(PYTHON) -m build $(PYTHON) -m twine upload dist/* test: $(PYTHON) run_pytest.py -v coverage: $(COVERAGE) erase $(COVERAGE) run run_test.py $(COVERAGE) report $(COVERAGE) html tox: ./get_PYKCS11LIB.py > tox.env tox -- -v pylint: $(PYTHON) -m pylint PyKCS11 $(PYTHON) -m pylint samples doc: cd docs ; ./generate.sh doc-upload: doc rm -rf api mv docs/_build/html api scp -r api ludov@web.sourceforge.net:/home/project-web/pkcs11wrap/htdocs .PHONY: build install clean doc test ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541149.979817 pykcs11-1.5.20/PKG-INFO0000644000175100017510000000302015246574336013647 0ustar00runnerrunnerMetadata-Version: 2.4 Name: pykcs11 Version: 1.5.20 Summary: A Full PKCS#11 wrapper for Python Home-page: https://github.com/LudovicRousseau/PyKCS11 Download-URL: http://sourceforge.net/projects/pkcs11wrap/files/pykcs11/ Author: Giuseppe Amato (Midori) Author-email: paipai@tiscali.it Maintainer: Ludovic Rousseau Maintainer-email: ludovic.rousseau@free.fr License: GPL-2.0-or-later Keywords: crypto,pki,pkcs11,c++ Platform: Win32 Unix Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Natural Language :: English Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: OS Independent Classifier: Operating System :: Unix Classifier: Programming Language :: C Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Topic :: Security :: Cryptography Classifier: Topic :: Software Development :: Libraries :: Python Modules License-File: COPYING Dynamic: author Dynamic: author-email Dynamic: classifier Dynamic: description Dynamic: download-url Dynamic: home-page Dynamic: keywords Dynamic: license Dynamic: license-file Dynamic: maintainer Dynamic: maintainer-email Dynamic: platform Dynamic: summary A complete PKCS#11 wrapper for Python. You can use any PKCS#11 (aka CryptoKi) module such as the PSM which comes as part of mozilla or the various modules supplied by vendors of hardware crypto tokens, and almost all PKCS#11 functions and data types. The wrapper has been generated with the help of the SWIG compiler. ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541146.592659 pykcs11-1.5.20/README.md0000644000175100017510000000334215246574333014035 0ustar00runnerrunnerPyKCS11 - PKCS#11 Wrapper for Python - Project Overview ======================================================= Authors ======= - Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) - Copyright (C) 2006-2018 Ludovic Rousseau (ludovic.rousseau@free.fr) Licence ======= This file is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Status ====== [![Coverage Status](https://coveralls.io/repos/github/LudovicRousseau/PyKCS11/badge.svg?branch=master)](https://coveralls.io/github/LudovicRousseau/PyKCS11?branch=master) API === The API documentation is available at https://pkcs11wrap.sourceforge.io/api/ Installation ============ pip install pykcs11 Unix build Howto ================ To build: python3 -m venv temp source temp/bin/activate pip3 install -r dev-requirements.txt make To install in editable mode: make install Windows build Howto =================== Prerequisites * Install python3 (and add "C:\Python34;C:\Python34\Scripts" to PATH environment variable) * Install swig (and add swig install folder to PATH environment variable) * Install Visual studio 2010 SDK To install: nmake install ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541146.592659 pykcs11-1.5.20/dev-requirements.txt0000644000175100017510000000007515246574333016616 0ustar00runnerrunnerasn1crypto build coverage coveralls pylint pytest setuptools ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9686477 pykcs11-1.5.20/docs/0000755000175100017510000000000015246574336013507 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541146.592659 pykcs11-1.5.20/docs/Makefile0000644000175100017510000000113515246574333015144 0ustar00runnerrunner# Minimal makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build SPHINXPROJ = PyKCS11 SOURCEDIR = . BUILDDIR = _build # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/docs/api.rst0000644000175100017510000000013515246574333015006 0ustar00runnerrunnerAPI documentation ***************** .. automodule:: PyKCS11 :members: :undoc-members: ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/docs/conf.py0000644000175100017510000001215515246574333015007 0ustar00runnerrunner# # Configuration file for the Sphinx documentation builder. # # This file does only contain a selection of the most common options. For a # full list see the documentation: # http://www.sphinx-doc.org/en/master/config # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # # import os # import sys # sys.path.insert(0, os.path.abspath('.')) # -- Project information ----------------------------------------------------- project = "PyKCS11" copyright = "2018, Giuseppe Amato (Midori), Ludovic Rousseau" author = "Giuseppe Amato (Midori), Ludovic Rousseau" # The short X.Y version version = "1.5" # The full version, including alpha/beta/rc tags release = "1.5.20" # -- General configuration --------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. # # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ "sphinx.ext.autodoc", "sphinx.ext.doctest", "sphinx.ext.coverage", "sphinx.ext.viewcode", "sphinx.ext.githubpages", "sphinx.ext.autosummary", ] # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] source_suffix = ".rst" # The master toctree document. master_doc = "index" # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = "en" # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path . exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] # The name of the Pygments (syntax highlighting) style to use. pygments_style = "sphinx" # Both the class’ and the __init__ method’s docstring are concatenated # and inserted. autoclass_content = "both" # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = "bizstyle" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # # html_theme_options = {} # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = [] # Custom sidebar templates, must be a dictionary that maps document names # to template names. # # The default sidebars (for documents that don't match any pattern) are # defined by theme itself. Builtin themes are using these templates by # default: ``['localtoc.html', 'relations.html', 'sourcelink.html', # 'searchbox.html']``. # # html_sidebars = {} # -- Options for HTMLHelp output --------------------------------------------- # Output file base name for HTML help builder. htmlhelp_basename = "PyKCS11doc" # -- Options for LaTeX output ------------------------------------------------ latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', # Additional stuff for the LaTeX preamble. # # 'preamble': '', # Latex figure (float) alignment # # 'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ ( master_doc, "PyKCS11.tex", "PyKCS11 Documentation", "Giuseppe Amato (Midori), Ludovic Rousseau", "manual", ), ] # -- Options for manual page output ------------------------------------------ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [(master_doc, "pykcs11", "PyKCS11 Documentation", [author], 1)] # -- Options for Texinfo output ---------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ( master_doc, "PyKCS11", "PyKCS11 Documentation", author, "PyKCS11", "One line description of project.", "Miscellaneous", ), ] # -- Extension configuration ------------------------------------------------- ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/docs/generate.sh0000755000175100017510000000043015246574333015632 0ustar00runnerrunner#!/bin/bash set -e cd $(dirname $0) # Enable a virtualenv before running the script to avoid modifying # the system Python libraries python3 -m venv tmp source tmp/bin/activate pip3 install sphinx setuptools (cd .. ; python3 -m pip install .) make html deactivate rm -r tmp ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/docs/index.rst0000644000175100017510000000163615246574333015353 0ustar00runnerrunner.. PyKCS11 documentation master file, created by sphinx-quickstart on Sat Jun 23 14:56:45 2018. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. Welcome to PyKCS11's documentation ================================== Download ******** The PyKCS11 project is available from different sources: * pypi https://pypi.org/project/pykcs11/ * github https://github.com/LudovicRousseau/PyKCS11 * sourceforge https://sourceforge.net/projects/pkcs11wrap/ Bug reports *********** Report bugs or issues on `github issues `_ Report patches as `github pull requests `_ API Documentation ***************** .. toctree:: :maxdepth: 4 :caption: Contents: api samples license Indices and tables ================== * :ref:`genindex` * :ref:`search` ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/docs/license.rst0000644000175100017510000000132415246574333015660 0ustar00runnerrunnerLicense ####### PyKCS11 is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. .. literalinclude:: ../COPYING ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/docs/samples.rst0000644000175100017510000000133515246574333015704 0ustar00runnerrunnerPyKCS11 samples codes ===================== Unblock a user PIN """""""""""""""""" .. literalinclude:: ../samples/unblock.py Generate a key pair """"""""""""""""""" .. literalinclude:: ../samples/generate.py Encrypt and decrypt """"""""""""""""""" .. literalinclude:: ../samples/encrypt.py Get token events """""""""""""""" .. literalinclude:: ../samples/events.py Get a public key modulus """""""""""""""""""""""" .. literalinclude:: ../samples/modulus.py RSA sign & verify """"""""""""""""" .. literalinclude:: ../samples/signature.py Get token information """"""""""""""""""""" .. literalinclude:: ../samples/getinfo.py Dump all the token objects """""""""""""""""""""""""" .. literalinclude:: ../samples/dumpit.py ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/get_PYKCS11LIB.py0000755000175100017510000000310115246574333015345 0ustar00runnerrunner#!/usr/bin/env python3 import os import sys def get_PYKCS11LIB(): # already configured if "PYKCS11LIB" in os.environ: return os.environ["PYKCS11LIB"] if "PKCS11SPY" in os.environ: # use OpenSC PKCS#11 spy if PKCS11SPY is defined as the PKCS#11 lib # to use LIBS = [ "/usr/local/lib/pkcs11-spy.so", # macOS or local build "/usr/lib/x86_64-linux-gnu/pkcs11-spy.so", # Debian amd64 "/usr/lib64/pkcs11/pkcs11-spy.so", # Fedora Linux ] else: if sys.maxsize > 2**32: # 64-bits WINDOWS_SOFTHSM = "c:/SoftHSM2/lib/softhsm2-x64.dll" else: # 32-bits WINDOWS_SOFTHSM = "c:/SoftHSM2/lib/softhsm2.dll" # use SoftHSM2 or SoftHSM1 LIBS = [ "/usr/local/lib/softhsm/libsofthsm2.so", # macOS or local build "/opt/homebrew/lib/softhsm/libsofthsm2.so", # macOS arm64 "/usr/lib/softhsm/libsofthsm2.so", # Debian libsofthsm2 "/usr/lib/softhsm/libsofthsm.so", # Debian libsofthsm "/usr/lib/libsofthsm.so", # Ubuntu 12.04 libsofthsm "/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so", # Ubuntu 16.04 libsofthsm2 "/usr/lib64/pkcs11/libsofthsm2.so", # Fedora Linux WINDOWS_SOFTHSM, # Windows ] for lib in LIBS: if os.path.isfile(lib): return lib raise Exception("PYKCS11LIB is not defined. No SoftHSM library found?") if __name__ == "__main__": lib = get_PYKCS11LIB() print(f"PYKCS11LIB={lib}") ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/pyproject.toml0000644000175100017510000000013115246574333015463 0ustar00runnerrunner[build-system] requires = ["setuptools", "swig"] build-backend = "setuptools.build_meta" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5935788 pykcs11-1.5.20/run_test.py0000755000175100017510000000101115246574333014765 0ustar00runnerrunner#!/usr/bin/env python3 # use: # ./run_test.py # ./run_test.py test_ckbytelist.py import os import sys import unittest import get_PYKCS11LIB pattern = "test*.py" if len(sys.argv) > 1: pattern = sys.argv[1] if __name__ == "__main__": lib = get_PYKCS11LIB.get_PYKCS11LIB() os.environ["PYKCS11LIB"] = lib tl = unittest.TestLoader() suite = tl.discover("test", pattern=pattern) result = unittest.TextTestRunner(verbosity=2).run(suite) if result.errors or result.failures: sys.exit(1) ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541149.971085 pykcs11-1.5.20/samples/0000755000175100017510000000000015246574336014223 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9719954 pykcs11-1.5.20/samples/LowLevel/0000755000175100017510000000000015246574336015754 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5942447 pykcs11-1.5.20/samples/LowLevel/InitTokenPin.py0000755000175100017510000000760615246574333020712 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # Copyright (C) 2018 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import os import PyKCS11.LowLevel a = PyKCS11.LowLevel.CPKCS11Lib() info = PyKCS11.LowLevel.CK_INFO() slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() lib = os.getenv("PYKCS11LIB") if lib is None: raise ValueError("Define PYKCS11LIB") session = PyKCS11.LowLevel.CK_SESSION_HANDLE() sessionInfo = PyKCS11.LowLevel.CK_SESSION_INFO() tokenInfo = PyKCS11.LowLevel.CK_TOKEN_INFO() slotList = PyKCS11.LowLevel.ckulonglist() pin = PyKCS11.LowLevel.ckbytelist(b"123456") puk = PyKCS11.LowLevel.ckbytelist(b"12345678") Label = "PyKCS#11 Initialized Token " print("Load of " + lib + ": " + str(a.Load(lib))) print("C_GetInfo: " + hex(a.C_GetInfo(info))) print("Library manufacturerID: " + info.GetManufacturerID()) del info print("C_GetSlotList(NULL): " + hex(a.C_GetSlotList(1, slotList))) print("\tAvailable Slots: " + str(len(slotList))) if len(slotList) != 0: print("\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slotList[0], slotInfo))) print("\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[0], tokenInfo))) print( "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() ) print( "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() ) print("\tC_InitToken(): " + hex(a.C_InitToken(slotList[0], puk, Label))) print("\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[0], tokenInfo))) print( "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() ) print( "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() ) print( "\tC_OpenSession(): " + hex( a.C_OpenSession( slotList[0], PyKCS11.LowLevel.CKF_SERIAL_SESSION | PyKCS11.LowLevel.CKF_RW_SESSION, session, ) ) ) print("\t\tSession:" + str(session)) print("\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo))) print( "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) ) print("\tC_Login(SO): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_SO, puk))) print("\tC_InitPIN(): " + hex(a.C_InitPIN(session, pin))) print("\tC_Logout(SO): " + hex(a.C_Logout(session))) print("\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slotList[0], tokenInfo))) print( "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() ) print( "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() ) print("C_Login(USER): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin))) print("C_Logout(USER): " + hex(a.C_Logout(session))) print("C_CloseSession(): " + hex(a.C_CloseSession(session))) print("C_Finalize(): " + hex(a.C_Finalize())) print(a.Unload()) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/LowLevel/dumpit.py0000755000175100017510000001405415246574333017634 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # Copyright (C) 2006-2018 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import os # pylint: disable=duplicate-code # pylint: disable=wildcard-import # pylint: disable=unused-wildcard-import from PyKCS11.LowLevel import * a = CPKCS11Lib() info = CK_INFO() slotInfo = CK_SLOT_INFO() lib = os.getenv("PYKCS11LIB") if lib is None: raise ValueError("Define PYKCS11LIB") session = CK_SESSION_HANDLE() sessionInfo = CK_SESSION_INFO() tokenInfo = CK_TOKEN_INFO() slotList = ckulonglist() pin = ckbytelist(b"1234") print("Load of " + lib + ": " + str(a.Load(lib))) print("C_GetInfo:", hex(a.C_GetInfo(info))) print("Library manufacturerID:", info.GetManufacturerID()) del info print("C_GetSlotList(NULL): " + hex(a.C_GetSlotList(0, slotList))) print("\tAvailable Slots: " + str(len(slotList))) for index, slot in enumerate(slotList): print("\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slot, slotInfo))) print( "\t\tSlot N." + str(index) + ": ID=" + str(slot) + ", name='" + slotInfo.GetSlotDescription() + "'" ) print( "\tC_OpenSession(): " + hex(a.C_OpenSession(slot, CKF_SERIAL_SESSION | CKF_RW_SESSION, session)) ) print("\t\tSession:" + str(session)) print("\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo))) print( "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) ) print("\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slot, tokenInfo))) print( "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() ) print( "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() ) print("\tC_Login(): " + hex(a.C_Login(session, CKU_USER, pin))) print("\tC_Logout(): " + hex(a.C_Logout(session))) print("\tC_CloseSession(): " + hex(a.C_CloseSession(session))) print( "C_OpenSession(): " + hex(a.C_OpenSession(slotList[0], CKF_SERIAL_SESSION, session)) ) print("C_Login(): " + hex(a.C_Login(session, CKU_USER, pin))) SearchResult = ckulonglist(10) SearchTemplate = ckattrlist(0) # SearchTemplate[0].SetNum(CKA_CLASS, CKO_CERTIFICATE) # SearchTemplate[1].SetBool(CKA_TOKEN, True) print("C_FindObjectsInit: " + hex(a.C_FindObjectsInit(session, SearchTemplate))) print("C_FindObjects: " + hex(a.C_FindObjects(session, SearchResult))) print("C_FindObjectsFinal: " + hex(a.C_FindObjectsFinal(session))) attributes = [ ["CKA_CLASS", CKA_CLASS], ["CKA_TOKEN", CKA_TOKEN], ["CKA_PRIVATE", CKA_PRIVATE], ["CKA_LABEL", CKA_LABEL], ["CKA_APPLICATION", CKA_APPLICATION], ["CKA_VALUE", CKA_VALUE], ["CKA_CERTIFICATE_TYPE", CKA_CERTIFICATE_TYPE], ["CKA_ISSUER", CKA_ISSUER], ["CKA_SERIAL_NUMBER", CKA_SERIAL_NUMBER], ["CKA_KEY_TYPE", CKA_KEY_TYPE], ["CKA_SUBJECT", CKA_SUBJECT], ["CKA_ID", CKA_ID], ["CKA_SENSITIVE", CKA_SENSITIVE], ["CKA_ENCRYPT", CKA_ENCRYPT], ["CKA_DECRYPT", CKA_DECRYPT], ["CKA_WRAP", CKA_WRAP], ["CKA_UNWRAP", CKA_UNWRAP], ["CKA_SIGN", CKA_SIGN], ["CKA_SIGN_RECOVER", CKA_SIGN_RECOVER], ["CKA_VERIFY", CKA_VERIFY], ["CKA_VERIFY_RECOVER", CKA_VERIFY_RECOVER], ["CKA_DERIVE", CKA_DERIVE], ["CKA_START_DATE", CKA_START_DATE], ["CKA_END_DATE", CKA_END_DATE], ["CKA_MODULUS", CKA_MODULUS], ["CKA_MODULUS_BITS", CKA_MODULUS_BITS], ["CKA_PUBLIC_EXPONENT", CKA_PUBLIC_EXPONENT], ["CKA_PRIVATE_EXPONENT", CKA_PRIVATE_EXPONENT], ["CKA_PRIME_1", CKA_PRIME_1], ["CKA_PRIME_2", CKA_PRIME_2], ["CKA_EXPONENT_1", CKA_EXPONENT_1], ["CKA_EXPONENT_2", CKA_EXPONENT_2], ["CKA_COEFFICIENT", CKA_COEFFICIENT], ["CKA_PRIME", CKA_PRIME], ["CKA_SUBPRIME", CKA_SUBPRIME], ["CKA_BASE", CKA_BASE], ["CKA_VALUE_BITS", CKA_VALUE_BITS], ["CKA_VALUE_LEN", CKA_VALUE_LEN], ["CKA_EXTRACTABLE", CKA_EXTRACTABLE], ["CKA_LOCAL", CKA_LOCAL], ["CKA_NEVER_EXTRACTABLE", CKA_NEVER_EXTRACTABLE], ["CKA_ALWAYS_SENSITIVE", CKA_ALWAYS_SENSITIVE], ["CKA_MODIFIABLE", CKA_MODIFIABLE], ["CKA_ECDSA_PARAMS", CKA_ECDSA_PARAMS], ["CKA_EC_POINT", CKA_EC_POINT], ] for x in SearchResult: print("object: " + hex(x.value())) valTemplate = ckattrlist(1) for attr in attributes: valTemplate[0].Reset() valTemplate[0].SetType(attr[1]) # first call to get the attribute size and reserve the memory a.C_GetAttributeValue(session, x, valTemplate) # second call to get the attribute value rv = a.C_GetAttributeValue(session, x, valTemplate) if rv == CKR_OK: print("\t" + attr[0] + ": ", end=" ") if valTemplate[0].IsNum(): print(valTemplate[0].GetNum()) if valTemplate[0].IsBool(): print(valTemplate[0].GetBool()) if valTemplate[0].IsString(): print(valTemplate[0].GetString()) if valTemplate[0].IsBin(): print("(" + str(valTemplate[0].GetLen()) + " bytes)", end=" ") print(list(map(hex, valTemplate[0].GetBin()))) print("C_Logout(): " + hex(a.C_Logout(session))) print("C_CloseSession(): " + hex(a.C_CloseSession(session))) print("C_Finalize(): " + hex(a.C_Finalize())) print(a.Unload()) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/LowLevel/rand.py0000755000175100017510000000417115246574333017255 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2010-2014 Ludovic Rousseau # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 # USA. """ import os import PyKCS11.LowLevel # pylint: disable=duplicate-code a = PyKCS11.LowLevel.CPKCS11Lib() info = PyKCS11.LowLevel.CK_INFO() slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() lib = os.getenv("PYKCS11LIB") if lib is None: # pylint: disable=broad-exception-raised raise ValueError("Define PYKCS11LIB") session = PyKCS11.LowLevel.CK_SESSION_HANDLE() slotList = PyKCS11.LowLevel.ckulonglist() rand = PyKCS11.LowLevel.ckbytelist(20) seed = PyKCS11.LowLevel.ckbytelist(5) print("Load of " + lib + ": " + str(a.Load(lib))) print("C_GetInfo: " + hex(a.C_GetInfo(info))) print("Library manufacturerID: " + info.GetManufacturerID()) del info print( "C_GetSlotList(CK_TRUE): " + hex(a.C_GetSlotList(PyKCS11.LowLevel.CK_TRUE, slotList)) ) print("\tAvailable Slots: " + str(len(slotList))) print( "C_OpenSession(): " + hex( a.C_OpenSession( slotList[0], PyKCS11.LowLevel.CKF_RW_SESSION | PyKCS11.LowLevel.CKF_SERIAL_SESSION, session, ) ) ) print(" ".join(f"{i:02X}" for i in seed)) print("C_SeedRandom(): " + hex(a.C_SeedRandom(session, seed))) print("C_GenerateRandom(): " + hex(a.C_GenerateRandom(session, rand))) print(" ".join(f"{i:02X}" for i in rand)) print("C_CloseSession(): " + hex(a.C_CloseSession(session))) print("C_Finalize(): " + hex(a.C_Finalize())) print(a.Unload()) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/LowLevel/test.py0000755000175100017510000001100415246574333017301 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # Copyright (C) 2018 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import os import PyKCS11.LowLevel from PyKCS11 import ckbytelist # pylint: disable=duplicate-code a = PyKCS11.LowLevel.CPKCS11Lib() info = PyKCS11.LowLevel.CK_INFO() slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() lib = os.getenv("PYKCS11LIB") if lib is None: raise ValueError("Define PYKCS11LIB") session = PyKCS11.LowLevel.CK_SESSION_HANDLE() sessionInfo = PyKCS11.LowLevel.CK_SESSION_INFO() tokenInfo = PyKCS11.LowLevel.CK_TOKEN_INFO() slotList = PyKCS11.LowLevel.ckulonglist() pin = ckbytelist("1234") print("Load of " + lib + ": " + str(a.Load(lib))) print("C_GetInfo: " + hex(a.C_GetInfo(info))) print("Library manufacturerID: " + info.GetManufacturerID()) del info print("C_GetSlotList(NULL): " + hex(a.C_GetSlotList(0, slotList))) print("\tAvailable Slots: " + str(len(slotList))) for index, slot in enumerate(slotList): print("\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slot, slotInfo))) print( "\t\tSlot N." + str(index) + ": ID=" + str(slot) + ", name='" + slotInfo.GetSlotDescription() + "'" ) print( "\tC_OpenSession(): " + hex( a.C_OpenSession( slot, PyKCS11.LowLevel.CKF_SERIAL_SESSION | PyKCS11.LowLevel.CKF_RW_SESSION, session, ) ) ) print("\t\tSession:" + str(session)) print("\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo))) print( "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) ) print("\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slot, tokenInfo))) print( "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() ) print( "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() ) print("\tC_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin))) print("\tC_Logout(): " + hex(a.C_Logout(session))) print("\tC_CloseSession(): " + hex(a.C_CloseSession(session))) print( "C_OpenSession(): " + hex(a.C_OpenSession(slotList[0], PyKCS11.LowLevel.CKF_SERIAL_SESSION, session)) ) print("C_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin))) SearchResult = PyKCS11.LowLevel.ckulonglist(10) SearchTemplate = PyKCS11.LowLevel.ckattrlist(2) SearchTemplate[0].SetNum(PyKCS11.LowLevel.CKA_CLASS, PyKCS11.LowLevel.CKO_CERTIFICATE) SearchTemplate[1].SetBool(PyKCS11.LowLevel.CKA_TOKEN, True) print("C_FindObjectsInit: " + hex(a.C_FindObjectsInit(session, SearchTemplate))) print("C_FindObjects: " + hex(a.C_FindObjects(session, SearchResult))) print("C_FindObjectsFinal: " + hex(a.C_FindObjectsFinal(session))) for x in SearchResult: print("object: " + hex(x.value())) valTemplate = PyKCS11.LowLevel.ckattrlist(2) valTemplate[0].SetType(PyKCS11.LowLevel.CKA_LABEL) # valTemplate[0].Reserve(128) valTemplate[1].SetType(PyKCS11.LowLevel.CKA_CLASS) # valTemplate[1].Reserve(4) print( "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) ) print( "CKA_LABEL Len: ", valTemplate[0].GetLen(), " CKA_CLASS Len: ", valTemplate[1].GetLen(), ) print( "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) ) print("\tCKO_CERTIFICATE: " + valTemplate[0].GetString()) print("\tCKA_TOKEN: " + str(valTemplate[1].GetNum())) print("C_Logout(): " + hex(a.C_Logout(session))) print("C_CloseSession(): " + hex(a.C_CloseSession(session))) print("C_Finalize(): " + hex(a.C_Finalize())) print(a.Unload()) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/LowLevel/test1.py0000755000175100017510000001127715246574333017376 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) # Copyright (C) 2018 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import os import PyKCS11.LowLevel from PyKCS11 import ckbytelist # pylint: disable=duplicate-code a = PyKCS11.LowLevel.CPKCS11Lib() info = PyKCS11.LowLevel.CK_INFO() slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() lib = os.getenv("PYKCS11LIB") if lib is None: raise ValueError("Define PYKCS11LIB") session = PyKCS11.LowLevel.CK_SESSION_HANDLE() sessionInfo = PyKCS11.LowLevel.CK_SESSION_INFO() tokenInfo = PyKCS11.LowLevel.CK_TOKEN_INFO() slotList = PyKCS11.LowLevel.ckulonglist() pin = ckbytelist("1234") print("Load of " + lib + ": " + str(a.Load(lib))) print("C_GetInfo: " + hex(a.C_GetInfo(info))) print("Library manufacturerID: " + info.GetManufacturerID()) del info print("C_GetSlotList(NULL): " + hex(a.C_GetSlotList(0, slotList))) print("\tAvailable Slots: " + str(len(slotList))) for index, slot in enumerate(slotList): print("\tC_SlotInfo(): " + hex(a.C_GetSlotInfo(slot, slotInfo))) print( "\t\tSlot N." + str(index) + ": ID=" + str(slot) + ", name='" + slotInfo.GetSlotDescription() + "'" ) print( "\tC_OpenSession(): " + hex( a.C_OpenSession( slot, PyKCS11.LowLevel.CKF_SERIAL_SESSION | PyKCS11.LowLevel.CKF_RW_SESSION, session, ) ) ) print("\t\tSession:" + str(session)) print("\tC_GetSessionInfo(): " + hex(a.C_GetSessionInfo(session, sessionInfo))) print( "\t\tSessionInfo: state=" + hex(sessionInfo.state) + ", flags=" + hex(sessionInfo.flags) ) print("\tC_GetTokenInfo(): " + hex(a.C_GetTokenInfo(slot, tokenInfo))) print( "\t\tTokenInfo: Label=" + tokenInfo.GetLabel() + ", ManufacturerID=" + tokenInfo.GetManufacturerID() ) print( "\t\tTokenInfo: flags=" + hex(tokenInfo.flags) + ", Model=" + tokenInfo.GetModel() ) print("\tC_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin))) print("\tC_Logout(): " + hex(a.C_Logout(session))) print("\tC_CloseSession(): " + hex(a.C_CloseSession(session))) print( "C_OpenSession(): " + hex( a.C_OpenSession( slotList[0], PyKCS11.LowLevel.CKF_RW_SESSION | PyKCS11.LowLevel.CKF_SERIAL_SESSION, session, ) ) ) print("C_Login(): " + hex(a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin))) SearchResult = PyKCS11.LowLevel.ckulonglist(10) SearchTemplate = PyKCS11.LowLevel.ckattrlist(2) SearchTemplate[0].SetNum(PyKCS11.LowLevel.CKA_CLASS, PyKCS11.LowLevel.CKO_CERTIFICATE) SearchTemplate[1].SetBool(PyKCS11.LowLevel.CKA_TOKEN, True) print("C_FindObjectsInit: " + hex(a.C_FindObjectsInit(session, SearchTemplate))) print("C_FindObjects: " + hex(a.C_FindObjects(session, SearchResult))) print("C_FindObjectsFinal: " + hex(a.C_FindObjectsFinal(session))) for x in SearchResult: print("object " + hex(x.value())) valTemplate = PyKCS11.LowLevel.ckattrlist(1) valTemplate[0].SetType(PyKCS11.LowLevel.CKA_ISSUER) # valTemplate[0].Reserve(128) print( "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) ) print("CKA_ISSUER Len: ", valTemplate[0].GetLen()) print( "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) ) binval = list(valTemplate[0].GetBin()) print("binval=", binval) binval[0] = 0 valTemplate[0].SetBin(PyKCS11.LowLevel.CKA_ISSUER, binval) binval = valTemplate[0].GetBin() # list(valTemplate[0].GetBin()) print("binval[0]=", binval[0]) binval[0] = 0 print( "C_SetAttributeValue(): " + hex(a.C_SetAttributeValue(session, x, valTemplate)) ) print("C_Logout(): " + hex(a.C_Logout(session))) print("C_CloseSession(): " + hex(a.C_CloseSession(session))) print("C_Finalize(): " + hex(a.C_Finalize())) print(a.Unload()) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/destroy_by_ID.py0000755000175100017510000000236215246574333017337 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2017 Ludovic Rousseau # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import PyKCS11 # the CKA_ID of the objects to destroy object_id = (0x22,) # slot PIN code pin = "1234" pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_RW_SESSION) session.login(pin) template = [(PyKCS11.CKA_ID, object_id)] objects = session.findObjects(template) for obj in objects: print(obj) session.destroyObject(obj) session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/dumpit.py0000755000175100017510000001630315246574333016102 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2006-2014 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import getopt import platform import sys import PyKCS11 # from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/142812 # Title: Hex dumper # Submitter: Sebastien Keim (other recipes) # Last Updated: 2002/08/05 # Version no: 1.0 def dump(src, length=16): """dump a binary buffer""" def to_ascii(x): if 32 <= x <= 127: return chr(x) return "." N = 0 result = "" while src: h, src = src[:length], src[length:] text_hexa = " ".join([f"{x:02X}" for x in h]) text_ascii = "".join(map(to_ascii, h)) result += f"{N:04X} {text_hexa:{length * 3}} {text_ascii}\n" N += length return result def usage(): """usage""" print("Usage:", sys.argv[0], end=" ") print("[-a][--all]", end=" ") print("[-p pin][--pin=pin] (use --pin=NULL for pinpad)", end=" ") print("[-c lib][--lib=lib]", end=" ") print("[-s slot][--slot=slot]", end=" ") print("[-h][--help]", end=" ") print() try: opts, args = getopt.getopt( sys.argv[1:], "p:c:Sdhs:a", ["pin=", "lib=", "slot=", "help", "all"], ) except getopt.GetoptError: # print help information and exit: usage() sys.exit(2) pin_available = False lib = None slot = None token_present = True for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() elif o in ("-p", "--pin"): pin = a if pin == "NULL": pin = None pin_available = True elif o in ("-c", "--lib"): lib = a print("using PKCS11 lib:", lib) elif o in ("-s", "--slot"): slot = int(a) if o in ("-a", "--all"): token_present = False red = blue = magenta = normal = "" if sys.stdout.isatty() and platform.system().lower() != "windows": red = "\x1b[01;31m" blue = "\x1b[34m" magenta = "\x1b[35m" normal = "\x1b[0m" format_long = magenta + " %s:" + blue + " %s (%s)" + normal format_binary = magenta + " %s:" + blue + " %d bytes" + normal format_normal = magenta + " %s:" + blue + " %s" + normal pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load(lib) info = pkcs11.getInfo() print("Library manufacturerID:", info.manufacturerID) slots = pkcs11.getSlotList(token_present) print("Available Slots:", len(slots), slots) if slot is not None: slots = [slots[slot]] print("Using slot:", slots[0]) for s in slots: try: i = pkcs11.getSlotInfo(s) print("Slot no:", s) print(format_normal % ("slotDescription", i.slotDescription.strip())) print(format_normal % ("manufacturerID ", i.manufacturerID.strip())) print(format_normal % ("hardwareVersion", i.hardwareVersion)) print(format_normal % ("firmwareVersion", i.firmwareVersion)) print(format_normal % ("flags ", ", ".join(i.flags2text()))) if not i.flags & PyKCS11.CKF_TOKEN_PRESENT: print(" Token not present") continue t = pkcs11.getTokenInfo(s) print("TokenInfo") print(format_normal % ("label", t.label.strip())) print(format_normal % ("manufacturerID", t.manufacturerID.strip())) print(format_normal % ("model", t.model.strip())) session = pkcs11.openSession(s) print(f"Opened session 0x{session.session.value():08X}") if pin_available: try: if (pin is None) and ( PyKCS11.CKF_PROTECTED_AUTHENTICATION_PATH & t.flags ): print(f"\nEnter your PIN for {t.label.strip()} on the pinpad") session.login(pin=pin) except PyKCS11.PyKCS11Error as e: print("login failed, exception:", e) break objects = session.findObjects() print() print(f"Found {len(objects)} objects: {[x.value() for x in objects]}") all_attributes = list(PyKCS11.CKA.keys()) # remove the CKR_ATTRIBUTE_SENSITIVE attributes since we can't get # their values and will get an exception instead all_attributes.remove(PyKCS11.CKA_PRIVATE_EXPONENT) all_attributes.remove(PyKCS11.CKA_PRIME_1) all_attributes.remove(PyKCS11.CKA_PRIME_2) all_attributes.remove(PyKCS11.CKA_EXPONENT_1) all_attributes.remove(PyKCS11.CKA_EXPONENT_2) all_attributes.remove(PyKCS11.CKA_COEFFICIENT) # only use the integer values and not the strings like 'CKM_RSA_PKCS' all_attributes = [e for e in all_attributes if isinstance(e, int)] n_obj = 1 for o in objects: print() print( ( red + "==================== Object: %d/%d (%d) ====================" + normal ) % (n_obj, len(objects), o.value()) ) n_obj += 1 try: attributes = session.getAttributeValue(o, all_attributes) except PyKCS11.PyKCS11Error as e: print("getAttributeValue failed:", e) continue attrDict = dict(list(zip(all_attributes, attributes))) print("Dumping attributes:") for q, a in zip(all_attributes, attributes): if a is None: # undefined (CKR_ATTRIBUTE_TYPE_INVALID) attribute continue if q == PyKCS11.CKA_CLASS: print(format_long % (PyKCS11.CKA[q], PyKCS11.CKO[a], a)) elif q == PyKCS11.CKA_CERTIFICATE_TYPE: print(format_long % (PyKCS11.CKA[q], PyKCS11.CKC[a], a)) elif q == PyKCS11.CKA_KEY_TYPE: print(format_long % (PyKCS11.CKA[q], PyKCS11.CKK[a], a)) elif session.isBin(q): print(format_binary % (PyKCS11.CKA[q], len(a))) if a: print(dump(a), end="") elif q == PyKCS11.CKA_SERIAL_NUMBER: print(format_binary % (PyKCS11.CKA[q], len(a))) if a: print(dump(a), end="") else: print(format_normal % (PyKCS11.CKA[q], a)) print() if pin_available: try: session.logout() except PyKCS11.PyKCS11Error as e: print("logout failed, exception:", e) break session.closeSession() except PyKCS11.PyKCS11Error as e: print("Error:", e) raise ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/ec_generate.py0000755000175100017510000000446115246574333017043 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2019 Atte Pellikka # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ from asn1crypto.keys import ECDomainParameters, NamedCurve import PyKCS11 pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION) session.login("1234") key_id = (0x22,) label = "test" # Select the curve to be used for the keys curve = "secp256r1" # Setup the domain parameters, unicode conversion needed for the curve string domain_params = ECDomainParameters(name="named", value=NamedCurve(curve)) ec_params = domain_params.dump() ec_public_tmpl = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_EC_PARAMS, ec_params), (PyKCS11.CKA_LABEL, label), (PyKCS11.CKA_ID, key_id), ] ec_priv_tmpl = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, label), (PyKCS11.CKA_ID, key_id), ] pub_key, priv_key = session.generateKeyPair( ec_public_tmpl, ec_priv_tmpl, mecha=PyKCS11.MechanismECGENERATEKEYPAIR ) session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/ec_signature.py0000755000175100017510000000376715246574333017262 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2015 Roman Pasechnik # Copyright (C) 2018 Ludovic Rousseau # Copyright (C) 2019 Atte Pellikka # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import binascii import PyKCS11 # pylint: disable=duplicate-code pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() # define environment variable PYKCS11LIB=YourPKCS11Lib # get 1st slot slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION) session.login("1234") priv_search_tmpl = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), ] pub_search_tmpl = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), ] # "Hello world" in hex toSign = "48656c6c6f20776f726c640d0a" mechanism = PyKCS11.Mechanism(PyKCS11.CKM_ECDSA, None) # find first private key and compute signature privKey = session.findObjects(priv_search_tmpl)[0] signature = session.sign(privKey, binascii.unhexlify(toSign), mechanism) print(f"\nsignature: {binascii.hexlify(bytearray(signature))}") # find first public key and verify signature pubKey = session.findObjects(pub_search_tmpl)[0] result = session.verify(pubKey, binascii.unhexlify(toSign), signature, mechanism) print("\nVerified:", result) # logout session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/encrypt.py0000755000175100017510000000316115246574333016262 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2015 Roman Pasechnik # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import binascii import PyKCS11 # pylint: disable=duplicate-code pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() # define environment variable PYKCS11LIB=YourPKCS11Lib # get 1st slot slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION) session.login("1234") # "Hello world" in hex message = "48656c6c6f20776f726c640d0a" # get first public and private keys pubKey = session.findObjects([(PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY)])[0] privKey = session.findObjects([(PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY)])[0] enc = session.encrypt(pubKey, binascii.unhexlify(message)) dec = session.decrypt(privKey, enc) print("\nmessage: " + message) print(f"\nencrypted: {binascii.hexlify(bytearray(enc))}") print(f"\ndecrypted: {bytearray(dec)}") # logout session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/events.py0000755000175100017510000000533715246574333016111 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2009-2014 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import getinfo import PyKCS11 if __name__ == "__main__": import getopt import sys def usage(): """usage""" print("Usage:", sys.argv[0], end=" ") print("[-p pin][--pin=pin] (use 'NULL' for pinpad)", end=" ") print("[-c lib][--lib=lib]", end=" ") print("[-h][--help]", end=" ") print("[-o][--opensession]") print("[-f][--full]") try: opts, args = getopt.getopt( sys.argv[1:], "p:c:homf", ["pin=", "lib=", "help", "opensession", "mechanisms", "full"], ) except getopt.GetoptError: # print help information and exit: usage() sys.exit(2) lib = None pin = "" open_session = False pin_available = False list_mechanisms = False full = False for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() if o in ("-p", "--pin"): pin = a if pin == "NULL": pin = None pin_available = True open_session = True if o in ("-c", "--lib"): lib = a if o in ("-o", "--opensession"): open_session = True if o in ("-m", "--mechanisms"): list_mechanisms = True if o in ("-f", "--full"): full = True gi = getinfo.getInfo(lib) gi.getInfo() slots = gi.pkcs11.getSlotList() print("Available Slots:", len(slots), slots) if len(slots) == 0: sys.exit(2) while True: print("waiting...") slot = gi.pkcs11.waitForSlotEvent() try: print(f"Slot {slot} changed") gi.getSlotInfo(slot, 0, len(slots)) if full: gi.getSessionInfo(slot, pin) gi.getTokenInfo(slot) if list_mechanisms: gi.getMechanismInfo(slot) except PyKCS11.PyKCS11Error as e: print("Error:", e) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/generate.py0000755000175100017510000000414415246574333016372 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2015 Roman Pasechnik # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import PyKCS11 # pylint: disable=duplicate-code # the key_id has to be the same for both objects key_id = (0x22,) pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() # define environment variable PYKCS11LIB=YourPKCS11Lib # get 1st slot slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION) session.login("1234") pubTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_MODULUS_BITS, 0x0400), (PyKCS11.CKA_PUBLIC_EXPONENT, (0x01, 0x00, 0x01)), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "My Public Key"), (PyKCS11.CKA_ID, key_id), ] privTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_ID, key_id), ] pubKey, privKey = session.generateKeyPair(pubTemplate, privTemplate) # logout session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/genkeypair_import_cert.py0000755000175100017510000001121215246574333021337 0ustar00runnerrunner#!/usr/bin/env python3 """ # contributed by Alex Railean, a dot railean at dekart.com # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import PyKCS11 # pylint: disable=duplicate-code pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() # define environment variable PYKCS11LIB=YourPKCS11Lib slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_RW_SESSION) pin = "1234" session.login(pin, PyKCS11.CKU_USER) # ############ key-pair generation ########################## # The first step in the process is to create the key-templates. See PKCS#11 # `10.8 Public key objects` to learn which attributes are available. Section # 10.9 covers private keys. label = "pkcs_is_fun" # just a label for identifying objects key_length = 2048 # key-length in bits # the key_id has to be the same for both objects, it will also be necessary # when importing the certificate, to ensure it is linked with these keys. key_id = (0x01,) public_template = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_RSA), (PyKCS11.CKA_VERIFY_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, label), (PyKCS11.CKA_MODULUS_BITS, key_length), (PyKCS11.CKA_ID, key_id), ] private_template = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, label), (PyKCS11.CKA_ID, key_id), ] session.generateKeyPair(public_template, private_template) # ############# the keys were generated and stored on the card ############### # At this point your keys are in the card, the private key is marked as # non-exportable. # To add a certificate, you have to prepare a CSR in PKCS#10 format and sign # it with the key. # It can be done with OpenSSL by typing the commands below in a terminal # 1. openssl # 2. engine dynamic -pre SO_PATH:/usr/lib/engines/engine_pkcs11.so -pre # ID:pkcs11 -pre LIST_ADD:1 -pre LOAD -pre MODULE_PATH:libacospkcs11.so # 3. req -engine pkcs11 -keyform engine -key 0:1 -new -text -out # /tmp/newcert.csr -subj "/O=users/CN=Test User" # Note that `-key 0:1` means "use slot 0, with key id 1" # The CSR will be printed to stdout and saved to /tmp/newcert.csr # The CSR is sent to a CA, which will issue a certificate and send it back. # Once you have the certificate, it has to be converted to BER (if it isn't # already). It will be assumed that the raw data of the certificate are in # `cert`. cert = b"replace this with the raw certificate itself" subject = b"foobar" # keep in mind that certain elements, such as the subject, must not be # passed as a string, but as an ASN1-encoded structure. Consider using # pyasn1 to do that, see http://pyasn1.sourceforge.net/ cert_template = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_CERTIFICATE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_LABEL, label), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_CERTIFICATE_TYPE, PyKCS11.CKC_X_509), (PyKCS11.CKA_MODIFIABLE, PyKCS11.CK_TRUE), (PyKCS11.CKA_VALUE, cert), # must be BER-encoded ( PyKCS11.CKA_SUBJECT, subject, ), # must be set and DER, see Table 24, X.509 Certificate Object Attributes ( PyKCS11.CKA_ID, key_id, ), # must be set, and DER see Table 24, X.509 Certificate Object Attributes ] # create the certificate object session.createObject(cert_template) # logout session.logout() session.closeSession() # At this point the certificate is on the card too. Some GUI tools # might display it as invalid, in that case make sure that the # entire certificate chain is available in the certificate store. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/getinfo.py0000755000175100017510000001235215246574333016233 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2006-2014 Ludovic Rousseau (ludovic.rousseau@free.fr) # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import getopt import platform import sys import PyKCS11 # pylint: disable=duplicate-code # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring class getInfo: red = blue = magenta = normal = "" def colorize(self, text, arg): print(self.magenta + text + self.blue, arg, self.normal) def display(self, obj, indent=""): dico = obj.to_dict() for key in sorted(dico.keys()): ck_type = obj.fields[key] left = indent + key + ":" if ck_type == "flags": self.colorize(left, ", ".join(dico[key])) elif ck_type == "pair": p1, p2 = dico[key] self.colorize(left, f"{p1}.{p2}") else: self.colorize(left, dico[key]) def __init__(self, lib=None): if sys.stdout.isatty() and platform.system().lower() != "windows": self.red = "\x1b[01;31m" self.blue = "\x1b[34m" self.magenta = "\x1b[35m" self.normal = "\x1b[0m" self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load(lib) def getSlotInfo(self, slot, slot_index, nb_slots): print() print(self.red + f"Slot {slot_index}/{nb_slots} (number {slot}):" + self.normal) self.display(self.pkcs11.getSlotInfo(slot), " ") def getTokenInfo(self, slot): print(" TokenInfo") self.display(self.pkcs11.getTokenInfo(slot), " ") def getMechanismInfo(self, slot): print(" Mechanism list: ") m = self.pkcs11.getMechanismList(slot) for x in m: self.colorize(" ", x) i = self.pkcs11.getMechanismInfo(slot, x) if not i.flags & PyKCS11.CKF_DIGEST: if i.ulMinKeySize != PyKCS11.CK_UNAVAILABLE_INFORMATION: self.colorize(" ulMinKeySize:", i.ulMinKeySize) if i.ulMaxKeySize != PyKCS11.CK_UNAVAILABLE_INFORMATION: self.colorize(" ulMaxKeySize:", i.ulMaxKeySize) self.colorize(" flags:", ", ".join(i.flags2text())) def getInfo(self): self.display(self.pkcs11.getInfo()) def getSessionInfo(self, slot, pin=""): print(" SessionInfo", end=" ") session = self.pkcs11.openSession(slot) if pin != "": if pin is None: print("(using pinpad)") else: print(f"(using pin: {pin})") session.login(pin) else: print() self.display(session.getSessionInfo(), " ") if pin: session.logout() def usage(): print("Usage:", sys.argv[0], end=" ") print("[-a][--all]", end=" ") print("[-p pin][--pin=pin] (use 'NULL' for pinpad)", end=" ") print("[-s slot][--slot=slot]", end=" ") print("[-c lib][--lib=lib]", end=" ") print("[-m][--mechanisms]", end=" ") print("[-h][--help]") def main(opts): # pylint: disable=too-many-branches slot = None lib = None pin = "" token_present = True list_mechanisms = False for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() if o in ("-p", "--pin"): pin = a if pin == "NULL": pin = None if o in ("-s", "--slot"): slot = int(a) if o in ("-c", "--lib"): lib = a if o in ("-a", "--all"): token_present = False if o in ("-m", "--mechanisms"): list_mechanisms = True gi = getInfo(lib) gi.getInfo() slots = gi.pkcs11.getSlotList(token_present) print("Available Slots:", len(slots), slots) if len(slots) == 0: sys.exit(2) if slot is not None: slots = [slots[slot]] print("Using slot:", slots[0]) slot_index = 0 nb_slots = len(slots) for slot in slots: slot_index += 1 try: gi.getSlotInfo(slot, slot_index, nb_slots) gi.getSessionInfo(slot, pin) gi.getTokenInfo(slot) if list_mechanisms: gi.getMechanismInfo(slot) except PyKCS11.PyKCS11Error as e: print("Error:", e) if __name__ == "__main__": try: options, args = getopt.getopt( sys.argv[1:], "p:s:c:ham", ["pin=", "slot=", "lib=", "help", "all", "mechanisms"], ) except getopt.GetoptError: # print help information and exit: usage() sys.exit(2) main(options) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/modulus.py0000755000175100017510000000302415246574333016264 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2015 Roman Pasechnik # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import binascii from PyKCS11 import ( CKA_CLASS, CKA_ID, CKA_MODULUS, CKF_RW_SESSION, CKF_SERIAL_SESSION, CKO_PUBLIC_KEY, PyKCS11Lib, ) pkcs11 = PyKCS11Lib() pkcs11.load() # define environment variable PYKCS11LIB=YourPKCS11Lib # get 1st slot slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, CKF_SERIAL_SESSION | CKF_RW_SESSION) session.login("1234") # key ID in hex (has to be tuple, that's why trailing comma) keyID = (0x22,) # find public key and print modulus pubKey = session.findObjects([(CKA_CLASS, CKO_PUBLIC_KEY), (CKA_ID, keyID)])[0] modulus = session.getAttributeValue(pubKey, [CKA_MODULUS])[0] print(f"\nmodulus: {binascii.hexlify(bytearray(modulus))}") # logout session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/rsa_encrypt.py0000755000175100017510000000450115246574333017126 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2015 Roman Pasechnik # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import PyKCS11 # pylint: disable=duplicate-code pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() # define environment variable PYKCS11LIB=YourPKCS11Lib # get 1st slot slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION) session.login("1234") pubTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_MODULUS_BITS, 2048), (PyKCS11.CKA_PUBLIC_EXPONENT, (0x01, 0x00, 0x01)), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "Encryption key"), (PyKCS11.CKA_ID, (0x43,)), ] privTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_ID, (0x43,)), ] pubKey, privKey = session.generateKeyPair(pubTemplate, privTemplate) PLAINTEXT = "A test string" mech = PyKCS11.RSAOAEPMechanism(PyKCS11.CKM_SHA_1, PyKCS11.CKG_MGF1_SHA1) ciphertext = session.encrypt(pubKey, PLAINTEXT, mech) decrypted = "".join([chr(i) for i in session.decrypt(privKey, ciphertext, mech)]) assert decrypted == PLAINTEXT session.logout() session.closeSession() print("That's all folks!") ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/signature.py0000755000175100017510000000351315246574333016600 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2015 Roman Pasechnik # Copyright (C) 2018 Ludovic Rousseau # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import binascii from PyKCS11 import ( CKA_CLASS, CKF_RW_SESSION, CKF_SERIAL_SESSION, CKM_SHA256_RSA_PKCS, CKO_PRIVATE_KEY, CKO_PUBLIC_KEY, Mechanism, PyKCS11Lib, ) # pylint: disable=duplicate-code pkcs11 = PyKCS11Lib() pkcs11.load() # define environment variable PYKCS11LIB=YourPKCS11Lib # get 1st slot slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, CKF_SERIAL_SESSION | CKF_RW_SESSION) session.login("1234") # message to sign toSign = "Hello World!" mechanism = Mechanism(CKM_SHA256_RSA_PKCS, None) # find first private key and compute signature privKey = session.findObjects([(CKA_CLASS, CKO_PRIVATE_KEY)])[0] signature = session.sign(privKey, toSign, mechanism) print(f"\nsignature: {binascii.hexlify(bytearray(signature))}") # find first public key and verify signature pubKey = session.findObjects([(CKA_CLASS, CKO_PUBLIC_KEY)])[0] result = session.verify(pubKey, toSign, signature, mechanism) print("\nVerified:", result) # logout session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/samples/unblock.py0000755000175100017510000000210715246574333016232 0ustar00runnerrunner#!/usr/bin/env python3 """ # Copyright (C) 2006-2014 Ludovic Rousseau # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ import PyKCS11 pin = "1234" puk = "1234" pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession(slot, PyKCS11.CKF_RW_SESSION) session.login(puk, PyKCS11.CKU_SO) session.initPin(pin) session.logout() session.closeSession() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9800937 pykcs11-1.5.20/setup.cfg0000644000175100017510000000004615246574336014400 0ustar00runnerrunner[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5943372 pykcs11-1.5.20/setup.py0000644000175100017510000000626415246574333014276 0ustar00runnerrunnerimport platform import shutil from os import path from shutil import which from sys import version_info as pyver from setuptools import Extension, setup from setuptools.command.build_py import build_py description = """A complete PKCS#11 wrapper for Python. You can use any PKCS#11 (aka CryptoKi) module such as the PSM which comes as part of mozilla or the various modules supplied by vendors of hardware crypto tokens, and almost all PKCS#11 functions and data types. The wrapper has been generated with the help of the SWIG compiler.""" classifiers = [ "Development Status :: 5 - Production/Stable", "Intended Audience :: Developers", "Natural Language :: English", "Operating System :: Microsoft :: Windows", "Operating System :: OS Independent", "Operating System :: Unix", "Programming Language :: C", "Programming Language :: C++", "Programming Language :: Python", "Topic :: Security :: Cryptography", "Topic :: Software Development :: Libraries :: Python Modules", ] lib_dirs = [] inc_dirs = ["src"] # some OS, such as FreeBSD, uses /usr/local folders if path.exists("/usr/local"): lib_dirs.append("/usr/local/lib") inc_dirs.append("/usr/local/include") source_files = [ "src/ck_attribute_smart.cpp", "src/pkcs11lib.cpp", "src/pykcs11string.cpp", "src/utility.cpp", "src/pykcs11.i", "src/pykcs11.cpp", ] define_macros = [] extra_compile_args = [] extra_link_args = [] if platform.system().lower() == "windows": source_files.append("src/dyn_win32.c") libraries_val = ["python%d%d" % pyver[:2]] extra_compile_args = ["/Fdvc70.pdb", "/Zi", "/GR", "/EHsc", "/std:c++20"] extra_link_args = [ "/DEBUG", "/PDB:_LowLevel.pdb", "/SUBSYSTEM:WINDOWS", "/OPT:REF", "/OPT:ICF", ] else: source_files.append("src/dyn_unix.c") libraries_val = [] class MyBuild(build_py): def run(self): if which("swig") is None: print("Install swig and try again") print("") exit(1) self.run_command("build_ext") build_py.run(self) setup( name="pykcs11", version="1.5.20", description="A Full PKCS#11 wrapper for Python", keywords="crypto,pki,pkcs11,c++", classifiers=classifiers, platforms="Win32 Unix", long_description=description, author="Giuseppe Amato (Midori)", author_email="paipai@tiscali.it", maintainer="Ludovic Rousseau", maintainer_email="ludovic.rousseau@free.fr", url="https://github.com/LudovicRousseau/PyKCS11", download_url="http://sourceforge.net/projects/pkcs11wrap/files/pykcs11/", license="GPL-2.0-or-later", cmdclass={"build_py": MyBuild}, package_dir={"": "src"}, ext_modules=[ Extension( name="PyKCS11._LowLevel", sources=source_files, include_dirs=inc_dirs, library_dirs=lib_dirs, libraries=libraries_val, define_macros=define_macros, swig_opts=["-c++", "-outdir", "src/PyKCS11"], extra_compile_args=extra_compile_args, extra_link_args=extra_link_args, ) ], py_modules=["PyKCS11.__init__", "PyKCS11.LowLevel", "PyKCS11.constants"], ) ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541149.974584 pykcs11-1.5.20/src/0000755000175100017510000000000015246574336013346 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9749603 pykcs11-1.5.20/src/PyKCS11/0000755000175100017510000000000015246574336014441 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5954602 pykcs11-1.5.20/src/PyKCS11/__init__.py0000644000175100017510000017721715246574333016566 0ustar00runnerrunner""" Copyright (C) 2006-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) Copyright (C) 2010 Giuseppe Amato (additions to original interface) This file is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. """ # pylint: disable=too-many-lines import os import threading import PyKCS11.LowLevel from .constants import * # special CKR[] values CKR[-4] = "C_GetFunctionList() not found" CKR[-3] = "Unknown format" CKR[-2] = "Unkown PKCS#11 type" CKR[-1] = "Load" class ckbytelist(PyKCS11.LowLevel.ckbytelist): """ add a __repr__() method to the LowLevel equivalent """ def __init__(self, data=None): if data is None: data = 0 elif isinstance(data, str): data = data.encode("utf-8") elif isinstance(data, (bytes, list, ckbytelist)): data = bytes(data) else: raise PyKCS11.PyKCS11Error(-3, text=str(type(data))) super().__init__(data) def __repr__(self): """ return the representation of a tuple the __str__ method will use it also """ rep = [int(elt) for elt in self] return repr(rep) def __add__(self, b): return ckbytelist(bytes(self) + bytes(b)) class CK_OBJECT_HANDLE(PyKCS11.LowLevel.CK_OBJECT_HANDLE): """ add a __repr__() method to the LowLevel equivalent """ def __init__(self, session): PyKCS11.LowLevel.CK_OBJECT_HANDLE.__init__(self) self.session = session def to_dict(self): """ convert the fields of the object into a dictionnary """ # all the attibutes defined by PKCS#11 all_attributes = PyKCS11.CKA.keys() # only use the integer values and not the strings like 'CKM_RSA_PKCS' all_attributes = [attr for attr in all_attributes if isinstance(attr, int)] # all the attributes of the object attributes = self.session.getAttributeValue(self, all_attributes) dico = {} for key, attr in zip(all_attributes, attributes): if attr is None: continue if key == CKA_CLASS: dico[PyKCS11.CKA[key]] = PyKCS11.CKO[attr] elif key == CKA_CERTIFICATE_TYPE: dico[PyKCS11.CKA[key]] = PyKCS11.CKC[attr] elif key == CKA_KEY_TYPE: dico[PyKCS11.CKA[key]] = PyKCS11.CKK[attr] else: dico[PyKCS11.CKA[key]] = attr return dico def __repr__(self): """ text representation of the object """ dico = self.to_dict() lines = [] for key in sorted(dico.keys()): lines.append(f"{key}: {dico[key]}") return "\n".join(lines) class CkClass: """ Base class for CK_* classes """ # dictionnary of integer_value: text_value for the flags bits flags_dict = {} # dictionnary of fields names and types # type can be "pair", "flags" or "text" fields = {} flags = 0 def flags2text(self): """ parse the `self.flags` field and create a list of `CKF_*` strings corresponding to bits set in flags :return: a list of strings :rtype: list """ r = [] for k, v in self.flags_dict.items(): if self.flags & k: r.append(v) return r def state2text(self): """ Dummy method. Will be overwriden if necessary """ return "" def to_dict(self): """ convert the fields of the object into a dictionnary """ dico = {} for field in self.fields: if field == "flags": dico[field] = self.flags2text() elif field == "state": dico[field] = self.state2text() else: dico[field] = self.__dict__[field] return dico def __str__(self): """ text representation of the object """ dico = self.to_dict() lines = [] for key in sorted(dico.keys()): ck_type = self.fields[key] if ck_type == "flags": flags = ", ".join(dico[key]) lines.append(f"{key}: {flags}") elif ck_type == "pair": p1, p2 = dico[key] lines.append(f"{key}: {p1}.{p2}") else: lines.append(f"{key}: {dico[key]}") return "\n".join(lines) class CK_SLOT_INFO(CkClass): """ matches the PKCS#11 CK_SLOT_INFO structure :ivar slotDescription: blank padded :type slotDescription: string :ivar manufacturerID: blank padded :type manufacturerID: string :ivar flags: See :func:`CkClass.flags2text` :type flags: integer :ivar hardwareVersion: 2 elements list :type hardwareVersion: list :ivar firmwareVersion: 2 elements list :type firmwareVersion: list """ flags_dict = { CKF_TOKEN_PRESENT: "CKF_TOKEN_PRESENT", CKF_REMOVABLE_DEVICE: "CKF_REMOVABLE_DEVICE", CKF_HW_SLOT: "CKF_HW_SLOT", } fields = { "slotDescription": "text", "manufacturerID": "text", "flags": "flags", "hardwareVersion": "text", "firmwareVersion": "text", } def __init__(self): self.slotDescription = None self.manufacturerID = None self.flags = None self.hardwareVersion = None self.firmwareVersion = None class CK_INFO(CkClass): """ matches the PKCS#11 CK_INFO structure :ivar cryptokiVersion: Cryptoki interface version :type cryptokiVersion: integer :ivar manufacturerID: blank padded :type manufacturerID: string :ivar flags: must be zero :type flags: integer :ivar libraryDescription: blank padded :type libraryDescription: string :var libraryVersion: 2 elements list :type libraryVersion: list """ fields = { "cryptokiVersion": "pair", "manufacturerID": "text", "flags": "flags", "libraryDescription": "text", "libraryVersion": "pair", } def __init__(self): self.cryptokiVersion = None self.manufacturerID = None self.flags = None self.libraryDescription = None self.libraryVersion = None class CK_SESSION_INFO(CkClass): """ matches the PKCS#11 CK_SESSION_INFO structure :ivar slotID: ID of the slot that interfaces with the token :type slotID: integer :ivar state: state of the session :type state: integer :ivar flags: bit flags that define the type of session :type flags: integer :ivar ulDeviceError: an error code defined by the cryptographic token :type ulDeviceError: integer """ flags_dict = { CKF_RW_SESSION: "CKF_RW_SESSION", CKF_SERIAL_SESSION: "CKF_SERIAL_SESSION", } def __init__(self): self.slotID = None self.state = None self.flags = None self.ulDeviceError = None def state2text(self): """ parse the `self.state` field and return a `CKS_*` string corresponding to the state :return: a string :rtype: string """ return CKS[self.state] fields = { "slotID": "text", "state": "text", "flags": "flags", "ulDeviceError": "text", } class CK_TOKEN_INFO(CkClass): """ matches the PKCS#11 CK_TOKEN_INFO structure :ivar label: blank padded :type label: string :ivar manufacturerID: blank padded :type manufacturerID: string :ivar model: string blank padded :type model: string :ivar serialNumber: string blank padded :type serialNumber: string :ivar flags: :type flags: integer :ivar ulMaxSessionCount: :type ulMaxSessionCount: integer :ivar ulSessionCount: :type ulSessionCount: integer :ivar ulMaxRwSessionCount: :type ulMaxRwSessionCount: integer :ivar ulRwSessionCount: :type ulRwSessionCount: integer :ivar ulMaxPinLen: :type ulMaxPinLen: integer :ivar ulMinPinLen: :type ulMinPinLen: integer :ivar ulTotalPublicMemory: :type ulTotalPublicMemory: integer :ivar ulFreePublicMemory: :type ulFreePublicMemory: integer :ivar ulTotalPrivateMemory: :type ulTotalPrivateMemory: integer :ivar ulFreePrivateMemory: :type ulFreePrivateMemory: integer :ivar hardwareVersion: 2 elements list :type hardwareVersion: list :ivar firmwareVersion: 2 elements list :type firmwareVersion: list :ivar utcTime: string :type utcTime: string """ # pylint: disable=too-many-instance-attributes flags_dict = { CKF_RNG: "CKF_RNG", CKF_WRITE_PROTECTED: "CKF_WRITE_PROTECTED", CKF_LOGIN_REQUIRED: "CKF_LOGIN_REQUIRED", CKF_USER_PIN_INITIALIZED: "CKF_USER_PIN_INITIALIZED", CKF_RESTORE_KEY_NOT_NEEDED: "CKF_RESTORE_KEY_NOT_NEEDED", CKF_CLOCK_ON_TOKEN: "CKF_CLOCK_ON_TOKEN", CKF_PROTECTED_AUTHENTICATION_PATH: "CKF_PROTECTED_AUTHENTICATION_PATH", CKF_DUAL_CRYPTO_OPERATIONS: "CKF_DUAL_CRYPTO_OPERATIONS", CKF_TOKEN_INITIALIZED: "CKF_TOKEN_INITIALIZED", CKF_SECONDARY_AUTHENTICATION: "CKF_SECONDARY_AUTHENTICATION", CKF_USER_PIN_COUNT_LOW: "CKF_USER_PIN_COUNT_LOW", CKF_USER_PIN_FINAL_TRY: "CKF_USER_PIN_FINAL_TRY", CKF_USER_PIN_LOCKED: "CKF_USER_PIN_LOCKED", CKF_USER_PIN_TO_BE_CHANGED: "CKF_USER_PIN_TO_BE_CHANGED", CKF_SO_PIN_COUNT_LOW: "CKF_SO_PIN_COUNT_LOW", CKF_SO_PIN_FINAL_TRY: "CKF_SO_PIN_FINAL_TRY", CKF_SO_PIN_LOCKED: "CKF_SO_PIN_LOCKED", CKF_SO_PIN_TO_BE_CHANGED: "CKF_SO_PIN_TO_BE_CHANGED", } fields = { "label": "text", "manufacturerID": "text", "model": "text", "serialNumber": "text", "flags": "flags", "ulMaxSessionCount": "text", "ulSessionCount": "text", "ulMaxRwSessionCount": "text", "ulRwSessionCount": "text", "ulMaxPinLen": "text", "ulMinPinLen": "text", "ulTotalPublicMemory": "text", "ulFreePublicMemory": "text", "ulTotalPrivateMemory": "text", "ulFreePrivateMemory": "text", "hardwareVersion": "pair", "firmwareVersion": "pair", "utcTime": "text", } def __init__(self): self.label = None self.manufacturerID = None self.model = None self.serialNumber = None self.flags = None self.ulMaxSessionCount = None self.ulSessionCount = None self.ulMaxRwSessionCount = None self.ulRwSessionCount = None self.ulMaxPinLen = None self.ulMinPinLen = None self.ulTotalPublicMemory = None self.ulFreePublicMemory = None self.ulTotalPrivateMemory = None self.ulFreePrivateMemory = None self.hardwareVersion = None self.firmwareVersion = None self.utcTime = None class CK_MECHANISM_INFO(CkClass): """ matches the PKCS#11 CK_MECHANISM_INFO structure :ivar ulMinKeySize: minimum size of the key :type ulMinKeySize: integer :ivar ulMaxKeySize: maximum size of the key :type ulMaxKeySize: integer :ivar flags: bit flags specifying mechanism capabilities :type flags: integer """ flags_dict = { CKF_HW: "CKF_HW", CKF_ENCRYPT: "CKF_ENCRYPT", CKF_DECRYPT: "CKF_DECRYPT", CKF_DIGEST: "CKF_DIGEST", CKF_SIGN: "CKF_SIGN", CKF_SIGN_RECOVER: "CKF_SIGN_RECOVER", CKF_VERIFY: "CKF_VERIFY", CKF_VERIFY_RECOVER: "CKF_VERIFY_RECOVER", CKF_GENERATE: "CKF_GENERATE", CKF_GENERATE_KEY_PAIR: "CKF_GENERATE_KEY_PAIR", CKF_WRAP: "CKF_WRAP", CKF_UNWRAP: "CKF_UNWRAP", CKF_DERIVE: "CKF_DERIVE", CKF_EXTENSION: "CKF_EXTENSION", } fields = {"ulMinKeySize": "text", "ulMaxKeySize": "text", "flags": "flags"} def __init__(self): self.ulMinKeySize = None self.ulMaxKeySize = None self.flags = None class PyKCS11Error(Exception): """define the possible PyKCS11 exceptions Positives values are for CKR_* codes -1: error in load() -2: error in template or attribute -3: error in ckbytelist() """ def __init__(self, value, text=""): self.value = value self.text = text def __str__(self): """ The text representation of a PKCS#11 error is something like: "CKR_DEVICE_ERROR (0x00000030)" """ if self.value in CKR: if self.value < 0: return CKR[self.value] + f" ({self.text})" return CKR[self.value] + f" (0x{self.value:08X})" if self.value & CKR_VENDOR_DEFINED: v = self.value & 0xFFFFFFFF & ~CKR_VENDOR_DEFINED return f"Vendor error (0x{v:08X})" return f"Unknown error (0x{self.value:08X})" class PyKCS11Lib: """high level PKCS#11 binding""" # shared by all instances _loaded_libs = {} _lock = threading.Lock() def __init__(self): self.lib = PyKCS11.LowLevel.CPKCS11Lib() self.pkcs11dll_filename = None def __del__(self): # pylint: disable=too-many-boolean-expressions if ( PyKCS11 and PyKCS11.__name__ and PyKCS11.LowLevel and PyKCS11.LowLevel.__name__ and PyKCS11.LowLevel._LowLevel and PyKCS11.LowLevel._LowLevel.__name__ ): # unload the library self.unload() def load(self, pkcs11dll_filename=None): """ load a PKCS#11 library :type pkcs11dll_filename: string :param pkcs11dll_filename: the library name. If this parameter is not set then the environment variable `PYKCS11LIB` is used instead :returns: a :class:`PyKCS11Lib` object :raises: :class:`PyKCS11Error` (-1): when the load fails """ if pkcs11dll_filename is None: pkcs11dll_filename = os.getenv("PYKCS11LIB") if pkcs11dll_filename is None: raise PyKCS11Error( -1, "No PKCS11 library specified (set PYKCS11LIB env variable)" ) with PyKCS11Lib._lock: if self.pkcs11dll_filename is not None: self._unload_locked() # unload the previous library # if the instance was previously initialized, # create a new low level library object for it self.lib = PyKCS11.LowLevel.CPKCS11Lib() # if the lib is already in use: reuse it if pkcs11dll_filename in PyKCS11Lib._loaded_libs: self.lib.Duplicate(PyKCS11Lib._loaded_libs[pkcs11dll_filename]["ref"]) else: # else load it rv = self.lib.Load(pkcs11dll_filename) if rv != CKR_OK: raise PyKCS11Error(rv, pkcs11dll_filename) PyKCS11Lib._loaded_libs[pkcs11dll_filename] = { "ref": self.lib, "nb_users": 0, } # remember the lib file name self.pkcs11dll_filename = pkcs11dll_filename # increase user number PyKCS11Lib._loaded_libs[pkcs11dll_filename]["nb_users"] += 1 return self def unload(self): """ unload the current instance of a PKCS#11 library """ with PyKCS11Lib._lock: self._unload_locked() def _unload_locked(self): """ unload the current instance of a PKCS#11 library The lock is already held """ # in case NO library was found and used if self.pkcs11dll_filename is None: return if self.pkcs11dll_filename not in PyKCS11Lib._loaded_libs: raise PyKCS11Error( -1, f"invalid PyKCS11Lib state: {self.pkcs11dll_filename} " + f"not in {PyKCS11Lib._loaded_libs}", ) # decrease user number PyKCS11Lib._loaded_libs[self.pkcs11dll_filename]["nb_users"] -= 1 if PyKCS11Lib._loaded_libs[self.pkcs11dll_filename]["nb_users"] == 0: # unload only if no more used self.lib.Unload() # remove unused entry # the case < 0 happens if lib loading failed if PyKCS11Lib._loaded_libs[self.pkcs11dll_filename]["nb_users"] <= 0: del PyKCS11Lib._loaded_libs[self.pkcs11dll_filename] self.pkcs11dll_filename = None def initToken(self, slot, pin, label): """ C_InitToken :param slot: slot number returned by :func:`getSlotList` :type slot: integer :param pin: Security Officer's initial PIN :param label: new label of the token """ pin1 = ckbytelist(pin) rv = self.lib.C_InitToken(slot, pin1, label) if rv != CKR_OK: raise PyKCS11Error(rv) def getInfo(self): """ C_GetInfo :return: a :class:`CK_INFO` object """ info = PyKCS11.LowLevel.CK_INFO() rv = self.lib.C_GetInfo(info) if rv != CKR_OK: raise PyKCS11Error(rv) i = CK_INFO() i.cryptokiVersion = (info.cryptokiVersion.major, info.cryptokiVersion.minor) i.manufacturerID = info.GetManufacturerID() i.flags = info.flags i.libraryDescription = info.GetLibraryDescription() i.libraryVersion = (info.libraryVersion.major, info.libraryVersion.minor) return i def getSlotList(self, tokenPresent=False): """ C_GetSlotList :param tokenPresent: `False` (default) to list all slots, `True` to list only slots with present tokens :type tokenPresent: bool :return: a list of available slots :rtype: list """ slotList = PyKCS11.LowLevel.ckulonglist() rv = self.lib.C_GetSlotList(CK_TRUE if tokenPresent else CK_FALSE, slotList) if rv != CKR_OK: raise PyKCS11Error(rv) s = [] for x in slotList: s.append(x) return s def getSlotInfo(self, slot): """ C_GetSlotInfo :param slot: slot number returned by :func:`getSlotList` :type slot: integer :return: a :class:`CK_SLOT_INFO` object """ slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() rv = self.lib.C_GetSlotInfo(slot, slotInfo) if rv != CKR_OK: raise PyKCS11Error(rv) s = CK_SLOT_INFO() s.slotDescription = slotInfo.GetSlotDescription() s.manufacturerID = slotInfo.GetManufacturerID() s.flags = slotInfo.flags s.hardwareVersion = slotInfo.GetHardwareVersion() s.firmwareVersion = slotInfo.GetFirmwareVersion() return s def getTokenInfo(self, slot): """ C_GetTokenInfo :param slot: slot number returned by :func:`getSlotList` :type slot: integer :return: a :class:`CK_TOKEN_INFO` object """ tokeninfo = PyKCS11.LowLevel.CK_TOKEN_INFO() rv = self.lib.C_GetTokenInfo(slot, tokeninfo) if rv != CKR_OK: raise PyKCS11Error(rv) t = CK_TOKEN_INFO() t.label = tokeninfo.GetLabel() t.manufacturerID = tokeninfo.GetManufacturerID() t.model = tokeninfo.GetModel() t.serialNumber = tokeninfo.GetSerialNumber() t.flags = tokeninfo.flags t.ulMaxSessionCount = tokeninfo.ulMaxSessionCount if t.ulMaxSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulMaxSessionCount = -1 t.ulSessionCount = tokeninfo.ulSessionCount if t.ulSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulSessionCount = -1 t.ulMaxRwSessionCount = tokeninfo.ulMaxRwSessionCount if t.ulMaxRwSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulMaxRwSessionCount = -1 t.ulRwSessionCount = tokeninfo.ulRwSessionCount if t.ulRwSessionCount == CK_UNAVAILABLE_INFORMATION: t.ulRwSessionCount = -1 t.ulMaxPinLen = tokeninfo.ulMaxPinLen t.ulMinPinLen = tokeninfo.ulMinPinLen t.ulTotalPublicMemory = tokeninfo.ulTotalPublicMemory if t.ulTotalPublicMemory == CK_UNAVAILABLE_INFORMATION: t.ulTotalPublicMemory = -1 t.ulFreePublicMemory = tokeninfo.ulFreePublicMemory if t.ulFreePublicMemory == CK_UNAVAILABLE_INFORMATION: t.ulFreePublicMemory = -1 t.ulTotalPrivateMemory = tokeninfo.ulTotalPrivateMemory if t.ulTotalPrivateMemory == CK_UNAVAILABLE_INFORMATION: t.ulTotalPrivateMemory = -1 t.ulFreePrivateMemory = tokeninfo.ulFreePrivateMemory if t.ulFreePrivateMemory == CK_UNAVAILABLE_INFORMATION: t.ulFreePrivateMemory = -1 t.hardwareVersion = ( tokeninfo.hardwareVersion.major, tokeninfo.hardwareVersion.minor, ) t.firmwareVersion = ( tokeninfo.firmwareVersion.major, tokeninfo.firmwareVersion.minor, ) t.utcTime = tokeninfo.GetUtcTime().replace("\000", " ") return t def openSession(self, slot, flags=0): """ C_OpenSession :param slot: slot number returned by :func:`getSlotList` :type slot: integer :param flags: 0 (default), `CKF_RW_SESSION` for RW session :type flags: integer :return: a :class:`Session` object """ se = PyKCS11.LowLevel.CK_SESSION_HANDLE() flags |= CKF_SERIAL_SESSION rv = self.lib.C_OpenSession(slot, flags, se) if rv != CKR_OK: raise PyKCS11Error(rv) return Session(self, se) def closeAllSessions(self, slot): """ C_CloseAllSessions :param slot: slot number :type slot: integer """ rv = self.lib.C_CloseAllSessions(slot) if rv != CKR_OK: raise PyKCS11Error(rv) def getMechanismList(self, slot): """ C_GetMechanismList :param slot: slot number returned by :func:`getSlotList` :type slot: integer :return: the list of available mechanisms for a slot :rtype: list """ mechanismList = PyKCS11.LowLevel.ckulonglist() rv = self.lib.C_GetMechanismList(slot, mechanismList) if rv != CKR_OK: raise PyKCS11Error(rv) m = [] mechanismList.append(0x1D) for mechanism in mechanismList: # Dynamically add unknown mechanisms: if mechanism not in CKM: if mechanism >= CKM_VENDOR_DEFINED: # Vendor defined mechanism mecha = mechanism - CKM_VENDOR_DEFINED k = f"CKM_VENDOR_DEFINED_0x{mecha:X}" else: # Not yet known mechanism k = f"CKM_UNKNOWN_0x{mechanism:X}" CKM[k] = mechanism CKM[mechanism] = k m.append(CKM[mechanism]) return m def getMechanismInfo(self, slot, ckm_type): """ C_GetMechanismInfo :param slot: slot number returned by :func:`getSlotList` :type slot: integer :param ckm_type: a `CKM_*` type :type ckm_type: integer :return: information about a mechanism :rtype: a :class:`CK_MECHANISM_INFO` object """ info = PyKCS11.LowLevel.CK_MECHANISM_INFO() rv = self.lib.C_GetMechanismInfo(slot, CKM[ckm_type], info) if rv != CKR_OK: raise PyKCS11Error(rv) i = CK_MECHANISM_INFO() i.ulMinKeySize = info.ulMinKeySize i.ulMaxKeySize = info.ulMaxKeySize i.flags = info.flags return i def waitForSlotEvent(self, flags=0): """ C_WaitForSlotEvent :param flags: 0 (default) or `CKF_DONT_BLOCK` :type flags: integer :return: slot :rtype: integer """ tmp = 0 rv, slot = self.lib.C_WaitForSlotEvent(flags, tmp) if rv != CKR_OK: raise PyKCS11Error(rv) return slot class Mechanism: """Wraps CK_MECHANISM""" # pylint: disable=too-few-public-methods def __init__(self, mechanism, param=None): """ :param mechanism: the mechanism to be used :type mechanism: integer, any `CKM_*` value :param param: data to be used as crypto operation parameter (i.e. the IV for some algorithms) :type param: string or list/tuple of bytes :see: :func:`Session.decrypt`, :func:`Session.sign` """ self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = mechanism self._param = None if param: self._param = ckbytelist(param) self._mech.pParameter = self._param self._mech.ulParameterLen = len(param) def to_native(self): """convert mechanism to native format""" return self._mech MechanismSHA1 = Mechanism(CKM_SHA_1, None) MechanismRSAPKCS1 = Mechanism(CKM_RSA_PKCS, None) MechanismRSAGENERATEKEYPAIR = Mechanism(CKM_RSA_PKCS_KEY_PAIR_GEN, None) MechanismECGENERATEKEYPAIR = Mechanism(CKM_EC_KEY_PAIR_GEN, None) MechanismAESGENERATEKEY = Mechanism(CKM_AES_KEY_GEN, None) class AES_GCM_Mechanism: """CKM_AES_GCM warpping mechanism""" # pylint: disable=too-few-public-methods def __init__(self, iv, aad, tagBits): """ :param iv: initialization vector :param aad: additional authentication data :param tagBits: length of authentication tag in bits """ self._param = PyKCS11.LowLevel.CK_GCM_PARAMS() self._source_iv = ckbytelist(iv) self._param.pIv = self._source_iv self._param.ulIvLen = len(self._source_iv) self._source_aad = ckbytelist(aad) self._param.pAAD = self._source_aad self._param.ulAADLen = len(self._source_aad) self._param.ulTagBits = tagBits self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = CKM_AES_GCM self._mech.pParameter = self._param self._mech.ulParameterLen = PyKCS11.LowLevel.CK_GCM_PARAMS_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class AES_CTR_Mechanism: """CKM_AES_CTR encryption mechanism""" # pylint: disable=too-few-public-methods def __init__(self, counterBits, counterBlock): """ :param counterBits: the number of incremented bits in the counter block :param counterBlock: a 16-byte initial value of the counter block """ self._param = PyKCS11.LowLevel.CK_AES_CTR_PARAMS() self._source_cb = ckbytelist(counterBlock) self._param.ulCounterBits = counterBits self._param.cb = self._source_cb self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = CKM_AES_CTR self._mech.pParameter = self._param self._mech.ulParameterLen = PyKCS11.LowLevel.CK_AES_CTR_PARAMS_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class RSAOAEPMechanism: """RSA OAEP Wrapping mechanism""" # pylint: disable=too-few-public-methods def __init__(self, hashAlg, mgf, label=None): """ :param hashAlg: the hash algorithm to use (like `CKM_SHA256`) :param mgf: the mask generation function to use (like `CKG_MGF1_SHA256`) :param label: the (optional) label to use """ self._param = PyKCS11.LowLevel.CK_RSA_PKCS_OAEP_PARAMS() self._param.hashAlg = hashAlg self._param.mgf = mgf self._source = None self._param.source = CKZ_DATA_SPECIFIED if label: self._source = ckbytelist(label) self._param.ulSourceDataLen = len(self._source) else: self._param.ulSourceDataLen = 0 self._param.pSourceData = self._source self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = CKM_RSA_PKCS_OAEP self._mech.pParameter = self._param self._mech.ulParameterLen = PyKCS11.LowLevel.CK_RSA_PKCS_OAEP_PARAMS_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class RSA_PSS_Mechanism: """RSA PSS Wrapping mechanism""" # pylint: disable=too-few-public-methods def __init__(self, mecha, hashAlg, mgf, sLen): """ :param mecha: the mechanism to use (like `CKM_SHA384_RSA_PKCS_PSS`) :param hashAlg: the hash algorithm to use (like `CKM_SHA384`) :param mgf: the mask generation function to use (like `CKG_MGF1_SHA384`) :param sLen: length, in bytes, of the salt value used in the PSS encoding (like 0 or the message length) """ self._param = PyKCS11.LowLevel.CK_RSA_PKCS_PSS_PARAMS() self._param.hashAlg = hashAlg self._param.mgf = mgf self._param.sLen = sLen self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = mecha self._mech.pParameter = self._param self._mech.ulParameterLen = PyKCS11.LowLevel.CK_RSA_PKCS_PSS_PARAMS_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class ECDH1_DERIVE_Mechanism: """CKM_ECDH1_DERIVE key derivation mechanism""" # pylint: disable=too-few-public-methods def __init__(self, publicData, kdf=CKD_NULL, sharedData=None): """ :param publicData: Other party public key which is EC Point [PC || coord-x || coord-y]. :param kdf: Key derivation function. OPTIONAL. Defaults to CKD_NULL :param sharedData: additional shared data. OPTIONAL """ self._param = PyKCS11.LowLevel.CK_ECDH1_DERIVE_PARAMS() self._param.kdf = kdf if sharedData: self._shared_data = ckbytelist(sharedData) self._param.pSharedData = self._shared_data self._param.ulSharedDataLen = len(self._shared_data) else: self._source_shared_data = None self._param.ulSharedDataLen = 0 self._public_data = ckbytelist(publicData) self._param.pPublicData = self._public_data self._param.ulPublicDataLen = len(self._public_data) self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = CKM_ECDH1_DERIVE self._mech.pParameter = self._param self._mech.ulParameterLen = PyKCS11.LowLevel.CK_ECDH1_DERIVE_PARAMS_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class CONCATENATE_BASE_AND_KEY_Mechanism: """CKM_CONCATENATE_BASE_AND_KEY key derivation mechanism""" # pylint: disable=too-few-public-methods def __init__(self, encKey): """ :param encKey: a handle of encryption key """ self._encKey = encKey self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = CKM_CONCATENATE_BASE_AND_KEY self._mech.pParameter = self._encKey self._mech.ulParameterLen = PyKCS11.LowLevel.CK_OBJECT_HANDLE_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class KEY_DERIVATION_STRING_DATA_MechanismBase: """Base class for mechanisms using derivation string data""" # pylint: disable=too-few-public-methods def __init__(self, data, mechType): """ :param data: a byte array to concatenate the key with :param mechType: mechanism type """ self._param = PyKCS11.LowLevel.CK_KEY_DERIVATION_STRING_DATA() self._data = ckbytelist(data) self._param.pData = self._data self._param.ulLen = len(self._data) self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = mechType self._mech.pParameter = self._param self._mech.ulParameterLen = ( PyKCS11.LowLevel.CK_KEY_DERIVATION_STRING_DATA_LENGTH ) def to_native(self): """convert mechanism to native format""" return self._mech class CONCATENATE_BASE_AND_DATA_Mechanism(KEY_DERIVATION_STRING_DATA_MechanismBase): """CKM_CONCATENATE_BASE_AND_DATA key derivation mechanism""" # pylint: disable=too-few-public-methods def __init__(self, data): """ :param data: a byte array to concatenate the key with """ super().__init__(data, CKM_CONCATENATE_BASE_AND_DATA) class CONCATENATE_DATA_AND_BASE_Mechanism(KEY_DERIVATION_STRING_DATA_MechanismBase): """CKM_CONCATENATE_DATA_AND_BASE key derivation mechanism""" # pylint: disable=too-few-public-methods def __init__(self, data): """ :param data: a byte array to concatenate the key with """ super().__init__(data, CKM_CONCATENATE_DATA_AND_BASE) class XOR_BASE_AND_DATA_Mechanism(KEY_DERIVATION_STRING_DATA_MechanismBase): """CKM_XOR_BASE_AND_DATA key derivation mechanism""" # pylint: disable=too-few-public-methods def __init__(self, data): """ :param data: a byte array to xor the key with """ super().__init__(data, CKM_XOR_BASE_AND_DATA) class EXTRACT_KEY_FROM_KEY_Mechanism: """CKM_EXTRACT_KEY_FROM_KEY key derivation mechanism""" # pylint: disable=too-few-public-methods def __init__(self, extractParams): """ :param extractParams: the index of the first bit of the original key to be used in the newly-derived key. For example if extractParams=5 then the 5 first bits are skipped and not used. """ self._param = PyKCS11.LowLevel.CK_EXTRACT_PARAMS() self._param.assign(extractParams) self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = CKM_EXTRACT_KEY_FROM_KEY self._mech.pParameter = self._param self._mech.ulParameterLen = PyKCS11.LowLevel.CK_EXTRACT_PARAMS_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class EDDSA_Mechanism: """CKM_EDDSA signature mechanism""" # pylint: disable=too-few-public-methods def __init__(self, phFlag=None, contextData=None): """ :param phFlag: prehash flag [True|False]. If this parameter is not set, Ed25519 in pure mode without context is assumed. :param context: context data (optional) """ self._param = PyKCS11.LowLevel.CK_EDDSA_PARAMS() self._mech = PyKCS11.LowLevel.CK_MECHANISM() self._mech.mechanism = CKM_EDDSA if not phFlag is None: self._phFlag = phFlag self._param.phFlag = self._phFlag if contextData: self._contextData = ckbytelist(contextData) self._param.pContextData = self._contextData self._param.ulContextDataLen = len(self._contextData) self._mech.pParameter = self._param self._mech.ulParameterLen = PyKCS11.LowLevel.CK_EDDSA_PARAMS_LENGTH def to_native(self): """convert mechanism to native format""" return self._mech class DigestSession: """Digest session""" def __init__(self, lib, session, mecha): self._lib = lib self._session = session self._mechanism = mecha.to_native() rv = self._lib.C_DigestInit(self._session, self._mechanism) if rv != CKR_OK: raise PyKCS11Error(rv) def update(self, data): """ C_DigestUpdate :param data: data to add to the digest :type data: bytes or string """ data1 = ckbytelist(data) rv = self._lib.C_DigestUpdate(self._session, data1) if rv != CKR_OK: raise PyKCS11Error(rv) return self def digestKey(self, handle): """ C_DigestKey :param handle: key handle :type handle: CK_OBJECT_HANDLE """ rv = self._lib.C_DigestKey(self._session, handle) if rv != CKR_OK: raise PyKCS11Error(rv) return self def final(self): """ C_DigestFinal :return: the digest :rtype: ckbytelist """ digest = ckbytelist() # Get the size of the digest rv = self._lib.C_DigestFinal(self._session, digest) if rv != CKR_OK: raise PyKCS11Error(rv) # Get the actual digest rv = self._lib.C_DigestFinal(self._session, digest) if rv != CKR_OK: raise PyKCS11Error(rv) return digest class Session: """Manage :func:`PyKCS11Lib.openSession` objects""" # pylint: disable=too-many-public-methods def __init__(self, pykcs11, session): """ :param pykcs11: PyKCS11 library object :type pykcs11: PyKCS11Lib :param session: session handle :type session: instance of :class:`CK_SESSION_HANDLE` """ if not isinstance(pykcs11, PyKCS11Lib): raise TypeError("pykcs11 must be a PyKCS11Lib") if not isinstance(session, PyKCS11.LowLevel.CK_SESSION_HANDLE): raise TypeError("session must be a CK_SESSION_HANDLE") # hold the PyKCS11Lib reference, so that it's not Garbage Collection'd self.pykcs11 = pykcs11 self.session = session @property def lib(self): """ Get the low level lib of the owning PyKCS11Lib """ return self.pykcs11.lib def closeSession(self): """ C_CloseSession """ rv = self.lib.C_CloseSession(self.session) if rv != CKR_OK: raise PyKCS11Error(rv) def getSessionInfo(self): """ C_GetSessionInfo :return: a :class:`CK_SESSION_INFO` object """ sessioninfo = PyKCS11.LowLevel.CK_SESSION_INFO() rv = self.lib.C_GetSessionInfo(self.session, sessioninfo) if rv != CKR_OK: raise PyKCS11Error(rv) s = CK_SESSION_INFO() s.slotID = sessioninfo.slotID s.state = sessioninfo.state s.flags = sessioninfo.flags s.ulDeviceError = sessioninfo.ulDeviceError return s def login(self, pin, user_type=CKU_USER): """ C_Login :param pin: the user's PIN or None for CKF_PROTECTED_AUTHENTICATION_PATH :type pin: string :param user_type: the user type. The default value is CKU_USER. You may also use CKU_SO :type user_type: integer """ pin1 = ckbytelist(pin) rv = self.lib.C_Login(self.session, user_type, pin1) if rv != CKR_OK: raise PyKCS11Error(rv) def logout(self): """ C_Logout """ rv = self.lib.C_Logout(self.session) if rv != CKR_OK: raise PyKCS11Error(rv) del self def initPin(self, pin): """ C_InitPIN :param pin: new PIN """ new_pin1 = ckbytelist(pin) rv = self.lib.C_InitPIN(self.session, new_pin1) if rv != CKR_OK: raise PyKCS11Error(rv) def setPin(self, old_pin, new_pin): """ C_SetPIN :param old_pin: old PIN :param new_pin: new PIN """ old_pin1 = ckbytelist(old_pin) new_pin1 = ckbytelist(new_pin) rv = self.lib.C_SetPIN(self.session, old_pin1, new_pin1) if rv != CKR_OK: raise PyKCS11Error(rv) def createObject(self, template): """ C_CreateObject :param template: object template """ attrs = self._template2ckattrlist(template) handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() rv = self.lib.C_CreateObject(self.session, attrs, handle) if rv != PyKCS11.CKR_OK: raise PyKCS11.PyKCS11Error(rv) return handle def destroyObject(self, obj): """ C_DestroyObject :param obj: object ID """ rv = self.lib.C_DestroyObject(self.session, obj) if rv != CKR_OK: raise PyKCS11Error(rv) def digestSession(self, mecha=MechanismSHA1): """ C_DigestInit/C_DigestUpdate/C_DigestKey/C_DigestFinal :param mecha: the digesting mechanism to be used (use `MechanismSHA1` for `CKM_SHA_1`) :type mecha: :class:`Mechanism` :return: A :class:`DigestSession` object :rtype: DigestSession """ return DigestSession(self.lib, self.session, mecha) def digest(self, data, mecha=MechanismSHA1): """ C_DigestInit/C_Digest :param data: the data to be digested :type data: (binary) sring or list/tuple of bytes :param mecha: the digesting mechanism to be used (use `MechanismSHA1` for `CKM_SHA_1`) :type mecha: :class:`Mechanism` :return: the computed digest :rtype: ckbytelist :note: the returned value is an istance of :class:`ckbytelist`. You can easly convert it to a binary string with: ``bytes(ckbytelistDigest)`` or, for Python 2: ``''.join(chr(i) for i in ckbytelistDigest)`` """ digest = ckbytelist() m = mecha.to_native() data1 = ckbytelist(data) rv = self.lib.C_DigestInit(self.session, m) if rv != CKR_OK: raise PyKCS11Error(rv) # first call get digest size rv = self.lib.C_Digest(self.session, data1, digest) if rv != CKR_OK: raise PyKCS11Error(rv) # second call get actual digest data rv = self.lib.C_Digest(self.session, data1, digest) if rv != CKR_OK: raise PyKCS11Error(rv) return digest def sign(self, key, data, mecha=MechanismRSAPKCS1): """ C_SignInit/C_Sign :param key: a key handle, obtained calling :func:`findObjects`. :type key: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param data: the data to be signed :type data: (binary) string or list/tuple of bytes :param mecha: the signing mechanism to be used (use `MechanismRSAPKCS1` for `CKM_RSA_PKCS`) :type mecha: :class:`Mechanism` :return: the computed signature :rtype: ckbytelist :note: the returned value is an instance of :class:`ckbytelist`. You can easly convert it to a binary string with: ``bytes(ckbytelistSignature)`` or, for Python 2: ``''.join(chr(i) for i in ckbytelistSignature)`` """ m = mecha.to_native() signature = ckbytelist() data1 = ckbytelist(data) rv = self.lib.C_SignInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) # first call get signature size rv = self.lib.C_Sign(self.session, data1, signature) if rv != CKR_OK: raise PyKCS11Error(rv) # second call get actual signature data rv = self.lib.C_Sign(self.session, data1, signature) if rv != CKR_OK: raise PyKCS11Error(rv) return signature def verify(self, key, data, signature, mecha=MechanismRSAPKCS1): """ C_VerifyInit/C_Verify :param key: a key handle, obtained calling :func:`findObjects`. :type key: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param data: the data that was signed :type data: (binary) string or list/tuple of bytes :param signature: the signature to be verified :type signature: (binary) string or list/tuple of bytes :param mecha: the signing mechanism to be used (use `MechanismRSAPKCS1` for `CKM_RSA_PKCS`) :type mecha: :class:`Mechanism` :return: True if signature is valid, False otherwise :rtype: bool """ m = mecha.to_native() data1 = ckbytelist(data) rv = self.lib.C_VerifyInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) rv = self.lib.C_Verify(self.session, data1, signature) if rv == CKR_OK: return True if rv == CKR_SIGNATURE_INVALID: return False raise PyKCS11Error(rv) def encrypt(self, key, data, mecha=MechanismRSAPKCS1): """ C_EncryptInit/C_Encrypt :param key: a key handle, obtained calling :func:`findObjects`. :type key: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param data: the data to be encrypted :type data: (binary) string or list/tuple of bytes :param mecha: the encryption mechanism to be used (use `MechanismRSAPKCS1` for `CKM_RSA_PKCS`) :type mecha: :class:`Mechanism` :return: the encrypted data :rtype: ckbytelist :note: the returned value is an instance of :class:`ckbytelist`. You can easly convert it to a binary string with: ``bytes(ckbytelistEncrypted)`` or, for Python 2: ``''.join(chr(i) for i in ckbytelistEncrypted)`` """ encrypted = ckbytelist() m = mecha.to_native() data1 = ckbytelist(data) rv = self.lib.C_EncryptInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) # first call get encrypted size rv = self.lib.C_Encrypt(self.session, data1, encrypted) if rv != CKR_OK: raise PyKCS11Error(rv) # second call get actual encrypted data rv = self.lib.C_Encrypt(self.session, data1, encrypted) if rv != CKR_OK: raise PyKCS11Error(rv) return encrypted def encryptInit(self, mech, key): """ C_EncryptInit :param mech: the encryption mechanism to be used :type mech: instance of :class:`Mechanism` :param key: a key handle :type key: integer """ m = mech.to_native() rv = self.lib.C_EncryptInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) def encryptUpdate(self, data): """ C_EncryptUpdate :param data: the data to be encrypted :type data: (binary) string or list/tuple of bytes """ encrypted = ckbytelist() data1 = ckbytelist(data) rv = self.lib.C_EncryptUpdate(self.session, data1, encrypted) if rv != CKR_OK: raise PyKCS11Error(rv) return encrypted def encryptFinal(self): """ C_EncryptFinal :return: the last part of data to be encrypted :rtype: (binary) string or list/tuple of bytes """ encrypted = ckbytelist() rv = self.lib.C_EncryptFinal(self.session, encrypted) if rv != CKR_OK: raise PyKCS11Error(rv) return encrypted def decrypt(self, key, data, mecha=MechanismRSAPKCS1): """ C_DecryptInit/C_Decrypt :param key: a key handle, obtained calling :func:`findObjects`. :type key: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param data: the data to be decrypted :type data: (binary) string or list/tuple of bytes :param mecha: the decrypt mechanism to be used :type mecha: :class:`Mechanism` instance or :class:`MechanismRSAPKCS1` for CKM_RSA_PKCS :return: the decrypted data :rtype: ckbytelist :note: the returned value is an instance of :class:`ckbytelist`. You can easly convert it to a binary string with: ``bytes(ckbytelistData)`` or, for Python 2: ``''.join(chr(i) for i in ckbytelistData)`` """ m = mecha.to_native() decrypted = ckbytelist() data1 = ckbytelist(data) rv = self.lib.C_DecryptInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) # first call get decrypted size rv = self.lib.C_Decrypt(self.session, data1, decrypted) if rv != CKR_OK: raise PyKCS11Error(rv) # second call get actual decrypted data rv = self.lib.C_Decrypt(self.session, data1, decrypted) if rv != CKR_OK: raise PyKCS11Error(rv) return decrypted def decryptInit(self, mech, key): """ C_DecryptInit :param mech: the decrypt mechanism to be used :type mech: instance of :class:`Mechanism` :param key: a key handle :type key: integer """ m = mech.to_native() rv = self.lib.C_DecryptInit(self.session, m, key) if rv != CKR_OK: raise PyKCS11Error(rv) def decryptUpdate(self, data): """ C_DecryptUpdate :param data: the data to be decrypted :type data: (binary) string or list/tuple of bytes """ decrypted = ckbytelist() encrypted = ckbytelist(data) rv = self.lib.C_DecryptUpdate(self.session, encrypted, decrypted) if rv != CKR_OK: raise PyKCS11Error(rv) return decrypted def decryptFinal(self): """ C_DecryptFinal :return: the last part of the decrypted data :rtype: (binary) string or list/tuple of bytes """ decrypted = ckbytelist() rv = self.lib.C_DecryptFinal(self.session, decrypted) if rv != CKR_OK: raise PyKCS11Error(rv) return decrypted def wrapKey(self, wrappingKey, key, mecha=MechanismRSAPKCS1): """ C_WrapKey :param wrappingKey: a wrapping key handle :type wrappingKey: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param key: a handle of the key to be wrapped :type key: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param mecha: the encrypt mechanism to be used (use `MechanismRSAPKCS1` for `CKM_RSA_PKCS`) :type mecha: :class:`Mechanism` :return: the wrapped key bytes :rtype: ckbytelist :note: the returned value is an instance of :class:`ckbytelist`. You can easily convert it to a binary string with: ``bytes(ckbytelistData)`` or, for Python 2: ``''.join(chr(i) for i in ckbytelistData)`` """ wrapped = ckbytelist() native = mecha.to_native() # first call get wrapped size rv = self.lib.C_WrapKey(self.session, native, wrappingKey, key, wrapped) if rv != CKR_OK: raise PyKCS11Error(rv) # second call get actual wrapped key data rv = self.lib.C_WrapKey(self.session, native, wrappingKey, key, wrapped) if rv != CKR_OK: raise PyKCS11Error(rv) return wrapped def unwrapKey(self, unwrappingKey, wrappedKey, template, mecha=MechanismRSAPKCS1): """ C_UnwrapKey :param unwrappingKey: the unwrapping key handle :type unwrappingKey: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param wrappedKey: the bytes of the wrapped key :type wrappedKey: (binary) string or list/tuple of bytes :param template: template for the unwrapped key :param mecha: the decrypt mechanism to be used (use `MechanismRSAPKCS1` for `CKM_RSA_PKCS`) :type mecha: :class:`Mechanism` :return: the unwrapped key object :rtype: PyKCS11.LowLevel.CK_OBJECT_HANDLE """ m = mecha.to_native() data1 = ckbytelist(wrappedKey) handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() attrs = self._template2ckattrlist(template) rv = self.lib.C_UnwrapKey(self.session, m, unwrappingKey, data1, attrs, handle) if rv != CKR_OK: raise PyKCS11Error(rv) return handle def deriveKey(self, baseKey, template, mecha): """ C_DeriveKey :param baseKey: the base key handle :type baseKey: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param template: template for the unwrapped key :param mecha: the decrypt mechanism to be used (use `ECDH1_DERIVE_Mechanism(...)` for `CKM_ECDH1_DERIVE`) :type mecha: :class:`Mechanism` :return: the unwrapped key object :rtype: PyKCS11.LowLevel.CK_OBJECT_HANDLE """ m = mecha.to_native() handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() attrs = self._template2ckattrlist(template) rv = self.lib.C_DeriveKey(self.session, m, baseKey, attrs, handle) if rv != CKR_OK: raise PyKCS11Error(rv) return handle def isNum(self, p11_type): """ is the type a numerical value? :param p11_type: PKCS#11 type like `CKA_CERTIFICATE_TYPE` :rtype: bool """ if p11_type in ( CKA_CERTIFICATE_TYPE, CKA_CLASS, CKA_HW_FEATURE_TYPE, CKA_KEY_GEN_MECHANISM, CKA_KEY_TYPE, CKA_MODULUS_BITS, CKA_VALUE_BITS, CKA_VALUE_LEN, ): return True return False def isString(self, p11_type): """ is the type a string value? :param p11_type: PKCS#11 type like `CKA_LABEL` :rtype: bool """ if p11_type in (CKA_LABEL, CKA_APPLICATION): return True return False def isBool(self, p11_type): """ is the type a boolean value? :param p11_type: PKCS#11 type like `CKA_ALWAYS_SENSITIVE` :rtype: bool """ if p11_type in ( CKA_ALWAYS_AUTHENTICATE, CKA_ALWAYS_SENSITIVE, CKA_DECRYPT, CKA_DERIVE, CKA_ENCRYPT, CKA_EXTRACTABLE, CKA_HAS_RESET, CKA_LOCAL, CKA_MODIFIABLE, CKA_COPYABLE, CKA_DESTROYABLE, CKA_NEVER_EXTRACTABLE, CKA_PRIVATE, CKA_RESET_ON_INIT, CKA_SENSITIVE, CKA_SIGN, CKA_SIGN_RECOVER, CKA_TOKEN, CKA_TRUSTED, CKA_UNWRAP, CKA_VERIFY, CKA_VERIFY_RECOVER, CKA_WRAP, CKA_WRAP_WITH_TRUSTED, ): return True return False def isBin(self, p11_type): """ is the type a byte array value? :param p11_type: PKCS#11 type like `CKA_MODULUS` :rtype: bool """ return ( (not self.isBool(p11_type)) and (not self.isString(p11_type)) and (not self.isNum(p11_type)) ) def isAttributeList(self, p11_type): """ is the type a attribute list value? :param p11_type: PKCS#11 type like `CKA_WRAP_TEMPLATE` :rtype: bool """ if p11_type in (CKA_WRAP_TEMPLATE, CKA_UNWRAP_TEMPLATE): return True return False def _template2ckattrlist(self, template): t = PyKCS11.LowLevel.ckattrlist(len(template)) for x, attr in enumerate(template): if self.isNum(attr[0]): t[x].SetNum(attr[0], int(attr[1])) elif self.isString(attr[0]): t[x].SetString(attr[0], str(attr[1])) elif self.isBool(attr[0]): t[x].SetBool(attr[0], attr[1] == CK_TRUE) elif self.isAttributeList(attr[0]): t[x].SetList(attr[0], self._template2ckattrlist(attr[1])) elif self.isBin(attr[0]): attrBin = attr[1] attrStr = attr[1] if isinstance(attr[1], int): attrStr = str(attr[1]) if isinstance(attr[1], bytes): attrBin = ckbytelist(attrStr) t[x].SetBin(attr[0], attrBin) else: raise PyKCS11Error(-2, f"attr: {attr[0]:08X}") return t def generateKey(self, template, mecha=MechanismAESGENERATEKEY): """ generate a secret key :param template: template for the secret key :param mecha: mechanism to use :return: handle of the generated key :rtype: PyKCS11.LowLevel.CK_OBJECT_HANDLE """ t = self._template2ckattrlist(template) ck_handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() m = mecha.to_native() rv = self.lib.C_GenerateKey(self.session, m, t, ck_handle) if rv != CKR_OK: raise PyKCS11Error(rv) return ck_handle def generateKeyPair( self, templatePub, templatePriv, mecha=MechanismRSAGENERATEKEYPAIR ): """ generate a key pair :param templatePub: template for the public key :param templatePriv: template for the private key :param mecha: mechanism to use :return: a tuple of handles (pub, priv) :rtype: tuple """ tPub = self._template2ckattrlist(templatePub) tPriv = self._template2ckattrlist(templatePriv) ck_pub_handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() ck_prv_handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE() m = mecha.to_native() rv = self.lib.C_GenerateKeyPair( self.session, m, tPub, tPriv, ck_pub_handle, ck_prv_handle ) if rv != CKR_OK: raise PyKCS11Error(rv) return ck_pub_handle, ck_prv_handle def findObjects(self, template=()): """ find the objects matching the template pattern :param template: list of attributes tuples (attribute,value). The default value is () and all the objects are returned :type template: list :return: a list of object ids :rtype: list """ t = self._template2ckattrlist(template) # we search for 10 objects by default. speed/memory tradeoff result = PyKCS11.LowLevel.ckulonglist(10) rv = self.lib.C_FindObjectsInit(self.session, t) if rv != CKR_OK: raise PyKCS11Error(rv) res = [] while True: rv = self.lib.C_FindObjects(self.session, result) if rv != CKR_OK: raise PyKCS11Error(rv) for x in result: # make a copy of the handle: the original value get # corrupted (!!) a = CK_OBJECT_HANDLE(self) a.assign(x) res.append(a) if len(result) == 0: break rv = self.lib.C_FindObjectsFinal(self.session) if rv != CKR_OK: raise PyKCS11Error(rv) return res def getAttributeValue(self, obj_id, attr, allAsBinary=False): """ C_GetAttributeValue :param obj_id: object ID returned by :func:`findObjects` :type obj_id: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param attr: list of attributes :type attr: list :param allAsBinary: return all values as binary data; default is False. :type allAsBinary: Boolean :return: a list of values corresponding to the list of attributes :rtype: list :see: :func:`getAttributeValue_fragmented` :note: if allAsBinary is True the function do not convert results to Python types (i.e.: CKA_TOKEN to Bool, CKA_CLASS to int, ...). Binary data is returned as :class:`ckbytelist` type, usable as a list containing only bytes. You can easly convert it to a binary string with: ``bytes(ckbytelistVariable)`` or, for Python 2: ``''.join(chr(i) for i in ckbytelistVariable)`` """ valTemplate = PyKCS11.LowLevel.ckattrlist(len(attr)) for index, value in enumerate(attr): valTemplate[index].SetType(value) # first call to get the attribute size and reserve the memory rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv in ( CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_SENSITIVE, CKR_ARGUMENTS_BAD, ): return self.getAttributeValue_fragmented(obj_id, attr, allAsBinary) if rv != CKR_OK: raise PyKCS11Error(rv) # second call to get the attribute value rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv != CKR_OK: raise PyKCS11Error(rv) res = [] for x in range(len(attr)): if allAsBinary: res.append(valTemplate[x].GetBin()) elif valTemplate[x].IsNum(): res.append(valTemplate[x].GetNum()) elif valTemplate[x].IsBool(): res.append(valTemplate[x].GetBool()) elif valTemplate[x].IsString(): res.append(valTemplate[x].GetString()) elif valTemplate[x].IsBin(): res.append(valTemplate[x].GetBin()) else: raise PyKCS11Error(-2, f"valTemplate: {valTemplate[x]:08X}") return res def getAttributeValue_fragmented(self, obj_id, attr, allAsBinary=False): """ Same as :func:`getAttributeValue` except that when some attribute is sensitive or unknown an empty value (None) is returned. Note: this is achived by getting attributes one by one. :see: :func:`getAttributeValue` """ # some attributes does not exists or is sensitive # but we don't know which ones. So try one by one valTemplate = PyKCS11.LowLevel.ckattrlist(1) res = [] for elt in attr: valTemplate[0].Reset() valTemplate[0].SetType(elt) # first call to get the attribute size and reserve the memory rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv in ( CKR_ATTRIBUTE_TYPE_INVALID, CKR_ATTRIBUTE_SENSITIVE, CKR_ARGUMENTS_BAD, ): # append an empty value res.append(None) continue if rv != CKR_OK: raise PyKCS11Error(rv) # second call to get the attribute value rv = self.lib.C_GetAttributeValue(self.session, obj_id, valTemplate) if rv != CKR_OK: raise PyKCS11Error(rv) if allAsBinary: res.append(valTemplate[0].GetBin()) elif valTemplate[0].IsNum(): res.append(valTemplate[0].GetNum()) elif valTemplate[0].IsBool(): res.append(valTemplate[0].GetBool()) elif valTemplate[0].IsString(): res.append(valTemplate[0].GetString()) elif valTemplate[0].IsBin(): res.append(valTemplate[0].GetBin()) elif valTemplate[0].IsAttributeList(): res.append(valTemplate[0].GetBin()) else: raise PyKCS11Error(-2) return res def setAttributeValue(self, obj_id, template): """ C_SetAttributeValue :param obj_id: object ID returned by :func:`findObjects` :type obj_id: PyKCS11.LowLevel.CK_OBJECT_HANDLE :param template: list of (attribute, value) pairs :type template: list :return: Nothing :rtype: None """ templ = self._template2ckattrlist(template) rv = self.lib.C_SetAttributeValue(self.session, obj_id, templ) if rv != CKR_OK: raise PyKCS11Error(rv) def seedRandom(self, seed): """ C_SeedRandom :param seed: seed material :type seed: iterable """ low_seed = ckbytelist(seed) rv = self.lib.C_SeedRandom(self.session, low_seed) if rv != CKR_OK: raise PyKCS11Error(rv) def generateRandom(self, size=16): """ C_GenerateRandom :param size: number of random bytes to get :type size: integer :note: the returned value is an instance of :class:`ckbytelist`. You can easly convert it to a binary string with: ``bytes(random)`` or, for Python 2: ``''.join(chr(i) for i in random)`` """ low_rand = ckbytelist([0] * size) rv = self.lib.C_GenerateRandom(self.session, low_rand) if rv != CKR_OK: raise PyKCS11Error(rv) return low_rand ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957732 pykcs11-1.5.20/src/PyKCS11/constants.py0000644000175100017510000044035215246574333017034 0ustar00runnerrunner# pylint: disable=missing-module-docstring, disable=too-many-lines import PyKCS11.LowLevel # This file is generated by "make constants" # To not edit by hand # redefine PKCS#11 constants CK_TRUE = PyKCS11.LowLevel.CK_TRUE CK_FALSE = PyKCS11.LowLevel.CK_FALSE CK_UNAVAILABLE_INFORMATION = PyKCS11.LowLevel.CK_UNAVAILABLE_INFORMATION CK_EFFECTIVELY_INFINITE = PyKCS11.LowLevel.CK_EFFECTIVELY_INFINITE CK_INVALID_HANDLE = PyKCS11.LowLevel.CK_INVALID_HANDLE # CKA constants CKA = {} CKA_CLASS = PyKCS11.LowLevel.CKA_CLASS CKA["CKA_CLASS"] = CKA_CLASS CKA[CKA_CLASS] = "CKA_CLASS" CKA_TOKEN = PyKCS11.LowLevel.CKA_TOKEN CKA["CKA_TOKEN"] = CKA_TOKEN CKA[CKA_TOKEN] = "CKA_TOKEN" CKA_PRIVATE = PyKCS11.LowLevel.CKA_PRIVATE CKA["CKA_PRIVATE"] = CKA_PRIVATE CKA[CKA_PRIVATE] = "CKA_PRIVATE" CKA_LABEL = PyKCS11.LowLevel.CKA_LABEL CKA["CKA_LABEL"] = CKA_LABEL CKA[CKA_LABEL] = "CKA_LABEL" CKA_UNIQUE_ID = PyKCS11.LowLevel.CKA_UNIQUE_ID CKA["CKA_UNIQUE_ID"] = CKA_UNIQUE_ID CKA[CKA_UNIQUE_ID] = "CKA_UNIQUE_ID" CKA_APPLICATION = PyKCS11.LowLevel.CKA_APPLICATION CKA["CKA_APPLICATION"] = CKA_APPLICATION CKA[CKA_APPLICATION] = "CKA_APPLICATION" CKA_VALUE = PyKCS11.LowLevel.CKA_VALUE CKA["CKA_VALUE"] = CKA_VALUE CKA[CKA_VALUE] = "CKA_VALUE" CKA_OBJECT_ID = PyKCS11.LowLevel.CKA_OBJECT_ID CKA["CKA_OBJECT_ID"] = CKA_OBJECT_ID CKA[CKA_OBJECT_ID] = "CKA_OBJECT_ID" CKA_CERTIFICATE_TYPE = PyKCS11.LowLevel.CKA_CERTIFICATE_TYPE CKA["CKA_CERTIFICATE_TYPE"] = CKA_CERTIFICATE_TYPE CKA[CKA_CERTIFICATE_TYPE] = "CKA_CERTIFICATE_TYPE" CKA_ISSUER = PyKCS11.LowLevel.CKA_ISSUER CKA["CKA_ISSUER"] = CKA_ISSUER CKA[CKA_ISSUER] = "CKA_ISSUER" CKA_SERIAL_NUMBER = PyKCS11.LowLevel.CKA_SERIAL_NUMBER CKA["CKA_SERIAL_NUMBER"] = CKA_SERIAL_NUMBER CKA[CKA_SERIAL_NUMBER] = "CKA_SERIAL_NUMBER" CKA_AC_ISSUER = PyKCS11.LowLevel.CKA_AC_ISSUER CKA["CKA_AC_ISSUER"] = CKA_AC_ISSUER CKA[CKA_AC_ISSUER] = "CKA_AC_ISSUER" CKA_OWNER = PyKCS11.LowLevel.CKA_OWNER CKA["CKA_OWNER"] = CKA_OWNER CKA[CKA_OWNER] = "CKA_OWNER" CKA_ATTR_TYPES = PyKCS11.LowLevel.CKA_ATTR_TYPES CKA["CKA_ATTR_TYPES"] = CKA_ATTR_TYPES CKA[CKA_ATTR_TYPES] = "CKA_ATTR_TYPES" CKA_TRUSTED = PyKCS11.LowLevel.CKA_TRUSTED CKA["CKA_TRUSTED"] = CKA_TRUSTED CKA[CKA_TRUSTED] = "CKA_TRUSTED" CKA_CERTIFICATE_CATEGORY = PyKCS11.LowLevel.CKA_CERTIFICATE_CATEGORY CKA["CKA_CERTIFICATE_CATEGORY"] = CKA_CERTIFICATE_CATEGORY CKA[CKA_CERTIFICATE_CATEGORY] = "CKA_CERTIFICATE_CATEGORY" CKA_JAVA_MIDP_SECURITY_DOMAIN = PyKCS11.LowLevel.CKA_JAVA_MIDP_SECURITY_DOMAIN CKA["CKA_JAVA_MIDP_SECURITY_DOMAIN"] = CKA_JAVA_MIDP_SECURITY_DOMAIN CKA[CKA_JAVA_MIDP_SECURITY_DOMAIN] = "CKA_JAVA_MIDP_SECURITY_DOMAIN" CKA_URL = PyKCS11.LowLevel.CKA_URL CKA["CKA_URL"] = CKA_URL CKA[CKA_URL] = "CKA_URL" CKA_HASH_OF_SUBJECT_PUBLIC_KEY = PyKCS11.LowLevel.CKA_HASH_OF_SUBJECT_PUBLIC_KEY CKA["CKA_HASH_OF_SUBJECT_PUBLIC_KEY"] = CKA_HASH_OF_SUBJECT_PUBLIC_KEY CKA[CKA_HASH_OF_SUBJECT_PUBLIC_KEY] = "CKA_HASH_OF_SUBJECT_PUBLIC_KEY" CKA_HASH_OF_ISSUER_PUBLIC_KEY = PyKCS11.LowLevel.CKA_HASH_OF_ISSUER_PUBLIC_KEY CKA["CKA_HASH_OF_ISSUER_PUBLIC_KEY"] = CKA_HASH_OF_ISSUER_PUBLIC_KEY CKA[CKA_HASH_OF_ISSUER_PUBLIC_KEY] = "CKA_HASH_OF_ISSUER_PUBLIC_KEY" CKA_NAME_HASH_ALGORITHM = PyKCS11.LowLevel.CKA_NAME_HASH_ALGORITHM CKA["CKA_NAME_HASH_ALGORITHM"] = CKA_NAME_HASH_ALGORITHM CKA[CKA_NAME_HASH_ALGORITHM] = "CKA_NAME_HASH_ALGORITHM" CKA_CHECK_VALUE = PyKCS11.LowLevel.CKA_CHECK_VALUE CKA["CKA_CHECK_VALUE"] = CKA_CHECK_VALUE CKA[CKA_CHECK_VALUE] = "CKA_CHECK_VALUE" CKA_KEY_TYPE = PyKCS11.LowLevel.CKA_KEY_TYPE CKA["CKA_KEY_TYPE"] = CKA_KEY_TYPE CKA[CKA_KEY_TYPE] = "CKA_KEY_TYPE" CKA_SUBJECT = PyKCS11.LowLevel.CKA_SUBJECT CKA["CKA_SUBJECT"] = CKA_SUBJECT CKA[CKA_SUBJECT] = "CKA_SUBJECT" CKA_ID = PyKCS11.LowLevel.CKA_ID CKA["CKA_ID"] = CKA_ID CKA[CKA_ID] = "CKA_ID" CKA_SENSITIVE = PyKCS11.LowLevel.CKA_SENSITIVE CKA["CKA_SENSITIVE"] = CKA_SENSITIVE CKA[CKA_SENSITIVE] = "CKA_SENSITIVE" CKA_ENCRYPT = PyKCS11.LowLevel.CKA_ENCRYPT CKA["CKA_ENCRYPT"] = CKA_ENCRYPT CKA[CKA_ENCRYPT] = "CKA_ENCRYPT" CKA_DECRYPT = PyKCS11.LowLevel.CKA_DECRYPT CKA["CKA_DECRYPT"] = CKA_DECRYPT CKA[CKA_DECRYPT] = "CKA_DECRYPT" CKA_WRAP = PyKCS11.LowLevel.CKA_WRAP CKA["CKA_WRAP"] = CKA_WRAP CKA[CKA_WRAP] = "CKA_WRAP" CKA_UNWRAP = PyKCS11.LowLevel.CKA_UNWRAP CKA["CKA_UNWRAP"] = CKA_UNWRAP CKA[CKA_UNWRAP] = "CKA_UNWRAP" CKA_SIGN = PyKCS11.LowLevel.CKA_SIGN CKA["CKA_SIGN"] = CKA_SIGN CKA[CKA_SIGN] = "CKA_SIGN" CKA_SIGN_RECOVER = PyKCS11.LowLevel.CKA_SIGN_RECOVER CKA["CKA_SIGN_RECOVER"] = CKA_SIGN_RECOVER CKA[CKA_SIGN_RECOVER] = "CKA_SIGN_RECOVER" CKA_VERIFY = PyKCS11.LowLevel.CKA_VERIFY CKA["CKA_VERIFY"] = CKA_VERIFY CKA[CKA_VERIFY] = "CKA_VERIFY" CKA_VERIFY_RECOVER = PyKCS11.LowLevel.CKA_VERIFY_RECOVER CKA["CKA_VERIFY_RECOVER"] = CKA_VERIFY_RECOVER CKA[CKA_VERIFY_RECOVER] = "CKA_VERIFY_RECOVER" CKA_DERIVE = PyKCS11.LowLevel.CKA_DERIVE CKA["CKA_DERIVE"] = CKA_DERIVE CKA[CKA_DERIVE] = "CKA_DERIVE" CKA_START_DATE = PyKCS11.LowLevel.CKA_START_DATE CKA["CKA_START_DATE"] = CKA_START_DATE CKA[CKA_START_DATE] = "CKA_START_DATE" CKA_END_DATE = PyKCS11.LowLevel.CKA_END_DATE CKA["CKA_END_DATE"] = CKA_END_DATE CKA[CKA_END_DATE] = "CKA_END_DATE" CKA_MODULUS = PyKCS11.LowLevel.CKA_MODULUS CKA["CKA_MODULUS"] = CKA_MODULUS CKA[CKA_MODULUS] = "CKA_MODULUS" CKA_MODULUS_BITS = PyKCS11.LowLevel.CKA_MODULUS_BITS CKA["CKA_MODULUS_BITS"] = CKA_MODULUS_BITS CKA[CKA_MODULUS_BITS] = "CKA_MODULUS_BITS" CKA_PUBLIC_EXPONENT = PyKCS11.LowLevel.CKA_PUBLIC_EXPONENT CKA["CKA_PUBLIC_EXPONENT"] = CKA_PUBLIC_EXPONENT CKA[CKA_PUBLIC_EXPONENT] = "CKA_PUBLIC_EXPONENT" CKA_PRIVATE_EXPONENT = PyKCS11.LowLevel.CKA_PRIVATE_EXPONENT CKA["CKA_PRIVATE_EXPONENT"] = CKA_PRIVATE_EXPONENT CKA[CKA_PRIVATE_EXPONENT] = "CKA_PRIVATE_EXPONENT" CKA_PRIME_1 = PyKCS11.LowLevel.CKA_PRIME_1 CKA["CKA_PRIME_1"] = CKA_PRIME_1 CKA[CKA_PRIME_1] = "CKA_PRIME_1" CKA_PRIME_2 = PyKCS11.LowLevel.CKA_PRIME_2 CKA["CKA_PRIME_2"] = CKA_PRIME_2 CKA[CKA_PRIME_2] = "CKA_PRIME_2" CKA_EXPONENT_1 = PyKCS11.LowLevel.CKA_EXPONENT_1 CKA["CKA_EXPONENT_1"] = CKA_EXPONENT_1 CKA[CKA_EXPONENT_1] = "CKA_EXPONENT_1" CKA_EXPONENT_2 = PyKCS11.LowLevel.CKA_EXPONENT_2 CKA["CKA_EXPONENT_2"] = CKA_EXPONENT_2 CKA[CKA_EXPONENT_2] = "CKA_EXPONENT_2" CKA_COEFFICIENT = PyKCS11.LowLevel.CKA_COEFFICIENT CKA["CKA_COEFFICIENT"] = CKA_COEFFICIENT CKA[CKA_COEFFICIENT] = "CKA_COEFFICIENT" CKA_PUBLIC_KEY_INFO = PyKCS11.LowLevel.CKA_PUBLIC_KEY_INFO CKA["CKA_PUBLIC_KEY_INFO"] = CKA_PUBLIC_KEY_INFO CKA[CKA_PUBLIC_KEY_INFO] = "CKA_PUBLIC_KEY_INFO" CKA_PRIME = PyKCS11.LowLevel.CKA_PRIME CKA["CKA_PRIME"] = CKA_PRIME CKA[CKA_PRIME] = "CKA_PRIME" CKA_SUBPRIME = PyKCS11.LowLevel.CKA_SUBPRIME CKA["CKA_SUBPRIME"] = CKA_SUBPRIME CKA[CKA_SUBPRIME] = "CKA_SUBPRIME" CKA_BASE = PyKCS11.LowLevel.CKA_BASE CKA["CKA_BASE"] = CKA_BASE CKA[CKA_BASE] = "CKA_BASE" CKA_PRIME_BITS = PyKCS11.LowLevel.CKA_PRIME_BITS CKA["CKA_PRIME_BITS"] = CKA_PRIME_BITS CKA[CKA_PRIME_BITS] = "CKA_PRIME_BITS" CKA_SUBPRIME_BITS = PyKCS11.LowLevel.CKA_SUBPRIME_BITS CKA["CKA_SUBPRIME_BITS"] = CKA_SUBPRIME_BITS CKA[CKA_SUBPRIME_BITS] = "CKA_SUBPRIME_BITS" CKA_SUB_PRIME_BITS = PyKCS11.LowLevel.CKA_SUB_PRIME_BITS CKA["CKA_SUB_PRIME_BITS"] = CKA_SUB_PRIME_BITS CKA[CKA_SUB_PRIME_BITS] = "CKA_SUB_PRIME_BITS" CKA_VALUE_BITS = PyKCS11.LowLevel.CKA_VALUE_BITS CKA["CKA_VALUE_BITS"] = CKA_VALUE_BITS CKA[CKA_VALUE_BITS] = "CKA_VALUE_BITS" CKA_VALUE_LEN = PyKCS11.LowLevel.CKA_VALUE_LEN CKA["CKA_VALUE_LEN"] = CKA_VALUE_LEN CKA[CKA_VALUE_LEN] = "CKA_VALUE_LEN" CKA_EXTRACTABLE = PyKCS11.LowLevel.CKA_EXTRACTABLE CKA["CKA_EXTRACTABLE"] = CKA_EXTRACTABLE CKA[CKA_EXTRACTABLE] = "CKA_EXTRACTABLE" CKA_LOCAL = PyKCS11.LowLevel.CKA_LOCAL CKA["CKA_LOCAL"] = CKA_LOCAL CKA[CKA_LOCAL] = "CKA_LOCAL" CKA_NEVER_EXTRACTABLE = PyKCS11.LowLevel.CKA_NEVER_EXTRACTABLE CKA["CKA_NEVER_EXTRACTABLE"] = CKA_NEVER_EXTRACTABLE CKA[CKA_NEVER_EXTRACTABLE] = "CKA_NEVER_EXTRACTABLE" CKA_ALWAYS_SENSITIVE = PyKCS11.LowLevel.CKA_ALWAYS_SENSITIVE CKA["CKA_ALWAYS_SENSITIVE"] = CKA_ALWAYS_SENSITIVE CKA[CKA_ALWAYS_SENSITIVE] = "CKA_ALWAYS_SENSITIVE" CKA_KEY_GEN_MECHANISM = PyKCS11.LowLevel.CKA_KEY_GEN_MECHANISM CKA["CKA_KEY_GEN_MECHANISM"] = CKA_KEY_GEN_MECHANISM CKA[CKA_KEY_GEN_MECHANISM] = "CKA_KEY_GEN_MECHANISM" CKA_MODIFIABLE = PyKCS11.LowLevel.CKA_MODIFIABLE CKA["CKA_MODIFIABLE"] = CKA_MODIFIABLE CKA[CKA_MODIFIABLE] = "CKA_MODIFIABLE" CKA_COPYABLE = PyKCS11.LowLevel.CKA_COPYABLE CKA["CKA_COPYABLE"] = CKA_COPYABLE CKA[CKA_COPYABLE] = "CKA_COPYABLE" CKA_DESTROYABLE = PyKCS11.LowLevel.CKA_DESTROYABLE CKA["CKA_DESTROYABLE"] = CKA_DESTROYABLE CKA[CKA_DESTROYABLE] = "CKA_DESTROYABLE" CKA_EC_PARAMS = PyKCS11.LowLevel.CKA_EC_PARAMS CKA["CKA_EC_PARAMS"] = CKA_EC_PARAMS CKA[CKA_EC_PARAMS] = "CKA_EC_PARAMS" CKA_EC_POINT = PyKCS11.LowLevel.CKA_EC_POINT CKA["CKA_EC_POINT"] = CKA_EC_POINT CKA[CKA_EC_POINT] = "CKA_EC_POINT" CKA_ALWAYS_AUTHENTICATE = PyKCS11.LowLevel.CKA_ALWAYS_AUTHENTICATE CKA["CKA_ALWAYS_AUTHENTICATE"] = CKA_ALWAYS_AUTHENTICATE CKA[CKA_ALWAYS_AUTHENTICATE] = "CKA_ALWAYS_AUTHENTICATE" CKA_WRAP_WITH_TRUSTED = PyKCS11.LowLevel.CKA_WRAP_WITH_TRUSTED CKA["CKA_WRAP_WITH_TRUSTED"] = CKA_WRAP_WITH_TRUSTED CKA[CKA_WRAP_WITH_TRUSTED] = "CKA_WRAP_WITH_TRUSTED" CKA_OTP_FORMAT = PyKCS11.LowLevel.CKA_OTP_FORMAT CKA["CKA_OTP_FORMAT"] = CKA_OTP_FORMAT CKA[CKA_OTP_FORMAT] = "CKA_OTP_FORMAT" CKA_OTP_LENGTH = PyKCS11.LowLevel.CKA_OTP_LENGTH CKA["CKA_OTP_LENGTH"] = CKA_OTP_LENGTH CKA[CKA_OTP_LENGTH] = "CKA_OTP_LENGTH" CKA_OTP_TIME_INTERVAL = PyKCS11.LowLevel.CKA_OTP_TIME_INTERVAL CKA["CKA_OTP_TIME_INTERVAL"] = CKA_OTP_TIME_INTERVAL CKA[CKA_OTP_TIME_INTERVAL] = "CKA_OTP_TIME_INTERVAL" CKA_OTP_USER_FRIENDLY_MODE = PyKCS11.LowLevel.CKA_OTP_USER_FRIENDLY_MODE CKA["CKA_OTP_USER_FRIENDLY_MODE"] = CKA_OTP_USER_FRIENDLY_MODE CKA[CKA_OTP_USER_FRIENDLY_MODE] = "CKA_OTP_USER_FRIENDLY_MODE" CKA_OTP_CHALLENGE_REQUIREMENT = PyKCS11.LowLevel.CKA_OTP_CHALLENGE_REQUIREMENT CKA["CKA_OTP_CHALLENGE_REQUIREMENT"] = CKA_OTP_CHALLENGE_REQUIREMENT CKA[CKA_OTP_CHALLENGE_REQUIREMENT] = "CKA_OTP_CHALLENGE_REQUIREMENT" CKA_OTP_TIME_REQUIREMENT = PyKCS11.LowLevel.CKA_OTP_TIME_REQUIREMENT CKA["CKA_OTP_TIME_REQUIREMENT"] = CKA_OTP_TIME_REQUIREMENT CKA[CKA_OTP_TIME_REQUIREMENT] = "CKA_OTP_TIME_REQUIREMENT" CKA_OTP_COUNTER_REQUIREMENT = PyKCS11.LowLevel.CKA_OTP_COUNTER_REQUIREMENT CKA["CKA_OTP_COUNTER_REQUIREMENT"] = CKA_OTP_COUNTER_REQUIREMENT CKA[CKA_OTP_COUNTER_REQUIREMENT] = "CKA_OTP_COUNTER_REQUIREMENT" CKA_OTP_PIN_REQUIREMENT = PyKCS11.LowLevel.CKA_OTP_PIN_REQUIREMENT CKA["CKA_OTP_PIN_REQUIREMENT"] = CKA_OTP_PIN_REQUIREMENT CKA[CKA_OTP_PIN_REQUIREMENT] = "CKA_OTP_PIN_REQUIREMENT" CKA_OTP_COUNTER = PyKCS11.LowLevel.CKA_OTP_COUNTER CKA["CKA_OTP_COUNTER"] = CKA_OTP_COUNTER CKA[CKA_OTP_COUNTER] = "CKA_OTP_COUNTER" CKA_OTP_TIME = PyKCS11.LowLevel.CKA_OTP_TIME CKA["CKA_OTP_TIME"] = CKA_OTP_TIME CKA[CKA_OTP_TIME] = "CKA_OTP_TIME" CKA_OTP_USER_IDENTIFIER = PyKCS11.LowLevel.CKA_OTP_USER_IDENTIFIER CKA["CKA_OTP_USER_IDENTIFIER"] = CKA_OTP_USER_IDENTIFIER CKA[CKA_OTP_USER_IDENTIFIER] = "CKA_OTP_USER_IDENTIFIER" CKA_OTP_SERVICE_IDENTIFIER = PyKCS11.LowLevel.CKA_OTP_SERVICE_IDENTIFIER CKA["CKA_OTP_SERVICE_IDENTIFIER"] = CKA_OTP_SERVICE_IDENTIFIER CKA[CKA_OTP_SERVICE_IDENTIFIER] = "CKA_OTP_SERVICE_IDENTIFIER" CKA_OTP_SERVICE_LOGO = PyKCS11.LowLevel.CKA_OTP_SERVICE_LOGO CKA["CKA_OTP_SERVICE_LOGO"] = CKA_OTP_SERVICE_LOGO CKA[CKA_OTP_SERVICE_LOGO] = "CKA_OTP_SERVICE_LOGO" CKA_OTP_SERVICE_LOGO_TYPE = PyKCS11.LowLevel.CKA_OTP_SERVICE_LOGO_TYPE CKA["CKA_OTP_SERVICE_LOGO_TYPE"] = CKA_OTP_SERVICE_LOGO_TYPE CKA[CKA_OTP_SERVICE_LOGO_TYPE] = "CKA_OTP_SERVICE_LOGO_TYPE" CKA_GOSTR3410_PARAMS = PyKCS11.LowLevel.CKA_GOSTR3410_PARAMS CKA["CKA_GOSTR3410_PARAMS"] = CKA_GOSTR3410_PARAMS CKA[CKA_GOSTR3410_PARAMS] = "CKA_GOSTR3410_PARAMS" CKA_GOSTR3411_PARAMS = PyKCS11.LowLevel.CKA_GOSTR3411_PARAMS CKA["CKA_GOSTR3411_PARAMS"] = CKA_GOSTR3411_PARAMS CKA[CKA_GOSTR3411_PARAMS] = "CKA_GOSTR3411_PARAMS" CKA_GOST28147_PARAMS = PyKCS11.LowLevel.CKA_GOST28147_PARAMS CKA["CKA_GOST28147_PARAMS"] = CKA_GOST28147_PARAMS CKA[CKA_GOST28147_PARAMS] = "CKA_GOST28147_PARAMS" CKA_HW_FEATURE_TYPE = PyKCS11.LowLevel.CKA_HW_FEATURE_TYPE CKA["CKA_HW_FEATURE_TYPE"] = CKA_HW_FEATURE_TYPE CKA[CKA_HW_FEATURE_TYPE] = "CKA_HW_FEATURE_TYPE" CKA_RESET_ON_INIT = PyKCS11.LowLevel.CKA_RESET_ON_INIT CKA["CKA_RESET_ON_INIT"] = CKA_RESET_ON_INIT CKA[CKA_RESET_ON_INIT] = "CKA_RESET_ON_INIT" CKA_HAS_RESET = PyKCS11.LowLevel.CKA_HAS_RESET CKA["CKA_HAS_RESET"] = CKA_HAS_RESET CKA[CKA_HAS_RESET] = "CKA_HAS_RESET" CKA_PIXEL_X = PyKCS11.LowLevel.CKA_PIXEL_X CKA["CKA_PIXEL_X"] = CKA_PIXEL_X CKA[CKA_PIXEL_X] = "CKA_PIXEL_X" CKA_PIXEL_Y = PyKCS11.LowLevel.CKA_PIXEL_Y CKA["CKA_PIXEL_Y"] = CKA_PIXEL_Y CKA[CKA_PIXEL_Y] = "CKA_PIXEL_Y" CKA_RESOLUTION = PyKCS11.LowLevel.CKA_RESOLUTION CKA["CKA_RESOLUTION"] = CKA_RESOLUTION CKA[CKA_RESOLUTION] = "CKA_RESOLUTION" CKA_CHAR_ROWS = PyKCS11.LowLevel.CKA_CHAR_ROWS CKA["CKA_CHAR_ROWS"] = CKA_CHAR_ROWS CKA[CKA_CHAR_ROWS] = "CKA_CHAR_ROWS" CKA_CHAR_COLUMNS = PyKCS11.LowLevel.CKA_CHAR_COLUMNS CKA["CKA_CHAR_COLUMNS"] = CKA_CHAR_COLUMNS CKA[CKA_CHAR_COLUMNS] = "CKA_CHAR_COLUMNS" CKA_COLOR = PyKCS11.LowLevel.CKA_COLOR CKA["CKA_COLOR"] = CKA_COLOR CKA[CKA_COLOR] = "CKA_COLOR" CKA_BITS_PER_PIXEL = PyKCS11.LowLevel.CKA_BITS_PER_PIXEL CKA["CKA_BITS_PER_PIXEL"] = CKA_BITS_PER_PIXEL CKA[CKA_BITS_PER_PIXEL] = "CKA_BITS_PER_PIXEL" CKA_CHAR_SETS = PyKCS11.LowLevel.CKA_CHAR_SETS CKA["CKA_CHAR_SETS"] = CKA_CHAR_SETS CKA[CKA_CHAR_SETS] = "CKA_CHAR_SETS" CKA_ENCODING_METHODS = PyKCS11.LowLevel.CKA_ENCODING_METHODS CKA["CKA_ENCODING_METHODS"] = CKA_ENCODING_METHODS CKA[CKA_ENCODING_METHODS] = "CKA_ENCODING_METHODS" CKA_MIME_TYPES = PyKCS11.LowLevel.CKA_MIME_TYPES CKA["CKA_MIME_TYPES"] = CKA_MIME_TYPES CKA[CKA_MIME_TYPES] = "CKA_MIME_TYPES" CKA_MECHANISM_TYPE = PyKCS11.LowLevel.CKA_MECHANISM_TYPE CKA["CKA_MECHANISM_TYPE"] = CKA_MECHANISM_TYPE CKA[CKA_MECHANISM_TYPE] = "CKA_MECHANISM_TYPE" CKA_REQUIRED_CMS_ATTRIBUTES = PyKCS11.LowLevel.CKA_REQUIRED_CMS_ATTRIBUTES CKA["CKA_REQUIRED_CMS_ATTRIBUTES"] = CKA_REQUIRED_CMS_ATTRIBUTES CKA[CKA_REQUIRED_CMS_ATTRIBUTES] = "CKA_REQUIRED_CMS_ATTRIBUTES" CKA_DEFAULT_CMS_ATTRIBUTES = PyKCS11.LowLevel.CKA_DEFAULT_CMS_ATTRIBUTES CKA["CKA_DEFAULT_CMS_ATTRIBUTES"] = CKA_DEFAULT_CMS_ATTRIBUTES CKA[CKA_DEFAULT_CMS_ATTRIBUTES] = "CKA_DEFAULT_CMS_ATTRIBUTES" CKA_SUPPORTED_CMS_ATTRIBUTES = PyKCS11.LowLevel.CKA_SUPPORTED_CMS_ATTRIBUTES CKA["CKA_SUPPORTED_CMS_ATTRIBUTES"] = CKA_SUPPORTED_CMS_ATTRIBUTES CKA[CKA_SUPPORTED_CMS_ATTRIBUTES] = "CKA_SUPPORTED_CMS_ATTRIBUTES" CKA_PROFILE_ID = PyKCS11.LowLevel.CKA_PROFILE_ID CKA["CKA_PROFILE_ID"] = CKA_PROFILE_ID CKA[CKA_PROFILE_ID] = "CKA_PROFILE_ID" CKA_X2RATCHET_BAG = PyKCS11.LowLevel.CKA_X2RATCHET_BAG CKA["CKA_X2RATCHET_BAG"] = CKA_X2RATCHET_BAG CKA[CKA_X2RATCHET_BAG] = "CKA_X2RATCHET_BAG" CKA_X2RATCHET_BAGSIZE = PyKCS11.LowLevel.CKA_X2RATCHET_BAGSIZE CKA["CKA_X2RATCHET_BAGSIZE"] = CKA_X2RATCHET_BAGSIZE CKA[CKA_X2RATCHET_BAGSIZE] = "CKA_X2RATCHET_BAGSIZE" CKA_X2RATCHET_BOBS1STMSG = PyKCS11.LowLevel.CKA_X2RATCHET_BOBS1STMSG CKA["CKA_X2RATCHET_BOBS1STMSG"] = CKA_X2RATCHET_BOBS1STMSG CKA[CKA_X2RATCHET_BOBS1STMSG] = "CKA_X2RATCHET_BOBS1STMSG" CKA_X2RATCHET_CKR = PyKCS11.LowLevel.CKA_X2RATCHET_CKR CKA["CKA_X2RATCHET_CKR"] = CKA_X2RATCHET_CKR CKA[CKA_X2RATCHET_CKR] = "CKA_X2RATCHET_CKR" CKA_X2RATCHET_CKS = PyKCS11.LowLevel.CKA_X2RATCHET_CKS CKA["CKA_X2RATCHET_CKS"] = CKA_X2RATCHET_CKS CKA[CKA_X2RATCHET_CKS] = "CKA_X2RATCHET_CKS" CKA_X2RATCHET_DHP = PyKCS11.LowLevel.CKA_X2RATCHET_DHP CKA["CKA_X2RATCHET_DHP"] = CKA_X2RATCHET_DHP CKA[CKA_X2RATCHET_DHP] = "CKA_X2RATCHET_DHP" CKA_X2RATCHET_DHR = PyKCS11.LowLevel.CKA_X2RATCHET_DHR CKA["CKA_X2RATCHET_DHR"] = CKA_X2RATCHET_DHR CKA[CKA_X2RATCHET_DHR] = "CKA_X2RATCHET_DHR" CKA_X2RATCHET_DHS = PyKCS11.LowLevel.CKA_X2RATCHET_DHS CKA["CKA_X2RATCHET_DHS"] = CKA_X2RATCHET_DHS CKA[CKA_X2RATCHET_DHS] = "CKA_X2RATCHET_DHS" CKA_X2RATCHET_HKR = PyKCS11.LowLevel.CKA_X2RATCHET_HKR CKA["CKA_X2RATCHET_HKR"] = CKA_X2RATCHET_HKR CKA[CKA_X2RATCHET_HKR] = "CKA_X2RATCHET_HKR" CKA_X2RATCHET_HKS = PyKCS11.LowLevel.CKA_X2RATCHET_HKS CKA["CKA_X2RATCHET_HKS"] = CKA_X2RATCHET_HKS CKA[CKA_X2RATCHET_HKS] = "CKA_X2RATCHET_HKS" CKA_X2RATCHET_ISALICE = PyKCS11.LowLevel.CKA_X2RATCHET_ISALICE CKA["CKA_X2RATCHET_ISALICE"] = CKA_X2RATCHET_ISALICE CKA[CKA_X2RATCHET_ISALICE] = "CKA_X2RATCHET_ISALICE" CKA_X2RATCHET_NHKR = PyKCS11.LowLevel.CKA_X2RATCHET_NHKR CKA["CKA_X2RATCHET_NHKR"] = CKA_X2RATCHET_NHKR CKA[CKA_X2RATCHET_NHKR] = "CKA_X2RATCHET_NHKR" CKA_X2RATCHET_NHKS = PyKCS11.LowLevel.CKA_X2RATCHET_NHKS CKA["CKA_X2RATCHET_NHKS"] = CKA_X2RATCHET_NHKS CKA[CKA_X2RATCHET_NHKS] = "CKA_X2RATCHET_NHKS" CKA_X2RATCHET_NR = PyKCS11.LowLevel.CKA_X2RATCHET_NR CKA["CKA_X2RATCHET_NR"] = CKA_X2RATCHET_NR CKA[CKA_X2RATCHET_NR] = "CKA_X2RATCHET_NR" CKA_X2RATCHET_NS = PyKCS11.LowLevel.CKA_X2RATCHET_NS CKA["CKA_X2RATCHET_NS"] = CKA_X2RATCHET_NS CKA[CKA_X2RATCHET_NS] = "CKA_X2RATCHET_NS" CKA_X2RATCHET_PNS = PyKCS11.LowLevel.CKA_X2RATCHET_PNS CKA["CKA_X2RATCHET_PNS"] = CKA_X2RATCHET_PNS CKA[CKA_X2RATCHET_PNS] = "CKA_X2RATCHET_PNS" CKA_X2RATCHET_RK = PyKCS11.LowLevel.CKA_X2RATCHET_RK CKA["CKA_X2RATCHET_RK"] = CKA_X2RATCHET_RK CKA[CKA_X2RATCHET_RK] = "CKA_X2RATCHET_RK" CKA_HSS_LEVELS = PyKCS11.LowLevel.CKA_HSS_LEVELS CKA["CKA_HSS_LEVELS"] = CKA_HSS_LEVELS CKA[CKA_HSS_LEVELS] = "CKA_HSS_LEVELS" CKA_HSS_LMS_TYPE = PyKCS11.LowLevel.CKA_HSS_LMS_TYPE CKA["CKA_HSS_LMS_TYPE"] = CKA_HSS_LMS_TYPE CKA[CKA_HSS_LMS_TYPE] = "CKA_HSS_LMS_TYPE" CKA_HSS_LMOTS_TYPE = PyKCS11.LowLevel.CKA_HSS_LMOTS_TYPE CKA["CKA_HSS_LMOTS_TYPE"] = CKA_HSS_LMOTS_TYPE CKA[CKA_HSS_LMOTS_TYPE] = "CKA_HSS_LMOTS_TYPE" CKA_HSS_LMS_TYPES = PyKCS11.LowLevel.CKA_HSS_LMS_TYPES CKA["CKA_HSS_LMS_TYPES"] = CKA_HSS_LMS_TYPES CKA[CKA_HSS_LMS_TYPES] = "CKA_HSS_LMS_TYPES" CKA_HSS_LMOTS_TYPES = PyKCS11.LowLevel.CKA_HSS_LMOTS_TYPES CKA["CKA_HSS_LMOTS_TYPES"] = CKA_HSS_LMOTS_TYPES CKA[CKA_HSS_LMOTS_TYPES] = "CKA_HSS_LMOTS_TYPES" CKA_HSS_KEYS_REMAINING = PyKCS11.LowLevel.CKA_HSS_KEYS_REMAINING CKA["CKA_HSS_KEYS_REMAINING"] = CKA_HSS_KEYS_REMAINING CKA[CKA_HSS_KEYS_REMAINING] = "CKA_HSS_KEYS_REMAINING" CKA_PARAMETER_SET = PyKCS11.LowLevel.CKA_PARAMETER_SET CKA["CKA_PARAMETER_SET"] = CKA_PARAMETER_SET CKA[CKA_PARAMETER_SET] = "CKA_PARAMETER_SET" CKA_OBJECT_VALIDATION_FLAGS = PyKCS11.LowLevel.CKA_OBJECT_VALIDATION_FLAGS CKA["CKA_OBJECT_VALIDATION_FLAGS"] = CKA_OBJECT_VALIDATION_FLAGS CKA[CKA_OBJECT_VALIDATION_FLAGS] = "CKA_OBJECT_VALIDATION_FLAGS" CKA_VALIDATION_TYPE = PyKCS11.LowLevel.CKA_VALIDATION_TYPE CKA["CKA_VALIDATION_TYPE"] = CKA_VALIDATION_TYPE CKA[CKA_VALIDATION_TYPE] = "CKA_VALIDATION_TYPE" CKA_VALIDATION_VERSION = PyKCS11.LowLevel.CKA_VALIDATION_VERSION CKA["CKA_VALIDATION_VERSION"] = CKA_VALIDATION_VERSION CKA[CKA_VALIDATION_VERSION] = "CKA_VALIDATION_VERSION" CKA_VALIDATION_LEVEL = PyKCS11.LowLevel.CKA_VALIDATION_LEVEL CKA["CKA_VALIDATION_LEVEL"] = CKA_VALIDATION_LEVEL CKA[CKA_VALIDATION_LEVEL] = "CKA_VALIDATION_LEVEL" CKA_VALIDATION_MODULE_ID = PyKCS11.LowLevel.CKA_VALIDATION_MODULE_ID CKA["CKA_VALIDATION_MODULE_ID"] = CKA_VALIDATION_MODULE_ID CKA[CKA_VALIDATION_MODULE_ID] = "CKA_VALIDATION_MODULE_ID" CKA_VALIDATION_FLAG = PyKCS11.LowLevel.CKA_VALIDATION_FLAG CKA["CKA_VALIDATION_FLAG"] = CKA_VALIDATION_FLAG CKA[CKA_VALIDATION_FLAG] = "CKA_VALIDATION_FLAG" CKA_VALIDATION_AUTHORITY_TYPE = PyKCS11.LowLevel.CKA_VALIDATION_AUTHORITY_TYPE CKA["CKA_VALIDATION_AUTHORITY_TYPE"] = CKA_VALIDATION_AUTHORITY_TYPE CKA[CKA_VALIDATION_AUTHORITY_TYPE] = "CKA_VALIDATION_AUTHORITY_TYPE" CKA_VALIDATION_COUNTRY = PyKCS11.LowLevel.CKA_VALIDATION_COUNTRY CKA["CKA_VALIDATION_COUNTRY"] = CKA_VALIDATION_COUNTRY CKA[CKA_VALIDATION_COUNTRY] = "CKA_VALIDATION_COUNTRY" CKA_VALIDATION_CERTIFICATE_IDENTIFIER = ( PyKCS11.LowLevel.CKA_VALIDATION_CERTIFICATE_IDENTIFIER ) CKA["CKA_VALIDATION_CERTIFICATE_IDENTIFIER"] = CKA_VALIDATION_CERTIFICATE_IDENTIFIER CKA[CKA_VALIDATION_CERTIFICATE_IDENTIFIER] = "CKA_VALIDATION_CERTIFICATE_IDENTIFIER" CKA_VALIDATION_CERTIFICATE_URI = PyKCS11.LowLevel.CKA_VALIDATION_CERTIFICATE_URI CKA["CKA_VALIDATION_CERTIFICATE_URI"] = CKA_VALIDATION_CERTIFICATE_URI CKA[CKA_VALIDATION_CERTIFICATE_URI] = "CKA_VALIDATION_CERTIFICATE_URI" CKA_VALIDATION_VENDOR_URI = PyKCS11.LowLevel.CKA_VALIDATION_VENDOR_URI CKA["CKA_VALIDATION_VENDOR_URI"] = CKA_VALIDATION_VENDOR_URI CKA[CKA_VALIDATION_VENDOR_URI] = "CKA_VALIDATION_VENDOR_URI" CKA_VALIDATION_PROFILE = PyKCS11.LowLevel.CKA_VALIDATION_PROFILE CKA["CKA_VALIDATION_PROFILE"] = CKA_VALIDATION_PROFILE CKA[CKA_VALIDATION_PROFILE] = "CKA_VALIDATION_PROFILE" CKA_ENCAPSULATE_TEMPLATE = PyKCS11.LowLevel.CKA_ENCAPSULATE_TEMPLATE CKA["CKA_ENCAPSULATE_TEMPLATE"] = CKA_ENCAPSULATE_TEMPLATE CKA[CKA_ENCAPSULATE_TEMPLATE] = "CKA_ENCAPSULATE_TEMPLATE" CKA_DECAPSULATE_TEMPLATE = PyKCS11.LowLevel.CKA_DECAPSULATE_TEMPLATE CKA["CKA_DECAPSULATE_TEMPLATE"] = CKA_DECAPSULATE_TEMPLATE CKA[CKA_DECAPSULATE_TEMPLATE] = "CKA_DECAPSULATE_TEMPLATE" CKA_TRUST_SERVER_AUTH = PyKCS11.LowLevel.CKA_TRUST_SERVER_AUTH CKA["CKA_TRUST_SERVER_AUTH"] = CKA_TRUST_SERVER_AUTH CKA[CKA_TRUST_SERVER_AUTH] = "CKA_TRUST_SERVER_AUTH" CKA_TRUST_CLIENT_AUTH = PyKCS11.LowLevel.CKA_TRUST_CLIENT_AUTH CKA["CKA_TRUST_CLIENT_AUTH"] = CKA_TRUST_CLIENT_AUTH CKA[CKA_TRUST_CLIENT_AUTH] = "CKA_TRUST_CLIENT_AUTH" CKA_TRUST_CODE_SIGNING = PyKCS11.LowLevel.CKA_TRUST_CODE_SIGNING CKA["CKA_TRUST_CODE_SIGNING"] = CKA_TRUST_CODE_SIGNING CKA[CKA_TRUST_CODE_SIGNING] = "CKA_TRUST_CODE_SIGNING" CKA_TRUST_EMAIL_PROTECTION = PyKCS11.LowLevel.CKA_TRUST_EMAIL_PROTECTION CKA["CKA_TRUST_EMAIL_PROTECTION"] = CKA_TRUST_EMAIL_PROTECTION CKA[CKA_TRUST_EMAIL_PROTECTION] = "CKA_TRUST_EMAIL_PROTECTION" CKA_TRUST_IPSEC_IKE = PyKCS11.LowLevel.CKA_TRUST_IPSEC_IKE CKA["CKA_TRUST_IPSEC_IKE"] = CKA_TRUST_IPSEC_IKE CKA[CKA_TRUST_IPSEC_IKE] = "CKA_TRUST_IPSEC_IKE" CKA_TRUST_TIME_STAMPING = PyKCS11.LowLevel.CKA_TRUST_TIME_STAMPING CKA["CKA_TRUST_TIME_STAMPING"] = CKA_TRUST_TIME_STAMPING CKA[CKA_TRUST_TIME_STAMPING] = "CKA_TRUST_TIME_STAMPING" CKA_TRUST_OCSP_SIGNING = PyKCS11.LowLevel.CKA_TRUST_OCSP_SIGNING CKA["CKA_TRUST_OCSP_SIGNING"] = CKA_TRUST_OCSP_SIGNING CKA[CKA_TRUST_OCSP_SIGNING] = "CKA_TRUST_OCSP_SIGNING" CKA_ENCAPSULATE = PyKCS11.LowLevel.CKA_ENCAPSULATE CKA["CKA_ENCAPSULATE"] = CKA_ENCAPSULATE CKA[CKA_ENCAPSULATE] = "CKA_ENCAPSULATE" CKA_DECAPSULATE = PyKCS11.LowLevel.CKA_DECAPSULATE CKA["CKA_DECAPSULATE"] = CKA_DECAPSULATE CKA[CKA_DECAPSULATE] = "CKA_DECAPSULATE" CKA_HASH_OF_CERTIFICATE = PyKCS11.LowLevel.CKA_HASH_OF_CERTIFICATE CKA["CKA_HASH_OF_CERTIFICATE"] = CKA_HASH_OF_CERTIFICATE CKA[CKA_HASH_OF_CERTIFICATE] = "CKA_HASH_OF_CERTIFICATE" CKA_PUBLIC_CRC64_VALUE = PyKCS11.LowLevel.CKA_PUBLIC_CRC64_VALUE CKA["CKA_PUBLIC_CRC64_VALUE"] = CKA_PUBLIC_CRC64_VALUE CKA[CKA_PUBLIC_CRC64_VALUE] = "CKA_PUBLIC_CRC64_VALUE" CKA_SEED = PyKCS11.LowLevel.CKA_SEED CKA["CKA_SEED"] = CKA_SEED CKA[CKA_SEED] = "CKA_SEED" CKA_VENDOR_DEFINED = PyKCS11.LowLevel.CKA_VENDOR_DEFINED CKA_WRAP_TEMPLATE = PyKCS11.LowLevel.CKA_WRAP_TEMPLATE CKA["CKA_WRAP_TEMPLATE"] = CKA_WRAP_TEMPLATE CKA[CKA_WRAP_TEMPLATE] = "CKA_WRAP_TEMPLATE" CKA_UNWRAP_TEMPLATE = PyKCS11.LowLevel.CKA_UNWRAP_TEMPLATE CKA["CKA_UNWRAP_TEMPLATE"] = CKA_UNWRAP_TEMPLATE CKA[CKA_UNWRAP_TEMPLATE] = "CKA_UNWRAP_TEMPLATE" CKA_DERIVE_TEMPLATE = PyKCS11.LowLevel.CKA_DERIVE_TEMPLATE CKA["CKA_DERIVE_TEMPLATE"] = CKA_DERIVE_TEMPLATE CKA[CKA_DERIVE_TEMPLATE] = "CKA_DERIVE_TEMPLATE" CKA_ALLOWED_MECHANISMS = PyKCS11.LowLevel.CKA_ALLOWED_MECHANISMS CKA["CKA_ALLOWED_MECHANISMS"] = CKA_ALLOWED_MECHANISMS CKA[CKA_ALLOWED_MECHANISMS] = "CKA_ALLOWED_MECHANISMS" CKA_ECDSA_PARAMS = PyKCS11.LowLevel.CKA_ECDSA_PARAMS CKA["CKA_ECDSA_PARAMS"] = CKA_ECDSA_PARAMS CKA[CKA_ECDSA_PARAMS] = "CKA_ECDSA_PARAMS" CKA_SECONDARY_AUTH = PyKCS11.LowLevel.CKA_SECONDARY_AUTH CKA["CKA_SECONDARY_AUTH"] = CKA_SECONDARY_AUTH CKA[CKA_SECONDARY_AUTH] = "CKA_SECONDARY_AUTH" CKA_AUTH_PIN_FLAGS = PyKCS11.LowLevel.CKA_AUTH_PIN_FLAGS CKA["CKA_AUTH_PIN_FLAGS"] = CKA_AUTH_PIN_FLAGS CKA[CKA_AUTH_PIN_FLAGS] = "CKA_AUTH_PIN_FLAGS" # CKC constants CKC = {} CKC_X_509 = PyKCS11.LowLevel.CKC_X_509 CKC["CKC_X_509"] = CKC_X_509 CKC[CKC_X_509] = "CKC_X_509" CKC_X_509_ATTR_CERT = PyKCS11.LowLevel.CKC_X_509_ATTR_CERT CKC["CKC_X_509_ATTR_CERT"] = CKC_X_509_ATTR_CERT CKC[CKC_X_509_ATTR_CERT] = "CKC_X_509_ATTR_CERT" CKC_WTLS = PyKCS11.LowLevel.CKC_WTLS CKC["CKC_WTLS"] = CKC_WTLS CKC[CKC_WTLS] = "CKC_WTLS" CKC_VENDOR_DEFINED = PyKCS11.LowLevel.CKC_VENDOR_DEFINED # CKD constants CKD = {} CKD_NULL = PyKCS11.LowLevel.CKD_NULL CKD["CKD_NULL"] = CKD_NULL CKD[CKD_NULL] = "CKD_NULL" CKD_SHA1_KDF = PyKCS11.LowLevel.CKD_SHA1_KDF CKD["CKD_SHA1_KDF"] = CKD_SHA1_KDF CKD[CKD_SHA1_KDF] = "CKD_SHA1_KDF" CKD_SHA1_KDF_ASN1 = PyKCS11.LowLevel.CKD_SHA1_KDF_ASN1 CKD["CKD_SHA1_KDF_ASN1"] = CKD_SHA1_KDF_ASN1 CKD[CKD_SHA1_KDF_ASN1] = "CKD_SHA1_KDF_ASN1" CKD_SHA1_KDF_CONCATENATE = PyKCS11.LowLevel.CKD_SHA1_KDF_CONCATENATE CKD["CKD_SHA1_KDF_CONCATENATE"] = CKD_SHA1_KDF_CONCATENATE CKD[CKD_SHA1_KDF_CONCATENATE] = "CKD_SHA1_KDF_CONCATENATE" CKD_SHA224_KDF = PyKCS11.LowLevel.CKD_SHA224_KDF CKD["CKD_SHA224_KDF"] = CKD_SHA224_KDF CKD[CKD_SHA224_KDF] = "CKD_SHA224_KDF" CKD_SHA256_KDF = PyKCS11.LowLevel.CKD_SHA256_KDF CKD["CKD_SHA256_KDF"] = CKD_SHA256_KDF CKD[CKD_SHA256_KDF] = "CKD_SHA256_KDF" CKD_SHA384_KDF = PyKCS11.LowLevel.CKD_SHA384_KDF CKD["CKD_SHA384_KDF"] = CKD_SHA384_KDF CKD[CKD_SHA384_KDF] = "CKD_SHA384_KDF" CKD_SHA512_KDF = PyKCS11.LowLevel.CKD_SHA512_KDF CKD["CKD_SHA512_KDF"] = CKD_SHA512_KDF CKD[CKD_SHA512_KDF] = "CKD_SHA512_KDF" CKD_CPDIVERSIFY_KDF = PyKCS11.LowLevel.CKD_CPDIVERSIFY_KDF CKD["CKD_CPDIVERSIFY_KDF"] = CKD_CPDIVERSIFY_KDF CKD[CKD_CPDIVERSIFY_KDF] = "CKD_CPDIVERSIFY_KDF" CKD_SHA3_224_KDF = PyKCS11.LowLevel.CKD_SHA3_224_KDF CKD["CKD_SHA3_224_KDF"] = CKD_SHA3_224_KDF CKD[CKD_SHA3_224_KDF] = "CKD_SHA3_224_KDF" CKD_SHA3_256_KDF = PyKCS11.LowLevel.CKD_SHA3_256_KDF CKD["CKD_SHA3_256_KDF"] = CKD_SHA3_256_KDF CKD[CKD_SHA3_256_KDF] = "CKD_SHA3_256_KDF" CKD_SHA3_384_KDF = PyKCS11.LowLevel.CKD_SHA3_384_KDF CKD["CKD_SHA3_384_KDF"] = CKD_SHA3_384_KDF CKD[CKD_SHA3_384_KDF] = "CKD_SHA3_384_KDF" CKD_SHA3_512_KDF = PyKCS11.LowLevel.CKD_SHA3_512_KDF CKD["CKD_SHA3_512_KDF"] = CKD_SHA3_512_KDF CKD[CKD_SHA3_512_KDF] = "CKD_SHA3_512_KDF" CKD_SHA1_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA1_KDF_SP800 CKD["CKD_SHA1_KDF_SP800"] = CKD_SHA1_KDF_SP800 CKD[CKD_SHA1_KDF_SP800] = "CKD_SHA1_KDF_SP800" CKD_SHA224_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA224_KDF_SP800 CKD["CKD_SHA224_KDF_SP800"] = CKD_SHA224_KDF_SP800 CKD[CKD_SHA224_KDF_SP800] = "CKD_SHA224_KDF_SP800" CKD_SHA256_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA256_KDF_SP800 CKD["CKD_SHA256_KDF_SP800"] = CKD_SHA256_KDF_SP800 CKD[CKD_SHA256_KDF_SP800] = "CKD_SHA256_KDF_SP800" CKD_SHA384_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA384_KDF_SP800 CKD["CKD_SHA384_KDF_SP800"] = CKD_SHA384_KDF_SP800 CKD[CKD_SHA384_KDF_SP800] = "CKD_SHA384_KDF_SP800" CKD_SHA512_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA512_KDF_SP800 CKD["CKD_SHA512_KDF_SP800"] = CKD_SHA512_KDF_SP800 CKD[CKD_SHA512_KDF_SP800] = "CKD_SHA512_KDF_SP800" CKD_SHA3_224_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA3_224_KDF_SP800 CKD["CKD_SHA3_224_KDF_SP800"] = CKD_SHA3_224_KDF_SP800 CKD[CKD_SHA3_224_KDF_SP800] = "CKD_SHA3_224_KDF_SP800" CKD_SHA3_256_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA3_256_KDF_SP800 CKD["CKD_SHA3_256_KDF_SP800"] = CKD_SHA3_256_KDF_SP800 CKD[CKD_SHA3_256_KDF_SP800] = "CKD_SHA3_256_KDF_SP800" CKD_SHA3_384_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA3_384_KDF_SP800 CKD["CKD_SHA3_384_KDF_SP800"] = CKD_SHA3_384_KDF_SP800 CKD[CKD_SHA3_384_KDF_SP800] = "CKD_SHA3_384_KDF_SP800" CKD_SHA3_512_KDF_SP800 = PyKCS11.LowLevel.CKD_SHA3_512_KDF_SP800 CKD["CKD_SHA3_512_KDF_SP800"] = CKD_SHA3_512_KDF_SP800 CKD[CKD_SHA3_512_KDF_SP800] = "CKD_SHA3_512_KDF_SP800" CKD_BLAKE2B_160_KDF = PyKCS11.LowLevel.CKD_BLAKE2B_160_KDF CKD["CKD_BLAKE2B_160_KDF"] = CKD_BLAKE2B_160_KDF CKD[CKD_BLAKE2B_160_KDF] = "CKD_BLAKE2B_160_KDF" CKD_BLAKE2B_256_KDF = PyKCS11.LowLevel.CKD_BLAKE2B_256_KDF CKD["CKD_BLAKE2B_256_KDF"] = CKD_BLAKE2B_256_KDF CKD[CKD_BLAKE2B_256_KDF] = "CKD_BLAKE2B_256_KDF" CKD_BLAKE2B_384_KDF = PyKCS11.LowLevel.CKD_BLAKE2B_384_KDF CKD["CKD_BLAKE2B_384_KDF"] = CKD_BLAKE2B_384_KDF CKD[CKD_BLAKE2B_384_KDF] = "CKD_BLAKE2B_384_KDF" CKD_BLAKE2B_512_KDF = PyKCS11.LowLevel.CKD_BLAKE2B_512_KDF CKD["CKD_BLAKE2B_512_KDF"] = CKD_BLAKE2B_512_KDF CKD[CKD_BLAKE2B_512_KDF] = "CKD_BLAKE2B_512_KDF" # CKF constants CKF = {} CKF_ARRAY_ATTRIBUTE = PyKCS11.LowLevel.CKF_ARRAY_ATTRIBUTE CKF["CKF_ARRAY_ATTRIBUTE"] = CKF_ARRAY_ATTRIBUTE CKF[CKF_ARRAY_ATTRIBUTE] = "CKF_ARRAY_ATTRIBUTE" CKF_LIBRARY_CANT_CREATE_OS_THREADS = PyKCS11.LowLevel.CKF_LIBRARY_CANT_CREATE_OS_THREADS CKF["CKF_LIBRARY_CANT_CREATE_OS_THREADS"] = CKF_LIBRARY_CANT_CREATE_OS_THREADS CKF[CKF_LIBRARY_CANT_CREATE_OS_THREADS] = "CKF_LIBRARY_CANT_CREATE_OS_THREADS" CKF_OS_LOCKING_OK = PyKCS11.LowLevel.CKF_OS_LOCKING_OK CKF["CKF_OS_LOCKING_OK"] = CKF_OS_LOCKING_OK CKF[CKF_OS_LOCKING_OK] = "CKF_OS_LOCKING_OK" CKF_HKDF_SALT_NULL = PyKCS11.LowLevel.CKF_HKDF_SALT_NULL CKF["CKF_HKDF_SALT_NULL"] = CKF_HKDF_SALT_NULL CKF[CKF_HKDF_SALT_NULL] = "CKF_HKDF_SALT_NULL" CKF_HKDF_SALT_DATA = PyKCS11.LowLevel.CKF_HKDF_SALT_DATA CKF["CKF_HKDF_SALT_DATA"] = CKF_HKDF_SALT_DATA CKF[CKF_HKDF_SALT_DATA] = "CKF_HKDF_SALT_DATA" CKF_HKDF_SALT_KEY = PyKCS11.LowLevel.CKF_HKDF_SALT_KEY CKF["CKF_HKDF_SALT_KEY"] = CKF_HKDF_SALT_KEY CKF[CKF_HKDF_SALT_KEY] = "CKF_HKDF_SALT_KEY" CKF_INTERFACE_FORK_SAFE = PyKCS11.LowLevel.CKF_INTERFACE_FORK_SAFE CKF["CKF_INTERFACE_FORK_SAFE"] = CKF_INTERFACE_FORK_SAFE CKF[CKF_INTERFACE_FORK_SAFE] = "CKF_INTERFACE_FORK_SAFE" CKF_HW = PyKCS11.LowLevel.CKF_HW CKF["CKF_HW"] = CKF_HW CKF[CKF_HW] = "CKF_HW" CKF_MESSAGE_ENCRYPT = PyKCS11.LowLevel.CKF_MESSAGE_ENCRYPT CKF["CKF_MESSAGE_ENCRYPT"] = CKF_MESSAGE_ENCRYPT CKF[CKF_MESSAGE_ENCRYPT] = "CKF_MESSAGE_ENCRYPT" CKF_MESSAGE_DECRYPT = PyKCS11.LowLevel.CKF_MESSAGE_DECRYPT CKF["CKF_MESSAGE_DECRYPT"] = CKF_MESSAGE_DECRYPT CKF[CKF_MESSAGE_DECRYPT] = "CKF_MESSAGE_DECRYPT" CKF_MESSAGE_SIGN = PyKCS11.LowLevel.CKF_MESSAGE_SIGN CKF["CKF_MESSAGE_SIGN"] = CKF_MESSAGE_SIGN CKF[CKF_MESSAGE_SIGN] = "CKF_MESSAGE_SIGN" CKF_MESSAGE_VERIFY = PyKCS11.LowLevel.CKF_MESSAGE_VERIFY CKF["CKF_MESSAGE_VERIFY"] = CKF_MESSAGE_VERIFY CKF[CKF_MESSAGE_VERIFY] = "CKF_MESSAGE_VERIFY" CKF_MULTI_MESSAGE = PyKCS11.LowLevel.CKF_MULTI_MESSAGE CKF["CKF_MULTI_MESSAGE"] = CKF_MULTI_MESSAGE CKF[CKF_MULTI_MESSAGE] = "CKF_MULTI_MESSAGE" CKF_MULTI_MESSGE = PyKCS11.LowLevel.CKF_MULTI_MESSGE CKF["CKF_MULTI_MESSGE"] = CKF_MULTI_MESSGE CKF[CKF_MULTI_MESSGE] = "CKF_MULTI_MESSGE" CKF_FIND_OBJECTS = PyKCS11.LowLevel.CKF_FIND_OBJECTS CKF["CKF_FIND_OBJECTS"] = CKF_FIND_OBJECTS CKF[CKF_FIND_OBJECTS] = "CKF_FIND_OBJECTS" CKF_ENCRYPT = PyKCS11.LowLevel.CKF_ENCRYPT CKF["CKF_ENCRYPT"] = CKF_ENCRYPT CKF[CKF_ENCRYPT] = "CKF_ENCRYPT" CKF_DECRYPT = PyKCS11.LowLevel.CKF_DECRYPT CKF["CKF_DECRYPT"] = CKF_DECRYPT CKF[CKF_DECRYPT] = "CKF_DECRYPT" CKF_DIGEST = PyKCS11.LowLevel.CKF_DIGEST CKF["CKF_DIGEST"] = CKF_DIGEST CKF[CKF_DIGEST] = "CKF_DIGEST" CKF_SIGN = PyKCS11.LowLevel.CKF_SIGN CKF["CKF_SIGN"] = CKF_SIGN CKF[CKF_SIGN] = "CKF_SIGN" CKF_SIGN_RECOVER = PyKCS11.LowLevel.CKF_SIGN_RECOVER CKF["CKF_SIGN_RECOVER"] = CKF_SIGN_RECOVER CKF[CKF_SIGN_RECOVER] = "CKF_SIGN_RECOVER" CKF_VERIFY = PyKCS11.LowLevel.CKF_VERIFY CKF["CKF_VERIFY"] = CKF_VERIFY CKF[CKF_VERIFY] = "CKF_VERIFY" CKF_VERIFY_RECOVER = PyKCS11.LowLevel.CKF_VERIFY_RECOVER CKF["CKF_VERIFY_RECOVER"] = CKF_VERIFY_RECOVER CKF[CKF_VERIFY_RECOVER] = "CKF_VERIFY_RECOVER" CKF_GENERATE = PyKCS11.LowLevel.CKF_GENERATE CKF["CKF_GENERATE"] = CKF_GENERATE CKF[CKF_GENERATE] = "CKF_GENERATE" CKF_GENERATE_KEY_PAIR = PyKCS11.LowLevel.CKF_GENERATE_KEY_PAIR CKF["CKF_GENERATE_KEY_PAIR"] = CKF_GENERATE_KEY_PAIR CKF[CKF_GENERATE_KEY_PAIR] = "CKF_GENERATE_KEY_PAIR" CKF_WRAP = PyKCS11.LowLevel.CKF_WRAP CKF["CKF_WRAP"] = CKF_WRAP CKF[CKF_WRAP] = "CKF_WRAP" CKF_UNWRAP = PyKCS11.LowLevel.CKF_UNWRAP CKF["CKF_UNWRAP"] = CKF_UNWRAP CKF[CKF_UNWRAP] = "CKF_UNWRAP" CKF_DERIVE = PyKCS11.LowLevel.CKF_DERIVE CKF["CKF_DERIVE"] = CKF_DERIVE CKF[CKF_DERIVE] = "CKF_DERIVE" CKF_EC_F_P = PyKCS11.LowLevel.CKF_EC_F_P CKF["CKF_EC_F_P"] = CKF_EC_F_P CKF[CKF_EC_F_P] = "CKF_EC_F_P" CKF_EC_F_2M = PyKCS11.LowLevel.CKF_EC_F_2M CKF["CKF_EC_F_2M"] = CKF_EC_F_2M CKF[CKF_EC_F_2M] = "CKF_EC_F_2M" CKF_EC_ECPARAMETERS = PyKCS11.LowLevel.CKF_EC_ECPARAMETERS CKF["CKF_EC_ECPARAMETERS"] = CKF_EC_ECPARAMETERS CKF[CKF_EC_ECPARAMETERS] = "CKF_EC_ECPARAMETERS" CKF_EC_OID = PyKCS11.LowLevel.CKF_EC_OID CKF["CKF_EC_OID"] = CKF_EC_OID CKF[CKF_EC_OID] = "CKF_EC_OID" CKF_EC_UNCOMPRESS = PyKCS11.LowLevel.CKF_EC_UNCOMPRESS CKF["CKF_EC_UNCOMPRESS"] = CKF_EC_UNCOMPRESS CKF[CKF_EC_UNCOMPRESS] = "CKF_EC_UNCOMPRESS" CKF_EC_COMPRESS = PyKCS11.LowLevel.CKF_EC_COMPRESS CKF["CKF_EC_COMPRESS"] = CKF_EC_COMPRESS CKF[CKF_EC_COMPRESS] = "CKF_EC_COMPRESS" CKF_EC_CURVENAME = PyKCS11.LowLevel.CKF_EC_CURVENAME CKF["CKF_EC_CURVENAME"] = CKF_EC_CURVENAME CKF[CKF_EC_CURVENAME] = "CKF_EC_CURVENAME" CKF_ENCAPSULATE = PyKCS11.LowLevel.CKF_ENCAPSULATE CKF["CKF_ENCAPSULATE"] = CKF_ENCAPSULATE CKF[CKF_ENCAPSULATE] = "CKF_ENCAPSULATE" CKF_DECAPSULATE = PyKCS11.LowLevel.CKF_DECAPSULATE CKF["CKF_DECAPSULATE"] = CKF_DECAPSULATE CKF[CKF_DECAPSULATE] = "CKF_DECAPSULATE" CKF_EXTENSION = PyKCS11.LowLevel.CKF_EXTENSION CKF["CKF_EXTENSION"] = CKF_EXTENSION CKF[CKF_EXTENSION] = "CKF_EXTENSION" CKF_EC_NAMEDCURVE = PyKCS11.LowLevel.CKF_EC_NAMEDCURVE CKF["CKF_EC_NAMEDCURVE"] = CKF_EC_NAMEDCURVE CKF[CKF_EC_NAMEDCURVE] = "CKF_EC_NAMEDCURVE" CKF_END_OF_MESSAGE = PyKCS11.LowLevel.CKF_END_OF_MESSAGE CKF["CKF_END_OF_MESSAGE"] = CKF_END_OF_MESSAGE CKF[CKF_END_OF_MESSAGE] = "CKF_END_OF_MESSAGE" CKF_NEXT_OTP = PyKCS11.LowLevel.CKF_NEXT_OTP CKF["CKF_NEXT_OTP"] = CKF_NEXT_OTP CKF[CKF_NEXT_OTP] = "CKF_NEXT_OTP" CKF_EXCLUDE_TIME = PyKCS11.LowLevel.CKF_EXCLUDE_TIME CKF["CKF_EXCLUDE_TIME"] = CKF_EXCLUDE_TIME CKF[CKF_EXCLUDE_TIME] = "CKF_EXCLUDE_TIME" CKF_EXCLUDE_COUNTER = PyKCS11.LowLevel.CKF_EXCLUDE_COUNTER CKF["CKF_EXCLUDE_COUNTER"] = CKF_EXCLUDE_COUNTER CKF[CKF_EXCLUDE_COUNTER] = "CKF_EXCLUDE_COUNTER" CKF_EXCLUDE_CHALLENGE = PyKCS11.LowLevel.CKF_EXCLUDE_CHALLENGE CKF["CKF_EXCLUDE_CHALLENGE"] = CKF_EXCLUDE_CHALLENGE CKF[CKF_EXCLUDE_CHALLENGE] = "CKF_EXCLUDE_CHALLENGE" CKF_EXCLUDE_PIN = PyKCS11.LowLevel.CKF_EXCLUDE_PIN CKF["CKF_EXCLUDE_PIN"] = CKF_EXCLUDE_PIN CKF[CKF_EXCLUDE_PIN] = "CKF_EXCLUDE_PIN" CKF_USER_FRIENDLY_OTP = PyKCS11.LowLevel.CKF_USER_FRIENDLY_OTP CKF["CKF_USER_FRIENDLY_OTP"] = CKF_USER_FRIENDLY_OTP CKF[CKF_USER_FRIENDLY_OTP] = "CKF_USER_FRIENDLY_OTP" CKF_DONT_BLOCK = PyKCS11.LowLevel.CKF_DONT_BLOCK CKF["CKF_DONT_BLOCK"] = CKF_DONT_BLOCK CKF[CKF_DONT_BLOCK] = "CKF_DONT_BLOCK" CKF_RW_SESSION = PyKCS11.LowLevel.CKF_RW_SESSION CKF["CKF_RW_SESSION"] = CKF_RW_SESSION CKF[CKF_RW_SESSION] = "CKF_RW_SESSION" CKF_SERIAL_SESSION = PyKCS11.LowLevel.CKF_SERIAL_SESSION CKF["CKF_SERIAL_SESSION"] = CKF_SERIAL_SESSION CKF[CKF_SERIAL_SESSION] = "CKF_SERIAL_SESSION" CKF_ASYNC_SESSION = PyKCS11.LowLevel.CKF_ASYNC_SESSION CKF["CKF_ASYNC_SESSION"] = CKF_ASYNC_SESSION CKF[CKF_ASYNC_SESSION] = "CKF_ASYNC_SESSION" CKF_TOKEN_PRESENT = PyKCS11.LowLevel.CKF_TOKEN_PRESENT CKF["CKF_TOKEN_PRESENT"] = CKF_TOKEN_PRESENT CKF[CKF_TOKEN_PRESENT] = "CKF_TOKEN_PRESENT" CKF_REMOVABLE_DEVICE = PyKCS11.LowLevel.CKF_REMOVABLE_DEVICE CKF["CKF_REMOVABLE_DEVICE"] = CKF_REMOVABLE_DEVICE CKF[CKF_REMOVABLE_DEVICE] = "CKF_REMOVABLE_DEVICE" CKF_HW_SLOT = PyKCS11.LowLevel.CKF_HW_SLOT CKF["CKF_HW_SLOT"] = CKF_HW_SLOT CKF[CKF_HW_SLOT] = "CKF_HW_SLOT" CKF_RNG = PyKCS11.LowLevel.CKF_RNG CKF["CKF_RNG"] = CKF_RNG CKF[CKF_RNG] = "CKF_RNG" CKF_WRITE_PROTECTED = PyKCS11.LowLevel.CKF_WRITE_PROTECTED CKF["CKF_WRITE_PROTECTED"] = CKF_WRITE_PROTECTED CKF[CKF_WRITE_PROTECTED] = "CKF_WRITE_PROTECTED" CKF_LOGIN_REQUIRED = PyKCS11.LowLevel.CKF_LOGIN_REQUIRED CKF["CKF_LOGIN_REQUIRED"] = CKF_LOGIN_REQUIRED CKF[CKF_LOGIN_REQUIRED] = "CKF_LOGIN_REQUIRED" CKF_USER_PIN_INITIALIZED = PyKCS11.LowLevel.CKF_USER_PIN_INITIALIZED CKF["CKF_USER_PIN_INITIALIZED"] = CKF_USER_PIN_INITIALIZED CKF[CKF_USER_PIN_INITIALIZED] = "CKF_USER_PIN_INITIALIZED" CKF_RESTORE_KEY_NOT_NEEDED = PyKCS11.LowLevel.CKF_RESTORE_KEY_NOT_NEEDED CKF["CKF_RESTORE_KEY_NOT_NEEDED"] = CKF_RESTORE_KEY_NOT_NEEDED CKF[CKF_RESTORE_KEY_NOT_NEEDED] = "CKF_RESTORE_KEY_NOT_NEEDED" CKF_CLOCK_ON_TOKEN = PyKCS11.LowLevel.CKF_CLOCK_ON_TOKEN CKF["CKF_CLOCK_ON_TOKEN"] = CKF_CLOCK_ON_TOKEN CKF[CKF_CLOCK_ON_TOKEN] = "CKF_CLOCK_ON_TOKEN" CKF_PROTECTED_AUTHENTICATION_PATH = PyKCS11.LowLevel.CKF_PROTECTED_AUTHENTICATION_PATH CKF["CKF_PROTECTED_AUTHENTICATION_PATH"] = CKF_PROTECTED_AUTHENTICATION_PATH CKF[CKF_PROTECTED_AUTHENTICATION_PATH] = "CKF_PROTECTED_AUTHENTICATION_PATH" CKF_DUAL_CRYPTO_OPERATIONS = PyKCS11.LowLevel.CKF_DUAL_CRYPTO_OPERATIONS CKF["CKF_DUAL_CRYPTO_OPERATIONS"] = CKF_DUAL_CRYPTO_OPERATIONS CKF[CKF_DUAL_CRYPTO_OPERATIONS] = "CKF_DUAL_CRYPTO_OPERATIONS" CKF_TOKEN_INITIALIZED = PyKCS11.LowLevel.CKF_TOKEN_INITIALIZED CKF["CKF_TOKEN_INITIALIZED"] = CKF_TOKEN_INITIALIZED CKF[CKF_TOKEN_INITIALIZED] = "CKF_TOKEN_INITIALIZED" CKF_SECONDARY_AUTHENTICATION = PyKCS11.LowLevel.CKF_SECONDARY_AUTHENTICATION CKF["CKF_SECONDARY_AUTHENTICATION"] = CKF_SECONDARY_AUTHENTICATION CKF[CKF_SECONDARY_AUTHENTICATION] = "CKF_SECONDARY_AUTHENTICATION" CKF_USER_PIN_COUNT_LOW = PyKCS11.LowLevel.CKF_USER_PIN_COUNT_LOW CKF["CKF_USER_PIN_COUNT_LOW"] = CKF_USER_PIN_COUNT_LOW CKF[CKF_USER_PIN_COUNT_LOW] = "CKF_USER_PIN_COUNT_LOW" CKF_USER_PIN_FINAL_TRY = PyKCS11.LowLevel.CKF_USER_PIN_FINAL_TRY CKF["CKF_USER_PIN_FINAL_TRY"] = CKF_USER_PIN_FINAL_TRY CKF[CKF_USER_PIN_FINAL_TRY] = "CKF_USER_PIN_FINAL_TRY" CKF_USER_PIN_LOCKED = PyKCS11.LowLevel.CKF_USER_PIN_LOCKED CKF["CKF_USER_PIN_LOCKED"] = CKF_USER_PIN_LOCKED CKF[CKF_USER_PIN_LOCKED] = "CKF_USER_PIN_LOCKED" CKF_USER_PIN_TO_BE_CHANGED = PyKCS11.LowLevel.CKF_USER_PIN_TO_BE_CHANGED CKF["CKF_USER_PIN_TO_BE_CHANGED"] = CKF_USER_PIN_TO_BE_CHANGED CKF[CKF_USER_PIN_TO_BE_CHANGED] = "CKF_USER_PIN_TO_BE_CHANGED" CKF_SO_PIN_COUNT_LOW = PyKCS11.LowLevel.CKF_SO_PIN_COUNT_LOW CKF["CKF_SO_PIN_COUNT_LOW"] = CKF_SO_PIN_COUNT_LOW CKF[CKF_SO_PIN_COUNT_LOW] = "CKF_SO_PIN_COUNT_LOW" CKF_SO_PIN_FINAL_TRY = PyKCS11.LowLevel.CKF_SO_PIN_FINAL_TRY CKF["CKF_SO_PIN_FINAL_TRY"] = CKF_SO_PIN_FINAL_TRY CKF[CKF_SO_PIN_FINAL_TRY] = "CKF_SO_PIN_FINAL_TRY" CKF_SO_PIN_LOCKED = PyKCS11.LowLevel.CKF_SO_PIN_LOCKED CKF["CKF_SO_PIN_LOCKED"] = CKF_SO_PIN_LOCKED CKF[CKF_SO_PIN_LOCKED] = "CKF_SO_PIN_LOCKED" CKF_SO_PIN_TO_BE_CHANGED = PyKCS11.LowLevel.CKF_SO_PIN_TO_BE_CHANGED CKF["CKF_SO_PIN_TO_BE_CHANGED"] = CKF_SO_PIN_TO_BE_CHANGED CKF[CKF_SO_PIN_TO_BE_CHANGED] = "CKF_SO_PIN_TO_BE_CHANGED" CKF_ERROR_STATE = PyKCS11.LowLevel.CKF_ERROR_STATE CKF["CKF_ERROR_STATE"] = CKF_ERROR_STATE CKF[CKF_ERROR_STATE] = "CKF_ERROR_STATE" CKF_SEED_RANDOM_REQUIRED = PyKCS11.LowLevel.CKF_SEED_RANDOM_REQUIRED CKF["CKF_SEED_RANDOM_REQUIRED"] = CKF_SEED_RANDOM_REQUIRED CKF[CKF_SEED_RANDOM_REQUIRED] = "CKF_SEED_RANDOM_REQUIRED" CKF_ASYNC_SESSION_SUPPORTED = PyKCS11.LowLevel.CKF_ASYNC_SESSION_SUPPORTED CKF["CKF_ASYNC_SESSION_SUPPORTED"] = CKF_ASYNC_SESSION_SUPPORTED CKF[CKF_ASYNC_SESSION_SUPPORTED] = "CKF_ASYNC_SESSION_SUPPORTED" # CKG constants CKG = {} CKG_NO_GENERATE = PyKCS11.LowLevel.CKG_NO_GENERATE CKG["CKG_NO_GENERATE"] = CKG_NO_GENERATE CKG[CKG_NO_GENERATE] = "CKG_NO_GENERATE" CKG_GENERATE = PyKCS11.LowLevel.CKG_GENERATE CKG["CKG_GENERATE"] = CKG_GENERATE CKG[CKG_GENERATE] = "CKG_GENERATE" CKG_GENERATE_COUNTER = PyKCS11.LowLevel.CKG_GENERATE_COUNTER CKG["CKG_GENERATE_COUNTER"] = CKG_GENERATE_COUNTER CKG[CKG_GENERATE_COUNTER] = "CKG_GENERATE_COUNTER" CKG_GENERATE_RANDOM = PyKCS11.LowLevel.CKG_GENERATE_RANDOM CKG["CKG_GENERATE_RANDOM"] = CKG_GENERATE_RANDOM CKG[CKG_GENERATE_RANDOM] = "CKG_GENERATE_RANDOM" CKG_GENERATE_COUNTER_XOR = PyKCS11.LowLevel.CKG_GENERATE_COUNTER_XOR CKG["CKG_GENERATE_COUNTER_XOR"] = CKG_GENERATE_COUNTER_XOR CKG[CKG_GENERATE_COUNTER_XOR] = "CKG_GENERATE_COUNTER_XOR" CKG_MGF1_SHA1 = PyKCS11.LowLevel.CKG_MGF1_SHA1 CKG["CKG_MGF1_SHA1"] = CKG_MGF1_SHA1 CKG[CKG_MGF1_SHA1] = "CKG_MGF1_SHA1" CKG_MGF1_SHA256 = PyKCS11.LowLevel.CKG_MGF1_SHA256 CKG["CKG_MGF1_SHA256"] = CKG_MGF1_SHA256 CKG[CKG_MGF1_SHA256] = "CKG_MGF1_SHA256" CKG_MGF1_SHA384 = PyKCS11.LowLevel.CKG_MGF1_SHA384 CKG["CKG_MGF1_SHA384"] = CKG_MGF1_SHA384 CKG[CKG_MGF1_SHA384] = "CKG_MGF1_SHA384" CKG_MGF1_SHA512 = PyKCS11.LowLevel.CKG_MGF1_SHA512 CKG["CKG_MGF1_SHA512"] = CKG_MGF1_SHA512 CKG[CKG_MGF1_SHA512] = "CKG_MGF1_SHA512" CKG_MGF1_SHA224 = PyKCS11.LowLevel.CKG_MGF1_SHA224 CKG["CKG_MGF1_SHA224"] = CKG_MGF1_SHA224 CKG[CKG_MGF1_SHA224] = "CKG_MGF1_SHA224" CKG_MGF1_SHA3_224 = PyKCS11.LowLevel.CKG_MGF1_SHA3_224 CKG["CKG_MGF1_SHA3_224"] = CKG_MGF1_SHA3_224 CKG[CKG_MGF1_SHA3_224] = "CKG_MGF1_SHA3_224" CKG_MGF1_SHA3_256 = PyKCS11.LowLevel.CKG_MGF1_SHA3_256 CKG["CKG_MGF1_SHA3_256"] = CKG_MGF1_SHA3_256 CKG[CKG_MGF1_SHA3_256] = "CKG_MGF1_SHA3_256" CKG_MGF1_SHA3_384 = PyKCS11.LowLevel.CKG_MGF1_SHA3_384 CKG["CKG_MGF1_SHA3_384"] = CKG_MGF1_SHA3_384 CKG[CKG_MGF1_SHA3_384] = "CKG_MGF1_SHA3_384" CKG_MGF1_SHA3_512 = PyKCS11.LowLevel.CKG_MGF1_SHA3_512 CKG["CKG_MGF1_SHA3_512"] = CKG_MGF1_SHA3_512 CKG[CKG_MGF1_SHA3_512] = "CKG_MGF1_SHA3_512" # CKH constants CKH = {} CKH_MONOTONIC_COUNTER = PyKCS11.LowLevel.CKH_MONOTONIC_COUNTER CKH["CKH_MONOTONIC_COUNTER"] = CKH_MONOTONIC_COUNTER CKH[CKH_MONOTONIC_COUNTER] = "CKH_MONOTONIC_COUNTER" CKH_CLOCK = PyKCS11.LowLevel.CKH_CLOCK CKH["CKH_CLOCK"] = CKH_CLOCK CKH[CKH_CLOCK] = "CKH_CLOCK" CKH_USER_INTERFACE = PyKCS11.LowLevel.CKH_USER_INTERFACE CKH["CKH_USER_INTERFACE"] = CKH_USER_INTERFACE CKH[CKH_USER_INTERFACE] = "CKH_USER_INTERFACE" CKH_VENDOR_DEFINED = PyKCS11.LowLevel.CKH_VENDOR_DEFINED CKH_HEDGE_PREFERRED = PyKCS11.LowLevel.CKH_HEDGE_PREFERRED CKH["CKH_HEDGE_PREFERRED"] = CKH_HEDGE_PREFERRED CKH[CKH_HEDGE_PREFERRED] = "CKH_HEDGE_PREFERRED" CKH_HEDGE_REQUIRED = PyKCS11.LowLevel.CKH_HEDGE_REQUIRED CKH["CKH_HEDGE_REQUIRED"] = CKH_HEDGE_REQUIRED CKH[CKH_HEDGE_REQUIRED] = "CKH_HEDGE_REQUIRED" CKH_DETERMINISTIC_REQUIRED = PyKCS11.LowLevel.CKH_DETERMINISTIC_REQUIRED CKH["CKH_DETERMINISTIC_REQUIRED"] = CKH_DETERMINISTIC_REQUIRED CKH[CKH_DETERMINISTIC_REQUIRED] = "CKH_DETERMINISTIC_REQUIRED" # CKK constants CKK = {} CKK_RSA = PyKCS11.LowLevel.CKK_RSA CKK["CKK_RSA"] = CKK_RSA CKK[CKK_RSA] = "CKK_RSA" CKK_DSA = PyKCS11.LowLevel.CKK_DSA CKK["CKK_DSA"] = CKK_DSA CKK[CKK_DSA] = "CKK_DSA" CKK_DH = PyKCS11.LowLevel.CKK_DH CKK["CKK_DH"] = CKK_DH CKK[CKK_DH] = "CKK_DH" CKK_EC = PyKCS11.LowLevel.CKK_EC CKK["CKK_EC"] = CKK_EC CKK[CKK_EC] = "CKK_EC" CKK_X9_42_DH = PyKCS11.LowLevel.CKK_X9_42_DH CKK["CKK_X9_42_DH"] = CKK_X9_42_DH CKK[CKK_X9_42_DH] = "CKK_X9_42_DH" CKK_KEA = PyKCS11.LowLevel.CKK_KEA CKK["CKK_KEA"] = CKK_KEA CKK[CKK_KEA] = "CKK_KEA" CKK_GENERIC_SECRET = PyKCS11.LowLevel.CKK_GENERIC_SECRET CKK["CKK_GENERIC_SECRET"] = CKK_GENERIC_SECRET CKK[CKK_GENERIC_SECRET] = "CKK_GENERIC_SECRET" CKK_RC2 = PyKCS11.LowLevel.CKK_RC2 CKK["CKK_RC2"] = CKK_RC2 CKK[CKK_RC2] = "CKK_RC2" CKK_RC4 = PyKCS11.LowLevel.CKK_RC4 CKK["CKK_RC4"] = CKK_RC4 CKK[CKK_RC4] = "CKK_RC4" CKK_DES = PyKCS11.LowLevel.CKK_DES CKK["CKK_DES"] = CKK_DES CKK[CKK_DES] = "CKK_DES" CKK_DES2 = PyKCS11.LowLevel.CKK_DES2 CKK["CKK_DES2"] = CKK_DES2 CKK[CKK_DES2] = "CKK_DES2" CKK_DES3 = PyKCS11.LowLevel.CKK_DES3 CKK["CKK_DES3"] = CKK_DES3 CKK[CKK_DES3] = "CKK_DES3" CKK_CAST = PyKCS11.LowLevel.CKK_CAST CKK["CKK_CAST"] = CKK_CAST CKK[CKK_CAST] = "CKK_CAST" CKK_CAST3 = PyKCS11.LowLevel.CKK_CAST3 CKK["CKK_CAST3"] = CKK_CAST3 CKK[CKK_CAST3] = "CKK_CAST3" CKK_CAST128 = PyKCS11.LowLevel.CKK_CAST128 CKK["CKK_CAST128"] = CKK_CAST128 CKK[CKK_CAST128] = "CKK_CAST128" CKK_RC5 = PyKCS11.LowLevel.CKK_RC5 CKK["CKK_RC5"] = CKK_RC5 CKK[CKK_RC5] = "CKK_RC5" CKK_IDEA = PyKCS11.LowLevel.CKK_IDEA CKK["CKK_IDEA"] = CKK_IDEA CKK[CKK_IDEA] = "CKK_IDEA" CKK_SKIPJACK = PyKCS11.LowLevel.CKK_SKIPJACK CKK["CKK_SKIPJACK"] = CKK_SKIPJACK CKK[CKK_SKIPJACK] = "CKK_SKIPJACK" CKK_BATON = PyKCS11.LowLevel.CKK_BATON CKK["CKK_BATON"] = CKK_BATON CKK[CKK_BATON] = "CKK_BATON" CKK_JUNIPER = PyKCS11.LowLevel.CKK_JUNIPER CKK["CKK_JUNIPER"] = CKK_JUNIPER CKK[CKK_JUNIPER] = "CKK_JUNIPER" CKK_CDMF = PyKCS11.LowLevel.CKK_CDMF CKK["CKK_CDMF"] = CKK_CDMF CKK[CKK_CDMF] = "CKK_CDMF" CKK_AES = PyKCS11.LowLevel.CKK_AES CKK["CKK_AES"] = CKK_AES CKK[CKK_AES] = "CKK_AES" CKK_BLOWFISH = PyKCS11.LowLevel.CKK_BLOWFISH CKK["CKK_BLOWFISH"] = CKK_BLOWFISH CKK[CKK_BLOWFISH] = "CKK_BLOWFISH" CKK_TWOFISH = PyKCS11.LowLevel.CKK_TWOFISH CKK["CKK_TWOFISH"] = CKK_TWOFISH CKK[CKK_TWOFISH] = "CKK_TWOFISH" CKK_SECURID = PyKCS11.LowLevel.CKK_SECURID CKK["CKK_SECURID"] = CKK_SECURID CKK[CKK_SECURID] = "CKK_SECURID" CKK_HOTP = PyKCS11.LowLevel.CKK_HOTP CKK["CKK_HOTP"] = CKK_HOTP CKK[CKK_HOTP] = "CKK_HOTP" CKK_ACTI = PyKCS11.LowLevel.CKK_ACTI CKK["CKK_ACTI"] = CKK_ACTI CKK[CKK_ACTI] = "CKK_ACTI" CKK_CAMELLIA = PyKCS11.LowLevel.CKK_CAMELLIA CKK["CKK_CAMELLIA"] = CKK_CAMELLIA CKK[CKK_CAMELLIA] = "CKK_CAMELLIA" CKK_ARIA = PyKCS11.LowLevel.CKK_ARIA CKK["CKK_ARIA"] = CKK_ARIA CKK[CKK_ARIA] = "CKK_ARIA" CKK_MD5_HMAC = PyKCS11.LowLevel.CKK_MD5_HMAC CKK["CKK_MD5_HMAC"] = CKK_MD5_HMAC CKK[CKK_MD5_HMAC] = "CKK_MD5_HMAC" CKK_SHA_1_HMAC = PyKCS11.LowLevel.CKK_SHA_1_HMAC CKK["CKK_SHA_1_HMAC"] = CKK_SHA_1_HMAC CKK[CKK_SHA_1_HMAC] = "CKK_SHA_1_HMAC" CKK_RIPEMD128_HMAC = PyKCS11.LowLevel.CKK_RIPEMD128_HMAC CKK["CKK_RIPEMD128_HMAC"] = CKK_RIPEMD128_HMAC CKK[CKK_RIPEMD128_HMAC] = "CKK_RIPEMD128_HMAC" CKK_RIPEMD160_HMAC = PyKCS11.LowLevel.CKK_RIPEMD160_HMAC CKK["CKK_RIPEMD160_HMAC"] = CKK_RIPEMD160_HMAC CKK[CKK_RIPEMD160_HMAC] = "CKK_RIPEMD160_HMAC" CKK_SHA256_HMAC = PyKCS11.LowLevel.CKK_SHA256_HMAC CKK["CKK_SHA256_HMAC"] = CKK_SHA256_HMAC CKK[CKK_SHA256_HMAC] = "CKK_SHA256_HMAC" CKK_SHA384_HMAC = PyKCS11.LowLevel.CKK_SHA384_HMAC CKK["CKK_SHA384_HMAC"] = CKK_SHA384_HMAC CKK[CKK_SHA384_HMAC] = "CKK_SHA384_HMAC" CKK_SHA512_HMAC = PyKCS11.LowLevel.CKK_SHA512_HMAC CKK["CKK_SHA512_HMAC"] = CKK_SHA512_HMAC CKK[CKK_SHA512_HMAC] = "CKK_SHA512_HMAC" CKK_SHA224_HMAC = PyKCS11.LowLevel.CKK_SHA224_HMAC CKK["CKK_SHA224_HMAC"] = CKK_SHA224_HMAC CKK[CKK_SHA224_HMAC] = "CKK_SHA224_HMAC" CKK_SEED = PyKCS11.LowLevel.CKK_SEED CKK["CKK_SEED"] = CKK_SEED CKK[CKK_SEED] = "CKK_SEED" CKK_GOSTR3410 = PyKCS11.LowLevel.CKK_GOSTR3410 CKK["CKK_GOSTR3410"] = CKK_GOSTR3410 CKK[CKK_GOSTR3410] = "CKK_GOSTR3410" CKK_GOSTR3411 = PyKCS11.LowLevel.CKK_GOSTR3411 CKK["CKK_GOSTR3411"] = CKK_GOSTR3411 CKK[CKK_GOSTR3411] = "CKK_GOSTR3411" CKK_GOST28147 = PyKCS11.LowLevel.CKK_GOST28147 CKK["CKK_GOST28147"] = CKK_GOST28147 CKK[CKK_GOST28147] = "CKK_GOST28147" CKK_CHACHA20 = PyKCS11.LowLevel.CKK_CHACHA20 CKK["CKK_CHACHA20"] = CKK_CHACHA20 CKK[CKK_CHACHA20] = "CKK_CHACHA20" CKK_POLY1305 = PyKCS11.LowLevel.CKK_POLY1305 CKK["CKK_POLY1305"] = CKK_POLY1305 CKK[CKK_POLY1305] = "CKK_POLY1305" CKK_AES_XTS = PyKCS11.LowLevel.CKK_AES_XTS CKK["CKK_AES_XTS"] = CKK_AES_XTS CKK[CKK_AES_XTS] = "CKK_AES_XTS" CKK_SHA3_224_HMAC = PyKCS11.LowLevel.CKK_SHA3_224_HMAC CKK["CKK_SHA3_224_HMAC"] = CKK_SHA3_224_HMAC CKK[CKK_SHA3_224_HMAC] = "CKK_SHA3_224_HMAC" CKK_SHA3_256_HMAC = PyKCS11.LowLevel.CKK_SHA3_256_HMAC CKK["CKK_SHA3_256_HMAC"] = CKK_SHA3_256_HMAC CKK[CKK_SHA3_256_HMAC] = "CKK_SHA3_256_HMAC" CKK_SHA3_384_HMAC = PyKCS11.LowLevel.CKK_SHA3_384_HMAC CKK["CKK_SHA3_384_HMAC"] = CKK_SHA3_384_HMAC CKK[CKK_SHA3_384_HMAC] = "CKK_SHA3_384_HMAC" CKK_SHA3_512_HMAC = PyKCS11.LowLevel.CKK_SHA3_512_HMAC CKK["CKK_SHA3_512_HMAC"] = CKK_SHA3_512_HMAC CKK[CKK_SHA3_512_HMAC] = "CKK_SHA3_512_HMAC" CKK_BLAKE2B_160_HMAC = PyKCS11.LowLevel.CKK_BLAKE2B_160_HMAC CKK["CKK_BLAKE2B_160_HMAC"] = CKK_BLAKE2B_160_HMAC CKK[CKK_BLAKE2B_160_HMAC] = "CKK_BLAKE2B_160_HMAC" CKK_BLAKE2B_256_HMAC = PyKCS11.LowLevel.CKK_BLAKE2B_256_HMAC CKK["CKK_BLAKE2B_256_HMAC"] = CKK_BLAKE2B_256_HMAC CKK[CKK_BLAKE2B_256_HMAC] = "CKK_BLAKE2B_256_HMAC" CKK_BLAKE2B_384_HMAC = PyKCS11.LowLevel.CKK_BLAKE2B_384_HMAC CKK["CKK_BLAKE2B_384_HMAC"] = CKK_BLAKE2B_384_HMAC CKK[CKK_BLAKE2B_384_HMAC] = "CKK_BLAKE2B_384_HMAC" CKK_BLAKE2B_512_HMAC = PyKCS11.LowLevel.CKK_BLAKE2B_512_HMAC CKK["CKK_BLAKE2B_512_HMAC"] = CKK_BLAKE2B_512_HMAC CKK[CKK_BLAKE2B_512_HMAC] = "CKK_BLAKE2B_512_HMAC" CKK_SALSA20 = PyKCS11.LowLevel.CKK_SALSA20 CKK["CKK_SALSA20"] = CKK_SALSA20 CKK[CKK_SALSA20] = "CKK_SALSA20" CKK_X2RATCHET = PyKCS11.LowLevel.CKK_X2RATCHET CKK["CKK_X2RATCHET"] = CKK_X2RATCHET CKK[CKK_X2RATCHET] = "CKK_X2RATCHET" CKK_EC_EDWARDS = PyKCS11.LowLevel.CKK_EC_EDWARDS CKK["CKK_EC_EDWARDS"] = CKK_EC_EDWARDS CKK[CKK_EC_EDWARDS] = "CKK_EC_EDWARDS" CKK_EC_MONTGOMERY = PyKCS11.LowLevel.CKK_EC_MONTGOMERY CKK["CKK_EC_MONTGOMERY"] = CKK_EC_MONTGOMERY CKK[CKK_EC_MONTGOMERY] = "CKK_EC_MONTGOMERY" CKK_HKDF = PyKCS11.LowLevel.CKK_HKDF CKK["CKK_HKDF"] = CKK_HKDF CKK[CKK_HKDF] = "CKK_HKDF" CKK_SHA512_224_HMAC = PyKCS11.LowLevel.CKK_SHA512_224_HMAC CKK["CKK_SHA512_224_HMAC"] = CKK_SHA512_224_HMAC CKK[CKK_SHA512_224_HMAC] = "CKK_SHA512_224_HMAC" CKK_SHA512_256_HMAC = PyKCS11.LowLevel.CKK_SHA512_256_HMAC CKK["CKK_SHA512_256_HMAC"] = CKK_SHA512_256_HMAC CKK[CKK_SHA512_256_HMAC] = "CKK_SHA512_256_HMAC" CKK_SHA512_T_HMAC = PyKCS11.LowLevel.CKK_SHA512_T_HMAC CKK["CKK_SHA512_T_HMAC"] = CKK_SHA512_T_HMAC CKK[CKK_SHA512_T_HMAC] = "CKK_SHA512_T_HMAC" CKK_HSS = PyKCS11.LowLevel.CKK_HSS CKK["CKK_HSS"] = CKK_HSS CKK[CKK_HSS] = "CKK_HSS" CKK_XMSS = PyKCS11.LowLevel.CKK_XMSS CKK["CKK_XMSS"] = CKK_XMSS CKK[CKK_XMSS] = "CKK_XMSS" CKK_XMSSMT = PyKCS11.LowLevel.CKK_XMSSMT CKK["CKK_XMSSMT"] = CKK_XMSSMT CKK[CKK_XMSSMT] = "CKK_XMSSMT" CKK_ML_KEM = PyKCS11.LowLevel.CKK_ML_KEM CKK["CKK_ML_KEM"] = CKK_ML_KEM CKK[CKK_ML_KEM] = "CKK_ML_KEM" CKK_ML_DSA = PyKCS11.LowLevel.CKK_ML_DSA CKK["CKK_ML_DSA"] = CKK_ML_DSA CKK[CKK_ML_DSA] = "CKK_ML_DSA" CKK_SLH_DSA = PyKCS11.LowLevel.CKK_SLH_DSA CKK["CKK_SLH_DSA"] = CKK_SLH_DSA CKK[CKK_SLH_DSA] = "CKK_SLH_DSA" CKK_VENDOR_DEFINED = PyKCS11.LowLevel.CKK_VENDOR_DEFINED CKK_ECDSA = PyKCS11.LowLevel.CKK_ECDSA CKK["CKK_ECDSA"] = CKK_ECDSA CKK[CKK_ECDSA] = "CKK_ECDSA" CKK_CAST5 = PyKCS11.LowLevel.CKK_CAST5 CKK["CKK_CAST5"] = CKK_CAST5 CKK[CKK_CAST5] = "CKK_CAST5" # CKM constants CKM = {} CKM_RSA_PKCS_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_RSA_PKCS_KEY_PAIR_GEN CKM["CKM_RSA_PKCS_KEY_PAIR_GEN"] = CKM_RSA_PKCS_KEY_PAIR_GEN CKM[CKM_RSA_PKCS_KEY_PAIR_GEN] = "CKM_RSA_PKCS_KEY_PAIR_GEN" CKM_RSA_PKCS = PyKCS11.LowLevel.CKM_RSA_PKCS CKM["CKM_RSA_PKCS"] = CKM_RSA_PKCS CKM[CKM_RSA_PKCS] = "CKM_RSA_PKCS" CKM_RSA_9796 = PyKCS11.LowLevel.CKM_RSA_9796 CKM["CKM_RSA_9796"] = CKM_RSA_9796 CKM[CKM_RSA_9796] = "CKM_RSA_9796" CKM_RSA_X_509 = PyKCS11.LowLevel.CKM_RSA_X_509 CKM["CKM_RSA_X_509"] = CKM_RSA_X_509 CKM[CKM_RSA_X_509] = "CKM_RSA_X_509" CKM_MD2_RSA_PKCS = PyKCS11.LowLevel.CKM_MD2_RSA_PKCS CKM["CKM_MD2_RSA_PKCS"] = CKM_MD2_RSA_PKCS CKM[CKM_MD2_RSA_PKCS] = "CKM_MD2_RSA_PKCS" CKM_MD5_RSA_PKCS = PyKCS11.LowLevel.CKM_MD5_RSA_PKCS CKM["CKM_MD5_RSA_PKCS"] = CKM_MD5_RSA_PKCS CKM[CKM_MD5_RSA_PKCS] = "CKM_MD5_RSA_PKCS" CKM_SHA1_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA1_RSA_PKCS CKM["CKM_SHA1_RSA_PKCS"] = CKM_SHA1_RSA_PKCS CKM[CKM_SHA1_RSA_PKCS] = "CKM_SHA1_RSA_PKCS" CKM_RIPEMD128_RSA_PKCS = PyKCS11.LowLevel.CKM_RIPEMD128_RSA_PKCS CKM["CKM_RIPEMD128_RSA_PKCS"] = CKM_RIPEMD128_RSA_PKCS CKM[CKM_RIPEMD128_RSA_PKCS] = "CKM_RIPEMD128_RSA_PKCS" CKM_RIPEMD160_RSA_PKCS = PyKCS11.LowLevel.CKM_RIPEMD160_RSA_PKCS CKM["CKM_RIPEMD160_RSA_PKCS"] = CKM_RIPEMD160_RSA_PKCS CKM[CKM_RIPEMD160_RSA_PKCS] = "CKM_RIPEMD160_RSA_PKCS" CKM_RSA_PKCS_OAEP = PyKCS11.LowLevel.CKM_RSA_PKCS_OAEP CKM["CKM_RSA_PKCS_OAEP"] = CKM_RSA_PKCS_OAEP CKM[CKM_RSA_PKCS_OAEP] = "CKM_RSA_PKCS_OAEP" CKM_RSA_X9_31_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_RSA_X9_31_KEY_PAIR_GEN CKM["CKM_RSA_X9_31_KEY_PAIR_GEN"] = CKM_RSA_X9_31_KEY_PAIR_GEN CKM[CKM_RSA_X9_31_KEY_PAIR_GEN] = "CKM_RSA_X9_31_KEY_PAIR_GEN" CKM_RSA_X9_31 = PyKCS11.LowLevel.CKM_RSA_X9_31 CKM["CKM_RSA_X9_31"] = CKM_RSA_X9_31 CKM[CKM_RSA_X9_31] = "CKM_RSA_X9_31" CKM_SHA1_RSA_X9_31 = PyKCS11.LowLevel.CKM_SHA1_RSA_X9_31 CKM["CKM_SHA1_RSA_X9_31"] = CKM_SHA1_RSA_X9_31 CKM[CKM_SHA1_RSA_X9_31] = "CKM_SHA1_RSA_X9_31" CKM_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_RSA_PKCS_PSS CKM["CKM_RSA_PKCS_PSS"] = CKM_RSA_PKCS_PSS CKM[CKM_RSA_PKCS_PSS] = "CKM_RSA_PKCS_PSS" CKM_SHA1_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA1_RSA_PKCS_PSS CKM["CKM_SHA1_RSA_PKCS_PSS"] = CKM_SHA1_RSA_PKCS_PSS CKM[CKM_SHA1_RSA_PKCS_PSS] = "CKM_SHA1_RSA_PKCS_PSS" CKM_ML_KEM_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_ML_KEM_KEY_PAIR_GEN CKM["CKM_ML_KEM_KEY_PAIR_GEN"] = CKM_ML_KEM_KEY_PAIR_GEN CKM[CKM_ML_KEM_KEY_PAIR_GEN] = "CKM_ML_KEM_KEY_PAIR_GEN" CKM_DSA_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_DSA_KEY_PAIR_GEN CKM["CKM_DSA_KEY_PAIR_GEN"] = CKM_DSA_KEY_PAIR_GEN CKM[CKM_DSA_KEY_PAIR_GEN] = "CKM_DSA_KEY_PAIR_GEN" CKM_DSA = PyKCS11.LowLevel.CKM_DSA CKM["CKM_DSA"] = CKM_DSA CKM[CKM_DSA] = "CKM_DSA" CKM_DSA_SHA1 = PyKCS11.LowLevel.CKM_DSA_SHA1 CKM["CKM_DSA_SHA1"] = CKM_DSA_SHA1 CKM[CKM_DSA_SHA1] = "CKM_DSA_SHA1" CKM_DSA_SHA224 = PyKCS11.LowLevel.CKM_DSA_SHA224 CKM["CKM_DSA_SHA224"] = CKM_DSA_SHA224 CKM[CKM_DSA_SHA224] = "CKM_DSA_SHA224" CKM_DSA_SHA256 = PyKCS11.LowLevel.CKM_DSA_SHA256 CKM["CKM_DSA_SHA256"] = CKM_DSA_SHA256 CKM[CKM_DSA_SHA256] = "CKM_DSA_SHA256" CKM_DSA_SHA384 = PyKCS11.LowLevel.CKM_DSA_SHA384 CKM["CKM_DSA_SHA384"] = CKM_DSA_SHA384 CKM[CKM_DSA_SHA384] = "CKM_DSA_SHA384" CKM_DSA_SHA512 = PyKCS11.LowLevel.CKM_DSA_SHA512 CKM["CKM_DSA_SHA512"] = CKM_DSA_SHA512 CKM[CKM_DSA_SHA512] = "CKM_DSA_SHA512" CKM_ML_KEM = PyKCS11.LowLevel.CKM_ML_KEM CKM["CKM_ML_KEM"] = CKM_ML_KEM CKM[CKM_ML_KEM] = "CKM_ML_KEM" CKM_DSA_SHA3_224 = PyKCS11.LowLevel.CKM_DSA_SHA3_224 CKM["CKM_DSA_SHA3_224"] = CKM_DSA_SHA3_224 CKM[CKM_DSA_SHA3_224] = "CKM_DSA_SHA3_224" CKM_DSA_SHA3_256 = PyKCS11.LowLevel.CKM_DSA_SHA3_256 CKM["CKM_DSA_SHA3_256"] = CKM_DSA_SHA3_256 CKM[CKM_DSA_SHA3_256] = "CKM_DSA_SHA3_256" CKM_DSA_SHA3_384 = PyKCS11.LowLevel.CKM_DSA_SHA3_384 CKM["CKM_DSA_SHA3_384"] = CKM_DSA_SHA3_384 CKM[CKM_DSA_SHA3_384] = "CKM_DSA_SHA3_384" CKM_DSA_SHA3_512 = PyKCS11.LowLevel.CKM_DSA_SHA3_512 CKM["CKM_DSA_SHA3_512"] = CKM_DSA_SHA3_512 CKM[CKM_DSA_SHA3_512] = "CKM_DSA_SHA3_512" CKM_ML_DSA_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_ML_DSA_KEY_PAIR_GEN CKM["CKM_ML_DSA_KEY_PAIR_GEN"] = CKM_ML_DSA_KEY_PAIR_GEN CKM[CKM_ML_DSA_KEY_PAIR_GEN] = "CKM_ML_DSA_KEY_PAIR_GEN" CKM_ML_DSA = PyKCS11.LowLevel.CKM_ML_DSA CKM["CKM_ML_DSA"] = CKM_ML_DSA CKM[CKM_ML_DSA] = "CKM_ML_DSA" CKM_HASH_ML_DSA = PyKCS11.LowLevel.CKM_HASH_ML_DSA CKM["CKM_HASH_ML_DSA"] = CKM_HASH_ML_DSA CKM[CKM_HASH_ML_DSA] = "CKM_HASH_ML_DSA" CKM_DH_PKCS_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_DH_PKCS_KEY_PAIR_GEN CKM["CKM_DH_PKCS_KEY_PAIR_GEN"] = CKM_DH_PKCS_KEY_PAIR_GEN CKM[CKM_DH_PKCS_KEY_PAIR_GEN] = "CKM_DH_PKCS_KEY_PAIR_GEN" CKM_DH_PKCS_DERIVE = PyKCS11.LowLevel.CKM_DH_PKCS_DERIVE CKM["CKM_DH_PKCS_DERIVE"] = CKM_DH_PKCS_DERIVE CKM[CKM_DH_PKCS_DERIVE] = "CKM_DH_PKCS_DERIVE" CKM_HASH_ML_DSA_SHA224 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA224 CKM["CKM_HASH_ML_DSA_SHA224"] = CKM_HASH_ML_DSA_SHA224 CKM[CKM_HASH_ML_DSA_SHA224] = "CKM_HASH_ML_DSA_SHA224" CKM_HASH_ML_DSA_SHA256 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA256 CKM["CKM_HASH_ML_DSA_SHA256"] = CKM_HASH_ML_DSA_SHA256 CKM[CKM_HASH_ML_DSA_SHA256] = "CKM_HASH_ML_DSA_SHA256" CKM_HASH_ML_DSA_SHA384 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA384 CKM["CKM_HASH_ML_DSA_SHA384"] = CKM_HASH_ML_DSA_SHA384 CKM[CKM_HASH_ML_DSA_SHA384] = "CKM_HASH_ML_DSA_SHA384" CKM_HASH_ML_DSA_SHA512 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA512 CKM["CKM_HASH_ML_DSA_SHA512"] = CKM_HASH_ML_DSA_SHA512 CKM[CKM_HASH_ML_DSA_SHA512] = "CKM_HASH_ML_DSA_SHA512" CKM_HASH_ML_DSA_SHA3_224 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA3_224 CKM["CKM_HASH_ML_DSA_SHA3_224"] = CKM_HASH_ML_DSA_SHA3_224 CKM[CKM_HASH_ML_DSA_SHA3_224] = "CKM_HASH_ML_DSA_SHA3_224" CKM_HASH_ML_DSA_SHA3_256 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA3_256 CKM["CKM_HASH_ML_DSA_SHA3_256"] = CKM_HASH_ML_DSA_SHA3_256 CKM[CKM_HASH_ML_DSA_SHA3_256] = "CKM_HASH_ML_DSA_SHA3_256" CKM_HASH_ML_DSA_SHA3_384 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA3_384 CKM["CKM_HASH_ML_DSA_SHA3_384"] = CKM_HASH_ML_DSA_SHA3_384 CKM[CKM_HASH_ML_DSA_SHA3_384] = "CKM_HASH_ML_DSA_SHA3_384" CKM_HASH_ML_DSA_SHA3_512 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHA3_512 CKM["CKM_HASH_ML_DSA_SHA3_512"] = CKM_HASH_ML_DSA_SHA3_512 CKM[CKM_HASH_ML_DSA_SHA3_512] = "CKM_HASH_ML_DSA_SHA3_512" CKM_HASH_ML_DSA_SHAKE128 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHAKE128 CKM["CKM_HASH_ML_DSA_SHAKE128"] = CKM_HASH_ML_DSA_SHAKE128 CKM[CKM_HASH_ML_DSA_SHAKE128] = "CKM_HASH_ML_DSA_SHAKE128" CKM_HASH_ML_DSA_SHAKE256 = PyKCS11.LowLevel.CKM_HASH_ML_DSA_SHAKE256 CKM["CKM_HASH_ML_DSA_SHAKE256"] = CKM_HASH_ML_DSA_SHAKE256 CKM[CKM_HASH_ML_DSA_SHAKE256] = "CKM_HASH_ML_DSA_SHAKE256" CKM_SLH_DSA_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_SLH_DSA_KEY_PAIR_GEN CKM["CKM_SLH_DSA_KEY_PAIR_GEN"] = CKM_SLH_DSA_KEY_PAIR_GEN CKM[CKM_SLH_DSA_KEY_PAIR_GEN] = "CKM_SLH_DSA_KEY_PAIR_GEN" CKM_SLH_DSA = PyKCS11.LowLevel.CKM_SLH_DSA CKM["CKM_SLH_DSA"] = CKM_SLH_DSA CKM[CKM_SLH_DSA] = "CKM_SLH_DSA" CKM_X9_42_DH_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_X9_42_DH_KEY_PAIR_GEN CKM["CKM_X9_42_DH_KEY_PAIR_GEN"] = CKM_X9_42_DH_KEY_PAIR_GEN CKM[CKM_X9_42_DH_KEY_PAIR_GEN] = "CKM_X9_42_DH_KEY_PAIR_GEN" CKM_X9_42_DH_DERIVE = PyKCS11.LowLevel.CKM_X9_42_DH_DERIVE CKM["CKM_X9_42_DH_DERIVE"] = CKM_X9_42_DH_DERIVE CKM[CKM_X9_42_DH_DERIVE] = "CKM_X9_42_DH_DERIVE" CKM_X9_42_DH_HYBRID_DERIVE = PyKCS11.LowLevel.CKM_X9_42_DH_HYBRID_DERIVE CKM["CKM_X9_42_DH_HYBRID_DERIVE"] = CKM_X9_42_DH_HYBRID_DERIVE CKM[CKM_X9_42_DH_HYBRID_DERIVE] = "CKM_X9_42_DH_HYBRID_DERIVE" CKM_X9_42_MQV_DERIVE = PyKCS11.LowLevel.CKM_X9_42_MQV_DERIVE CKM["CKM_X9_42_MQV_DERIVE"] = CKM_X9_42_MQV_DERIVE CKM[CKM_X9_42_MQV_DERIVE] = "CKM_X9_42_MQV_DERIVE" CKM_HASH_SLH_DSA = PyKCS11.LowLevel.CKM_HASH_SLH_DSA CKM["CKM_HASH_SLH_DSA"] = CKM_HASH_SLH_DSA CKM[CKM_HASH_SLH_DSA] = "CKM_HASH_SLH_DSA" CKM_HASH_SLH_DSA_SHA224 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA224 CKM["CKM_HASH_SLH_DSA_SHA224"] = CKM_HASH_SLH_DSA_SHA224 CKM[CKM_HASH_SLH_DSA_SHA224] = "CKM_HASH_SLH_DSA_SHA224" CKM_HASH_SLH_DSA_SHA256 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA256 CKM["CKM_HASH_SLH_DSA_SHA256"] = CKM_HASH_SLH_DSA_SHA256 CKM[CKM_HASH_SLH_DSA_SHA256] = "CKM_HASH_SLH_DSA_SHA256" CKM_HASH_SLH_DSA_SHA384 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA384 CKM["CKM_HASH_SLH_DSA_SHA384"] = CKM_HASH_SLH_DSA_SHA384 CKM[CKM_HASH_SLH_DSA_SHA384] = "CKM_HASH_SLH_DSA_SHA384" CKM_HASH_SLH_DSA_SHA512 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA512 CKM["CKM_HASH_SLH_DSA_SHA512"] = CKM_HASH_SLH_DSA_SHA512 CKM[CKM_HASH_SLH_DSA_SHA512] = "CKM_HASH_SLH_DSA_SHA512" CKM_HASH_SLH_DSA_SHA3_224 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA3_224 CKM["CKM_HASH_SLH_DSA_SHA3_224"] = CKM_HASH_SLH_DSA_SHA3_224 CKM[CKM_HASH_SLH_DSA_SHA3_224] = "CKM_HASH_SLH_DSA_SHA3_224" CKM_HASH_SLH_DSA_SHA3_256 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA3_256 CKM["CKM_HASH_SLH_DSA_SHA3_256"] = CKM_HASH_SLH_DSA_SHA3_256 CKM[CKM_HASH_SLH_DSA_SHA3_256] = "CKM_HASH_SLH_DSA_SHA3_256" CKM_HASH_SLH_DSA_SHA3_384 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA3_384 CKM["CKM_HASH_SLH_DSA_SHA3_384"] = CKM_HASH_SLH_DSA_SHA3_384 CKM[CKM_HASH_SLH_DSA_SHA3_384] = "CKM_HASH_SLH_DSA_SHA3_384" CKM_HASH_SLH_DSA_SHA3_512 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHA3_512 CKM["CKM_HASH_SLH_DSA_SHA3_512"] = CKM_HASH_SLH_DSA_SHA3_512 CKM[CKM_HASH_SLH_DSA_SHA3_512] = "CKM_HASH_SLH_DSA_SHA3_512" CKM_HASH_SLH_DSA_SHAKE128 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHAKE128 CKM["CKM_HASH_SLH_DSA_SHAKE128"] = CKM_HASH_SLH_DSA_SHAKE128 CKM[CKM_HASH_SLH_DSA_SHAKE128] = "CKM_HASH_SLH_DSA_SHAKE128" CKM_HASH_SLH_DSA_SHAKE256 = PyKCS11.LowLevel.CKM_HASH_SLH_DSA_SHAKE256 CKM["CKM_HASH_SLH_DSA_SHAKE256"] = CKM_HASH_SLH_DSA_SHAKE256 CKM[CKM_HASH_SLH_DSA_SHAKE256] = "CKM_HASH_SLH_DSA_SHAKE256" CKM_SHA256_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA256_RSA_PKCS CKM["CKM_SHA256_RSA_PKCS"] = CKM_SHA256_RSA_PKCS CKM[CKM_SHA256_RSA_PKCS] = "CKM_SHA256_RSA_PKCS" CKM_SHA384_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA384_RSA_PKCS CKM["CKM_SHA384_RSA_PKCS"] = CKM_SHA384_RSA_PKCS CKM[CKM_SHA384_RSA_PKCS] = "CKM_SHA384_RSA_PKCS" CKM_SHA512_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA512_RSA_PKCS CKM["CKM_SHA512_RSA_PKCS"] = CKM_SHA512_RSA_PKCS CKM[CKM_SHA512_RSA_PKCS] = "CKM_SHA512_RSA_PKCS" CKM_SHA256_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA256_RSA_PKCS_PSS CKM["CKM_SHA256_RSA_PKCS_PSS"] = CKM_SHA256_RSA_PKCS_PSS CKM[CKM_SHA256_RSA_PKCS_PSS] = "CKM_SHA256_RSA_PKCS_PSS" CKM_SHA384_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA384_RSA_PKCS_PSS CKM["CKM_SHA384_RSA_PKCS_PSS"] = CKM_SHA384_RSA_PKCS_PSS CKM[CKM_SHA384_RSA_PKCS_PSS] = "CKM_SHA384_RSA_PKCS_PSS" CKM_SHA512_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA512_RSA_PKCS_PSS CKM["CKM_SHA512_RSA_PKCS_PSS"] = CKM_SHA512_RSA_PKCS_PSS CKM[CKM_SHA512_RSA_PKCS_PSS] = "CKM_SHA512_RSA_PKCS_PSS" CKM_SHA224_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA224_RSA_PKCS CKM["CKM_SHA224_RSA_PKCS"] = CKM_SHA224_RSA_PKCS CKM[CKM_SHA224_RSA_PKCS] = "CKM_SHA224_RSA_PKCS" CKM_SHA224_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA224_RSA_PKCS_PSS CKM["CKM_SHA224_RSA_PKCS_PSS"] = CKM_SHA224_RSA_PKCS_PSS CKM[CKM_SHA224_RSA_PKCS_PSS] = "CKM_SHA224_RSA_PKCS_PSS" CKM_SHA512_224 = PyKCS11.LowLevel.CKM_SHA512_224 CKM["CKM_SHA512_224"] = CKM_SHA512_224 CKM[CKM_SHA512_224] = "CKM_SHA512_224" CKM_SHA512_224_HMAC = PyKCS11.LowLevel.CKM_SHA512_224_HMAC CKM["CKM_SHA512_224_HMAC"] = CKM_SHA512_224_HMAC CKM[CKM_SHA512_224_HMAC] = "CKM_SHA512_224_HMAC" CKM_SHA512_224_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA512_224_HMAC_GENERAL CKM["CKM_SHA512_224_HMAC_GENERAL"] = CKM_SHA512_224_HMAC_GENERAL CKM[CKM_SHA512_224_HMAC_GENERAL] = "CKM_SHA512_224_HMAC_GENERAL" CKM_SHA512_224_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA512_224_KEY_DERIVATION CKM["CKM_SHA512_224_KEY_DERIVATION"] = CKM_SHA512_224_KEY_DERIVATION CKM[CKM_SHA512_224_KEY_DERIVATION] = "CKM_SHA512_224_KEY_DERIVATION" CKM_SHA512_256 = PyKCS11.LowLevel.CKM_SHA512_256 CKM["CKM_SHA512_256"] = CKM_SHA512_256 CKM[CKM_SHA512_256] = "CKM_SHA512_256" CKM_SHA512_256_HMAC = PyKCS11.LowLevel.CKM_SHA512_256_HMAC CKM["CKM_SHA512_256_HMAC"] = CKM_SHA512_256_HMAC CKM[CKM_SHA512_256_HMAC] = "CKM_SHA512_256_HMAC" CKM_SHA512_256_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA512_256_HMAC_GENERAL CKM["CKM_SHA512_256_HMAC_GENERAL"] = CKM_SHA512_256_HMAC_GENERAL CKM[CKM_SHA512_256_HMAC_GENERAL] = "CKM_SHA512_256_HMAC_GENERAL" CKM_SHA512_256_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA512_256_KEY_DERIVATION CKM["CKM_SHA512_256_KEY_DERIVATION"] = CKM_SHA512_256_KEY_DERIVATION CKM[CKM_SHA512_256_KEY_DERIVATION] = "CKM_SHA512_256_KEY_DERIVATION" CKM_SHA512_T = PyKCS11.LowLevel.CKM_SHA512_T CKM["CKM_SHA512_T"] = CKM_SHA512_T CKM[CKM_SHA512_T] = "CKM_SHA512_T" CKM_SHA512_T_HMAC = PyKCS11.LowLevel.CKM_SHA512_T_HMAC CKM["CKM_SHA512_T_HMAC"] = CKM_SHA512_T_HMAC CKM[CKM_SHA512_T_HMAC] = "CKM_SHA512_T_HMAC" CKM_SHA512_T_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA512_T_HMAC_GENERAL CKM["CKM_SHA512_T_HMAC_GENERAL"] = CKM_SHA512_T_HMAC_GENERAL CKM[CKM_SHA512_T_HMAC_GENERAL] = "CKM_SHA512_T_HMAC_GENERAL" CKM_SHA512_T_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA512_T_KEY_DERIVATION CKM["CKM_SHA512_T_KEY_DERIVATION"] = CKM_SHA512_T_KEY_DERIVATION CKM[CKM_SHA512_T_KEY_DERIVATION] = "CKM_SHA512_T_KEY_DERIVATION" CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE = ( PyKCS11.LowLevel.CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE ) CKM["CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE"] = CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE CKM[CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE] = "CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE" CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH = ( PyKCS11.LowLevel.CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH ) CKM["CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH"] = CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH CKM[CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH] = "CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH" CKM_SHA3_256_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA3_256_RSA_PKCS CKM["CKM_SHA3_256_RSA_PKCS"] = CKM_SHA3_256_RSA_PKCS CKM[CKM_SHA3_256_RSA_PKCS] = "CKM_SHA3_256_RSA_PKCS" CKM_SHA3_384_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA3_384_RSA_PKCS CKM["CKM_SHA3_384_RSA_PKCS"] = CKM_SHA3_384_RSA_PKCS CKM[CKM_SHA3_384_RSA_PKCS] = "CKM_SHA3_384_RSA_PKCS" CKM_SHA3_512_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA3_512_RSA_PKCS CKM["CKM_SHA3_512_RSA_PKCS"] = CKM_SHA3_512_RSA_PKCS CKM[CKM_SHA3_512_RSA_PKCS] = "CKM_SHA3_512_RSA_PKCS" CKM_SHA3_256_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA3_256_RSA_PKCS_PSS CKM["CKM_SHA3_256_RSA_PKCS_PSS"] = CKM_SHA3_256_RSA_PKCS_PSS CKM[CKM_SHA3_256_RSA_PKCS_PSS] = "CKM_SHA3_256_RSA_PKCS_PSS" CKM_SHA3_384_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA3_384_RSA_PKCS_PSS CKM["CKM_SHA3_384_RSA_PKCS_PSS"] = CKM_SHA3_384_RSA_PKCS_PSS CKM[CKM_SHA3_384_RSA_PKCS_PSS] = "CKM_SHA3_384_RSA_PKCS_PSS" CKM_SHA3_512_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA3_512_RSA_PKCS_PSS CKM["CKM_SHA3_512_RSA_PKCS_PSS"] = CKM_SHA3_512_RSA_PKCS_PSS CKM[CKM_SHA3_512_RSA_PKCS_PSS] = "CKM_SHA3_512_RSA_PKCS_PSS" CKM_SHA3_224_RSA_PKCS = PyKCS11.LowLevel.CKM_SHA3_224_RSA_PKCS CKM["CKM_SHA3_224_RSA_PKCS"] = CKM_SHA3_224_RSA_PKCS CKM[CKM_SHA3_224_RSA_PKCS] = "CKM_SHA3_224_RSA_PKCS" CKM_SHA3_224_RSA_PKCS_PSS = PyKCS11.LowLevel.CKM_SHA3_224_RSA_PKCS_PSS CKM["CKM_SHA3_224_RSA_PKCS_PSS"] = CKM_SHA3_224_RSA_PKCS_PSS CKM[CKM_SHA3_224_RSA_PKCS_PSS] = "CKM_SHA3_224_RSA_PKCS_PSS" CKM_RC2_KEY_GEN = PyKCS11.LowLevel.CKM_RC2_KEY_GEN CKM["CKM_RC2_KEY_GEN"] = CKM_RC2_KEY_GEN CKM[CKM_RC2_KEY_GEN] = "CKM_RC2_KEY_GEN" CKM_RC2_ECB = PyKCS11.LowLevel.CKM_RC2_ECB CKM["CKM_RC2_ECB"] = CKM_RC2_ECB CKM[CKM_RC2_ECB] = "CKM_RC2_ECB" CKM_RC2_CBC = PyKCS11.LowLevel.CKM_RC2_CBC CKM["CKM_RC2_CBC"] = CKM_RC2_CBC CKM[CKM_RC2_CBC] = "CKM_RC2_CBC" CKM_RC2_MAC = PyKCS11.LowLevel.CKM_RC2_MAC CKM["CKM_RC2_MAC"] = CKM_RC2_MAC CKM[CKM_RC2_MAC] = "CKM_RC2_MAC" CKM_RC2_MAC_GENERAL = PyKCS11.LowLevel.CKM_RC2_MAC_GENERAL CKM["CKM_RC2_MAC_GENERAL"] = CKM_RC2_MAC_GENERAL CKM[CKM_RC2_MAC_GENERAL] = "CKM_RC2_MAC_GENERAL" CKM_RC2_CBC_PAD = PyKCS11.LowLevel.CKM_RC2_CBC_PAD CKM["CKM_RC2_CBC_PAD"] = CKM_RC2_CBC_PAD CKM[CKM_RC2_CBC_PAD] = "CKM_RC2_CBC_PAD" CKM_RC4_KEY_GEN = PyKCS11.LowLevel.CKM_RC4_KEY_GEN CKM["CKM_RC4_KEY_GEN"] = CKM_RC4_KEY_GEN CKM[CKM_RC4_KEY_GEN] = "CKM_RC4_KEY_GEN" CKM_RC4 = PyKCS11.LowLevel.CKM_RC4 CKM["CKM_RC4"] = CKM_RC4 CKM[CKM_RC4] = "CKM_RC4" CKM_DES_KEY_GEN = PyKCS11.LowLevel.CKM_DES_KEY_GEN CKM["CKM_DES_KEY_GEN"] = CKM_DES_KEY_GEN CKM[CKM_DES_KEY_GEN] = "CKM_DES_KEY_GEN" CKM_DES_ECB = PyKCS11.LowLevel.CKM_DES_ECB CKM["CKM_DES_ECB"] = CKM_DES_ECB CKM[CKM_DES_ECB] = "CKM_DES_ECB" CKM_DES_CBC = PyKCS11.LowLevel.CKM_DES_CBC CKM["CKM_DES_CBC"] = CKM_DES_CBC CKM[CKM_DES_CBC] = "CKM_DES_CBC" CKM_DES_MAC = PyKCS11.LowLevel.CKM_DES_MAC CKM["CKM_DES_MAC"] = CKM_DES_MAC CKM[CKM_DES_MAC] = "CKM_DES_MAC" CKM_DES_MAC_GENERAL = PyKCS11.LowLevel.CKM_DES_MAC_GENERAL CKM["CKM_DES_MAC_GENERAL"] = CKM_DES_MAC_GENERAL CKM[CKM_DES_MAC_GENERAL] = "CKM_DES_MAC_GENERAL" CKM_DES_CBC_PAD = PyKCS11.LowLevel.CKM_DES_CBC_PAD CKM["CKM_DES_CBC_PAD"] = CKM_DES_CBC_PAD CKM[CKM_DES_CBC_PAD] = "CKM_DES_CBC_PAD" CKM_DES2_KEY_GEN = PyKCS11.LowLevel.CKM_DES2_KEY_GEN CKM["CKM_DES2_KEY_GEN"] = CKM_DES2_KEY_GEN CKM[CKM_DES2_KEY_GEN] = "CKM_DES2_KEY_GEN" CKM_DES3_KEY_GEN = PyKCS11.LowLevel.CKM_DES3_KEY_GEN CKM["CKM_DES3_KEY_GEN"] = CKM_DES3_KEY_GEN CKM[CKM_DES3_KEY_GEN] = "CKM_DES3_KEY_GEN" CKM_DES3_ECB = PyKCS11.LowLevel.CKM_DES3_ECB CKM["CKM_DES3_ECB"] = CKM_DES3_ECB CKM[CKM_DES3_ECB] = "CKM_DES3_ECB" CKM_DES3_CBC = PyKCS11.LowLevel.CKM_DES3_CBC CKM["CKM_DES3_CBC"] = CKM_DES3_CBC CKM[CKM_DES3_CBC] = "CKM_DES3_CBC" CKM_DES3_MAC = PyKCS11.LowLevel.CKM_DES3_MAC CKM["CKM_DES3_MAC"] = CKM_DES3_MAC CKM[CKM_DES3_MAC] = "CKM_DES3_MAC" CKM_DES3_MAC_GENERAL = PyKCS11.LowLevel.CKM_DES3_MAC_GENERAL CKM["CKM_DES3_MAC_GENERAL"] = CKM_DES3_MAC_GENERAL CKM[CKM_DES3_MAC_GENERAL] = "CKM_DES3_MAC_GENERAL" CKM_DES3_CBC_PAD = PyKCS11.LowLevel.CKM_DES3_CBC_PAD CKM["CKM_DES3_CBC_PAD"] = CKM_DES3_CBC_PAD CKM[CKM_DES3_CBC_PAD] = "CKM_DES3_CBC_PAD" CKM_DES3_CMAC_GENERAL = PyKCS11.LowLevel.CKM_DES3_CMAC_GENERAL CKM["CKM_DES3_CMAC_GENERAL"] = CKM_DES3_CMAC_GENERAL CKM[CKM_DES3_CMAC_GENERAL] = "CKM_DES3_CMAC_GENERAL" CKM_DES3_CMAC = PyKCS11.LowLevel.CKM_DES3_CMAC CKM["CKM_DES3_CMAC"] = CKM_DES3_CMAC CKM[CKM_DES3_CMAC] = "CKM_DES3_CMAC" CKM_CDMF_KEY_GEN = PyKCS11.LowLevel.CKM_CDMF_KEY_GEN CKM["CKM_CDMF_KEY_GEN"] = CKM_CDMF_KEY_GEN CKM[CKM_CDMF_KEY_GEN] = "CKM_CDMF_KEY_GEN" CKM_CDMF_ECB = PyKCS11.LowLevel.CKM_CDMF_ECB CKM["CKM_CDMF_ECB"] = CKM_CDMF_ECB CKM[CKM_CDMF_ECB] = "CKM_CDMF_ECB" CKM_CDMF_CBC = PyKCS11.LowLevel.CKM_CDMF_CBC CKM["CKM_CDMF_CBC"] = CKM_CDMF_CBC CKM[CKM_CDMF_CBC] = "CKM_CDMF_CBC" CKM_CDMF_MAC = PyKCS11.LowLevel.CKM_CDMF_MAC CKM["CKM_CDMF_MAC"] = CKM_CDMF_MAC CKM[CKM_CDMF_MAC] = "CKM_CDMF_MAC" CKM_CDMF_MAC_GENERAL = PyKCS11.LowLevel.CKM_CDMF_MAC_GENERAL CKM["CKM_CDMF_MAC_GENERAL"] = CKM_CDMF_MAC_GENERAL CKM[CKM_CDMF_MAC_GENERAL] = "CKM_CDMF_MAC_GENERAL" CKM_CDMF_CBC_PAD = PyKCS11.LowLevel.CKM_CDMF_CBC_PAD CKM["CKM_CDMF_CBC_PAD"] = CKM_CDMF_CBC_PAD CKM[CKM_CDMF_CBC_PAD] = "CKM_CDMF_CBC_PAD" CKM_DES_OFB64 = PyKCS11.LowLevel.CKM_DES_OFB64 CKM["CKM_DES_OFB64"] = CKM_DES_OFB64 CKM[CKM_DES_OFB64] = "CKM_DES_OFB64" CKM_DES_OFB8 = PyKCS11.LowLevel.CKM_DES_OFB8 CKM["CKM_DES_OFB8"] = CKM_DES_OFB8 CKM[CKM_DES_OFB8] = "CKM_DES_OFB8" CKM_DES_CFB64 = PyKCS11.LowLevel.CKM_DES_CFB64 CKM["CKM_DES_CFB64"] = CKM_DES_CFB64 CKM[CKM_DES_CFB64] = "CKM_DES_CFB64" CKM_DES_CFB8 = PyKCS11.LowLevel.CKM_DES_CFB8 CKM["CKM_DES_CFB8"] = CKM_DES_CFB8 CKM[CKM_DES_CFB8] = "CKM_DES_CFB8" CKM_MD2 = PyKCS11.LowLevel.CKM_MD2 CKM["CKM_MD2"] = CKM_MD2 CKM[CKM_MD2] = "CKM_MD2" CKM_MD2_HMAC = PyKCS11.LowLevel.CKM_MD2_HMAC CKM["CKM_MD2_HMAC"] = CKM_MD2_HMAC CKM[CKM_MD2_HMAC] = "CKM_MD2_HMAC" CKM_MD2_HMAC_GENERAL = PyKCS11.LowLevel.CKM_MD2_HMAC_GENERAL CKM["CKM_MD2_HMAC_GENERAL"] = CKM_MD2_HMAC_GENERAL CKM[CKM_MD2_HMAC_GENERAL] = "CKM_MD2_HMAC_GENERAL" CKM_MD5 = PyKCS11.LowLevel.CKM_MD5 CKM["CKM_MD5"] = CKM_MD5 CKM[CKM_MD5] = "CKM_MD5" CKM_MD5_HMAC = PyKCS11.LowLevel.CKM_MD5_HMAC CKM["CKM_MD5_HMAC"] = CKM_MD5_HMAC CKM[CKM_MD5_HMAC] = "CKM_MD5_HMAC" CKM_MD5_HMAC_GENERAL = PyKCS11.LowLevel.CKM_MD5_HMAC_GENERAL CKM["CKM_MD5_HMAC_GENERAL"] = CKM_MD5_HMAC_GENERAL CKM[CKM_MD5_HMAC_GENERAL] = "CKM_MD5_HMAC_GENERAL" CKM_SHA_1 = PyKCS11.LowLevel.CKM_SHA_1 CKM["CKM_SHA_1"] = CKM_SHA_1 CKM[CKM_SHA_1] = "CKM_SHA_1" CKM_SHA_1_HMAC = PyKCS11.LowLevel.CKM_SHA_1_HMAC CKM["CKM_SHA_1_HMAC"] = CKM_SHA_1_HMAC CKM[CKM_SHA_1_HMAC] = "CKM_SHA_1_HMAC" CKM_SHA_1_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA_1_HMAC_GENERAL CKM["CKM_SHA_1_HMAC_GENERAL"] = CKM_SHA_1_HMAC_GENERAL CKM[CKM_SHA_1_HMAC_GENERAL] = "CKM_SHA_1_HMAC_GENERAL" CKM_RIPEMD128 = PyKCS11.LowLevel.CKM_RIPEMD128 CKM["CKM_RIPEMD128"] = CKM_RIPEMD128 CKM[CKM_RIPEMD128] = "CKM_RIPEMD128" CKM_RIPEMD128_HMAC = PyKCS11.LowLevel.CKM_RIPEMD128_HMAC CKM["CKM_RIPEMD128_HMAC"] = CKM_RIPEMD128_HMAC CKM[CKM_RIPEMD128_HMAC] = "CKM_RIPEMD128_HMAC" CKM_RIPEMD128_HMAC_GENERAL = PyKCS11.LowLevel.CKM_RIPEMD128_HMAC_GENERAL CKM["CKM_RIPEMD128_HMAC_GENERAL"] = CKM_RIPEMD128_HMAC_GENERAL CKM[CKM_RIPEMD128_HMAC_GENERAL] = "CKM_RIPEMD128_HMAC_GENERAL" CKM_RIPEMD160 = PyKCS11.LowLevel.CKM_RIPEMD160 CKM["CKM_RIPEMD160"] = CKM_RIPEMD160 CKM[CKM_RIPEMD160] = "CKM_RIPEMD160" CKM_RIPEMD160_HMAC = PyKCS11.LowLevel.CKM_RIPEMD160_HMAC CKM["CKM_RIPEMD160_HMAC"] = CKM_RIPEMD160_HMAC CKM[CKM_RIPEMD160_HMAC] = "CKM_RIPEMD160_HMAC" CKM_RIPEMD160_HMAC_GENERAL = PyKCS11.LowLevel.CKM_RIPEMD160_HMAC_GENERAL CKM["CKM_RIPEMD160_HMAC_GENERAL"] = CKM_RIPEMD160_HMAC_GENERAL CKM[CKM_RIPEMD160_HMAC_GENERAL] = "CKM_RIPEMD160_HMAC_GENERAL" CKM_SHA256 = PyKCS11.LowLevel.CKM_SHA256 CKM["CKM_SHA256"] = CKM_SHA256 CKM[CKM_SHA256] = "CKM_SHA256" CKM_SHA256_HMAC = PyKCS11.LowLevel.CKM_SHA256_HMAC CKM["CKM_SHA256_HMAC"] = CKM_SHA256_HMAC CKM[CKM_SHA256_HMAC] = "CKM_SHA256_HMAC" CKM_SHA256_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA256_HMAC_GENERAL CKM["CKM_SHA256_HMAC_GENERAL"] = CKM_SHA256_HMAC_GENERAL CKM[CKM_SHA256_HMAC_GENERAL] = "CKM_SHA256_HMAC_GENERAL" CKM_SHA224 = PyKCS11.LowLevel.CKM_SHA224 CKM["CKM_SHA224"] = CKM_SHA224 CKM[CKM_SHA224] = "CKM_SHA224" CKM_SHA224_HMAC = PyKCS11.LowLevel.CKM_SHA224_HMAC CKM["CKM_SHA224_HMAC"] = CKM_SHA224_HMAC CKM[CKM_SHA224_HMAC] = "CKM_SHA224_HMAC" CKM_SHA224_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA224_HMAC_GENERAL CKM["CKM_SHA224_HMAC_GENERAL"] = CKM_SHA224_HMAC_GENERAL CKM[CKM_SHA224_HMAC_GENERAL] = "CKM_SHA224_HMAC_GENERAL" CKM_SHA384 = PyKCS11.LowLevel.CKM_SHA384 CKM["CKM_SHA384"] = CKM_SHA384 CKM[CKM_SHA384] = "CKM_SHA384" CKM_SHA384_HMAC = PyKCS11.LowLevel.CKM_SHA384_HMAC CKM["CKM_SHA384_HMAC"] = CKM_SHA384_HMAC CKM[CKM_SHA384_HMAC] = "CKM_SHA384_HMAC" CKM_SHA384_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA384_HMAC_GENERAL CKM["CKM_SHA384_HMAC_GENERAL"] = CKM_SHA384_HMAC_GENERAL CKM[CKM_SHA384_HMAC_GENERAL] = "CKM_SHA384_HMAC_GENERAL" CKM_SHA512 = PyKCS11.LowLevel.CKM_SHA512 CKM["CKM_SHA512"] = CKM_SHA512 CKM[CKM_SHA512] = "CKM_SHA512" CKM_SHA512_HMAC = PyKCS11.LowLevel.CKM_SHA512_HMAC CKM["CKM_SHA512_HMAC"] = CKM_SHA512_HMAC CKM[CKM_SHA512_HMAC] = "CKM_SHA512_HMAC" CKM_SHA512_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA512_HMAC_GENERAL CKM["CKM_SHA512_HMAC_GENERAL"] = CKM_SHA512_HMAC_GENERAL CKM[CKM_SHA512_HMAC_GENERAL] = "CKM_SHA512_HMAC_GENERAL" CKM_SECURID_KEY_GEN = PyKCS11.LowLevel.CKM_SECURID_KEY_GEN CKM["CKM_SECURID_KEY_GEN"] = CKM_SECURID_KEY_GEN CKM[CKM_SECURID_KEY_GEN] = "CKM_SECURID_KEY_GEN" CKM_SECURID = PyKCS11.LowLevel.CKM_SECURID CKM["CKM_SECURID"] = CKM_SECURID CKM[CKM_SECURID] = "CKM_SECURID" CKM_HOTP_KEY_GEN = PyKCS11.LowLevel.CKM_HOTP_KEY_GEN CKM["CKM_HOTP_KEY_GEN"] = CKM_HOTP_KEY_GEN CKM[CKM_HOTP_KEY_GEN] = "CKM_HOTP_KEY_GEN" CKM_HOTP = PyKCS11.LowLevel.CKM_HOTP CKM["CKM_HOTP"] = CKM_HOTP CKM[CKM_HOTP] = "CKM_HOTP" CKM_ACTI = PyKCS11.LowLevel.CKM_ACTI CKM["CKM_ACTI"] = CKM_ACTI CKM[CKM_ACTI] = "CKM_ACTI" CKM_ACTI_KEY_GEN = PyKCS11.LowLevel.CKM_ACTI_KEY_GEN CKM["CKM_ACTI_KEY_GEN"] = CKM_ACTI_KEY_GEN CKM[CKM_ACTI_KEY_GEN] = "CKM_ACTI_KEY_GEN" CKM_SHA3_256 = PyKCS11.LowLevel.CKM_SHA3_256 CKM["CKM_SHA3_256"] = CKM_SHA3_256 CKM[CKM_SHA3_256] = "CKM_SHA3_256" CKM_SHA3_256_HMAC = PyKCS11.LowLevel.CKM_SHA3_256_HMAC CKM["CKM_SHA3_256_HMAC"] = CKM_SHA3_256_HMAC CKM[CKM_SHA3_256_HMAC] = "CKM_SHA3_256_HMAC" CKM_SHA3_256_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA3_256_HMAC_GENERAL CKM["CKM_SHA3_256_HMAC_GENERAL"] = CKM_SHA3_256_HMAC_GENERAL CKM[CKM_SHA3_256_HMAC_GENERAL] = "CKM_SHA3_256_HMAC_GENERAL" CKM_SHA3_256_KEY_GEN = PyKCS11.LowLevel.CKM_SHA3_256_KEY_GEN CKM["CKM_SHA3_256_KEY_GEN"] = CKM_SHA3_256_KEY_GEN CKM[CKM_SHA3_256_KEY_GEN] = "CKM_SHA3_256_KEY_GEN" CKM_SHA3_224 = PyKCS11.LowLevel.CKM_SHA3_224 CKM["CKM_SHA3_224"] = CKM_SHA3_224 CKM[CKM_SHA3_224] = "CKM_SHA3_224" CKM_SHA3_224_HMAC = PyKCS11.LowLevel.CKM_SHA3_224_HMAC CKM["CKM_SHA3_224_HMAC"] = CKM_SHA3_224_HMAC CKM[CKM_SHA3_224_HMAC] = "CKM_SHA3_224_HMAC" CKM_SHA3_224_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA3_224_HMAC_GENERAL CKM["CKM_SHA3_224_HMAC_GENERAL"] = CKM_SHA3_224_HMAC_GENERAL CKM[CKM_SHA3_224_HMAC_GENERAL] = "CKM_SHA3_224_HMAC_GENERAL" CKM_SHA3_224_KEY_GEN = PyKCS11.LowLevel.CKM_SHA3_224_KEY_GEN CKM["CKM_SHA3_224_KEY_GEN"] = CKM_SHA3_224_KEY_GEN CKM[CKM_SHA3_224_KEY_GEN] = "CKM_SHA3_224_KEY_GEN" CKM_SHA3_384 = PyKCS11.LowLevel.CKM_SHA3_384 CKM["CKM_SHA3_384"] = CKM_SHA3_384 CKM[CKM_SHA3_384] = "CKM_SHA3_384" CKM_SHA3_384_HMAC = PyKCS11.LowLevel.CKM_SHA3_384_HMAC CKM["CKM_SHA3_384_HMAC"] = CKM_SHA3_384_HMAC CKM[CKM_SHA3_384_HMAC] = "CKM_SHA3_384_HMAC" CKM_SHA3_384_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA3_384_HMAC_GENERAL CKM["CKM_SHA3_384_HMAC_GENERAL"] = CKM_SHA3_384_HMAC_GENERAL CKM[CKM_SHA3_384_HMAC_GENERAL] = "CKM_SHA3_384_HMAC_GENERAL" CKM_SHA3_384_KEY_GEN = PyKCS11.LowLevel.CKM_SHA3_384_KEY_GEN CKM["CKM_SHA3_384_KEY_GEN"] = CKM_SHA3_384_KEY_GEN CKM[CKM_SHA3_384_KEY_GEN] = "CKM_SHA3_384_KEY_GEN" CKM_SHA3_512 = PyKCS11.LowLevel.CKM_SHA3_512 CKM["CKM_SHA3_512"] = CKM_SHA3_512 CKM[CKM_SHA3_512] = "CKM_SHA3_512" CKM_SHA3_512_HMAC = PyKCS11.LowLevel.CKM_SHA3_512_HMAC CKM["CKM_SHA3_512_HMAC"] = CKM_SHA3_512_HMAC CKM[CKM_SHA3_512_HMAC] = "CKM_SHA3_512_HMAC" CKM_SHA3_512_HMAC_GENERAL = PyKCS11.LowLevel.CKM_SHA3_512_HMAC_GENERAL CKM["CKM_SHA3_512_HMAC_GENERAL"] = CKM_SHA3_512_HMAC_GENERAL CKM[CKM_SHA3_512_HMAC_GENERAL] = "CKM_SHA3_512_HMAC_GENERAL" CKM_SHA3_512_KEY_GEN = PyKCS11.LowLevel.CKM_SHA3_512_KEY_GEN CKM["CKM_SHA3_512_KEY_GEN"] = CKM_SHA3_512_KEY_GEN CKM[CKM_SHA3_512_KEY_GEN] = "CKM_SHA3_512_KEY_GEN" CKM_CAST_KEY_GEN = PyKCS11.LowLevel.CKM_CAST_KEY_GEN CKM["CKM_CAST_KEY_GEN"] = CKM_CAST_KEY_GEN CKM[CKM_CAST_KEY_GEN] = "CKM_CAST_KEY_GEN" CKM_CAST_ECB = PyKCS11.LowLevel.CKM_CAST_ECB CKM["CKM_CAST_ECB"] = CKM_CAST_ECB CKM[CKM_CAST_ECB] = "CKM_CAST_ECB" CKM_CAST_CBC = PyKCS11.LowLevel.CKM_CAST_CBC CKM["CKM_CAST_CBC"] = CKM_CAST_CBC CKM[CKM_CAST_CBC] = "CKM_CAST_CBC" CKM_CAST_MAC = PyKCS11.LowLevel.CKM_CAST_MAC CKM["CKM_CAST_MAC"] = CKM_CAST_MAC CKM[CKM_CAST_MAC] = "CKM_CAST_MAC" CKM_CAST_MAC_GENERAL = PyKCS11.LowLevel.CKM_CAST_MAC_GENERAL CKM["CKM_CAST_MAC_GENERAL"] = CKM_CAST_MAC_GENERAL CKM[CKM_CAST_MAC_GENERAL] = "CKM_CAST_MAC_GENERAL" CKM_CAST_CBC_PAD = PyKCS11.LowLevel.CKM_CAST_CBC_PAD CKM["CKM_CAST_CBC_PAD"] = CKM_CAST_CBC_PAD CKM[CKM_CAST_CBC_PAD] = "CKM_CAST_CBC_PAD" CKM_CAST3_KEY_GEN = PyKCS11.LowLevel.CKM_CAST3_KEY_GEN CKM["CKM_CAST3_KEY_GEN"] = CKM_CAST3_KEY_GEN CKM[CKM_CAST3_KEY_GEN] = "CKM_CAST3_KEY_GEN" CKM_CAST3_ECB = PyKCS11.LowLevel.CKM_CAST3_ECB CKM["CKM_CAST3_ECB"] = CKM_CAST3_ECB CKM[CKM_CAST3_ECB] = "CKM_CAST3_ECB" CKM_CAST3_CBC = PyKCS11.LowLevel.CKM_CAST3_CBC CKM["CKM_CAST3_CBC"] = CKM_CAST3_CBC CKM[CKM_CAST3_CBC] = "CKM_CAST3_CBC" CKM_CAST3_MAC = PyKCS11.LowLevel.CKM_CAST3_MAC CKM["CKM_CAST3_MAC"] = CKM_CAST3_MAC CKM[CKM_CAST3_MAC] = "CKM_CAST3_MAC" CKM_CAST3_MAC_GENERAL = PyKCS11.LowLevel.CKM_CAST3_MAC_GENERAL CKM["CKM_CAST3_MAC_GENERAL"] = CKM_CAST3_MAC_GENERAL CKM[CKM_CAST3_MAC_GENERAL] = "CKM_CAST3_MAC_GENERAL" CKM_CAST3_CBC_PAD = PyKCS11.LowLevel.CKM_CAST3_CBC_PAD CKM["CKM_CAST3_CBC_PAD"] = CKM_CAST3_CBC_PAD CKM[CKM_CAST3_CBC_PAD] = "CKM_CAST3_CBC_PAD" CKM_CAST128_KEY_GEN = PyKCS11.LowLevel.CKM_CAST128_KEY_GEN CKM["CKM_CAST128_KEY_GEN"] = CKM_CAST128_KEY_GEN CKM[CKM_CAST128_KEY_GEN] = "CKM_CAST128_KEY_GEN" CKM_CAST128_ECB = PyKCS11.LowLevel.CKM_CAST128_ECB CKM["CKM_CAST128_ECB"] = CKM_CAST128_ECB CKM[CKM_CAST128_ECB] = "CKM_CAST128_ECB" CKM_CAST128_MAC = PyKCS11.LowLevel.CKM_CAST128_MAC CKM["CKM_CAST128_MAC"] = CKM_CAST128_MAC CKM[CKM_CAST128_MAC] = "CKM_CAST128_MAC" CKM_CAST128_CBC = PyKCS11.LowLevel.CKM_CAST128_CBC CKM["CKM_CAST128_CBC"] = CKM_CAST128_CBC CKM[CKM_CAST128_CBC] = "CKM_CAST128_CBC" CKM_CAST128_MAC_GENERAL = PyKCS11.LowLevel.CKM_CAST128_MAC_GENERAL CKM["CKM_CAST128_MAC_GENERAL"] = CKM_CAST128_MAC_GENERAL CKM[CKM_CAST128_MAC_GENERAL] = "CKM_CAST128_MAC_GENERAL" CKM_CAST128_CBC_PAD = PyKCS11.LowLevel.CKM_CAST128_CBC_PAD CKM["CKM_CAST128_CBC_PAD"] = CKM_CAST128_CBC_PAD CKM[CKM_CAST128_CBC_PAD] = "CKM_CAST128_CBC_PAD" CKM_RC5_KEY_GEN = PyKCS11.LowLevel.CKM_RC5_KEY_GEN CKM["CKM_RC5_KEY_GEN"] = CKM_RC5_KEY_GEN CKM[CKM_RC5_KEY_GEN] = "CKM_RC5_KEY_GEN" CKM_RC5_ECB = PyKCS11.LowLevel.CKM_RC5_ECB CKM["CKM_RC5_ECB"] = CKM_RC5_ECB CKM[CKM_RC5_ECB] = "CKM_RC5_ECB" CKM_RC5_CBC = PyKCS11.LowLevel.CKM_RC5_CBC CKM["CKM_RC5_CBC"] = CKM_RC5_CBC CKM[CKM_RC5_CBC] = "CKM_RC5_CBC" CKM_RC5_MAC = PyKCS11.LowLevel.CKM_RC5_MAC CKM["CKM_RC5_MAC"] = CKM_RC5_MAC CKM[CKM_RC5_MAC] = "CKM_RC5_MAC" CKM_RC5_MAC_GENERAL = PyKCS11.LowLevel.CKM_RC5_MAC_GENERAL CKM["CKM_RC5_MAC_GENERAL"] = CKM_RC5_MAC_GENERAL CKM[CKM_RC5_MAC_GENERAL] = "CKM_RC5_MAC_GENERAL" CKM_RC5_CBC_PAD = PyKCS11.LowLevel.CKM_RC5_CBC_PAD CKM["CKM_RC5_CBC_PAD"] = CKM_RC5_CBC_PAD CKM[CKM_RC5_CBC_PAD] = "CKM_RC5_CBC_PAD" CKM_IDEA_KEY_GEN = PyKCS11.LowLevel.CKM_IDEA_KEY_GEN CKM["CKM_IDEA_KEY_GEN"] = CKM_IDEA_KEY_GEN CKM[CKM_IDEA_KEY_GEN] = "CKM_IDEA_KEY_GEN" CKM_IDEA_ECB = PyKCS11.LowLevel.CKM_IDEA_ECB CKM["CKM_IDEA_ECB"] = CKM_IDEA_ECB CKM[CKM_IDEA_ECB] = "CKM_IDEA_ECB" CKM_IDEA_CBC = PyKCS11.LowLevel.CKM_IDEA_CBC CKM["CKM_IDEA_CBC"] = CKM_IDEA_CBC CKM[CKM_IDEA_CBC] = "CKM_IDEA_CBC" CKM_IDEA_MAC = PyKCS11.LowLevel.CKM_IDEA_MAC CKM["CKM_IDEA_MAC"] = CKM_IDEA_MAC CKM[CKM_IDEA_MAC] = "CKM_IDEA_MAC" CKM_IDEA_MAC_GENERAL = PyKCS11.LowLevel.CKM_IDEA_MAC_GENERAL CKM["CKM_IDEA_MAC_GENERAL"] = CKM_IDEA_MAC_GENERAL CKM[CKM_IDEA_MAC_GENERAL] = "CKM_IDEA_MAC_GENERAL" CKM_IDEA_CBC_PAD = PyKCS11.LowLevel.CKM_IDEA_CBC_PAD CKM["CKM_IDEA_CBC_PAD"] = CKM_IDEA_CBC_PAD CKM[CKM_IDEA_CBC_PAD] = "CKM_IDEA_CBC_PAD" CKM_GENERIC_SECRET_KEY_GEN = PyKCS11.LowLevel.CKM_GENERIC_SECRET_KEY_GEN CKM["CKM_GENERIC_SECRET_KEY_GEN"] = CKM_GENERIC_SECRET_KEY_GEN CKM[CKM_GENERIC_SECRET_KEY_GEN] = "CKM_GENERIC_SECRET_KEY_GEN" CKM_CONCATENATE_BASE_AND_KEY = PyKCS11.LowLevel.CKM_CONCATENATE_BASE_AND_KEY CKM["CKM_CONCATENATE_BASE_AND_KEY"] = CKM_CONCATENATE_BASE_AND_KEY CKM[CKM_CONCATENATE_BASE_AND_KEY] = "CKM_CONCATENATE_BASE_AND_KEY" CKM_CONCATENATE_BASE_AND_DATA = PyKCS11.LowLevel.CKM_CONCATENATE_BASE_AND_DATA CKM["CKM_CONCATENATE_BASE_AND_DATA"] = CKM_CONCATENATE_BASE_AND_DATA CKM[CKM_CONCATENATE_BASE_AND_DATA] = "CKM_CONCATENATE_BASE_AND_DATA" CKM_CONCATENATE_DATA_AND_BASE = PyKCS11.LowLevel.CKM_CONCATENATE_DATA_AND_BASE CKM["CKM_CONCATENATE_DATA_AND_BASE"] = CKM_CONCATENATE_DATA_AND_BASE CKM[CKM_CONCATENATE_DATA_AND_BASE] = "CKM_CONCATENATE_DATA_AND_BASE" CKM_XOR_BASE_AND_DATA = PyKCS11.LowLevel.CKM_XOR_BASE_AND_DATA CKM["CKM_XOR_BASE_AND_DATA"] = CKM_XOR_BASE_AND_DATA CKM[CKM_XOR_BASE_AND_DATA] = "CKM_XOR_BASE_AND_DATA" CKM_EXTRACT_KEY_FROM_KEY = PyKCS11.LowLevel.CKM_EXTRACT_KEY_FROM_KEY CKM["CKM_EXTRACT_KEY_FROM_KEY"] = CKM_EXTRACT_KEY_FROM_KEY CKM[CKM_EXTRACT_KEY_FROM_KEY] = "CKM_EXTRACT_KEY_FROM_KEY" CKM_SSL3_PRE_MASTER_KEY_GEN = PyKCS11.LowLevel.CKM_SSL3_PRE_MASTER_KEY_GEN CKM["CKM_SSL3_PRE_MASTER_KEY_GEN"] = CKM_SSL3_PRE_MASTER_KEY_GEN CKM[CKM_SSL3_PRE_MASTER_KEY_GEN] = "CKM_SSL3_PRE_MASTER_KEY_GEN" CKM_SSL3_MASTER_KEY_DERIVE = PyKCS11.LowLevel.CKM_SSL3_MASTER_KEY_DERIVE CKM["CKM_SSL3_MASTER_KEY_DERIVE"] = CKM_SSL3_MASTER_KEY_DERIVE CKM[CKM_SSL3_MASTER_KEY_DERIVE] = "CKM_SSL3_MASTER_KEY_DERIVE" CKM_SSL3_KEY_AND_MAC_DERIVE = PyKCS11.LowLevel.CKM_SSL3_KEY_AND_MAC_DERIVE CKM["CKM_SSL3_KEY_AND_MAC_DERIVE"] = CKM_SSL3_KEY_AND_MAC_DERIVE CKM[CKM_SSL3_KEY_AND_MAC_DERIVE] = "CKM_SSL3_KEY_AND_MAC_DERIVE" CKM_SSL3_MASTER_KEY_DERIVE_DH = PyKCS11.LowLevel.CKM_SSL3_MASTER_KEY_DERIVE_DH CKM["CKM_SSL3_MASTER_KEY_DERIVE_DH"] = CKM_SSL3_MASTER_KEY_DERIVE_DH CKM[CKM_SSL3_MASTER_KEY_DERIVE_DH] = "CKM_SSL3_MASTER_KEY_DERIVE_DH" CKM_TLS_PRE_MASTER_KEY_GEN = PyKCS11.LowLevel.CKM_TLS_PRE_MASTER_KEY_GEN CKM["CKM_TLS_PRE_MASTER_KEY_GEN"] = CKM_TLS_PRE_MASTER_KEY_GEN CKM[CKM_TLS_PRE_MASTER_KEY_GEN] = "CKM_TLS_PRE_MASTER_KEY_GEN" CKM_TLS_MASTER_KEY_DERIVE = PyKCS11.LowLevel.CKM_TLS_MASTER_KEY_DERIVE CKM["CKM_TLS_MASTER_KEY_DERIVE"] = CKM_TLS_MASTER_KEY_DERIVE CKM[CKM_TLS_MASTER_KEY_DERIVE] = "CKM_TLS_MASTER_KEY_DERIVE" CKM_TLS_KEY_AND_MAC_DERIVE = PyKCS11.LowLevel.CKM_TLS_KEY_AND_MAC_DERIVE CKM["CKM_TLS_KEY_AND_MAC_DERIVE"] = CKM_TLS_KEY_AND_MAC_DERIVE CKM[CKM_TLS_KEY_AND_MAC_DERIVE] = "CKM_TLS_KEY_AND_MAC_DERIVE" CKM_TLS_MASTER_KEY_DERIVE_DH = PyKCS11.LowLevel.CKM_TLS_MASTER_KEY_DERIVE_DH CKM["CKM_TLS_MASTER_KEY_DERIVE_DH"] = CKM_TLS_MASTER_KEY_DERIVE_DH CKM[CKM_TLS_MASTER_KEY_DERIVE_DH] = "CKM_TLS_MASTER_KEY_DERIVE_DH" CKM_TLS_PRF = PyKCS11.LowLevel.CKM_TLS_PRF CKM["CKM_TLS_PRF"] = CKM_TLS_PRF CKM[CKM_TLS_PRF] = "CKM_TLS_PRF" CKM_SSL3_MD5_MAC = PyKCS11.LowLevel.CKM_SSL3_MD5_MAC CKM["CKM_SSL3_MD5_MAC"] = CKM_SSL3_MD5_MAC CKM[CKM_SSL3_MD5_MAC] = "CKM_SSL3_MD5_MAC" CKM_SSL3_SHA1_MAC = PyKCS11.LowLevel.CKM_SSL3_SHA1_MAC CKM["CKM_SSL3_SHA1_MAC"] = CKM_SSL3_SHA1_MAC CKM[CKM_SSL3_SHA1_MAC] = "CKM_SSL3_SHA1_MAC" CKM_MD5_KEY_DERIVATION = PyKCS11.LowLevel.CKM_MD5_KEY_DERIVATION CKM["CKM_MD5_KEY_DERIVATION"] = CKM_MD5_KEY_DERIVATION CKM[CKM_MD5_KEY_DERIVATION] = "CKM_MD5_KEY_DERIVATION" CKM_MD2_KEY_DERIVATION = PyKCS11.LowLevel.CKM_MD2_KEY_DERIVATION CKM["CKM_MD2_KEY_DERIVATION"] = CKM_MD2_KEY_DERIVATION CKM[CKM_MD2_KEY_DERIVATION] = "CKM_MD2_KEY_DERIVATION" CKM_SHA1_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA1_KEY_DERIVATION CKM["CKM_SHA1_KEY_DERIVATION"] = CKM_SHA1_KEY_DERIVATION CKM[CKM_SHA1_KEY_DERIVATION] = "CKM_SHA1_KEY_DERIVATION" CKM_SHA256_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA256_KEY_DERIVATION CKM["CKM_SHA256_KEY_DERIVATION"] = CKM_SHA256_KEY_DERIVATION CKM[CKM_SHA256_KEY_DERIVATION] = "CKM_SHA256_KEY_DERIVATION" CKM_SHA384_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA384_KEY_DERIVATION CKM["CKM_SHA384_KEY_DERIVATION"] = CKM_SHA384_KEY_DERIVATION CKM[CKM_SHA384_KEY_DERIVATION] = "CKM_SHA384_KEY_DERIVATION" CKM_SHA512_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA512_KEY_DERIVATION CKM["CKM_SHA512_KEY_DERIVATION"] = CKM_SHA512_KEY_DERIVATION CKM[CKM_SHA512_KEY_DERIVATION] = "CKM_SHA512_KEY_DERIVATION" CKM_SHA224_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA224_KEY_DERIVATION CKM["CKM_SHA224_KEY_DERIVATION"] = CKM_SHA224_KEY_DERIVATION CKM[CKM_SHA224_KEY_DERIVATION] = "CKM_SHA224_KEY_DERIVATION" CKM_SHA3_256_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA3_256_KEY_DERIVATION CKM["CKM_SHA3_256_KEY_DERIVATION"] = CKM_SHA3_256_KEY_DERIVATION CKM[CKM_SHA3_256_KEY_DERIVATION] = "CKM_SHA3_256_KEY_DERIVATION" CKM_SHA3_256_KEY_DERIVE = PyKCS11.LowLevel.CKM_SHA3_256_KEY_DERIVE CKM["CKM_SHA3_256_KEY_DERIVE"] = CKM_SHA3_256_KEY_DERIVE CKM[CKM_SHA3_256_KEY_DERIVE] = "CKM_SHA3_256_KEY_DERIVE" CKM_SHA3_224_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA3_224_KEY_DERIVATION CKM["CKM_SHA3_224_KEY_DERIVATION"] = CKM_SHA3_224_KEY_DERIVATION CKM[CKM_SHA3_224_KEY_DERIVATION] = "CKM_SHA3_224_KEY_DERIVATION" CKM_SHA3_224_KEY_DERIVE = PyKCS11.LowLevel.CKM_SHA3_224_KEY_DERIVE CKM["CKM_SHA3_224_KEY_DERIVE"] = CKM_SHA3_224_KEY_DERIVE CKM[CKM_SHA3_224_KEY_DERIVE] = "CKM_SHA3_224_KEY_DERIVE" CKM_SHA3_384_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA3_384_KEY_DERIVATION CKM["CKM_SHA3_384_KEY_DERIVATION"] = CKM_SHA3_384_KEY_DERIVATION CKM[CKM_SHA3_384_KEY_DERIVATION] = "CKM_SHA3_384_KEY_DERIVATION" CKM_SHA3_384_KEY_DERIVE = PyKCS11.LowLevel.CKM_SHA3_384_KEY_DERIVE CKM["CKM_SHA3_384_KEY_DERIVE"] = CKM_SHA3_384_KEY_DERIVE CKM[CKM_SHA3_384_KEY_DERIVE] = "CKM_SHA3_384_KEY_DERIVE" CKM_SHA3_512_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHA3_512_KEY_DERIVATION CKM["CKM_SHA3_512_KEY_DERIVATION"] = CKM_SHA3_512_KEY_DERIVATION CKM[CKM_SHA3_512_KEY_DERIVATION] = "CKM_SHA3_512_KEY_DERIVATION" CKM_SHA3_512_KEY_DERIVE = PyKCS11.LowLevel.CKM_SHA3_512_KEY_DERIVE CKM["CKM_SHA3_512_KEY_DERIVE"] = CKM_SHA3_512_KEY_DERIVE CKM[CKM_SHA3_512_KEY_DERIVE] = "CKM_SHA3_512_KEY_DERIVE" CKM_SHAKE_128_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHAKE_128_KEY_DERIVATION CKM["CKM_SHAKE_128_KEY_DERIVATION"] = CKM_SHAKE_128_KEY_DERIVATION CKM[CKM_SHAKE_128_KEY_DERIVATION] = "CKM_SHAKE_128_KEY_DERIVATION" CKM_SHAKE_128_KEY_DERIVE = PyKCS11.LowLevel.CKM_SHAKE_128_KEY_DERIVE CKM["CKM_SHAKE_128_KEY_DERIVE"] = CKM_SHAKE_128_KEY_DERIVE CKM[CKM_SHAKE_128_KEY_DERIVE] = "CKM_SHAKE_128_KEY_DERIVE" CKM_SHAKE_256_KEY_DERIVATION = PyKCS11.LowLevel.CKM_SHAKE_256_KEY_DERIVATION CKM["CKM_SHAKE_256_KEY_DERIVATION"] = CKM_SHAKE_256_KEY_DERIVATION CKM[CKM_SHAKE_256_KEY_DERIVATION] = "CKM_SHAKE_256_KEY_DERIVATION" CKM_SHAKE_256_KEY_DERIVE = PyKCS11.LowLevel.CKM_SHAKE_256_KEY_DERIVE CKM["CKM_SHAKE_256_KEY_DERIVE"] = CKM_SHAKE_256_KEY_DERIVE CKM[CKM_SHAKE_256_KEY_DERIVE] = "CKM_SHAKE_256_KEY_DERIVE" CKM_PBE_MD2_DES_CBC = PyKCS11.LowLevel.CKM_PBE_MD2_DES_CBC CKM["CKM_PBE_MD2_DES_CBC"] = CKM_PBE_MD2_DES_CBC CKM[CKM_PBE_MD2_DES_CBC] = "CKM_PBE_MD2_DES_CBC" CKM_PBE_MD5_DES_CBC = PyKCS11.LowLevel.CKM_PBE_MD5_DES_CBC CKM["CKM_PBE_MD5_DES_CBC"] = CKM_PBE_MD5_DES_CBC CKM[CKM_PBE_MD5_DES_CBC] = "CKM_PBE_MD5_DES_CBC" CKM_PBE_MD5_CAST_CBC = PyKCS11.LowLevel.CKM_PBE_MD5_CAST_CBC CKM["CKM_PBE_MD5_CAST_CBC"] = CKM_PBE_MD5_CAST_CBC CKM[CKM_PBE_MD5_CAST_CBC] = "CKM_PBE_MD5_CAST_CBC" CKM_PBE_MD5_CAST3_CBC = PyKCS11.LowLevel.CKM_PBE_MD5_CAST3_CBC CKM["CKM_PBE_MD5_CAST3_CBC"] = CKM_PBE_MD5_CAST3_CBC CKM[CKM_PBE_MD5_CAST3_CBC] = "CKM_PBE_MD5_CAST3_CBC" CKM_PBE_MD5_CAST128_CBC = PyKCS11.LowLevel.CKM_PBE_MD5_CAST128_CBC CKM["CKM_PBE_MD5_CAST128_CBC"] = CKM_PBE_MD5_CAST128_CBC CKM[CKM_PBE_MD5_CAST128_CBC] = "CKM_PBE_MD5_CAST128_CBC" CKM_PBE_SHA1_CAST128_CBC = PyKCS11.LowLevel.CKM_PBE_SHA1_CAST128_CBC CKM["CKM_PBE_SHA1_CAST128_CBC"] = CKM_PBE_SHA1_CAST128_CBC CKM[CKM_PBE_SHA1_CAST128_CBC] = "CKM_PBE_SHA1_CAST128_CBC" CKM_PBE_SHA1_RC4_128 = PyKCS11.LowLevel.CKM_PBE_SHA1_RC4_128 CKM["CKM_PBE_SHA1_RC4_128"] = CKM_PBE_SHA1_RC4_128 CKM[CKM_PBE_SHA1_RC4_128] = "CKM_PBE_SHA1_RC4_128" CKM_PBE_SHA1_RC4_40 = PyKCS11.LowLevel.CKM_PBE_SHA1_RC4_40 CKM["CKM_PBE_SHA1_RC4_40"] = CKM_PBE_SHA1_RC4_40 CKM[CKM_PBE_SHA1_RC4_40] = "CKM_PBE_SHA1_RC4_40" CKM_PBE_SHA1_DES3_EDE_CBC = PyKCS11.LowLevel.CKM_PBE_SHA1_DES3_EDE_CBC CKM["CKM_PBE_SHA1_DES3_EDE_CBC"] = CKM_PBE_SHA1_DES3_EDE_CBC CKM[CKM_PBE_SHA1_DES3_EDE_CBC] = "CKM_PBE_SHA1_DES3_EDE_CBC" CKM_PBE_SHA1_DES2_EDE_CBC = PyKCS11.LowLevel.CKM_PBE_SHA1_DES2_EDE_CBC CKM["CKM_PBE_SHA1_DES2_EDE_CBC"] = CKM_PBE_SHA1_DES2_EDE_CBC CKM[CKM_PBE_SHA1_DES2_EDE_CBC] = "CKM_PBE_SHA1_DES2_EDE_CBC" CKM_PBE_SHA1_RC2_128_CBC = PyKCS11.LowLevel.CKM_PBE_SHA1_RC2_128_CBC CKM["CKM_PBE_SHA1_RC2_128_CBC"] = CKM_PBE_SHA1_RC2_128_CBC CKM[CKM_PBE_SHA1_RC2_128_CBC] = "CKM_PBE_SHA1_RC2_128_CBC" CKM_PBE_SHA1_RC2_40_CBC = PyKCS11.LowLevel.CKM_PBE_SHA1_RC2_40_CBC CKM["CKM_PBE_SHA1_RC2_40_CBC"] = CKM_PBE_SHA1_RC2_40_CBC CKM[CKM_PBE_SHA1_RC2_40_CBC] = "CKM_PBE_SHA1_RC2_40_CBC" CKM_PKCS5_PBKD2 = PyKCS11.LowLevel.CKM_PKCS5_PBKD2 CKM["CKM_PKCS5_PBKD2"] = CKM_PKCS5_PBKD2 CKM[CKM_PKCS5_PBKD2] = "CKM_PKCS5_PBKD2" CKM_PBA_SHA1_WITH_SHA1_HMAC = PyKCS11.LowLevel.CKM_PBA_SHA1_WITH_SHA1_HMAC CKM["CKM_PBA_SHA1_WITH_SHA1_HMAC"] = CKM_PBA_SHA1_WITH_SHA1_HMAC CKM[CKM_PBA_SHA1_WITH_SHA1_HMAC] = "CKM_PBA_SHA1_WITH_SHA1_HMAC" CKM_WTLS_PRE_MASTER_KEY_GEN = PyKCS11.LowLevel.CKM_WTLS_PRE_MASTER_KEY_GEN CKM["CKM_WTLS_PRE_MASTER_KEY_GEN"] = CKM_WTLS_PRE_MASTER_KEY_GEN CKM[CKM_WTLS_PRE_MASTER_KEY_GEN] = "CKM_WTLS_PRE_MASTER_KEY_GEN" CKM_WTLS_MASTER_KEY_DERIVE = PyKCS11.LowLevel.CKM_WTLS_MASTER_KEY_DERIVE CKM["CKM_WTLS_MASTER_KEY_DERIVE"] = CKM_WTLS_MASTER_KEY_DERIVE CKM[CKM_WTLS_MASTER_KEY_DERIVE] = "CKM_WTLS_MASTER_KEY_DERIVE" CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC = PyKCS11.LowLevel.CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC CKM["CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC"] = CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC CKM[CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC] = "CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC" CKM_WTLS_PRF = PyKCS11.LowLevel.CKM_WTLS_PRF CKM["CKM_WTLS_PRF"] = CKM_WTLS_PRF CKM[CKM_WTLS_PRF] = "CKM_WTLS_PRF" CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE = PyKCS11.LowLevel.CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE CKM["CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE"] = CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE CKM[CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE] = "CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE" CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE = PyKCS11.LowLevel.CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE CKM["CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE"] = CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE CKM[CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE] = "CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE" CKM_TLS10_MAC_SERVER = PyKCS11.LowLevel.CKM_TLS10_MAC_SERVER CKM["CKM_TLS10_MAC_SERVER"] = CKM_TLS10_MAC_SERVER CKM[CKM_TLS10_MAC_SERVER] = "CKM_TLS10_MAC_SERVER" CKM_TLS10_MAC_CLIENT = PyKCS11.LowLevel.CKM_TLS10_MAC_CLIENT CKM["CKM_TLS10_MAC_CLIENT"] = CKM_TLS10_MAC_CLIENT CKM[CKM_TLS10_MAC_CLIENT] = "CKM_TLS10_MAC_CLIENT" CKM_TLS12_MAC = PyKCS11.LowLevel.CKM_TLS12_MAC CKM["CKM_TLS12_MAC"] = CKM_TLS12_MAC CKM[CKM_TLS12_MAC] = "CKM_TLS12_MAC" CKM_TLS12_KDF = PyKCS11.LowLevel.CKM_TLS12_KDF CKM["CKM_TLS12_KDF"] = CKM_TLS12_KDF CKM[CKM_TLS12_KDF] = "CKM_TLS12_KDF" CKM_TLS12_MASTER_KEY_DERIVE = PyKCS11.LowLevel.CKM_TLS12_MASTER_KEY_DERIVE CKM["CKM_TLS12_MASTER_KEY_DERIVE"] = CKM_TLS12_MASTER_KEY_DERIVE CKM[CKM_TLS12_MASTER_KEY_DERIVE] = "CKM_TLS12_MASTER_KEY_DERIVE" CKM_TLS12_KEY_AND_MAC_DERIVE = PyKCS11.LowLevel.CKM_TLS12_KEY_AND_MAC_DERIVE CKM["CKM_TLS12_KEY_AND_MAC_DERIVE"] = CKM_TLS12_KEY_AND_MAC_DERIVE CKM[CKM_TLS12_KEY_AND_MAC_DERIVE] = "CKM_TLS12_KEY_AND_MAC_DERIVE" CKM_TLS12_MASTER_KEY_DERIVE_DH = PyKCS11.LowLevel.CKM_TLS12_MASTER_KEY_DERIVE_DH CKM["CKM_TLS12_MASTER_KEY_DERIVE_DH"] = CKM_TLS12_MASTER_KEY_DERIVE_DH CKM[CKM_TLS12_MASTER_KEY_DERIVE_DH] = "CKM_TLS12_MASTER_KEY_DERIVE_DH" CKM_TLS12_KEY_SAFE_DERIVE = PyKCS11.LowLevel.CKM_TLS12_KEY_SAFE_DERIVE CKM["CKM_TLS12_KEY_SAFE_DERIVE"] = CKM_TLS12_KEY_SAFE_DERIVE CKM[CKM_TLS12_KEY_SAFE_DERIVE] = "CKM_TLS12_KEY_SAFE_DERIVE" CKM_TLS_MAC = PyKCS11.LowLevel.CKM_TLS_MAC CKM["CKM_TLS_MAC"] = CKM_TLS_MAC CKM[CKM_TLS_MAC] = "CKM_TLS_MAC" CKM_TLS_KDF = PyKCS11.LowLevel.CKM_TLS_KDF CKM["CKM_TLS_KDF"] = CKM_TLS_KDF CKM[CKM_TLS_KDF] = "CKM_TLS_KDF" CKM_KEY_WRAP_LYNKS = PyKCS11.LowLevel.CKM_KEY_WRAP_LYNKS CKM["CKM_KEY_WRAP_LYNKS"] = CKM_KEY_WRAP_LYNKS CKM[CKM_KEY_WRAP_LYNKS] = "CKM_KEY_WRAP_LYNKS" CKM_KEY_WRAP_SET_OAEP = PyKCS11.LowLevel.CKM_KEY_WRAP_SET_OAEP CKM["CKM_KEY_WRAP_SET_OAEP"] = CKM_KEY_WRAP_SET_OAEP CKM[CKM_KEY_WRAP_SET_OAEP] = "CKM_KEY_WRAP_SET_OAEP" CKM_CMS_SIG = PyKCS11.LowLevel.CKM_CMS_SIG CKM["CKM_CMS_SIG"] = CKM_CMS_SIG CKM[CKM_CMS_SIG] = "CKM_CMS_SIG" CKM_KIP_DERIVE = PyKCS11.LowLevel.CKM_KIP_DERIVE CKM["CKM_KIP_DERIVE"] = CKM_KIP_DERIVE CKM[CKM_KIP_DERIVE] = "CKM_KIP_DERIVE" CKM_KIP_WRAP = PyKCS11.LowLevel.CKM_KIP_WRAP CKM["CKM_KIP_WRAP"] = CKM_KIP_WRAP CKM[CKM_KIP_WRAP] = "CKM_KIP_WRAP" CKM_KIP_MAC = PyKCS11.LowLevel.CKM_KIP_MAC CKM["CKM_KIP_MAC"] = CKM_KIP_MAC CKM[CKM_KIP_MAC] = "CKM_KIP_MAC" CKM_CAMELLIA_KEY_GEN = PyKCS11.LowLevel.CKM_CAMELLIA_KEY_GEN CKM["CKM_CAMELLIA_KEY_GEN"] = CKM_CAMELLIA_KEY_GEN CKM[CKM_CAMELLIA_KEY_GEN] = "CKM_CAMELLIA_KEY_GEN" CKM_CAMELLIA_ECB = PyKCS11.LowLevel.CKM_CAMELLIA_ECB CKM["CKM_CAMELLIA_ECB"] = CKM_CAMELLIA_ECB CKM[CKM_CAMELLIA_ECB] = "CKM_CAMELLIA_ECB" CKM_CAMELLIA_CBC = PyKCS11.LowLevel.CKM_CAMELLIA_CBC CKM["CKM_CAMELLIA_CBC"] = CKM_CAMELLIA_CBC CKM[CKM_CAMELLIA_CBC] = "CKM_CAMELLIA_CBC" CKM_CAMELLIA_MAC = PyKCS11.LowLevel.CKM_CAMELLIA_MAC CKM["CKM_CAMELLIA_MAC"] = CKM_CAMELLIA_MAC CKM[CKM_CAMELLIA_MAC] = "CKM_CAMELLIA_MAC" CKM_CAMELLIA_MAC_GENERAL = PyKCS11.LowLevel.CKM_CAMELLIA_MAC_GENERAL CKM["CKM_CAMELLIA_MAC_GENERAL"] = CKM_CAMELLIA_MAC_GENERAL CKM[CKM_CAMELLIA_MAC_GENERAL] = "CKM_CAMELLIA_MAC_GENERAL" CKM_CAMELLIA_CBC_PAD = PyKCS11.LowLevel.CKM_CAMELLIA_CBC_PAD CKM["CKM_CAMELLIA_CBC_PAD"] = CKM_CAMELLIA_CBC_PAD CKM[CKM_CAMELLIA_CBC_PAD] = "CKM_CAMELLIA_CBC_PAD" CKM_CAMELLIA_ECB_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_CAMELLIA_ECB_ENCRYPT_DATA CKM["CKM_CAMELLIA_ECB_ENCRYPT_DATA"] = CKM_CAMELLIA_ECB_ENCRYPT_DATA CKM[CKM_CAMELLIA_ECB_ENCRYPT_DATA] = "CKM_CAMELLIA_ECB_ENCRYPT_DATA" CKM_CAMELLIA_CBC_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_CAMELLIA_CBC_ENCRYPT_DATA CKM["CKM_CAMELLIA_CBC_ENCRYPT_DATA"] = CKM_CAMELLIA_CBC_ENCRYPT_DATA CKM[CKM_CAMELLIA_CBC_ENCRYPT_DATA] = "CKM_CAMELLIA_CBC_ENCRYPT_DATA" CKM_CAMELLIA_CTR = PyKCS11.LowLevel.CKM_CAMELLIA_CTR CKM["CKM_CAMELLIA_CTR"] = CKM_CAMELLIA_CTR CKM[CKM_CAMELLIA_CTR] = "CKM_CAMELLIA_CTR" CKM_ARIA_KEY_GEN = PyKCS11.LowLevel.CKM_ARIA_KEY_GEN CKM["CKM_ARIA_KEY_GEN"] = CKM_ARIA_KEY_GEN CKM[CKM_ARIA_KEY_GEN] = "CKM_ARIA_KEY_GEN" CKM_ARIA_ECB = PyKCS11.LowLevel.CKM_ARIA_ECB CKM["CKM_ARIA_ECB"] = CKM_ARIA_ECB CKM[CKM_ARIA_ECB] = "CKM_ARIA_ECB" CKM_ARIA_CBC = PyKCS11.LowLevel.CKM_ARIA_CBC CKM["CKM_ARIA_CBC"] = CKM_ARIA_CBC CKM[CKM_ARIA_CBC] = "CKM_ARIA_CBC" CKM_ARIA_MAC = PyKCS11.LowLevel.CKM_ARIA_MAC CKM["CKM_ARIA_MAC"] = CKM_ARIA_MAC CKM[CKM_ARIA_MAC] = "CKM_ARIA_MAC" CKM_ARIA_MAC_GENERAL = PyKCS11.LowLevel.CKM_ARIA_MAC_GENERAL CKM["CKM_ARIA_MAC_GENERAL"] = CKM_ARIA_MAC_GENERAL CKM[CKM_ARIA_MAC_GENERAL] = "CKM_ARIA_MAC_GENERAL" CKM_ARIA_CBC_PAD = PyKCS11.LowLevel.CKM_ARIA_CBC_PAD CKM["CKM_ARIA_CBC_PAD"] = CKM_ARIA_CBC_PAD CKM[CKM_ARIA_CBC_PAD] = "CKM_ARIA_CBC_PAD" CKM_ARIA_ECB_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_ARIA_ECB_ENCRYPT_DATA CKM["CKM_ARIA_ECB_ENCRYPT_DATA"] = CKM_ARIA_ECB_ENCRYPT_DATA CKM[CKM_ARIA_ECB_ENCRYPT_DATA] = "CKM_ARIA_ECB_ENCRYPT_DATA" CKM_ARIA_CBC_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_ARIA_CBC_ENCRYPT_DATA CKM["CKM_ARIA_CBC_ENCRYPT_DATA"] = CKM_ARIA_CBC_ENCRYPT_DATA CKM[CKM_ARIA_CBC_ENCRYPT_DATA] = "CKM_ARIA_CBC_ENCRYPT_DATA" CKM_SEED_KEY_GEN = PyKCS11.LowLevel.CKM_SEED_KEY_GEN CKM["CKM_SEED_KEY_GEN"] = CKM_SEED_KEY_GEN CKM[CKM_SEED_KEY_GEN] = "CKM_SEED_KEY_GEN" CKM_SEED_ECB = PyKCS11.LowLevel.CKM_SEED_ECB CKM["CKM_SEED_ECB"] = CKM_SEED_ECB CKM[CKM_SEED_ECB] = "CKM_SEED_ECB" CKM_SEED_CBC = PyKCS11.LowLevel.CKM_SEED_CBC CKM["CKM_SEED_CBC"] = CKM_SEED_CBC CKM[CKM_SEED_CBC] = "CKM_SEED_CBC" CKM_SEED_MAC = PyKCS11.LowLevel.CKM_SEED_MAC CKM["CKM_SEED_MAC"] = CKM_SEED_MAC CKM[CKM_SEED_MAC] = "CKM_SEED_MAC" CKM_SEED_MAC_GENERAL = PyKCS11.LowLevel.CKM_SEED_MAC_GENERAL CKM["CKM_SEED_MAC_GENERAL"] = CKM_SEED_MAC_GENERAL CKM[CKM_SEED_MAC_GENERAL] = "CKM_SEED_MAC_GENERAL" CKM_SEED_CBC_PAD = PyKCS11.LowLevel.CKM_SEED_CBC_PAD CKM["CKM_SEED_CBC_PAD"] = CKM_SEED_CBC_PAD CKM[CKM_SEED_CBC_PAD] = "CKM_SEED_CBC_PAD" CKM_SEED_ECB_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_SEED_ECB_ENCRYPT_DATA CKM["CKM_SEED_ECB_ENCRYPT_DATA"] = CKM_SEED_ECB_ENCRYPT_DATA CKM[CKM_SEED_ECB_ENCRYPT_DATA] = "CKM_SEED_ECB_ENCRYPT_DATA" CKM_SEED_CBC_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_SEED_CBC_ENCRYPT_DATA CKM["CKM_SEED_CBC_ENCRYPT_DATA"] = CKM_SEED_CBC_ENCRYPT_DATA CKM[CKM_SEED_CBC_ENCRYPT_DATA] = "CKM_SEED_CBC_ENCRYPT_DATA" CKM_SKIPJACK_KEY_GEN = PyKCS11.LowLevel.CKM_SKIPJACK_KEY_GEN CKM["CKM_SKIPJACK_KEY_GEN"] = CKM_SKIPJACK_KEY_GEN CKM[CKM_SKIPJACK_KEY_GEN] = "CKM_SKIPJACK_KEY_GEN" CKM_SKIPJACK_ECB64 = PyKCS11.LowLevel.CKM_SKIPJACK_ECB64 CKM["CKM_SKIPJACK_ECB64"] = CKM_SKIPJACK_ECB64 CKM[CKM_SKIPJACK_ECB64] = "CKM_SKIPJACK_ECB64" CKM_SKIPJACK_CBC64 = PyKCS11.LowLevel.CKM_SKIPJACK_CBC64 CKM["CKM_SKIPJACK_CBC64"] = CKM_SKIPJACK_CBC64 CKM[CKM_SKIPJACK_CBC64] = "CKM_SKIPJACK_CBC64" CKM_SKIPJACK_OFB64 = PyKCS11.LowLevel.CKM_SKIPJACK_OFB64 CKM["CKM_SKIPJACK_OFB64"] = CKM_SKIPJACK_OFB64 CKM[CKM_SKIPJACK_OFB64] = "CKM_SKIPJACK_OFB64" CKM_SKIPJACK_CFB64 = PyKCS11.LowLevel.CKM_SKIPJACK_CFB64 CKM["CKM_SKIPJACK_CFB64"] = CKM_SKIPJACK_CFB64 CKM[CKM_SKIPJACK_CFB64] = "CKM_SKIPJACK_CFB64" CKM_SKIPJACK_CFB32 = PyKCS11.LowLevel.CKM_SKIPJACK_CFB32 CKM["CKM_SKIPJACK_CFB32"] = CKM_SKIPJACK_CFB32 CKM[CKM_SKIPJACK_CFB32] = "CKM_SKIPJACK_CFB32" CKM_SKIPJACK_CFB16 = PyKCS11.LowLevel.CKM_SKIPJACK_CFB16 CKM["CKM_SKIPJACK_CFB16"] = CKM_SKIPJACK_CFB16 CKM[CKM_SKIPJACK_CFB16] = "CKM_SKIPJACK_CFB16" CKM_SKIPJACK_CFB8 = PyKCS11.LowLevel.CKM_SKIPJACK_CFB8 CKM["CKM_SKIPJACK_CFB8"] = CKM_SKIPJACK_CFB8 CKM[CKM_SKIPJACK_CFB8] = "CKM_SKIPJACK_CFB8" CKM_SKIPJACK_WRAP = PyKCS11.LowLevel.CKM_SKIPJACK_WRAP CKM["CKM_SKIPJACK_WRAP"] = CKM_SKIPJACK_WRAP CKM[CKM_SKIPJACK_WRAP] = "CKM_SKIPJACK_WRAP" CKM_SKIPJACK_PRIVATE_WRAP = PyKCS11.LowLevel.CKM_SKIPJACK_PRIVATE_WRAP CKM["CKM_SKIPJACK_PRIVATE_WRAP"] = CKM_SKIPJACK_PRIVATE_WRAP CKM[CKM_SKIPJACK_PRIVATE_WRAP] = "CKM_SKIPJACK_PRIVATE_WRAP" CKM_SKIPJACK_RELAYX = PyKCS11.LowLevel.CKM_SKIPJACK_RELAYX CKM["CKM_SKIPJACK_RELAYX"] = CKM_SKIPJACK_RELAYX CKM[CKM_SKIPJACK_RELAYX] = "CKM_SKIPJACK_RELAYX" CKM_KEA_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_KEA_KEY_PAIR_GEN CKM["CKM_KEA_KEY_PAIR_GEN"] = CKM_KEA_KEY_PAIR_GEN CKM[CKM_KEA_KEY_PAIR_GEN] = "CKM_KEA_KEY_PAIR_GEN" CKM_KEA_KEY_DERIVE = PyKCS11.LowLevel.CKM_KEA_KEY_DERIVE CKM["CKM_KEA_KEY_DERIVE"] = CKM_KEA_KEY_DERIVE CKM[CKM_KEA_KEY_DERIVE] = "CKM_KEA_KEY_DERIVE" CKM_KEA_DERIVE = PyKCS11.LowLevel.CKM_KEA_DERIVE CKM["CKM_KEA_DERIVE"] = CKM_KEA_DERIVE CKM[CKM_KEA_DERIVE] = "CKM_KEA_DERIVE" CKM_FORTEZZA_TIMESTAMP = PyKCS11.LowLevel.CKM_FORTEZZA_TIMESTAMP CKM["CKM_FORTEZZA_TIMESTAMP"] = CKM_FORTEZZA_TIMESTAMP CKM[CKM_FORTEZZA_TIMESTAMP] = "CKM_FORTEZZA_TIMESTAMP" CKM_BATON_KEY_GEN = PyKCS11.LowLevel.CKM_BATON_KEY_GEN CKM["CKM_BATON_KEY_GEN"] = CKM_BATON_KEY_GEN CKM[CKM_BATON_KEY_GEN] = "CKM_BATON_KEY_GEN" CKM_BATON_ECB128 = PyKCS11.LowLevel.CKM_BATON_ECB128 CKM["CKM_BATON_ECB128"] = CKM_BATON_ECB128 CKM[CKM_BATON_ECB128] = "CKM_BATON_ECB128" CKM_BATON_ECB96 = PyKCS11.LowLevel.CKM_BATON_ECB96 CKM["CKM_BATON_ECB96"] = CKM_BATON_ECB96 CKM[CKM_BATON_ECB96] = "CKM_BATON_ECB96" CKM_BATON_CBC128 = PyKCS11.LowLevel.CKM_BATON_CBC128 CKM["CKM_BATON_CBC128"] = CKM_BATON_CBC128 CKM[CKM_BATON_CBC128] = "CKM_BATON_CBC128" CKM_BATON_COUNTER = PyKCS11.LowLevel.CKM_BATON_COUNTER CKM["CKM_BATON_COUNTER"] = CKM_BATON_COUNTER CKM[CKM_BATON_COUNTER] = "CKM_BATON_COUNTER" CKM_BATON_SHUFFLE = PyKCS11.LowLevel.CKM_BATON_SHUFFLE CKM["CKM_BATON_SHUFFLE"] = CKM_BATON_SHUFFLE CKM[CKM_BATON_SHUFFLE] = "CKM_BATON_SHUFFLE" CKM_BATON_WRAP = PyKCS11.LowLevel.CKM_BATON_WRAP CKM["CKM_BATON_WRAP"] = CKM_BATON_WRAP CKM[CKM_BATON_WRAP] = "CKM_BATON_WRAP" CKM_EC_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_EC_KEY_PAIR_GEN CKM["CKM_EC_KEY_PAIR_GEN"] = CKM_EC_KEY_PAIR_GEN CKM[CKM_EC_KEY_PAIR_GEN] = "CKM_EC_KEY_PAIR_GEN" CKM_ECDSA = PyKCS11.LowLevel.CKM_ECDSA CKM["CKM_ECDSA"] = CKM_ECDSA CKM[CKM_ECDSA] = "CKM_ECDSA" CKM_ECDSA_SHA1 = PyKCS11.LowLevel.CKM_ECDSA_SHA1 CKM["CKM_ECDSA_SHA1"] = CKM_ECDSA_SHA1 CKM[CKM_ECDSA_SHA1] = "CKM_ECDSA_SHA1" CKM_ECDSA_SHA224 = PyKCS11.LowLevel.CKM_ECDSA_SHA224 CKM["CKM_ECDSA_SHA224"] = CKM_ECDSA_SHA224 CKM[CKM_ECDSA_SHA224] = "CKM_ECDSA_SHA224" CKM_ECDSA_SHA256 = PyKCS11.LowLevel.CKM_ECDSA_SHA256 CKM["CKM_ECDSA_SHA256"] = CKM_ECDSA_SHA256 CKM[CKM_ECDSA_SHA256] = "CKM_ECDSA_SHA256" CKM_ECDSA_SHA384 = PyKCS11.LowLevel.CKM_ECDSA_SHA384 CKM["CKM_ECDSA_SHA384"] = CKM_ECDSA_SHA384 CKM[CKM_ECDSA_SHA384] = "CKM_ECDSA_SHA384" CKM_ECDSA_SHA512 = PyKCS11.LowLevel.CKM_ECDSA_SHA512 CKM["CKM_ECDSA_SHA512"] = CKM_ECDSA_SHA512 CKM[CKM_ECDSA_SHA512] = "CKM_ECDSA_SHA512" CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS = PyKCS11.LowLevel.CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS CKM["CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS"] = CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS CKM[CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS] = "CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS" CKM_ECDH1_DERIVE = PyKCS11.LowLevel.CKM_ECDH1_DERIVE CKM["CKM_ECDH1_DERIVE"] = CKM_ECDH1_DERIVE CKM[CKM_ECDH1_DERIVE] = "CKM_ECDH1_DERIVE" CKM_ECDH1_COFACTOR_DERIVE = PyKCS11.LowLevel.CKM_ECDH1_COFACTOR_DERIVE CKM["CKM_ECDH1_COFACTOR_DERIVE"] = CKM_ECDH1_COFACTOR_DERIVE CKM[CKM_ECDH1_COFACTOR_DERIVE] = "CKM_ECDH1_COFACTOR_DERIVE" CKM_ECMQV_DERIVE = PyKCS11.LowLevel.CKM_ECMQV_DERIVE CKM["CKM_ECMQV_DERIVE"] = CKM_ECMQV_DERIVE CKM[CKM_ECMQV_DERIVE] = "CKM_ECMQV_DERIVE" CKM_ECDH_AES_KEY_WRAP = PyKCS11.LowLevel.CKM_ECDH_AES_KEY_WRAP CKM["CKM_ECDH_AES_KEY_WRAP"] = CKM_ECDH_AES_KEY_WRAP CKM[CKM_ECDH_AES_KEY_WRAP] = "CKM_ECDH_AES_KEY_WRAP" CKM_RSA_AES_KEY_WRAP = PyKCS11.LowLevel.CKM_RSA_AES_KEY_WRAP CKM["CKM_RSA_AES_KEY_WRAP"] = CKM_RSA_AES_KEY_WRAP CKM[CKM_RSA_AES_KEY_WRAP] = "CKM_RSA_AES_KEY_WRAP" CKM_JUNIPER_KEY_GEN = PyKCS11.LowLevel.CKM_JUNIPER_KEY_GEN CKM["CKM_JUNIPER_KEY_GEN"] = CKM_JUNIPER_KEY_GEN CKM[CKM_JUNIPER_KEY_GEN] = "CKM_JUNIPER_KEY_GEN" CKM_JUNIPER_ECB128 = PyKCS11.LowLevel.CKM_JUNIPER_ECB128 CKM["CKM_JUNIPER_ECB128"] = CKM_JUNIPER_ECB128 CKM[CKM_JUNIPER_ECB128] = "CKM_JUNIPER_ECB128" CKM_JUNIPER_CBC128 = PyKCS11.LowLevel.CKM_JUNIPER_CBC128 CKM["CKM_JUNIPER_CBC128"] = CKM_JUNIPER_CBC128 CKM[CKM_JUNIPER_CBC128] = "CKM_JUNIPER_CBC128" CKM_JUNIPER_COUNTER = PyKCS11.LowLevel.CKM_JUNIPER_COUNTER CKM["CKM_JUNIPER_COUNTER"] = CKM_JUNIPER_COUNTER CKM[CKM_JUNIPER_COUNTER] = "CKM_JUNIPER_COUNTER" CKM_JUNIPER_SHUFFLE = PyKCS11.LowLevel.CKM_JUNIPER_SHUFFLE CKM["CKM_JUNIPER_SHUFFLE"] = CKM_JUNIPER_SHUFFLE CKM[CKM_JUNIPER_SHUFFLE] = "CKM_JUNIPER_SHUFFLE" CKM_JUNIPER_WRAP = PyKCS11.LowLevel.CKM_JUNIPER_WRAP CKM["CKM_JUNIPER_WRAP"] = CKM_JUNIPER_WRAP CKM[CKM_JUNIPER_WRAP] = "CKM_JUNIPER_WRAP" CKM_FASTHASH = PyKCS11.LowLevel.CKM_FASTHASH CKM["CKM_FASTHASH"] = CKM_FASTHASH CKM[CKM_FASTHASH] = "CKM_FASTHASH" CKM_AES_XTS = PyKCS11.LowLevel.CKM_AES_XTS CKM["CKM_AES_XTS"] = CKM_AES_XTS CKM[CKM_AES_XTS] = "CKM_AES_XTS" CKM_AES_XTS_KEY_GEN = PyKCS11.LowLevel.CKM_AES_XTS_KEY_GEN CKM["CKM_AES_XTS_KEY_GEN"] = CKM_AES_XTS_KEY_GEN CKM[CKM_AES_XTS_KEY_GEN] = "CKM_AES_XTS_KEY_GEN" CKM_AES_KEY_GEN = PyKCS11.LowLevel.CKM_AES_KEY_GEN CKM["CKM_AES_KEY_GEN"] = CKM_AES_KEY_GEN CKM[CKM_AES_KEY_GEN] = "CKM_AES_KEY_GEN" CKM_AES_ECB = PyKCS11.LowLevel.CKM_AES_ECB CKM["CKM_AES_ECB"] = CKM_AES_ECB CKM[CKM_AES_ECB] = "CKM_AES_ECB" CKM_AES_CBC = PyKCS11.LowLevel.CKM_AES_CBC CKM["CKM_AES_CBC"] = CKM_AES_CBC CKM[CKM_AES_CBC] = "CKM_AES_CBC" CKM_AES_MAC = PyKCS11.LowLevel.CKM_AES_MAC CKM["CKM_AES_MAC"] = CKM_AES_MAC CKM[CKM_AES_MAC] = "CKM_AES_MAC" CKM_AES_MAC_GENERAL = PyKCS11.LowLevel.CKM_AES_MAC_GENERAL CKM["CKM_AES_MAC_GENERAL"] = CKM_AES_MAC_GENERAL CKM[CKM_AES_MAC_GENERAL] = "CKM_AES_MAC_GENERAL" CKM_AES_CBC_PAD = PyKCS11.LowLevel.CKM_AES_CBC_PAD CKM["CKM_AES_CBC_PAD"] = CKM_AES_CBC_PAD CKM[CKM_AES_CBC_PAD] = "CKM_AES_CBC_PAD" CKM_AES_CTR = PyKCS11.LowLevel.CKM_AES_CTR CKM["CKM_AES_CTR"] = CKM_AES_CTR CKM[CKM_AES_CTR] = "CKM_AES_CTR" CKM_AES_GCM = PyKCS11.LowLevel.CKM_AES_GCM CKM["CKM_AES_GCM"] = CKM_AES_GCM CKM[CKM_AES_GCM] = "CKM_AES_GCM" CKM_AES_CCM = PyKCS11.LowLevel.CKM_AES_CCM CKM["CKM_AES_CCM"] = CKM_AES_CCM CKM[CKM_AES_CCM] = "CKM_AES_CCM" CKM_AES_CTS = PyKCS11.LowLevel.CKM_AES_CTS CKM["CKM_AES_CTS"] = CKM_AES_CTS CKM[CKM_AES_CTS] = "CKM_AES_CTS" CKM_AES_CMAC = PyKCS11.LowLevel.CKM_AES_CMAC CKM["CKM_AES_CMAC"] = CKM_AES_CMAC CKM[CKM_AES_CMAC] = "CKM_AES_CMAC" CKM_AES_CMAC_GENERAL = PyKCS11.LowLevel.CKM_AES_CMAC_GENERAL CKM["CKM_AES_CMAC_GENERAL"] = CKM_AES_CMAC_GENERAL CKM[CKM_AES_CMAC_GENERAL] = "CKM_AES_CMAC_GENERAL" CKM_AES_XCBC_MAC = PyKCS11.LowLevel.CKM_AES_XCBC_MAC CKM["CKM_AES_XCBC_MAC"] = CKM_AES_XCBC_MAC CKM[CKM_AES_XCBC_MAC] = "CKM_AES_XCBC_MAC" CKM_AES_XCBC_MAC_96 = PyKCS11.LowLevel.CKM_AES_XCBC_MAC_96 CKM["CKM_AES_XCBC_MAC_96"] = CKM_AES_XCBC_MAC_96 CKM[CKM_AES_XCBC_MAC_96] = "CKM_AES_XCBC_MAC_96" CKM_AES_GMAC = PyKCS11.LowLevel.CKM_AES_GMAC CKM["CKM_AES_GMAC"] = CKM_AES_GMAC CKM[CKM_AES_GMAC] = "CKM_AES_GMAC" CKM_BLOWFISH_KEY_GEN = PyKCS11.LowLevel.CKM_BLOWFISH_KEY_GEN CKM["CKM_BLOWFISH_KEY_GEN"] = CKM_BLOWFISH_KEY_GEN CKM[CKM_BLOWFISH_KEY_GEN] = "CKM_BLOWFISH_KEY_GEN" CKM_BLOWFISH_CBC = PyKCS11.LowLevel.CKM_BLOWFISH_CBC CKM["CKM_BLOWFISH_CBC"] = CKM_BLOWFISH_CBC CKM[CKM_BLOWFISH_CBC] = "CKM_BLOWFISH_CBC" CKM_TWOFISH_KEY_GEN = PyKCS11.LowLevel.CKM_TWOFISH_KEY_GEN CKM["CKM_TWOFISH_KEY_GEN"] = CKM_TWOFISH_KEY_GEN CKM[CKM_TWOFISH_KEY_GEN] = "CKM_TWOFISH_KEY_GEN" CKM_TWOFISH_CBC = PyKCS11.LowLevel.CKM_TWOFISH_CBC CKM["CKM_TWOFISH_CBC"] = CKM_TWOFISH_CBC CKM[CKM_TWOFISH_CBC] = "CKM_TWOFISH_CBC" CKM_BLOWFISH_CBC_PAD = PyKCS11.LowLevel.CKM_BLOWFISH_CBC_PAD CKM["CKM_BLOWFISH_CBC_PAD"] = CKM_BLOWFISH_CBC_PAD CKM[CKM_BLOWFISH_CBC_PAD] = "CKM_BLOWFISH_CBC_PAD" CKM_TWOFISH_CBC_PAD = PyKCS11.LowLevel.CKM_TWOFISH_CBC_PAD CKM["CKM_TWOFISH_CBC_PAD"] = CKM_TWOFISH_CBC_PAD CKM[CKM_TWOFISH_CBC_PAD] = "CKM_TWOFISH_CBC_PAD" CKM_DES_ECB_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_DES_ECB_ENCRYPT_DATA CKM["CKM_DES_ECB_ENCRYPT_DATA"] = CKM_DES_ECB_ENCRYPT_DATA CKM[CKM_DES_ECB_ENCRYPT_DATA] = "CKM_DES_ECB_ENCRYPT_DATA" CKM_DES_CBC_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_DES_CBC_ENCRYPT_DATA CKM["CKM_DES_CBC_ENCRYPT_DATA"] = CKM_DES_CBC_ENCRYPT_DATA CKM[CKM_DES_CBC_ENCRYPT_DATA] = "CKM_DES_CBC_ENCRYPT_DATA" CKM_DES3_ECB_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_DES3_ECB_ENCRYPT_DATA CKM["CKM_DES3_ECB_ENCRYPT_DATA"] = CKM_DES3_ECB_ENCRYPT_DATA CKM[CKM_DES3_ECB_ENCRYPT_DATA] = "CKM_DES3_ECB_ENCRYPT_DATA" CKM_DES3_CBC_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_DES3_CBC_ENCRYPT_DATA CKM["CKM_DES3_CBC_ENCRYPT_DATA"] = CKM_DES3_CBC_ENCRYPT_DATA CKM[CKM_DES3_CBC_ENCRYPT_DATA] = "CKM_DES3_CBC_ENCRYPT_DATA" CKM_AES_ECB_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_AES_ECB_ENCRYPT_DATA CKM["CKM_AES_ECB_ENCRYPT_DATA"] = CKM_AES_ECB_ENCRYPT_DATA CKM[CKM_AES_ECB_ENCRYPT_DATA] = "CKM_AES_ECB_ENCRYPT_DATA" CKM_AES_CBC_ENCRYPT_DATA = PyKCS11.LowLevel.CKM_AES_CBC_ENCRYPT_DATA CKM["CKM_AES_CBC_ENCRYPT_DATA"] = CKM_AES_CBC_ENCRYPT_DATA CKM[CKM_AES_CBC_ENCRYPT_DATA] = "CKM_AES_CBC_ENCRYPT_DATA" CKM_GOSTR3410_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_GOSTR3410_KEY_PAIR_GEN CKM["CKM_GOSTR3410_KEY_PAIR_GEN"] = CKM_GOSTR3410_KEY_PAIR_GEN CKM[CKM_GOSTR3410_KEY_PAIR_GEN] = "CKM_GOSTR3410_KEY_PAIR_GEN" CKM_GOSTR3410 = PyKCS11.LowLevel.CKM_GOSTR3410 CKM["CKM_GOSTR3410"] = CKM_GOSTR3410 CKM[CKM_GOSTR3410] = "CKM_GOSTR3410" CKM_GOSTR3410_WITH_GOSTR3411 = PyKCS11.LowLevel.CKM_GOSTR3410_WITH_GOSTR3411 CKM["CKM_GOSTR3410_WITH_GOSTR3411"] = CKM_GOSTR3410_WITH_GOSTR3411 CKM[CKM_GOSTR3410_WITH_GOSTR3411] = "CKM_GOSTR3410_WITH_GOSTR3411" CKM_GOSTR3410_KEY_WRAP = PyKCS11.LowLevel.CKM_GOSTR3410_KEY_WRAP CKM["CKM_GOSTR3410_KEY_WRAP"] = CKM_GOSTR3410_KEY_WRAP CKM[CKM_GOSTR3410_KEY_WRAP] = "CKM_GOSTR3410_KEY_WRAP" CKM_GOSTR3410_DERIVE = PyKCS11.LowLevel.CKM_GOSTR3410_DERIVE CKM["CKM_GOSTR3410_DERIVE"] = CKM_GOSTR3410_DERIVE CKM[CKM_GOSTR3410_DERIVE] = "CKM_GOSTR3410_DERIVE" CKM_GOSTR3411 = PyKCS11.LowLevel.CKM_GOSTR3411 CKM["CKM_GOSTR3411"] = CKM_GOSTR3411 CKM[CKM_GOSTR3411] = "CKM_GOSTR3411" CKM_GOSTR3411_HMAC = PyKCS11.LowLevel.CKM_GOSTR3411_HMAC CKM["CKM_GOSTR3411_HMAC"] = CKM_GOSTR3411_HMAC CKM[CKM_GOSTR3411_HMAC] = "CKM_GOSTR3411_HMAC" CKM_GOST28147_KEY_GEN = PyKCS11.LowLevel.CKM_GOST28147_KEY_GEN CKM["CKM_GOST28147_KEY_GEN"] = CKM_GOST28147_KEY_GEN CKM[CKM_GOST28147_KEY_GEN] = "CKM_GOST28147_KEY_GEN" CKM_GOST28147_ECB = PyKCS11.LowLevel.CKM_GOST28147_ECB CKM["CKM_GOST28147_ECB"] = CKM_GOST28147_ECB CKM[CKM_GOST28147_ECB] = "CKM_GOST28147_ECB" CKM_GOST28147 = PyKCS11.LowLevel.CKM_GOST28147 CKM["CKM_GOST28147"] = CKM_GOST28147 CKM[CKM_GOST28147] = "CKM_GOST28147" CKM_GOST28147_MAC = PyKCS11.LowLevel.CKM_GOST28147_MAC CKM["CKM_GOST28147_MAC"] = CKM_GOST28147_MAC CKM[CKM_GOST28147_MAC] = "CKM_GOST28147_MAC" CKM_GOST28147_KEY_WRAP = PyKCS11.LowLevel.CKM_GOST28147_KEY_WRAP CKM["CKM_GOST28147_KEY_WRAP"] = CKM_GOST28147_KEY_WRAP CKM[CKM_GOST28147_KEY_WRAP] = "CKM_GOST28147_KEY_WRAP" CKM_CHACHA20_KEY_GEN = PyKCS11.LowLevel.CKM_CHACHA20_KEY_GEN CKM["CKM_CHACHA20_KEY_GEN"] = CKM_CHACHA20_KEY_GEN CKM[CKM_CHACHA20_KEY_GEN] = "CKM_CHACHA20_KEY_GEN" CKM_CHACHA20 = PyKCS11.LowLevel.CKM_CHACHA20 CKM["CKM_CHACHA20"] = CKM_CHACHA20 CKM[CKM_CHACHA20] = "CKM_CHACHA20" CKM_POLY1305_KEY_GEN = PyKCS11.LowLevel.CKM_POLY1305_KEY_GEN CKM["CKM_POLY1305_KEY_GEN"] = CKM_POLY1305_KEY_GEN CKM[CKM_POLY1305_KEY_GEN] = "CKM_POLY1305_KEY_GEN" CKM_POLY1305 = PyKCS11.LowLevel.CKM_POLY1305 CKM["CKM_POLY1305"] = CKM_POLY1305 CKM[CKM_POLY1305] = "CKM_POLY1305" CKM_DSA_PARAMETER_GEN = PyKCS11.LowLevel.CKM_DSA_PARAMETER_GEN CKM["CKM_DSA_PARAMETER_GEN"] = CKM_DSA_PARAMETER_GEN CKM[CKM_DSA_PARAMETER_GEN] = "CKM_DSA_PARAMETER_GEN" CKM_DH_PKCS_PARAMETER_GEN = PyKCS11.LowLevel.CKM_DH_PKCS_PARAMETER_GEN CKM["CKM_DH_PKCS_PARAMETER_GEN"] = CKM_DH_PKCS_PARAMETER_GEN CKM[CKM_DH_PKCS_PARAMETER_GEN] = "CKM_DH_PKCS_PARAMETER_GEN" CKM_X9_42_DH_PARAMETER_GEN = PyKCS11.LowLevel.CKM_X9_42_DH_PARAMETER_GEN CKM["CKM_X9_42_DH_PARAMETER_GEN"] = CKM_X9_42_DH_PARAMETER_GEN CKM[CKM_X9_42_DH_PARAMETER_GEN] = "CKM_X9_42_DH_PARAMETER_GEN" CKM_DSA_PROBABILISTIC_PARAMETER_GEN = ( PyKCS11.LowLevel.CKM_DSA_PROBABILISTIC_PARAMETER_GEN ) CKM["CKM_DSA_PROBABILISTIC_PARAMETER_GEN"] = CKM_DSA_PROBABILISTIC_PARAMETER_GEN CKM[CKM_DSA_PROBABILISTIC_PARAMETER_GEN] = "CKM_DSA_PROBABILISTIC_PARAMETER_GEN" CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN = PyKCS11.LowLevel.CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN CKM["CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN"] = CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN CKM[CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN] = "CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN" CKM_DSA_FIPS_G_GEN = PyKCS11.LowLevel.CKM_DSA_FIPS_G_GEN CKM["CKM_DSA_FIPS_G_GEN"] = CKM_DSA_FIPS_G_GEN CKM[CKM_DSA_FIPS_G_GEN] = "CKM_DSA_FIPS_G_GEN" CKM_AES_OFB = PyKCS11.LowLevel.CKM_AES_OFB CKM["CKM_AES_OFB"] = CKM_AES_OFB CKM[CKM_AES_OFB] = "CKM_AES_OFB" CKM_AES_CFB64 = PyKCS11.LowLevel.CKM_AES_CFB64 CKM["CKM_AES_CFB64"] = CKM_AES_CFB64 CKM[CKM_AES_CFB64] = "CKM_AES_CFB64" CKM_AES_CFB8 = PyKCS11.LowLevel.CKM_AES_CFB8 CKM["CKM_AES_CFB8"] = CKM_AES_CFB8 CKM[CKM_AES_CFB8] = "CKM_AES_CFB8" CKM_AES_CFB128 = PyKCS11.LowLevel.CKM_AES_CFB128 CKM["CKM_AES_CFB128"] = CKM_AES_CFB128 CKM[CKM_AES_CFB128] = "CKM_AES_CFB128" CKM_AES_CFB1 = PyKCS11.LowLevel.CKM_AES_CFB1 CKM["CKM_AES_CFB1"] = CKM_AES_CFB1 CKM[CKM_AES_CFB1] = "CKM_AES_CFB1" CKM_AES_KEY_WRAP = PyKCS11.LowLevel.CKM_AES_KEY_WRAP CKM["CKM_AES_KEY_WRAP"] = CKM_AES_KEY_WRAP CKM[CKM_AES_KEY_WRAP] = "CKM_AES_KEY_WRAP" CKM_AES_KEY_WRAP_PAD = PyKCS11.LowLevel.CKM_AES_KEY_WRAP_PAD CKM["CKM_AES_KEY_WRAP_PAD"] = CKM_AES_KEY_WRAP_PAD CKM[CKM_AES_KEY_WRAP_PAD] = "CKM_AES_KEY_WRAP_PAD" CKM_AES_KEY_WRAP_KWP = PyKCS11.LowLevel.CKM_AES_KEY_WRAP_KWP CKM["CKM_AES_KEY_WRAP_KWP"] = CKM_AES_KEY_WRAP_KWP CKM[CKM_AES_KEY_WRAP_KWP] = "CKM_AES_KEY_WRAP_KWP" CKM_AES_KEY_WRAP_PKCS7 = PyKCS11.LowLevel.CKM_AES_KEY_WRAP_PKCS7 CKM["CKM_AES_KEY_WRAP_PKCS7"] = CKM_AES_KEY_WRAP_PKCS7 CKM[CKM_AES_KEY_WRAP_PKCS7] = "CKM_AES_KEY_WRAP_PKCS7" CKM_RSA_PKCS_TPM_1_1 = PyKCS11.LowLevel.CKM_RSA_PKCS_TPM_1_1 CKM["CKM_RSA_PKCS_TPM_1_1"] = CKM_RSA_PKCS_TPM_1_1 CKM[CKM_RSA_PKCS_TPM_1_1] = "CKM_RSA_PKCS_TPM_1_1" CKM_RSA_PKCS_OAEP_TPM_1_1 = PyKCS11.LowLevel.CKM_RSA_PKCS_OAEP_TPM_1_1 CKM["CKM_RSA_PKCS_OAEP_TPM_1_1"] = CKM_RSA_PKCS_OAEP_TPM_1_1 CKM[CKM_RSA_PKCS_OAEP_TPM_1_1] = "CKM_RSA_PKCS_OAEP_TPM_1_1" CKM_SHA_1_KEY_GEN = PyKCS11.LowLevel.CKM_SHA_1_KEY_GEN CKM["CKM_SHA_1_KEY_GEN"] = CKM_SHA_1_KEY_GEN CKM[CKM_SHA_1_KEY_GEN] = "CKM_SHA_1_KEY_GEN" CKM_SHA224_KEY_GEN = PyKCS11.LowLevel.CKM_SHA224_KEY_GEN CKM["CKM_SHA224_KEY_GEN"] = CKM_SHA224_KEY_GEN CKM[CKM_SHA224_KEY_GEN] = "CKM_SHA224_KEY_GEN" CKM_SHA256_KEY_GEN = PyKCS11.LowLevel.CKM_SHA256_KEY_GEN CKM["CKM_SHA256_KEY_GEN"] = CKM_SHA256_KEY_GEN CKM[CKM_SHA256_KEY_GEN] = "CKM_SHA256_KEY_GEN" CKM_SHA384_KEY_GEN = PyKCS11.LowLevel.CKM_SHA384_KEY_GEN CKM["CKM_SHA384_KEY_GEN"] = CKM_SHA384_KEY_GEN CKM[CKM_SHA384_KEY_GEN] = "CKM_SHA384_KEY_GEN" CKM_SHA512_KEY_GEN = PyKCS11.LowLevel.CKM_SHA512_KEY_GEN CKM["CKM_SHA512_KEY_GEN"] = CKM_SHA512_KEY_GEN CKM[CKM_SHA512_KEY_GEN] = "CKM_SHA512_KEY_GEN" CKM_SHA512_224_KEY_GEN = PyKCS11.LowLevel.CKM_SHA512_224_KEY_GEN CKM["CKM_SHA512_224_KEY_GEN"] = CKM_SHA512_224_KEY_GEN CKM[CKM_SHA512_224_KEY_GEN] = "CKM_SHA512_224_KEY_GEN" CKM_SHA512_256_KEY_GEN = PyKCS11.LowLevel.CKM_SHA512_256_KEY_GEN CKM["CKM_SHA512_256_KEY_GEN"] = CKM_SHA512_256_KEY_GEN CKM[CKM_SHA512_256_KEY_GEN] = "CKM_SHA512_256_KEY_GEN" CKM_SHA512_T_KEY_GEN = PyKCS11.LowLevel.CKM_SHA512_T_KEY_GEN CKM["CKM_SHA512_T_KEY_GEN"] = CKM_SHA512_T_KEY_GEN CKM[CKM_SHA512_T_KEY_GEN] = "CKM_SHA512_T_KEY_GEN" CKM_NULL = PyKCS11.LowLevel.CKM_NULL CKM["CKM_NULL"] = CKM_NULL CKM[CKM_NULL] = "CKM_NULL" CKM_BLAKE2B_160 = PyKCS11.LowLevel.CKM_BLAKE2B_160 CKM["CKM_BLAKE2B_160"] = CKM_BLAKE2B_160 CKM[CKM_BLAKE2B_160] = "CKM_BLAKE2B_160" CKM_BLAKE2B_160_HMAC = PyKCS11.LowLevel.CKM_BLAKE2B_160_HMAC CKM["CKM_BLAKE2B_160_HMAC"] = CKM_BLAKE2B_160_HMAC CKM[CKM_BLAKE2B_160_HMAC] = "CKM_BLAKE2B_160_HMAC" CKM_BLAKE2B_160_HMAC_GENERAL = PyKCS11.LowLevel.CKM_BLAKE2B_160_HMAC_GENERAL CKM["CKM_BLAKE2B_160_HMAC_GENERAL"] = CKM_BLAKE2B_160_HMAC_GENERAL CKM[CKM_BLAKE2B_160_HMAC_GENERAL] = "CKM_BLAKE2B_160_HMAC_GENERAL" CKM_BLAKE2B_160_KEY_DERIVE = PyKCS11.LowLevel.CKM_BLAKE2B_160_KEY_DERIVE CKM["CKM_BLAKE2B_160_KEY_DERIVE"] = CKM_BLAKE2B_160_KEY_DERIVE CKM[CKM_BLAKE2B_160_KEY_DERIVE] = "CKM_BLAKE2B_160_KEY_DERIVE" CKM_BLAKE2B_160_KEY_GEN = PyKCS11.LowLevel.CKM_BLAKE2B_160_KEY_GEN CKM["CKM_BLAKE2B_160_KEY_GEN"] = CKM_BLAKE2B_160_KEY_GEN CKM[CKM_BLAKE2B_160_KEY_GEN] = "CKM_BLAKE2B_160_KEY_GEN" CKM_BLAKE2B_256 = PyKCS11.LowLevel.CKM_BLAKE2B_256 CKM["CKM_BLAKE2B_256"] = CKM_BLAKE2B_256 CKM[CKM_BLAKE2B_256] = "CKM_BLAKE2B_256" CKM_BLAKE2B_256_HMAC = PyKCS11.LowLevel.CKM_BLAKE2B_256_HMAC CKM["CKM_BLAKE2B_256_HMAC"] = CKM_BLAKE2B_256_HMAC CKM[CKM_BLAKE2B_256_HMAC] = "CKM_BLAKE2B_256_HMAC" CKM_BLAKE2B_256_HMAC_GENERAL = PyKCS11.LowLevel.CKM_BLAKE2B_256_HMAC_GENERAL CKM["CKM_BLAKE2B_256_HMAC_GENERAL"] = CKM_BLAKE2B_256_HMAC_GENERAL CKM[CKM_BLAKE2B_256_HMAC_GENERAL] = "CKM_BLAKE2B_256_HMAC_GENERAL" CKM_BLAKE2B_256_KEY_DERIVE = PyKCS11.LowLevel.CKM_BLAKE2B_256_KEY_DERIVE CKM["CKM_BLAKE2B_256_KEY_DERIVE"] = CKM_BLAKE2B_256_KEY_DERIVE CKM[CKM_BLAKE2B_256_KEY_DERIVE] = "CKM_BLAKE2B_256_KEY_DERIVE" CKM_BLAKE2B_256_KEY_GEN = PyKCS11.LowLevel.CKM_BLAKE2B_256_KEY_GEN CKM["CKM_BLAKE2B_256_KEY_GEN"] = CKM_BLAKE2B_256_KEY_GEN CKM[CKM_BLAKE2B_256_KEY_GEN] = "CKM_BLAKE2B_256_KEY_GEN" CKM_BLAKE2B_384 = PyKCS11.LowLevel.CKM_BLAKE2B_384 CKM["CKM_BLAKE2B_384"] = CKM_BLAKE2B_384 CKM[CKM_BLAKE2B_384] = "CKM_BLAKE2B_384" CKM_BLAKE2B_384_HMAC = PyKCS11.LowLevel.CKM_BLAKE2B_384_HMAC CKM["CKM_BLAKE2B_384_HMAC"] = CKM_BLAKE2B_384_HMAC CKM[CKM_BLAKE2B_384_HMAC] = "CKM_BLAKE2B_384_HMAC" CKM_BLAKE2B_384_HMAC_GENERAL = PyKCS11.LowLevel.CKM_BLAKE2B_384_HMAC_GENERAL CKM["CKM_BLAKE2B_384_HMAC_GENERAL"] = CKM_BLAKE2B_384_HMAC_GENERAL CKM[CKM_BLAKE2B_384_HMAC_GENERAL] = "CKM_BLAKE2B_384_HMAC_GENERAL" CKM_BLAKE2B_384_KEY_DERIVE = PyKCS11.LowLevel.CKM_BLAKE2B_384_KEY_DERIVE CKM["CKM_BLAKE2B_384_KEY_DERIVE"] = CKM_BLAKE2B_384_KEY_DERIVE CKM[CKM_BLAKE2B_384_KEY_DERIVE] = "CKM_BLAKE2B_384_KEY_DERIVE" CKM_BLAKE2B_384_KEY_GEN = PyKCS11.LowLevel.CKM_BLAKE2B_384_KEY_GEN CKM["CKM_BLAKE2B_384_KEY_GEN"] = CKM_BLAKE2B_384_KEY_GEN CKM[CKM_BLAKE2B_384_KEY_GEN] = "CKM_BLAKE2B_384_KEY_GEN" CKM_BLAKE2B_512 = PyKCS11.LowLevel.CKM_BLAKE2B_512 CKM["CKM_BLAKE2B_512"] = CKM_BLAKE2B_512 CKM[CKM_BLAKE2B_512] = "CKM_BLAKE2B_512" CKM_BLAKE2B_512_HMAC = PyKCS11.LowLevel.CKM_BLAKE2B_512_HMAC CKM["CKM_BLAKE2B_512_HMAC"] = CKM_BLAKE2B_512_HMAC CKM[CKM_BLAKE2B_512_HMAC] = "CKM_BLAKE2B_512_HMAC" CKM_BLAKE2B_512_HMAC_GENERAL = PyKCS11.LowLevel.CKM_BLAKE2B_512_HMAC_GENERAL CKM["CKM_BLAKE2B_512_HMAC_GENERAL"] = CKM_BLAKE2B_512_HMAC_GENERAL CKM[CKM_BLAKE2B_512_HMAC_GENERAL] = "CKM_BLAKE2B_512_HMAC_GENERAL" CKM_BLAKE2B_512_KEY_DERIVE = PyKCS11.LowLevel.CKM_BLAKE2B_512_KEY_DERIVE CKM["CKM_BLAKE2B_512_KEY_DERIVE"] = CKM_BLAKE2B_512_KEY_DERIVE CKM[CKM_BLAKE2B_512_KEY_DERIVE] = "CKM_BLAKE2B_512_KEY_DERIVE" CKM_BLAKE2B_512_KEY_GEN = PyKCS11.LowLevel.CKM_BLAKE2B_512_KEY_GEN CKM["CKM_BLAKE2B_512_KEY_GEN"] = CKM_BLAKE2B_512_KEY_GEN CKM[CKM_BLAKE2B_512_KEY_GEN] = "CKM_BLAKE2B_512_KEY_GEN" CKM_SALSA20 = PyKCS11.LowLevel.CKM_SALSA20 CKM["CKM_SALSA20"] = CKM_SALSA20 CKM[CKM_SALSA20] = "CKM_SALSA20" CKM_CHACHA20_POLY1305 = PyKCS11.LowLevel.CKM_CHACHA20_POLY1305 CKM["CKM_CHACHA20_POLY1305"] = CKM_CHACHA20_POLY1305 CKM[CKM_CHACHA20_POLY1305] = "CKM_CHACHA20_POLY1305" CKM_SALSA20_POLY1305 = PyKCS11.LowLevel.CKM_SALSA20_POLY1305 CKM["CKM_SALSA20_POLY1305"] = CKM_SALSA20_POLY1305 CKM[CKM_SALSA20_POLY1305] = "CKM_SALSA20_POLY1305" CKM_X3DH_INITIALIZE = PyKCS11.LowLevel.CKM_X3DH_INITIALIZE CKM["CKM_X3DH_INITIALIZE"] = CKM_X3DH_INITIALIZE CKM[CKM_X3DH_INITIALIZE] = "CKM_X3DH_INITIALIZE" CKM_X3DH_RESPOND = PyKCS11.LowLevel.CKM_X3DH_RESPOND CKM["CKM_X3DH_RESPOND"] = CKM_X3DH_RESPOND CKM[CKM_X3DH_RESPOND] = "CKM_X3DH_RESPOND" CKM_X2RATCHET_INITIALIZE = PyKCS11.LowLevel.CKM_X2RATCHET_INITIALIZE CKM["CKM_X2RATCHET_INITIALIZE"] = CKM_X2RATCHET_INITIALIZE CKM[CKM_X2RATCHET_INITIALIZE] = "CKM_X2RATCHET_INITIALIZE" CKM_X2RATCHET_RESPOND = PyKCS11.LowLevel.CKM_X2RATCHET_RESPOND CKM["CKM_X2RATCHET_RESPOND"] = CKM_X2RATCHET_RESPOND CKM[CKM_X2RATCHET_RESPOND] = "CKM_X2RATCHET_RESPOND" CKM_X2RATCHET_ENCRYPT = PyKCS11.LowLevel.CKM_X2RATCHET_ENCRYPT CKM["CKM_X2RATCHET_ENCRYPT"] = CKM_X2RATCHET_ENCRYPT CKM[CKM_X2RATCHET_ENCRYPT] = "CKM_X2RATCHET_ENCRYPT" CKM_X2RATCHET_DECRYPT = PyKCS11.LowLevel.CKM_X2RATCHET_DECRYPT CKM["CKM_X2RATCHET_DECRYPT"] = CKM_X2RATCHET_DECRYPT CKM[CKM_X2RATCHET_DECRYPT] = "CKM_X2RATCHET_DECRYPT" CKM_XEDDSA = PyKCS11.LowLevel.CKM_XEDDSA CKM["CKM_XEDDSA"] = CKM_XEDDSA CKM[CKM_XEDDSA] = "CKM_XEDDSA" CKM_HKDF_DERIVE = PyKCS11.LowLevel.CKM_HKDF_DERIVE CKM["CKM_HKDF_DERIVE"] = CKM_HKDF_DERIVE CKM[CKM_HKDF_DERIVE] = "CKM_HKDF_DERIVE" CKM_HKDF_DATA = PyKCS11.LowLevel.CKM_HKDF_DATA CKM["CKM_HKDF_DATA"] = CKM_HKDF_DATA CKM[CKM_HKDF_DATA] = "CKM_HKDF_DATA" CKM_HKDF_KEY_GEN = PyKCS11.LowLevel.CKM_HKDF_KEY_GEN CKM["CKM_HKDF_KEY_GEN"] = CKM_HKDF_KEY_GEN CKM[CKM_HKDF_KEY_GEN] = "CKM_HKDF_KEY_GEN" CKM_SALSA20_KEY_GEN = PyKCS11.LowLevel.CKM_SALSA20_KEY_GEN CKM["CKM_SALSA20_KEY_GEN"] = CKM_SALSA20_KEY_GEN CKM[CKM_SALSA20_KEY_GEN] = "CKM_SALSA20_KEY_GEN" CKM_ECDSA_SHA3_224 = PyKCS11.LowLevel.CKM_ECDSA_SHA3_224 CKM["CKM_ECDSA_SHA3_224"] = CKM_ECDSA_SHA3_224 CKM[CKM_ECDSA_SHA3_224] = "CKM_ECDSA_SHA3_224" CKM_ECDSA_SHA3_256 = PyKCS11.LowLevel.CKM_ECDSA_SHA3_256 CKM["CKM_ECDSA_SHA3_256"] = CKM_ECDSA_SHA3_256 CKM[CKM_ECDSA_SHA3_256] = "CKM_ECDSA_SHA3_256" CKM_ECDSA_SHA3_384 = PyKCS11.LowLevel.CKM_ECDSA_SHA3_384 CKM["CKM_ECDSA_SHA3_384"] = CKM_ECDSA_SHA3_384 CKM[CKM_ECDSA_SHA3_384] = "CKM_ECDSA_SHA3_384" CKM_ECDSA_SHA3_512 = PyKCS11.LowLevel.CKM_ECDSA_SHA3_512 CKM["CKM_ECDSA_SHA3_512"] = CKM_ECDSA_SHA3_512 CKM[CKM_ECDSA_SHA3_512] = "CKM_ECDSA_SHA3_512" CKM_EC_EDWARDS_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_EC_EDWARDS_KEY_PAIR_GEN CKM["CKM_EC_EDWARDS_KEY_PAIR_GEN"] = CKM_EC_EDWARDS_KEY_PAIR_GEN CKM[CKM_EC_EDWARDS_KEY_PAIR_GEN] = "CKM_EC_EDWARDS_KEY_PAIR_GEN" CKM_EC_MONTGOMERY_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_EC_MONTGOMERY_KEY_PAIR_GEN CKM["CKM_EC_MONTGOMERY_KEY_PAIR_GEN"] = CKM_EC_MONTGOMERY_KEY_PAIR_GEN CKM[CKM_EC_MONTGOMERY_KEY_PAIR_GEN] = "CKM_EC_MONTGOMERY_KEY_PAIR_GEN" CKM_EDDSA = PyKCS11.LowLevel.CKM_EDDSA CKM["CKM_EDDSA"] = CKM_EDDSA CKM[CKM_EDDSA] = "CKM_EDDSA" CKM_SP800_108_COUNTER_KDF = PyKCS11.LowLevel.CKM_SP800_108_COUNTER_KDF CKM["CKM_SP800_108_COUNTER_KDF"] = CKM_SP800_108_COUNTER_KDF CKM[CKM_SP800_108_COUNTER_KDF] = "CKM_SP800_108_COUNTER_KDF" CKM_SP800_108_FEEDBACK_KDF = PyKCS11.LowLevel.CKM_SP800_108_FEEDBACK_KDF CKM["CKM_SP800_108_FEEDBACK_KDF"] = CKM_SP800_108_FEEDBACK_KDF CKM[CKM_SP800_108_FEEDBACK_KDF] = "CKM_SP800_108_FEEDBACK_KDF" CKM_SP800_108_DOUBLE_PIPELINE_KDF = PyKCS11.LowLevel.CKM_SP800_108_DOUBLE_PIPELINE_KDF CKM["CKM_SP800_108_DOUBLE_PIPELINE_KDF"] = CKM_SP800_108_DOUBLE_PIPELINE_KDF CKM[CKM_SP800_108_DOUBLE_PIPELINE_KDF] = "CKM_SP800_108_DOUBLE_PIPELINE_KDF" CKM_IKE2_PRF_PLUS_DERIVE = PyKCS11.LowLevel.CKM_IKE2_PRF_PLUS_DERIVE CKM["CKM_IKE2_PRF_PLUS_DERIVE"] = CKM_IKE2_PRF_PLUS_DERIVE CKM[CKM_IKE2_PRF_PLUS_DERIVE] = "CKM_IKE2_PRF_PLUS_DERIVE" CKM_IKE_PRF_DERIVE = PyKCS11.LowLevel.CKM_IKE_PRF_DERIVE CKM["CKM_IKE_PRF_DERIVE"] = CKM_IKE_PRF_DERIVE CKM[CKM_IKE_PRF_DERIVE] = "CKM_IKE_PRF_DERIVE" CKM_IKE1_PRF_DERIVE = PyKCS11.LowLevel.CKM_IKE1_PRF_DERIVE CKM["CKM_IKE1_PRF_DERIVE"] = CKM_IKE1_PRF_DERIVE CKM[CKM_IKE1_PRF_DERIVE] = "CKM_IKE1_PRF_DERIVE" CKM_IKE1_EXTENDED_DERIVE = PyKCS11.LowLevel.CKM_IKE1_EXTENDED_DERIVE CKM["CKM_IKE1_EXTENDED_DERIVE"] = CKM_IKE1_EXTENDED_DERIVE CKM[CKM_IKE1_EXTENDED_DERIVE] = "CKM_IKE1_EXTENDED_DERIVE" CKM_HSS_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_HSS_KEY_PAIR_GEN CKM["CKM_HSS_KEY_PAIR_GEN"] = CKM_HSS_KEY_PAIR_GEN CKM[CKM_HSS_KEY_PAIR_GEN] = "CKM_HSS_KEY_PAIR_GEN" CKM_HSS = PyKCS11.LowLevel.CKM_HSS CKM["CKM_HSS"] = CKM_HSS CKM[CKM_HSS] = "CKM_HSS" CKM_XMSS_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_XMSS_KEY_PAIR_GEN CKM["CKM_XMSS_KEY_PAIR_GEN"] = CKM_XMSS_KEY_PAIR_GEN CKM[CKM_XMSS_KEY_PAIR_GEN] = "CKM_XMSS_KEY_PAIR_GEN" CKM_XMSSMT_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_XMSSMT_KEY_PAIR_GEN CKM["CKM_XMSSMT_KEY_PAIR_GEN"] = CKM_XMSSMT_KEY_PAIR_GEN CKM[CKM_XMSSMT_KEY_PAIR_GEN] = "CKM_XMSSMT_KEY_PAIR_GEN" CKM_XMSS = PyKCS11.LowLevel.CKM_XMSS CKM["CKM_XMSS"] = CKM_XMSS CKM[CKM_XMSS] = "CKM_XMSS" CKM_XMSSMT = PyKCS11.LowLevel.CKM_XMSSMT CKM["CKM_XMSSMT"] = CKM_XMSSMT CKM[CKM_XMSSMT] = "CKM_XMSSMT" CKM_ECDH_X_AES_KEY_WRAP = PyKCS11.LowLevel.CKM_ECDH_X_AES_KEY_WRAP CKM["CKM_ECDH_X_AES_KEY_WRAP"] = CKM_ECDH_X_AES_KEY_WRAP CKM[CKM_ECDH_X_AES_KEY_WRAP] = "CKM_ECDH_X_AES_KEY_WRAP" CKM_ECDH_COF_AES_KEY_WRAP = PyKCS11.LowLevel.CKM_ECDH_COF_AES_KEY_WRAP CKM["CKM_ECDH_COF_AES_KEY_WRAP"] = CKM_ECDH_COF_AES_KEY_WRAP CKM[CKM_ECDH_COF_AES_KEY_WRAP] = "CKM_ECDH_COF_AES_KEY_WRAP" CKM_PUB_KEY_FROM_PRIV_KEY = PyKCS11.LowLevel.CKM_PUB_KEY_FROM_PRIV_KEY CKM["CKM_PUB_KEY_FROM_PRIV_KEY"] = CKM_PUB_KEY_FROM_PRIV_KEY CKM[CKM_PUB_KEY_FROM_PRIV_KEY] = "CKM_PUB_KEY_FROM_PRIV_KEY" CKM_VENDOR_DEFINED = PyKCS11.LowLevel.CKM_VENDOR_DEFINED CKM_CAST5_KEY_GEN = PyKCS11.LowLevel.CKM_CAST5_KEY_GEN CKM["CKM_CAST5_KEY_GEN"] = CKM_CAST5_KEY_GEN CKM[CKM_CAST5_KEY_GEN] = "CKM_CAST5_KEY_GEN" CKM_CAST5_ECB = PyKCS11.LowLevel.CKM_CAST5_ECB CKM["CKM_CAST5_ECB"] = CKM_CAST5_ECB CKM[CKM_CAST5_ECB] = "CKM_CAST5_ECB" CKM_CAST5_CBC = PyKCS11.LowLevel.CKM_CAST5_CBC CKM["CKM_CAST5_CBC"] = CKM_CAST5_CBC CKM[CKM_CAST5_CBC] = "CKM_CAST5_CBC" CKM_CAST5_MAC = PyKCS11.LowLevel.CKM_CAST5_MAC CKM["CKM_CAST5_MAC"] = CKM_CAST5_MAC CKM[CKM_CAST5_MAC] = "CKM_CAST5_MAC" CKM_CAST5_MAC_GENERAL = PyKCS11.LowLevel.CKM_CAST5_MAC_GENERAL CKM["CKM_CAST5_MAC_GENERAL"] = CKM_CAST5_MAC_GENERAL CKM[CKM_CAST5_MAC_GENERAL] = "CKM_CAST5_MAC_GENERAL" CKM_CAST5_CBC_PAD = PyKCS11.LowLevel.CKM_CAST5_CBC_PAD CKM["CKM_CAST5_CBC_PAD"] = CKM_CAST5_CBC_PAD CKM[CKM_CAST5_CBC_PAD] = "CKM_CAST5_CBC_PAD" CKM_PBE_MD5_CAST5_CBC = PyKCS11.LowLevel.CKM_PBE_MD5_CAST5_CBC CKM["CKM_PBE_MD5_CAST5_CBC"] = CKM_PBE_MD5_CAST5_CBC CKM[CKM_PBE_MD5_CAST5_CBC] = "CKM_PBE_MD5_CAST5_CBC" CKM_PBE_SHA1_CAST5_CBC = PyKCS11.LowLevel.CKM_PBE_SHA1_CAST5_CBC CKM["CKM_PBE_SHA1_CAST5_CBC"] = CKM_PBE_SHA1_CAST5_CBC CKM[CKM_PBE_SHA1_CAST5_CBC] = "CKM_PBE_SHA1_CAST5_CBC" CKM_ECDSA_KEY_PAIR_GEN = PyKCS11.LowLevel.CKM_ECDSA_KEY_PAIR_GEN CKM["CKM_ECDSA_KEY_PAIR_GEN"] = CKM_ECDSA_KEY_PAIR_GEN CKM[CKM_ECDSA_KEY_PAIR_GEN] = "CKM_ECDSA_KEY_PAIR_GEN" CKM_DSA_PROBABLISTIC_PARAMETER_GEN = PyKCS11.LowLevel.CKM_DSA_PROBABLISTIC_PARAMETER_GEN CKM["CKM_DSA_PROBABLISTIC_PARAMETER_GEN"] = CKM_DSA_PROBABLISTIC_PARAMETER_GEN CKM[CKM_DSA_PROBABLISTIC_PARAMETER_GEN] = "CKM_DSA_PROBABLISTIC_PARAMETER_GEN" # CKO constants CKO = {} CKO_DATA = PyKCS11.LowLevel.CKO_DATA CKO["CKO_DATA"] = CKO_DATA CKO[CKO_DATA] = "CKO_DATA" CKO_CERTIFICATE = PyKCS11.LowLevel.CKO_CERTIFICATE CKO["CKO_CERTIFICATE"] = CKO_CERTIFICATE CKO[CKO_CERTIFICATE] = "CKO_CERTIFICATE" CKO_PUBLIC_KEY = PyKCS11.LowLevel.CKO_PUBLIC_KEY CKO["CKO_PUBLIC_KEY"] = CKO_PUBLIC_KEY CKO[CKO_PUBLIC_KEY] = "CKO_PUBLIC_KEY" CKO_PRIVATE_KEY = PyKCS11.LowLevel.CKO_PRIVATE_KEY CKO["CKO_PRIVATE_KEY"] = CKO_PRIVATE_KEY CKO[CKO_PRIVATE_KEY] = "CKO_PRIVATE_KEY" CKO_SECRET_KEY = PyKCS11.LowLevel.CKO_SECRET_KEY CKO["CKO_SECRET_KEY"] = CKO_SECRET_KEY CKO[CKO_SECRET_KEY] = "CKO_SECRET_KEY" CKO_HW_FEATURE = PyKCS11.LowLevel.CKO_HW_FEATURE CKO["CKO_HW_FEATURE"] = CKO_HW_FEATURE CKO[CKO_HW_FEATURE] = "CKO_HW_FEATURE" CKO_DOMAIN_PARAMETERS = PyKCS11.LowLevel.CKO_DOMAIN_PARAMETERS CKO["CKO_DOMAIN_PARAMETERS"] = CKO_DOMAIN_PARAMETERS CKO[CKO_DOMAIN_PARAMETERS] = "CKO_DOMAIN_PARAMETERS" CKO_MECHANISM = PyKCS11.LowLevel.CKO_MECHANISM CKO["CKO_MECHANISM"] = CKO_MECHANISM CKO[CKO_MECHANISM] = "CKO_MECHANISM" CKO_OTP_KEY = PyKCS11.LowLevel.CKO_OTP_KEY CKO["CKO_OTP_KEY"] = CKO_OTP_KEY CKO[CKO_OTP_KEY] = "CKO_OTP_KEY" CKO_PROFILE = PyKCS11.LowLevel.CKO_PROFILE CKO["CKO_PROFILE"] = CKO_PROFILE CKO[CKO_PROFILE] = "CKO_PROFILE" CKO_VALIDATION = PyKCS11.LowLevel.CKO_VALIDATION CKO["CKO_VALIDATION"] = CKO_VALIDATION CKO[CKO_VALIDATION] = "CKO_VALIDATION" CKO_TRUST = PyKCS11.LowLevel.CKO_TRUST CKO["CKO_TRUST"] = CKO_TRUST CKO[CKO_TRUST] = "CKO_TRUST" CKO_VENDOR_DEFINED = PyKCS11.LowLevel.CKO_VENDOR_DEFINED # CKR constants CKR = {} CKR_OK = PyKCS11.LowLevel.CKR_OK CKR["CKR_OK"] = CKR_OK CKR[CKR_OK] = "CKR_OK" CKR_CANCEL = PyKCS11.LowLevel.CKR_CANCEL CKR["CKR_CANCEL"] = CKR_CANCEL CKR[CKR_CANCEL] = "CKR_CANCEL" CKR_HOST_MEMORY = PyKCS11.LowLevel.CKR_HOST_MEMORY CKR["CKR_HOST_MEMORY"] = CKR_HOST_MEMORY CKR[CKR_HOST_MEMORY] = "CKR_HOST_MEMORY" CKR_SLOT_ID_INVALID = PyKCS11.LowLevel.CKR_SLOT_ID_INVALID CKR["CKR_SLOT_ID_INVALID"] = CKR_SLOT_ID_INVALID CKR[CKR_SLOT_ID_INVALID] = "CKR_SLOT_ID_INVALID" CKR_GENERAL_ERROR = PyKCS11.LowLevel.CKR_GENERAL_ERROR CKR["CKR_GENERAL_ERROR"] = CKR_GENERAL_ERROR CKR[CKR_GENERAL_ERROR] = "CKR_GENERAL_ERROR" CKR_FUNCTION_FAILED = PyKCS11.LowLevel.CKR_FUNCTION_FAILED CKR["CKR_FUNCTION_FAILED"] = CKR_FUNCTION_FAILED CKR[CKR_FUNCTION_FAILED] = "CKR_FUNCTION_FAILED" CKR_ARGUMENTS_BAD = PyKCS11.LowLevel.CKR_ARGUMENTS_BAD CKR["CKR_ARGUMENTS_BAD"] = CKR_ARGUMENTS_BAD CKR[CKR_ARGUMENTS_BAD] = "CKR_ARGUMENTS_BAD" CKR_NO_EVENT = PyKCS11.LowLevel.CKR_NO_EVENT CKR["CKR_NO_EVENT"] = CKR_NO_EVENT CKR[CKR_NO_EVENT] = "CKR_NO_EVENT" CKR_NEED_TO_CREATE_THREADS = PyKCS11.LowLevel.CKR_NEED_TO_CREATE_THREADS CKR["CKR_NEED_TO_CREATE_THREADS"] = CKR_NEED_TO_CREATE_THREADS CKR[CKR_NEED_TO_CREATE_THREADS] = "CKR_NEED_TO_CREATE_THREADS" CKR_CANT_LOCK = PyKCS11.LowLevel.CKR_CANT_LOCK CKR["CKR_CANT_LOCK"] = CKR_CANT_LOCK CKR[CKR_CANT_LOCK] = "CKR_CANT_LOCK" CKR_ATTRIBUTE_READ_ONLY = PyKCS11.LowLevel.CKR_ATTRIBUTE_READ_ONLY CKR["CKR_ATTRIBUTE_READ_ONLY"] = CKR_ATTRIBUTE_READ_ONLY CKR[CKR_ATTRIBUTE_READ_ONLY] = "CKR_ATTRIBUTE_READ_ONLY" CKR_ATTRIBUTE_SENSITIVE = PyKCS11.LowLevel.CKR_ATTRIBUTE_SENSITIVE CKR["CKR_ATTRIBUTE_SENSITIVE"] = CKR_ATTRIBUTE_SENSITIVE CKR[CKR_ATTRIBUTE_SENSITIVE] = "CKR_ATTRIBUTE_SENSITIVE" CKR_ATTRIBUTE_TYPE_INVALID = PyKCS11.LowLevel.CKR_ATTRIBUTE_TYPE_INVALID CKR["CKR_ATTRIBUTE_TYPE_INVALID"] = CKR_ATTRIBUTE_TYPE_INVALID CKR[CKR_ATTRIBUTE_TYPE_INVALID] = "CKR_ATTRIBUTE_TYPE_INVALID" CKR_ATTRIBUTE_VALUE_INVALID = PyKCS11.LowLevel.CKR_ATTRIBUTE_VALUE_INVALID CKR["CKR_ATTRIBUTE_VALUE_INVALID"] = CKR_ATTRIBUTE_VALUE_INVALID CKR[CKR_ATTRIBUTE_VALUE_INVALID] = "CKR_ATTRIBUTE_VALUE_INVALID" CKR_ACTION_PROHIBITED = PyKCS11.LowLevel.CKR_ACTION_PROHIBITED CKR["CKR_ACTION_PROHIBITED"] = CKR_ACTION_PROHIBITED CKR[CKR_ACTION_PROHIBITED] = "CKR_ACTION_PROHIBITED" CKR_DATA_INVALID = PyKCS11.LowLevel.CKR_DATA_INVALID CKR["CKR_DATA_INVALID"] = CKR_DATA_INVALID CKR[CKR_DATA_INVALID] = "CKR_DATA_INVALID" CKR_DATA_LEN_RANGE = PyKCS11.LowLevel.CKR_DATA_LEN_RANGE CKR["CKR_DATA_LEN_RANGE"] = CKR_DATA_LEN_RANGE CKR[CKR_DATA_LEN_RANGE] = "CKR_DATA_LEN_RANGE" CKR_DEVICE_ERROR = PyKCS11.LowLevel.CKR_DEVICE_ERROR CKR["CKR_DEVICE_ERROR"] = CKR_DEVICE_ERROR CKR[CKR_DEVICE_ERROR] = "CKR_DEVICE_ERROR" CKR_DEVICE_MEMORY = PyKCS11.LowLevel.CKR_DEVICE_MEMORY CKR["CKR_DEVICE_MEMORY"] = CKR_DEVICE_MEMORY CKR[CKR_DEVICE_MEMORY] = "CKR_DEVICE_MEMORY" CKR_DEVICE_REMOVED = PyKCS11.LowLevel.CKR_DEVICE_REMOVED CKR["CKR_DEVICE_REMOVED"] = CKR_DEVICE_REMOVED CKR[CKR_DEVICE_REMOVED] = "CKR_DEVICE_REMOVED" CKR_ENCRYPTED_DATA_INVALID = PyKCS11.LowLevel.CKR_ENCRYPTED_DATA_INVALID CKR["CKR_ENCRYPTED_DATA_INVALID"] = CKR_ENCRYPTED_DATA_INVALID CKR[CKR_ENCRYPTED_DATA_INVALID] = "CKR_ENCRYPTED_DATA_INVALID" CKR_ENCRYPTED_DATA_LEN_RANGE = PyKCS11.LowLevel.CKR_ENCRYPTED_DATA_LEN_RANGE CKR["CKR_ENCRYPTED_DATA_LEN_RANGE"] = CKR_ENCRYPTED_DATA_LEN_RANGE CKR[CKR_ENCRYPTED_DATA_LEN_RANGE] = "CKR_ENCRYPTED_DATA_LEN_RANGE" CKR_AEAD_DECRYPT_FAILED = PyKCS11.LowLevel.CKR_AEAD_DECRYPT_FAILED CKR["CKR_AEAD_DECRYPT_FAILED"] = CKR_AEAD_DECRYPT_FAILED CKR[CKR_AEAD_DECRYPT_FAILED] = "CKR_AEAD_DECRYPT_FAILED" CKR_FUNCTION_CANCELED = PyKCS11.LowLevel.CKR_FUNCTION_CANCELED CKR["CKR_FUNCTION_CANCELED"] = CKR_FUNCTION_CANCELED CKR[CKR_FUNCTION_CANCELED] = "CKR_FUNCTION_CANCELED" CKR_FUNCTION_NOT_PARALLEL = PyKCS11.LowLevel.CKR_FUNCTION_NOT_PARALLEL CKR["CKR_FUNCTION_NOT_PARALLEL"] = CKR_FUNCTION_NOT_PARALLEL CKR[CKR_FUNCTION_NOT_PARALLEL] = "CKR_FUNCTION_NOT_PARALLEL" CKR_FUNCTION_NOT_SUPPORTED = PyKCS11.LowLevel.CKR_FUNCTION_NOT_SUPPORTED CKR["CKR_FUNCTION_NOT_SUPPORTED"] = CKR_FUNCTION_NOT_SUPPORTED CKR[CKR_FUNCTION_NOT_SUPPORTED] = "CKR_FUNCTION_NOT_SUPPORTED" CKR_KEY_HANDLE_INVALID = PyKCS11.LowLevel.CKR_KEY_HANDLE_INVALID CKR["CKR_KEY_HANDLE_INVALID"] = CKR_KEY_HANDLE_INVALID CKR[CKR_KEY_HANDLE_INVALID] = "CKR_KEY_HANDLE_INVALID" CKR_KEY_SIZE_RANGE = PyKCS11.LowLevel.CKR_KEY_SIZE_RANGE CKR["CKR_KEY_SIZE_RANGE"] = CKR_KEY_SIZE_RANGE CKR[CKR_KEY_SIZE_RANGE] = "CKR_KEY_SIZE_RANGE" CKR_KEY_TYPE_INCONSISTENT = PyKCS11.LowLevel.CKR_KEY_TYPE_INCONSISTENT CKR["CKR_KEY_TYPE_INCONSISTENT"] = CKR_KEY_TYPE_INCONSISTENT CKR[CKR_KEY_TYPE_INCONSISTENT] = "CKR_KEY_TYPE_INCONSISTENT" CKR_KEY_NOT_NEEDED = PyKCS11.LowLevel.CKR_KEY_NOT_NEEDED CKR["CKR_KEY_NOT_NEEDED"] = CKR_KEY_NOT_NEEDED CKR[CKR_KEY_NOT_NEEDED] = "CKR_KEY_NOT_NEEDED" CKR_KEY_CHANGED = PyKCS11.LowLevel.CKR_KEY_CHANGED CKR["CKR_KEY_CHANGED"] = CKR_KEY_CHANGED CKR[CKR_KEY_CHANGED] = "CKR_KEY_CHANGED" CKR_KEY_NEEDED = PyKCS11.LowLevel.CKR_KEY_NEEDED CKR["CKR_KEY_NEEDED"] = CKR_KEY_NEEDED CKR[CKR_KEY_NEEDED] = "CKR_KEY_NEEDED" CKR_KEY_INDIGESTIBLE = PyKCS11.LowLevel.CKR_KEY_INDIGESTIBLE CKR["CKR_KEY_INDIGESTIBLE"] = CKR_KEY_INDIGESTIBLE CKR[CKR_KEY_INDIGESTIBLE] = "CKR_KEY_INDIGESTIBLE" CKR_KEY_FUNCTION_NOT_PERMITTED = PyKCS11.LowLevel.CKR_KEY_FUNCTION_NOT_PERMITTED CKR["CKR_KEY_FUNCTION_NOT_PERMITTED"] = CKR_KEY_FUNCTION_NOT_PERMITTED CKR[CKR_KEY_FUNCTION_NOT_PERMITTED] = "CKR_KEY_FUNCTION_NOT_PERMITTED" CKR_KEY_NOT_WRAPPABLE = PyKCS11.LowLevel.CKR_KEY_NOT_WRAPPABLE CKR["CKR_KEY_NOT_WRAPPABLE"] = CKR_KEY_NOT_WRAPPABLE CKR[CKR_KEY_NOT_WRAPPABLE] = "CKR_KEY_NOT_WRAPPABLE" CKR_KEY_UNEXTRACTABLE = PyKCS11.LowLevel.CKR_KEY_UNEXTRACTABLE CKR["CKR_KEY_UNEXTRACTABLE"] = CKR_KEY_UNEXTRACTABLE CKR[CKR_KEY_UNEXTRACTABLE] = "CKR_KEY_UNEXTRACTABLE" CKR_MECHANISM_INVALID = PyKCS11.LowLevel.CKR_MECHANISM_INVALID CKR["CKR_MECHANISM_INVALID"] = CKR_MECHANISM_INVALID CKR[CKR_MECHANISM_INVALID] = "CKR_MECHANISM_INVALID" CKR_MECHANISM_PARAM_INVALID = PyKCS11.LowLevel.CKR_MECHANISM_PARAM_INVALID CKR["CKR_MECHANISM_PARAM_INVALID"] = CKR_MECHANISM_PARAM_INVALID CKR[CKR_MECHANISM_PARAM_INVALID] = "CKR_MECHANISM_PARAM_INVALID" CKR_OBJECT_HANDLE_INVALID = PyKCS11.LowLevel.CKR_OBJECT_HANDLE_INVALID CKR["CKR_OBJECT_HANDLE_INVALID"] = CKR_OBJECT_HANDLE_INVALID CKR[CKR_OBJECT_HANDLE_INVALID] = "CKR_OBJECT_HANDLE_INVALID" CKR_OPERATION_ACTIVE = PyKCS11.LowLevel.CKR_OPERATION_ACTIVE CKR["CKR_OPERATION_ACTIVE"] = CKR_OPERATION_ACTIVE CKR[CKR_OPERATION_ACTIVE] = "CKR_OPERATION_ACTIVE" CKR_OPERATION_NOT_INITIALIZED = PyKCS11.LowLevel.CKR_OPERATION_NOT_INITIALIZED CKR["CKR_OPERATION_NOT_INITIALIZED"] = CKR_OPERATION_NOT_INITIALIZED CKR[CKR_OPERATION_NOT_INITIALIZED] = "CKR_OPERATION_NOT_INITIALIZED" CKR_PIN_INCORRECT = PyKCS11.LowLevel.CKR_PIN_INCORRECT CKR["CKR_PIN_INCORRECT"] = CKR_PIN_INCORRECT CKR[CKR_PIN_INCORRECT] = "CKR_PIN_INCORRECT" CKR_PIN_INVALID = PyKCS11.LowLevel.CKR_PIN_INVALID CKR["CKR_PIN_INVALID"] = CKR_PIN_INVALID CKR[CKR_PIN_INVALID] = "CKR_PIN_INVALID" CKR_PIN_LEN_RANGE = PyKCS11.LowLevel.CKR_PIN_LEN_RANGE CKR["CKR_PIN_LEN_RANGE"] = CKR_PIN_LEN_RANGE CKR[CKR_PIN_LEN_RANGE] = "CKR_PIN_LEN_RANGE" CKR_PIN_EXPIRED = PyKCS11.LowLevel.CKR_PIN_EXPIRED CKR["CKR_PIN_EXPIRED"] = CKR_PIN_EXPIRED CKR[CKR_PIN_EXPIRED] = "CKR_PIN_EXPIRED" CKR_PIN_LOCKED = PyKCS11.LowLevel.CKR_PIN_LOCKED CKR["CKR_PIN_LOCKED"] = CKR_PIN_LOCKED CKR[CKR_PIN_LOCKED] = "CKR_PIN_LOCKED" CKR_SESSION_CLOSED = PyKCS11.LowLevel.CKR_SESSION_CLOSED CKR["CKR_SESSION_CLOSED"] = CKR_SESSION_CLOSED CKR[CKR_SESSION_CLOSED] = "CKR_SESSION_CLOSED" CKR_SESSION_COUNT = PyKCS11.LowLevel.CKR_SESSION_COUNT CKR["CKR_SESSION_COUNT"] = CKR_SESSION_COUNT CKR[CKR_SESSION_COUNT] = "CKR_SESSION_COUNT" CKR_SESSION_HANDLE_INVALID = PyKCS11.LowLevel.CKR_SESSION_HANDLE_INVALID CKR["CKR_SESSION_HANDLE_INVALID"] = CKR_SESSION_HANDLE_INVALID CKR[CKR_SESSION_HANDLE_INVALID] = "CKR_SESSION_HANDLE_INVALID" CKR_SESSION_PARALLEL_NOT_SUPPORTED = PyKCS11.LowLevel.CKR_SESSION_PARALLEL_NOT_SUPPORTED CKR["CKR_SESSION_PARALLEL_NOT_SUPPORTED"] = CKR_SESSION_PARALLEL_NOT_SUPPORTED CKR[CKR_SESSION_PARALLEL_NOT_SUPPORTED] = "CKR_SESSION_PARALLEL_NOT_SUPPORTED" CKR_SESSION_READ_ONLY = PyKCS11.LowLevel.CKR_SESSION_READ_ONLY CKR["CKR_SESSION_READ_ONLY"] = CKR_SESSION_READ_ONLY CKR[CKR_SESSION_READ_ONLY] = "CKR_SESSION_READ_ONLY" CKR_SESSION_EXISTS = PyKCS11.LowLevel.CKR_SESSION_EXISTS CKR["CKR_SESSION_EXISTS"] = CKR_SESSION_EXISTS CKR[CKR_SESSION_EXISTS] = "CKR_SESSION_EXISTS" CKR_SESSION_READ_ONLY_EXISTS = PyKCS11.LowLevel.CKR_SESSION_READ_ONLY_EXISTS CKR["CKR_SESSION_READ_ONLY_EXISTS"] = CKR_SESSION_READ_ONLY_EXISTS CKR[CKR_SESSION_READ_ONLY_EXISTS] = "CKR_SESSION_READ_ONLY_EXISTS" CKR_SESSION_READ_WRITE_SO_EXISTS = PyKCS11.LowLevel.CKR_SESSION_READ_WRITE_SO_EXISTS CKR["CKR_SESSION_READ_WRITE_SO_EXISTS"] = CKR_SESSION_READ_WRITE_SO_EXISTS CKR[CKR_SESSION_READ_WRITE_SO_EXISTS] = "CKR_SESSION_READ_WRITE_SO_EXISTS" CKR_SIGNATURE_INVALID = PyKCS11.LowLevel.CKR_SIGNATURE_INVALID CKR["CKR_SIGNATURE_INVALID"] = CKR_SIGNATURE_INVALID CKR[CKR_SIGNATURE_INVALID] = "CKR_SIGNATURE_INVALID" CKR_SIGNATURE_LEN_RANGE = PyKCS11.LowLevel.CKR_SIGNATURE_LEN_RANGE CKR["CKR_SIGNATURE_LEN_RANGE"] = CKR_SIGNATURE_LEN_RANGE CKR[CKR_SIGNATURE_LEN_RANGE] = "CKR_SIGNATURE_LEN_RANGE" CKR_TEMPLATE_INCOMPLETE = PyKCS11.LowLevel.CKR_TEMPLATE_INCOMPLETE CKR["CKR_TEMPLATE_INCOMPLETE"] = CKR_TEMPLATE_INCOMPLETE CKR[CKR_TEMPLATE_INCOMPLETE] = "CKR_TEMPLATE_INCOMPLETE" CKR_TEMPLATE_INCONSISTENT = PyKCS11.LowLevel.CKR_TEMPLATE_INCONSISTENT CKR["CKR_TEMPLATE_INCONSISTENT"] = CKR_TEMPLATE_INCONSISTENT CKR[CKR_TEMPLATE_INCONSISTENT] = "CKR_TEMPLATE_INCONSISTENT" CKR_TOKEN_NOT_PRESENT = PyKCS11.LowLevel.CKR_TOKEN_NOT_PRESENT CKR["CKR_TOKEN_NOT_PRESENT"] = CKR_TOKEN_NOT_PRESENT CKR[CKR_TOKEN_NOT_PRESENT] = "CKR_TOKEN_NOT_PRESENT" CKR_TOKEN_NOT_RECOGNIZED = PyKCS11.LowLevel.CKR_TOKEN_NOT_RECOGNIZED CKR["CKR_TOKEN_NOT_RECOGNIZED"] = CKR_TOKEN_NOT_RECOGNIZED CKR[CKR_TOKEN_NOT_RECOGNIZED] = "CKR_TOKEN_NOT_RECOGNIZED" CKR_TOKEN_WRITE_PROTECTED = PyKCS11.LowLevel.CKR_TOKEN_WRITE_PROTECTED CKR["CKR_TOKEN_WRITE_PROTECTED"] = CKR_TOKEN_WRITE_PROTECTED CKR[CKR_TOKEN_WRITE_PROTECTED] = "CKR_TOKEN_WRITE_PROTECTED" CKR_UNWRAPPING_KEY_HANDLE_INVALID = PyKCS11.LowLevel.CKR_UNWRAPPING_KEY_HANDLE_INVALID CKR["CKR_UNWRAPPING_KEY_HANDLE_INVALID"] = CKR_UNWRAPPING_KEY_HANDLE_INVALID CKR[CKR_UNWRAPPING_KEY_HANDLE_INVALID] = "CKR_UNWRAPPING_KEY_HANDLE_INVALID" CKR_UNWRAPPING_KEY_SIZE_RANGE = PyKCS11.LowLevel.CKR_UNWRAPPING_KEY_SIZE_RANGE CKR["CKR_UNWRAPPING_KEY_SIZE_RANGE"] = CKR_UNWRAPPING_KEY_SIZE_RANGE CKR[CKR_UNWRAPPING_KEY_SIZE_RANGE] = "CKR_UNWRAPPING_KEY_SIZE_RANGE" CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT = ( PyKCS11.LowLevel.CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT ) CKR["CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT"] = CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT CKR[CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT] = "CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT" CKR_USER_ALREADY_LOGGED_IN = PyKCS11.LowLevel.CKR_USER_ALREADY_LOGGED_IN CKR["CKR_USER_ALREADY_LOGGED_IN"] = CKR_USER_ALREADY_LOGGED_IN CKR[CKR_USER_ALREADY_LOGGED_IN] = "CKR_USER_ALREADY_LOGGED_IN" CKR_USER_NOT_LOGGED_IN = PyKCS11.LowLevel.CKR_USER_NOT_LOGGED_IN CKR["CKR_USER_NOT_LOGGED_IN"] = CKR_USER_NOT_LOGGED_IN CKR[CKR_USER_NOT_LOGGED_IN] = "CKR_USER_NOT_LOGGED_IN" CKR_USER_PIN_NOT_INITIALIZED = PyKCS11.LowLevel.CKR_USER_PIN_NOT_INITIALIZED CKR["CKR_USER_PIN_NOT_INITIALIZED"] = CKR_USER_PIN_NOT_INITIALIZED CKR[CKR_USER_PIN_NOT_INITIALIZED] = "CKR_USER_PIN_NOT_INITIALIZED" CKR_USER_TYPE_INVALID = PyKCS11.LowLevel.CKR_USER_TYPE_INVALID CKR["CKR_USER_TYPE_INVALID"] = CKR_USER_TYPE_INVALID CKR[CKR_USER_TYPE_INVALID] = "CKR_USER_TYPE_INVALID" CKR_USER_ANOTHER_ALREADY_LOGGED_IN = PyKCS11.LowLevel.CKR_USER_ANOTHER_ALREADY_LOGGED_IN CKR["CKR_USER_ANOTHER_ALREADY_LOGGED_IN"] = CKR_USER_ANOTHER_ALREADY_LOGGED_IN CKR[CKR_USER_ANOTHER_ALREADY_LOGGED_IN] = "CKR_USER_ANOTHER_ALREADY_LOGGED_IN" CKR_USER_TOO_MANY_TYPES = PyKCS11.LowLevel.CKR_USER_TOO_MANY_TYPES CKR["CKR_USER_TOO_MANY_TYPES"] = CKR_USER_TOO_MANY_TYPES CKR[CKR_USER_TOO_MANY_TYPES] = "CKR_USER_TOO_MANY_TYPES" CKR_WRAPPED_KEY_INVALID = PyKCS11.LowLevel.CKR_WRAPPED_KEY_INVALID CKR["CKR_WRAPPED_KEY_INVALID"] = CKR_WRAPPED_KEY_INVALID CKR[CKR_WRAPPED_KEY_INVALID] = "CKR_WRAPPED_KEY_INVALID" CKR_WRAPPED_KEY_LEN_RANGE = PyKCS11.LowLevel.CKR_WRAPPED_KEY_LEN_RANGE CKR["CKR_WRAPPED_KEY_LEN_RANGE"] = CKR_WRAPPED_KEY_LEN_RANGE CKR[CKR_WRAPPED_KEY_LEN_RANGE] = "CKR_WRAPPED_KEY_LEN_RANGE" CKR_WRAPPING_KEY_HANDLE_INVALID = PyKCS11.LowLevel.CKR_WRAPPING_KEY_HANDLE_INVALID CKR["CKR_WRAPPING_KEY_HANDLE_INVALID"] = CKR_WRAPPING_KEY_HANDLE_INVALID CKR[CKR_WRAPPING_KEY_HANDLE_INVALID] = "CKR_WRAPPING_KEY_HANDLE_INVALID" CKR_WRAPPING_KEY_SIZE_RANGE = PyKCS11.LowLevel.CKR_WRAPPING_KEY_SIZE_RANGE CKR["CKR_WRAPPING_KEY_SIZE_RANGE"] = CKR_WRAPPING_KEY_SIZE_RANGE CKR[CKR_WRAPPING_KEY_SIZE_RANGE] = "CKR_WRAPPING_KEY_SIZE_RANGE" CKR_WRAPPING_KEY_TYPE_INCONSISTENT = PyKCS11.LowLevel.CKR_WRAPPING_KEY_TYPE_INCONSISTENT CKR["CKR_WRAPPING_KEY_TYPE_INCONSISTENT"] = CKR_WRAPPING_KEY_TYPE_INCONSISTENT CKR[CKR_WRAPPING_KEY_TYPE_INCONSISTENT] = "CKR_WRAPPING_KEY_TYPE_INCONSISTENT" CKR_RANDOM_SEED_NOT_SUPPORTED = PyKCS11.LowLevel.CKR_RANDOM_SEED_NOT_SUPPORTED CKR["CKR_RANDOM_SEED_NOT_SUPPORTED"] = CKR_RANDOM_SEED_NOT_SUPPORTED CKR[CKR_RANDOM_SEED_NOT_SUPPORTED] = "CKR_RANDOM_SEED_NOT_SUPPORTED" CKR_RANDOM_NO_RNG = PyKCS11.LowLevel.CKR_RANDOM_NO_RNG CKR["CKR_RANDOM_NO_RNG"] = CKR_RANDOM_NO_RNG CKR[CKR_RANDOM_NO_RNG] = "CKR_RANDOM_NO_RNG" CKR_DOMAIN_PARAMS_INVALID = PyKCS11.LowLevel.CKR_DOMAIN_PARAMS_INVALID CKR["CKR_DOMAIN_PARAMS_INVALID"] = CKR_DOMAIN_PARAMS_INVALID CKR[CKR_DOMAIN_PARAMS_INVALID] = "CKR_DOMAIN_PARAMS_INVALID" CKR_CURVE_NOT_SUPPORTED = PyKCS11.LowLevel.CKR_CURVE_NOT_SUPPORTED CKR["CKR_CURVE_NOT_SUPPORTED"] = CKR_CURVE_NOT_SUPPORTED CKR[CKR_CURVE_NOT_SUPPORTED] = "CKR_CURVE_NOT_SUPPORTED" CKR_BUFFER_TOO_SMALL = PyKCS11.LowLevel.CKR_BUFFER_TOO_SMALL CKR["CKR_BUFFER_TOO_SMALL"] = CKR_BUFFER_TOO_SMALL CKR[CKR_BUFFER_TOO_SMALL] = "CKR_BUFFER_TOO_SMALL" CKR_SAVED_STATE_INVALID = PyKCS11.LowLevel.CKR_SAVED_STATE_INVALID CKR["CKR_SAVED_STATE_INVALID"] = CKR_SAVED_STATE_INVALID CKR[CKR_SAVED_STATE_INVALID] = "CKR_SAVED_STATE_INVALID" CKR_INFORMATION_SENSITIVE = PyKCS11.LowLevel.CKR_INFORMATION_SENSITIVE CKR["CKR_INFORMATION_SENSITIVE"] = CKR_INFORMATION_SENSITIVE CKR[CKR_INFORMATION_SENSITIVE] = "CKR_INFORMATION_SENSITIVE" CKR_STATE_UNSAVEABLE = PyKCS11.LowLevel.CKR_STATE_UNSAVEABLE CKR["CKR_STATE_UNSAVEABLE"] = CKR_STATE_UNSAVEABLE CKR[CKR_STATE_UNSAVEABLE] = "CKR_STATE_UNSAVEABLE" CKR_CRYPTOKI_NOT_INITIALIZED = PyKCS11.LowLevel.CKR_CRYPTOKI_NOT_INITIALIZED CKR["CKR_CRYPTOKI_NOT_INITIALIZED"] = CKR_CRYPTOKI_NOT_INITIALIZED CKR[CKR_CRYPTOKI_NOT_INITIALIZED] = "CKR_CRYPTOKI_NOT_INITIALIZED" CKR_CRYPTOKI_ALREADY_INITIALIZED = PyKCS11.LowLevel.CKR_CRYPTOKI_ALREADY_INITIALIZED CKR["CKR_CRYPTOKI_ALREADY_INITIALIZED"] = CKR_CRYPTOKI_ALREADY_INITIALIZED CKR[CKR_CRYPTOKI_ALREADY_INITIALIZED] = "CKR_CRYPTOKI_ALREADY_INITIALIZED" CKR_MUTEX_BAD = PyKCS11.LowLevel.CKR_MUTEX_BAD CKR["CKR_MUTEX_BAD"] = CKR_MUTEX_BAD CKR[CKR_MUTEX_BAD] = "CKR_MUTEX_BAD" CKR_MUTEX_NOT_LOCKED = PyKCS11.LowLevel.CKR_MUTEX_NOT_LOCKED CKR["CKR_MUTEX_NOT_LOCKED"] = CKR_MUTEX_NOT_LOCKED CKR[CKR_MUTEX_NOT_LOCKED] = "CKR_MUTEX_NOT_LOCKED" CKR_NEW_PIN_MODE = PyKCS11.LowLevel.CKR_NEW_PIN_MODE CKR["CKR_NEW_PIN_MODE"] = CKR_NEW_PIN_MODE CKR[CKR_NEW_PIN_MODE] = "CKR_NEW_PIN_MODE" CKR_NEXT_OTP = PyKCS11.LowLevel.CKR_NEXT_OTP CKR["CKR_NEXT_OTP"] = CKR_NEXT_OTP CKR[CKR_NEXT_OTP] = "CKR_NEXT_OTP" CKR_EXCEEDED_MAX_ITERATIONS = PyKCS11.LowLevel.CKR_EXCEEDED_MAX_ITERATIONS CKR["CKR_EXCEEDED_MAX_ITERATIONS"] = CKR_EXCEEDED_MAX_ITERATIONS CKR[CKR_EXCEEDED_MAX_ITERATIONS] = "CKR_EXCEEDED_MAX_ITERATIONS" CKR_FIPS_SELF_TEST_FAILED = PyKCS11.LowLevel.CKR_FIPS_SELF_TEST_FAILED CKR["CKR_FIPS_SELF_TEST_FAILED"] = CKR_FIPS_SELF_TEST_FAILED CKR[CKR_FIPS_SELF_TEST_FAILED] = "CKR_FIPS_SELF_TEST_FAILED" CKR_LIBRARY_LOAD_FAILED = PyKCS11.LowLevel.CKR_LIBRARY_LOAD_FAILED CKR["CKR_LIBRARY_LOAD_FAILED"] = CKR_LIBRARY_LOAD_FAILED CKR[CKR_LIBRARY_LOAD_FAILED] = "CKR_LIBRARY_LOAD_FAILED" CKR_PIN_TOO_WEAK = PyKCS11.LowLevel.CKR_PIN_TOO_WEAK CKR["CKR_PIN_TOO_WEAK"] = CKR_PIN_TOO_WEAK CKR[CKR_PIN_TOO_WEAK] = "CKR_PIN_TOO_WEAK" CKR_PUBLIC_KEY_INVALID = PyKCS11.LowLevel.CKR_PUBLIC_KEY_INVALID CKR["CKR_PUBLIC_KEY_INVALID"] = CKR_PUBLIC_KEY_INVALID CKR[CKR_PUBLIC_KEY_INVALID] = "CKR_PUBLIC_KEY_INVALID" CKR_FUNCTION_REJECTED = PyKCS11.LowLevel.CKR_FUNCTION_REJECTED CKR["CKR_FUNCTION_REJECTED"] = CKR_FUNCTION_REJECTED CKR[CKR_FUNCTION_REJECTED] = "CKR_FUNCTION_REJECTED" CKR_TOKEN_RESOURCE_EXCEEDED = PyKCS11.LowLevel.CKR_TOKEN_RESOURCE_EXCEEDED CKR["CKR_TOKEN_RESOURCE_EXCEEDED"] = CKR_TOKEN_RESOURCE_EXCEEDED CKR[CKR_TOKEN_RESOURCE_EXCEEDED] = "CKR_TOKEN_RESOURCE_EXCEEDED" CKR_OPERATION_CANCEL_FAILED = PyKCS11.LowLevel.CKR_OPERATION_CANCEL_FAILED CKR["CKR_OPERATION_CANCEL_FAILED"] = CKR_OPERATION_CANCEL_FAILED CKR[CKR_OPERATION_CANCEL_FAILED] = "CKR_OPERATION_CANCEL_FAILED" CKR_KEY_EXHAUSTED = PyKCS11.LowLevel.CKR_KEY_EXHAUSTED CKR["CKR_KEY_EXHAUSTED"] = CKR_KEY_EXHAUSTED CKR[CKR_KEY_EXHAUSTED] = "CKR_KEY_EXHAUSTED" CKR_PENDING = PyKCS11.LowLevel.CKR_PENDING CKR["CKR_PENDING"] = CKR_PENDING CKR[CKR_PENDING] = "CKR_PENDING" CKR_SESSION_ASYNC_NOT_SUPPORTED = PyKCS11.LowLevel.CKR_SESSION_ASYNC_NOT_SUPPORTED CKR["CKR_SESSION_ASYNC_NOT_SUPPORTED"] = CKR_SESSION_ASYNC_NOT_SUPPORTED CKR[CKR_SESSION_ASYNC_NOT_SUPPORTED] = "CKR_SESSION_ASYNC_NOT_SUPPORTED" CKR_SEED_RANDOM_REQUIRED = PyKCS11.LowLevel.CKR_SEED_RANDOM_REQUIRED CKR["CKR_SEED_RANDOM_REQUIRED"] = CKR_SEED_RANDOM_REQUIRED CKR[CKR_SEED_RANDOM_REQUIRED] = "CKR_SEED_RANDOM_REQUIRED" CKR_OPERATION_NOT_VALIDATED = PyKCS11.LowLevel.CKR_OPERATION_NOT_VALIDATED CKR["CKR_OPERATION_NOT_VALIDATED"] = CKR_OPERATION_NOT_VALIDATED CKR[CKR_OPERATION_NOT_VALIDATED] = "CKR_OPERATION_NOT_VALIDATED" CKR_TOKEN_NOT_INITIALIZED = PyKCS11.LowLevel.CKR_TOKEN_NOT_INITIALIZED CKR["CKR_TOKEN_NOT_INITIALIZED"] = CKR_TOKEN_NOT_INITIALIZED CKR[CKR_TOKEN_NOT_INITIALIZED] = "CKR_TOKEN_NOT_INITIALIZED" CKR_PARAMETER_SET_NOT_SUPPORTED = PyKCS11.LowLevel.CKR_PARAMETER_SET_NOT_SUPPORTED CKR["CKR_PARAMETER_SET_NOT_SUPPORTED"] = CKR_PARAMETER_SET_NOT_SUPPORTED CKR[CKR_PARAMETER_SET_NOT_SUPPORTED] = "CKR_PARAMETER_SET_NOT_SUPPORTED" CKR_VENDOR_DEFINED = PyKCS11.LowLevel.CKR_VENDOR_DEFINED # CKS constants CKS = {} CKS_RO_PUBLIC_SESSION = PyKCS11.LowLevel.CKS_RO_PUBLIC_SESSION CKS["CKS_RO_PUBLIC_SESSION"] = CKS_RO_PUBLIC_SESSION CKS[CKS_RO_PUBLIC_SESSION] = "CKS_RO_PUBLIC_SESSION" CKS_RO_USER_FUNCTIONS = PyKCS11.LowLevel.CKS_RO_USER_FUNCTIONS CKS["CKS_RO_USER_FUNCTIONS"] = CKS_RO_USER_FUNCTIONS CKS[CKS_RO_USER_FUNCTIONS] = "CKS_RO_USER_FUNCTIONS" CKS_RW_PUBLIC_SESSION = PyKCS11.LowLevel.CKS_RW_PUBLIC_SESSION CKS["CKS_RW_PUBLIC_SESSION"] = CKS_RW_PUBLIC_SESSION CKS[CKS_RW_PUBLIC_SESSION] = "CKS_RW_PUBLIC_SESSION" CKS_RW_USER_FUNCTIONS = PyKCS11.LowLevel.CKS_RW_USER_FUNCTIONS CKS["CKS_RW_USER_FUNCTIONS"] = CKS_RW_USER_FUNCTIONS CKS[CKS_RW_USER_FUNCTIONS] = "CKS_RW_USER_FUNCTIONS" CKS_RW_SO_FUNCTIONS = PyKCS11.LowLevel.CKS_RW_SO_FUNCTIONS CKS["CKS_RW_SO_FUNCTIONS"] = CKS_RW_SO_FUNCTIONS CKS[CKS_RW_SO_FUNCTIONS] = "CKS_RW_SO_FUNCTIONS" CKS_LAST_VALIDATION_OK = PyKCS11.LowLevel.CKS_LAST_VALIDATION_OK CKS["CKS_LAST_VALIDATION_OK"] = CKS_LAST_VALIDATION_OK CKS[CKS_LAST_VALIDATION_OK] = "CKS_LAST_VALIDATION_OK" # CKU constants CKU = {} CKU_SO = PyKCS11.LowLevel.CKU_SO CKU["CKU_SO"] = CKU_SO CKU[CKU_SO] = "CKU_SO" CKU_USER = PyKCS11.LowLevel.CKU_USER CKU["CKU_USER"] = CKU_USER CKU[CKU_USER] = "CKU_USER" CKU_CONTEXT_SPECIFIC = PyKCS11.LowLevel.CKU_CONTEXT_SPECIFIC CKU["CKU_CONTEXT_SPECIFIC"] = CKU_CONTEXT_SPECIFIC CKU[CKU_CONTEXT_SPECIFIC] = "CKU_CONTEXT_SPECIFIC" # CKZ constants CKZ = {} CKZ_DATA_SPECIFIED = PyKCS11.LowLevel.CKZ_DATA_SPECIFIED CKZ["CKZ_DATA_SPECIFIED"] = CKZ_DATA_SPECIFIED CKZ[CKZ_DATA_SPECIFIED] = "CKZ_DATA_SPECIFIED" CKZ_SALT_SPECIFIED = PyKCS11.LowLevel.CKZ_SALT_SPECIFIED CKZ["CKZ_SALT_SPECIFIED"] = CKZ_SALT_SPECIFIED CKZ[CKZ_SALT_SPECIFIED] = "CKZ_SALT_SPECIFIED" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957732 pykcs11-1.5.20/src/ck_attribute_smart.cpp0000644000175100017510000001343615246574333017744 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2017-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #include "stdafx.h" #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" #include "utility.h" #include #include CK_ATTRIBUTE_SMART::CK_ATTRIBUTE_SMART(CK_ULONG type, const CK_BYTE* pValue, CK_ULONG len) { this->m_type = type; CK_ULONG i; if (pValue) { m_value.reserve(len); m_value.clear(); for (i=0; i(len); } CK_ATTRIBUTE_SMART::CK_ATTRIBUTE_SMART(const CK_ATTRIBUTE_SMART & val) { vector::const_iterator it; for (it = val.m_value.begin(); it != val.m_value.end(); it++) m_value.push_back(*it); m_type = val.m_type; } CK_ATTRIBUTE_SMART& CK_ATTRIBUTE_SMART::operator=(const CK_ATTRIBUTE_SMART & val) { m_value = val.m_value; m_type = val.m_type; return *this; } CK_ATTRIBUTE_SMART::CK_ATTRIBUTE_SMART() { m_value.reserve(1024); } CK_ATTRIBUTE_SMART::~CK_ATTRIBUTE_SMART() { Reset(); } CK_ULONG CK_ATTRIBUTE_SMART::GetType() const { return m_type; } void CK_ATTRIBUTE_SMART::SetType(CK_ULONG attrType) { m_type = attrType; } int CK_ATTRIBUTE_SMART::GetLen() const { return (int)m_value.size(); } bool CK_ATTRIBUTE_SMART::IsString() const { switch(m_type) { case CKA_LABEL: case CKA_APPLICATION: return true; default: return false; } } bool CK_ATTRIBUTE_SMART::IsBool() const { switch(m_type) { case CKA_ALWAYS_AUTHENTICATE: case CKA_ALWAYS_SENSITIVE: case CKA_DECRYPT: case CKA_DERIVE: case CKA_ENCRYPT: case CKA_EXTRACTABLE: case CKA_HAS_RESET: case CKA_LOCAL: case CKA_MODIFIABLE: case CKA_COPYABLE: case CKA_DESTROYABLE: case CKA_NEVER_EXTRACTABLE: case CKA_PRIVATE: case CKA_RESET_ON_INIT: case CKA_SENSITIVE: case CKA_SIGN: case CKA_SIGN_RECOVER: case CKA_TOKEN: case CKA_TRUSTED: case CKA_UNWRAP: case CKA_VERIFY: case CKA_VERIFY_RECOVER: case CKA_WRAP: case CKA_WRAP_WITH_TRUSTED: return true; default: return false; } } bool CK_ATTRIBUTE_SMART::IsNum() const { switch(m_type) { case CKA_CERTIFICATE_TYPE: case CKA_CLASS: case CKA_HW_FEATURE_TYPE: case CKA_KEY_GEN_MECHANISM: case CKA_KEY_TYPE: case CKA_MODULUS_BITS: case CKA_VALUE_BITS: case CKA_VALUE_LEN: return true; default: return false; } } bool CK_ATTRIBUTE_SMART::IsAttributeList() const { switch(m_type) { case CKA_WRAP_TEMPLATE: case CKA_UNWRAP_TEMPLATE: return true; default: return false; } } bool CK_ATTRIBUTE_SMART::IsBin() const { return !IsBool() && !IsString() && !IsNum() && !IsAttributeList(); } void CK_ATTRIBUTE_SMART::Reset() { m_value.clear(); m_value.reserve(1024); m_type = 0; } void CK_ATTRIBUTE_SMART::ResetValue() { m_value.clear(); m_value.reserve(1024); } void CK_ATTRIBUTE_SMART::Reserve(long len) { m_value = vector(len); } PyKCS11String CK_ATTRIBUTE_SMART::GetString() const { return PyKCS11String(m_value); } void CK_ATTRIBUTE_SMART::SetString(CK_ULONG attrType, const char* szValue) { Reset(); m_type = attrType; if (szValue && strlen(szValue)) { size_t i; size_t iLen = strlen(szValue); for (i=0; i< iLen; i++) m_value.push_back((unsigned char)szValue[i]); } } long CK_ATTRIBUTE_SMART::GetNum() const { if (!IsNum() || m_value.size() != sizeof(CK_ULONG)) return 0; else { CK_ULONG i; CK_ULONG ulRes = 0; unsigned char* pVal = (unsigned char*)&ulRes; for (i=0; i& val) { Reset(); m_type = attrType; vector RWcopy = val; CK_ULONG ulCount = 0; CK_ATTRIBUTE * pTemplate = AttrVector2Template(RWcopy, ulCount); if (pTemplate) { const CK_BYTE* tmp2 = (const CK_BYTE*)pTemplate; CK_ULONG i; m_value.reserve(ulCount); m_value.reserve(ulCount * sizeof(CK_ATTRIBUTE)); m_value.clear(); for (i=0; i& CK_ATTRIBUTE_SMART::GetBin() { return m_value; } void CK_ATTRIBUTE_SMART::SetBin(unsigned long attrType, const vector& pBuf) { Reset(); m_value = pBuf; m_type = attrType; } ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957732 pykcs11-1.5.20/src/ck_attribute_smart.h0000644000175100017510000000401115246574333017376 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2017-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #pragma once #include "pykcs11string.h" #include using namespace std; class CK_ATTRIBUTE_SMART { CK_ATTRIBUTE_TYPE m_type; vector m_value; public: CK_ATTRIBUTE_SMART(unsigned long type, const unsigned char* pValue, unsigned long len); CK_ATTRIBUTE_SMART(const CK_ATTRIBUTE_SMART & val); CK_ATTRIBUTE_SMART& operator=(const CK_ATTRIBUTE_SMART & val); CK_ATTRIBUTE_SMART(); ~CK_ATTRIBUTE_SMART(); void Reset(); void ResetValue(); void Reserve(long len); unsigned long GetType() const; void SetType(unsigned long attrType); int GetLen() const; bool IsString() const; bool IsBool() const; bool IsNum() const; bool IsAttributeList() const; bool IsBin() const; // returns the value as SWIG "cdata.i"'s struct PyKCS11String GetString() const; void SetString(unsigned long attrType, const char* szValue); long GetNum() const; void SetNum(unsigned long attrType, unsigned long ulValue); bool GetBool() const; void SetBool(unsigned long attrType, bool bValue); void SetList(unsigned long attrType, const vector& val); vector& GetBin(); void SetBin(unsigned long attrType, const vector& pBuf); }; ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957732 pykcs11-1.5.20/src/dyn_generic.h0000644000175100017510000000435015246574333016004 0ustar00runnerrunner/* * This abstracts dynamic library loading functions. * * MUSCLE SmartCard Development ( http://www.linuxnet.com ) * * Copyright (C) 1999 * David Corcoran * Copyright (C) 2017-2025 * Ludovic Rousseau * * $Id: dyn_generic.h,v 1.3 2003/10/18 17:19:36 aet-guest Exp $ */ #ifndef __dyn_generic_h__ #define __dyn_generic_h__ /** * @file * @brief load dynamic libraries * * @code * #include "dyn_generic.h" * * #ifdef WIN32 * #define LIBRARY_NAME "foobar.dll" * #else * #define LIBRARY_NAME "foobar.so" * #endif * * void *handle; * void (*p)(int, int); * * SYS_dyn_LoadLibrary(&handle, LIBRARY_NAME); * if (NULL == handle) * { * printf("Can't open %s", LIBRARY_NAME); * return -1; * } * * // we need a cast since function_ptr is of type "void (*)(void)" * // and p is of type "void (*)(int, int)" * SYS_dyn_GetAddress(handle, (function_ptr*)&p, FUNCTION_NAME); * * // we close now to not forget it after testing p value * SYS_dyn_CloseLibrary(&handle); * * if (NULL == p) * { * printf("function %s not found", FUNCTION_NAME); * return -1; * } * * // call the function * p(1, 2); * @endcode */ #ifdef __cplusplus extern "C" { #endif typedef void (*function_ptr)(void); /** * dynamically loads a library * @param handle returned handle * @param library_name library file name * @retval 0 if OK * @retval -1 on error and *pvLHandle is set to NULL */ int SYS_dyn_LoadLibrary(void **handle, const char *library_name); /** * close/unload a dynamically loaded library * @param handle handle returned by SYS_dyn_LoadLibrary() * @retval 0 if OK * @retval -1 on error * * Side effect: *pvLHandle is set to NULL */ int SYS_dyn_CloseLibrary(void **handle); /** * get the adsress of a function from a dynamicall loaded library * @param handle handle returned by SYS_dyn_LoadLibrary() * @param function_ptr address to store the function address * @param function_name function name * @retval 0 if OK * @retval -1 on error and pvFHandle is set to NULL */ int SYS_dyn_GetAddress(void *handle, function_ptr *function_ptr, const char *function_name); #ifdef __cplusplus } #endif #endif ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957732 pykcs11-1.5.20/src/dyn_unix.c0000644000175100017510000000342615246574333015351 0ustar00runnerrunner/* * This abstracts dynamic library loading functions and timing. * * MUSCLE SmartCard Development ( http://www.linuxnet.com ) * * Copyright (C) 1999 * David Corcoran * Copyright (C) 2004-2025 * Ludovic Rousseau * * $Id: dyn_unix.c,v 1.13 2005/02/22 14:40:26 rousseau Exp $ */ //#include "config.h" #define HAVE_DLFCN_H #include #include #if defined(HAVE_DLFCN_H) && !defined(HAVE_DL_H) #include #include #include "dyn_generic.h" #define Log2(a, b) printf("%s:%d:%s() " a "\n", __FILE__, __LINE__, __FUNCTION__, b); #define Log3(a, b, c) printf("%s:%d:%s() " a "\n", __FILE__, __LINE__, __FUNCTION__, b, c); int SYS_dyn_LoadLibrary(void **handle, const char *library_name) { *handle = NULL; *handle = dlopen(library_name, RTLD_NOW); if (*handle == NULL) { Log2("%s", dlerror()); return -1; } return 0; } /* SYS_dyn_LoadLibrary */ int SYS_dyn_CloseLibrary(void **handle) { int ret; ret = dlclose(*handle); *handle = NULL; if (ret) { Log2("%s", dlerror()); return -1; } return 0; } /* SYS_dyn_CloseLibrary */ int SYS_dyn_GetAddress(void *handle, function_ptr *func_ptr, const char *function_name) { char new_function_name[256]; int rv; /* Some platforms might need a leading underscore for the symbol */ snprintf(new_function_name, sizeof(new_function_name), "_%s", function_name); *func_ptr = NULL; *func_ptr = dlsym(handle, new_function_name); /* Failed? Try again without the leading underscore */ if (*func_ptr == NULL) *func_ptr = dlsym(handle, function_name); if (*func_ptr == NULL) { Log3("%s: %s", function_name, dlerror()); rv = -1; } else rv = 0; return rv; } /* SYS_dyn_GetAddress */ #endif /* HAVE_DLFCN_H && !HAVE_DL_H && !__APPLE__ */ ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957732 pykcs11-1.5.20/src/dyn_win32.c0000644000175100017510000000415315246574333015326 0ustar00runnerrunner/* * MUSCLE SmartCard Development ( http://www.linuxnet.com ) * * Copyright (C) 1999 * David Corcoran * Copyright (C) 2017-2025 * Ludovic Rousseau * * $Id: dyn_win32.c 1957 2006-03-21 13:59:18Z rousseau $ */ /** * @file * @brief This abstracts dynamic library loading functions and timing. */ #if defined(WIN32) || defined(_WIN32) #include #include "windows.h" #include #include #include "dyn_generic.h" /* copy from https://docs.microsoft.com/fr-fr/windows/desktop/Debug/retrieving-the-last-error-code */ static void DisplayError(LPTSTR lpszFunction) { // Retrieve the system error message for the last-error code LPTSTR lpMsgBuf; DWORD dw = GetLastError(); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL ); // Display the error message printf("%s failed with error %d: %s\n", lpszFunction, dw, lpMsgBuf); LocalFree(lpMsgBuf); } int SYS_dyn_LoadLibrary(void **pvLHandle, const char *pcLibrary) { *pvLHandle = NULL; *pvLHandle = LoadLibrary(pcLibrary); if (*pvLHandle == NULL) { DisplayError("LoadLibrary()"); return -1; } return 0; } int SYS_dyn_CloseLibrary(void **pvLHandle) { int ret; ret = FreeLibrary(*pvLHandle); *pvLHandle = NULL; /* If the function fails, the return value is zero. To get extended error * information, call GetLastError. */ if (ret == 0) { DisplayError("FreeLibrary()"); return -1; } return 0; } int SYS_dyn_GetAddress(void *pvLHandle, function_ptr *pvFHandle, const char *pcFunction) { int rv; const char *pcFunctionName; /* * Zero out everything */ rv = 0; pcFunctionName = NULL; pcFunctionName = pcFunction; *pvFHandle = NULL; *pvFHandle = (function_ptr)GetProcAddress(pvLHandle, pcFunctionName); if (*pvFHandle == NULL) { DisplayError("GetProcAddress()"); rv = -1; } else rv = 0; return rv; } #endif /* WIN32 */ ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9751751 pykcs11-1.5.20/src/opensc/0000755000175100017510000000000015246574336014635 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/opensc/pkcs11.h0000644000175100017510000030614715246574333016120 0ustar00runnerrunner/* https://github.com/latchset/pkcs11-headers/blob/main/public-domain/3.2/pkcs11.h */ // clang-format off /* This file is in the Public Domain */ #ifndef _PD_PKCS11_ #define _PD_PKCS11_ #define CRYPTOKI_VERSION_MAJOR 3 #define CRYPTOKI_VERSION_MINOR 2 #define CRYPTOKI_VERSION_AMENDMENT 0 /* Basic types */ typedef unsigned char CK_BBOOL; typedef unsigned char CK_BYTE; typedef unsigned char CK_CHAR; typedef unsigned char CK_UTF8CHAR; typedef unsigned long int CK_ULONG; typedef CK_BBOOL * CK_BBOOL_PTR; typedef CK_BYTE * CK_BYTE_PTR; typedef CK_CHAR * CK_CHAR_PTR; typedef CK_UTF8CHAR * CK_UTF8CHAR_PTR; typedef CK_ULONG * CK_ULONG_PTR; /* Basic defines */ #define NULL_PTR ((void *)0) typedef void * CK_VOID_PTR; typedef void ** CK_VOID_PTR_PTR; #define CK_EFFECTIVELY_INFINITE 0UL #define CK_UNAVAILABLE_INFORMATION ~0UL #define CK_INVALID_HANDLE 0UL #define CK_TRUE 1 #define CK_FALSE 0 /* CK_ types in alphabetical order */ #define ULONGDEF(__name__) \ typedef CK_ULONG __name__; \ typedef __name__ * __name__ ## _PTR; ULONGDEF(CK_ATTRIBUTE_TYPE); ULONGDEF(CK_CERTIFICATE_CATEGORY); ULONGDEF(CK_CERTIFICATE_TYPE); ULONGDEF(CK_EC_KDF_TYPE); ULONGDEF(CK_EXTRACT_PARAMS); ULONGDEF(CK_FLAGS); ULONGDEF(CK_GENERATOR_FUNCTION); ULONGDEF(CK_HEDGE_TYPE); ULONGDEF(CK_HSS_LEVELS); ULONGDEF(CK_HW_FEATURE_TYPE); ULONGDEF(CK_JAVA_MIDP_SECURITY_DOMAIN); ULONGDEF(CK_KEY_TYPE); ULONGDEF(CK_LMS_TYPE); ULONGDEF(CK_LMOTS_TYPE); ULONGDEF(CK_MAC_GENERAL_PARAMS); ULONGDEF(CK_MECHANISM_TYPE); ULONGDEF(CK_ML_DSA_PARAMETER_SET_TYPE); ULONGDEF(CK_ML_KEM_PARAMETER_SET_TYPE); ULONGDEF(CK_NOTIFICATION); ULONGDEF(CK_OBJECT_CLASS); ULONGDEF(CK_OBJECT_HANDLE); ULONGDEF(CK_OTP_PARAM_TYPE); ULONGDEF(CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE); ULONGDEF(CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE); ULONGDEF(CK_PRF_DATA_TYPE); ULONGDEF(CK_PROFILE_ID); ULONGDEF(CK_RC2_PARAMS); ULONGDEF(CK_RSA_PKCS_MGF_TYPE); ULONGDEF(CK_RSA_PKCS_OAEP_SOURCE_TYPE); ULONGDEF(CK_RV); ULONGDEF(CK_SESSION_HANDLE); ULONGDEF(CK_SESSION_VALIDATION_FLAGS_TYPE); ULONGDEF(CK_SLH_DSA_PARAMETER_SET_TYPE); ULONGDEF(CK_SLOT_ID); ULONGDEF(CK_SP800_108_DKM_LENGTH_METHOD); ULONGDEF(CK_STATE); ULONGDEF(CK_TRUST); ULONGDEF(CK_USER_TYPE); ULONGDEF(CK_VALIDATION_AUTHORITY_TYPE); ULONGDEF(CK_VALIDATION_TYPE); ULONGDEF(CK_X2RATCHET_KDF_TYPE); ULONGDEF(CK_X3DH_KDF_TYPE); ULONGDEF(CK_X9_42_DH_KDF_TYPE); ULONGDEF(CK_XEDDSA_HASH_TYPE); ULONGDEF(CK_XMSSMT_PARAMETER_SET_TYPE); ULONGDEF(CK_XMSS_PARAMETER_SET_TYPE); /* domain specific values and constants */ /* CK (certificate) */ #define CK_CERTIFICATE_CATEGORY_UNSPECIFIED 0UL #define CK_CERTIFICATE_CATEGORY_TOKEN_USER 1UL #define CK_CERTIFICATE_CATEGORY_AUTHORITY 2UL #define CK_CERTIFICATE_CATEGORY_OTHER_ENTITY 3UL /* CK (OTP) */ #define CK_OTP_VALUE 0UL #define CK_OTP_PIN 1UL #define CK_OTP_CHALLENGE 2UL #define CK_OTP_TIME 3UL #define CK_OTP_COUNTER 4UL #define CK_OTP_FLAGS 5UL #define CK_OTP_OUTPUT_LENGTH 6UL #define CK_OTP_OUTPUT_FORMAT 7UL /* CK (OTP format) */ #define CK_OTP_FORMAT_DECIMAL 0UL #define CK_OTP_FORMAT_HEXADECIMAL 1UL #define CK_OTP_FORMAT_ALPHANUMERIC 2UL #define CK_OTP_FORMAT_BINARY 3UL /* CK (OTP requirement) */ #define CK_OTP_PARAM_IGNORED 0UL #define CK_OTP_PARAM_OPTIONAL 1UL #define CK_OTP_PARAM_MANDATORY 2UL /* CK (security) */ #define CK_SECURITY_DOMAIN_UNSPECIFIED 0UL #define CK_SECURITY_DOMAIN_MANUFACTURER 1UL #define CK_SECURITY_DOMAIN_OPERATOR 2UL #define CK_SECURITY_DOMAIN_THIRD_PARTY 3UL /* CK (SP800 KDF) */ #define CK_SP800_108_ITERATION_VARIABLE 0x00000001UL #define CK_SP800_108_OPTIONAL_COUNTER 0x00000002UL #define CK_SP800_108_COUNTER 0x00000002UL #define CK_SP800_108_DKM_LENGTH 0x00000003UL #define CK_SP800_108_BYTE_ARRAY 0x00000004UL #define CK_SP800_108_KEY_HANDLE 0x00000005UL /* CK (SP800 DKM) */ #define CK_SP800_108_DKM_LENGTH_SUM_OF_KEYS 0x00000001UL #define CK_SP800_108_DKM_LENGTH_SUM_OF_SEGMENTS 0x00000002UL /* CKA */ #define CKA_CLASS 0x00000000UL #define CKA_TOKEN 0x00000001UL #define CKA_PRIVATE 0x00000002UL #define CKA_LABEL 0x00000003UL #define CKA_UNIQUE_ID 0x00000004UL #define CKA_APPLICATION 0x00000010UL #define CKA_VALUE 0x00000011UL #define CKA_OBJECT_ID 0x00000012UL #define CKA_CERTIFICATE_TYPE 0x00000080UL #define CKA_ISSUER 0x00000081UL #define CKA_SERIAL_NUMBER 0x00000082UL #define CKA_AC_ISSUER 0x00000083UL #define CKA_OWNER 0x00000084UL #define CKA_ATTR_TYPES 0x00000085UL #define CKA_TRUSTED 0x00000086UL #define CKA_CERTIFICATE_CATEGORY 0x00000087UL #define CKA_JAVA_MIDP_SECURITY_DOMAIN 0x00000088UL #define CKA_URL 0x00000089UL #define CKA_HASH_OF_SUBJECT_PUBLIC_KEY 0x0000008AUL #define CKA_HASH_OF_ISSUER_PUBLIC_KEY 0x0000008BUL #define CKA_NAME_HASH_ALGORITHM 0x0000008CUL #define CKA_CHECK_VALUE 0x00000090UL #define CKA_KEY_TYPE 0x00000100UL #define CKA_SUBJECT 0x00000101UL #define CKA_ID 0x00000102UL #define CKA_SENSITIVE 0x00000103UL #define CKA_ENCRYPT 0x00000104UL #define CKA_DECRYPT 0x00000105UL #define CKA_WRAP 0x00000106UL #define CKA_UNWRAP 0x00000107UL #define CKA_SIGN 0x00000108UL #define CKA_SIGN_RECOVER 0x00000109UL #define CKA_VERIFY 0x0000010AUL #define CKA_VERIFY_RECOVER 0x0000010BUL #define CKA_DERIVE 0x0000010CUL #define CKA_START_DATE 0x00000110UL #define CKA_END_DATE 0x00000111UL #define CKA_MODULUS 0x00000120UL #define CKA_MODULUS_BITS 0x00000121UL #define CKA_PUBLIC_EXPONENT 0x00000122UL #define CKA_PRIVATE_EXPONENT 0x00000123UL #define CKA_PRIME_1 0x00000124UL #define CKA_PRIME_2 0x00000125UL #define CKA_EXPONENT_1 0x00000126UL #define CKA_EXPONENT_2 0x00000127UL #define CKA_COEFFICIENT 0x00000128UL #define CKA_PUBLIC_KEY_INFO 0x00000129UL #define CKA_PRIME 0x00000130UL #define CKA_SUBPRIME 0x00000131UL #define CKA_BASE 0x00000132UL #define CKA_PRIME_BITS 0x00000133UL #define CKA_SUBPRIME_BITS 0x00000134UL #define CKA_SUB_PRIME_BITS 0x00000134UL #define CKA_VALUE_BITS 0x00000160UL #define CKA_VALUE_LEN 0x00000161UL #define CKA_EXTRACTABLE 0x00000162UL #define CKA_LOCAL 0x00000163UL #define CKA_NEVER_EXTRACTABLE 0x00000164UL #define CKA_ALWAYS_SENSITIVE 0x00000165UL #define CKA_KEY_GEN_MECHANISM 0x00000166UL #define CKA_MODIFIABLE 0x00000170UL #define CKA_COPYABLE 0x00000171UL #define CKA_DESTROYABLE 0x00000172UL #define CKA_EC_PARAMS 0x00000180UL #define CKA_EC_POINT 0x00000181UL #define CKA_ALWAYS_AUTHENTICATE 0x00000202UL #define CKA_WRAP_WITH_TRUSTED 0x00000210UL #define CKA_OTP_FORMAT 0x00000220UL #define CKA_OTP_LENGTH 0x00000221UL #define CKA_OTP_TIME_INTERVAL 0x00000222UL #define CKA_OTP_USER_FRIENDLY_MODE 0x00000223UL #define CKA_OTP_CHALLENGE_REQUIREMENT 0x00000224UL #define CKA_OTP_TIME_REQUIREMENT 0x00000225UL #define CKA_OTP_COUNTER_REQUIREMENT 0x00000226UL #define CKA_OTP_PIN_REQUIREMENT 0x00000227UL #define CKA_OTP_COUNTER 0x0000022EUL #define CKA_OTP_TIME 0x0000022FUL #define CKA_OTP_USER_IDENTIFIER 0x0000022AUL #define CKA_OTP_SERVICE_IDENTIFIER 0x0000022BUL #define CKA_OTP_SERVICE_LOGO 0x0000022CUL #define CKA_OTP_SERVICE_LOGO_TYPE 0x0000022DUL #define CKA_GOSTR3410_PARAMS 0x00000250UL #define CKA_GOSTR3411_PARAMS 0x00000251UL #define CKA_GOST28147_PARAMS 0x00000252UL #define CKA_HW_FEATURE_TYPE 0x00000300UL #define CKA_RESET_ON_INIT 0x00000301UL #define CKA_HAS_RESET 0x00000302UL #define CKA_PIXEL_X 0x00000400UL #define CKA_PIXEL_Y 0x00000401UL #define CKA_RESOLUTION 0x00000402UL #define CKA_CHAR_ROWS 0x00000403UL #define CKA_CHAR_COLUMNS 0x00000404UL #define CKA_COLOR 0x00000405UL #define CKA_BITS_PER_PIXEL 0x00000406UL #define CKA_CHAR_SETS 0x00000480UL #define CKA_ENCODING_METHODS 0x00000481UL #define CKA_MIME_TYPES 0x00000482UL #define CKA_MECHANISM_TYPE 0x00000500UL #define CKA_REQUIRED_CMS_ATTRIBUTES 0x00000501UL #define CKA_DEFAULT_CMS_ATTRIBUTES 0x00000502UL #define CKA_SUPPORTED_CMS_ATTRIBUTES 0x00000503UL #define CKA_PROFILE_ID 0x00000601UL #define CKA_X2RATCHET_BAG 0x00000602UL #define CKA_X2RATCHET_BAGSIZE 0x00000603UL #define CKA_X2RATCHET_BOBS1STMSG 0x00000604UL #define CKA_X2RATCHET_CKR 0x00000605UL #define CKA_X2RATCHET_CKS 0x00000606UL #define CKA_X2RATCHET_DHP 0x00000607UL #define CKA_X2RATCHET_DHR 0x00000608UL #define CKA_X2RATCHET_DHS 0x00000609UL #define CKA_X2RATCHET_HKR 0x0000060AUL #define CKA_X2RATCHET_HKS 0x0000060BUL #define CKA_X2RATCHET_ISALICE 0x0000060CUL #define CKA_X2RATCHET_NHKR 0x0000060DUL #define CKA_X2RATCHET_NHKS 0x0000060EUL #define CKA_X2RATCHET_NR 0x0000060FUL #define CKA_X2RATCHET_NS 0x00000610UL #define CKA_X2RATCHET_PNS 0x00000611UL #define CKA_X2RATCHET_RK 0x00000612UL #define CKA_HSS_LEVELS 0x00000617UL #define CKA_HSS_LMS_TYPE 0x00000618UL #define CKA_HSS_LMOTS_TYPE 0x00000619UL #define CKA_HSS_LMS_TYPES 0x0000061AUL #define CKA_HSS_LMOTS_TYPES 0x0000061BUL #define CKA_HSS_KEYS_REMAINING 0x0000061CUL #define CKA_PARAMETER_SET 0x0000061DUL #define CKA_OBJECT_VALIDATION_FLAGS 0x0000061EUL #define CKA_VALIDATION_TYPE 0x0000061FUL #define CKA_VALIDATION_VERSION 0x00000620UL #define CKA_VALIDATION_LEVEL 0x00000621UL #define CKA_VALIDATION_MODULE_ID 0x00000622UL #define CKA_VALIDATION_FLAG 0x00000623UL #define CKA_VALIDATION_AUTHORITY_TYPE 0x00000624UL #define CKA_VALIDATION_COUNTRY 0x00000625UL #define CKA_VALIDATION_CERTIFICATE_IDENTIFIER 0x00000626UL #define CKA_VALIDATION_CERTIFICATE_URI 0x00000627UL #define CKA_VALIDATION_VENDOR_URI 0x00000628UL #define CKA_VALIDATION_PROFILE 0x00000629UL #define CKA_ENCAPSULATE_TEMPLATE 0x0000062AUL #define CKA_DECAPSULATE_TEMPLATE 0x0000062BUL #define CKA_TRUST_SERVER_AUTH 0x0000062CUL #define CKA_TRUST_CLIENT_AUTH 0x0000062DUL #define CKA_TRUST_CODE_SIGNING 0x0000062EUL #define CKA_TRUST_EMAIL_PROTECTION 0x0000062FUL #define CKA_TRUST_IPSEC_IKE 0x00000630UL #define CKA_TRUST_TIME_STAMPING 0x00000631UL #define CKA_TRUST_OCSP_SIGNING 0x00000632UL #define CKA_ENCAPSULATE 0x00000633UL #define CKA_DECAPSULATE 0x00000634UL #define CKA_HASH_OF_CERTIFICATE 0x00000635UL #define CKA_PUBLIC_CRC64_VALUE 0x00000636UL #define CKA_SEED 0x00000637UL #define CKA_VENDOR_DEFINED 0x80000000UL /* Array attributes */ #define CKA_WRAP_TEMPLATE 0x40000211UL #define CKA_UNWRAP_TEMPLATE 0x40000212UL #define CKA_DERIVE_TEMPLATE 0x40000213UL #define CKA_ALLOWED_MECHANISMS 0x40000600UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKA_ECDSA_PARAMS 0x00000180UL #define CKA_SECONDARY_AUTH 0x00000200UL #define CKA_AUTH_PIN_FLAGS 0x00000201UL #endif /* CKC */ #define CKC_X_509 0x00000000UL #define CKC_X_509_ATTR_CERT 0x00000001UL #define CKC_WTLS 0x00000002UL #define CKC_VENDOR_DEFINED 0x80000000UL /* CKD */ #define CKD_NULL 0x00000001UL #define CKD_SHA1_KDF 0x00000002UL #define CKD_SHA1_KDF_ASN1 0x00000003UL #define CKD_SHA1_KDF_CONCATENATE 0x00000004UL #define CKD_SHA224_KDF 0x00000005UL #define CKD_SHA256_KDF 0x00000006UL #define CKD_SHA384_KDF 0x00000007UL #define CKD_SHA512_KDF 0x00000008UL #define CKD_CPDIVERSIFY_KDF 0x00000009UL #define CKD_SHA3_224_KDF 0x0000000AUL #define CKD_SHA3_256_KDF 0x0000000BUL #define CKD_SHA3_384_KDF 0x0000000CUL #define CKD_SHA3_512_KDF 0x0000000DUL #define CKD_SHA1_KDF_SP800 0x0000000EUL #define CKD_SHA224_KDF_SP800 0x0000000FUL #define CKD_SHA256_KDF_SP800 0x00000010UL #define CKD_SHA384_KDF_SP800 0x00000011UL #define CKD_SHA512_KDF_SP800 0x00000012UL #define CKD_SHA3_224_KDF_SP800 0x00000013UL #define CKD_SHA3_256_KDF_SP800 0x00000014UL #define CKD_SHA3_384_KDF_SP800 0x00000015UL #define CKD_SHA3_512_KDF_SP800 0x00000016UL #define CKD_BLAKE2B_160_KDF 0x00000017UL #define CKD_BLAKE2B_256_KDF 0x00000018UL #define CKD_BLAKE2B_384_KDF 0x00000019UL #define CKD_BLAKE2B_512_KDF 0x0000001AUL /* CFK (array attributes) */ #define CKF_ARRAY_ATTRIBUTE 0x40000000UL /* CKF (capabilities) */ #define CKF_LIBRARY_CANT_CREATE_OS_THREADS 0x00000001UL #define CKF_OS_LOCKING_OK 0x00000002UL /* CKF (HKDF) */ #define CKF_HKDF_SALT_NULL 0x00000001UL #define CKF_HKDF_SALT_DATA 0x00000002UL #define CKF_HKDF_SALT_KEY 0x00000004UL /* CKF (interface) */ #define CKF_INTERFACE_FORK_SAFE 0x00000001UL /* CKF (mechanism) */ #define CKF_HW 0x00000001UL #define CKF_MESSAGE_ENCRYPT 0x00000002UL #define CKF_MESSAGE_DECRYPT 0x00000004UL #define CKF_MESSAGE_SIGN 0x00000008UL #define CKF_MESSAGE_VERIFY 0x00000010UL #define CKF_MULTI_MESSAGE 0x00000020UL #define CKF_MULTI_MESSGE 0x00000020UL #define CKF_FIND_OBJECTS 0x00000040UL #define CKF_ENCRYPT 0x00000100UL #define CKF_DECRYPT 0x00000200UL #define CKF_DIGEST 0x00000400UL #define CKF_SIGN 0x00000800UL #define CKF_SIGN_RECOVER 0x00001000UL #define CKF_VERIFY 0x00002000UL #define CKF_VERIFY_RECOVER 0x00004000UL #define CKF_GENERATE 0x00008000UL #define CKF_GENERATE_KEY_PAIR 0x00010000UL #define CKF_WRAP 0x00020000UL #define CKF_UNWRAP 0x00040000UL #define CKF_DERIVE 0x00080000UL #define CKF_EC_F_P 0x00100000UL #define CKF_EC_F_2M 0x00200000UL #define CKF_EC_ECPARAMETERS 0x00400000UL #define CKF_EC_OID 0x00800000UL #define CKF_EC_UNCOMPRESS 0x01000000UL #define CKF_EC_COMPRESS 0x02000000UL #define CKF_EC_CURVENAME 0x04000000UL #define CKF_ENCAPSULATE 0x10000000UL #define CKF_DECAPSULATE 0x20000000UL #define CKF_EXTENSION 0x80000000UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKF_EC_NAMEDCURVE 0x00800000U #endif /* CKF (message) */ #define CKF_END_OF_MESSAGE 0x00000001UL /* CKF (OTP) */ #define CKF_NEXT_OTP 0x00000001UL #define CKF_EXCLUDE_TIME 0x00000002UL #define CKF_EXCLUDE_COUNTER 0x00000004UL #define CKF_EXCLUDE_CHALLENGE 0x00000008UL #define CKF_EXCLUDE_PIN 0x00000010UL #define CKF_USER_FRIENDLY_OTP 0x00000020UL /* CKF (parameters to functions) */ #define CKF_DONT_BLOCK 1 /* CKF (session) */ #define CKF_RW_SESSION 0x00000002UL #define CKF_SERIAL_SESSION 0x00000004UL #define CKF_ASYNC_SESSION 0x00000008UL /* CFK (slot) */ #define CKF_TOKEN_PRESENT 0x00000001UL #define CKF_REMOVABLE_DEVICE 0x00000002UL #define CKF_HW_SLOT 0x00000004UL /* CKF (token) */ #define CKF_RNG 0x00000001UL #define CKF_WRITE_PROTECTED 0x00000002UL #define CKF_LOGIN_REQUIRED 0x00000004UL #define CKF_USER_PIN_INITIALIZED 0x00000008UL #define CKF_RESTORE_KEY_NOT_NEEDED 0x00000020UL #define CKF_CLOCK_ON_TOKEN 0x00000040UL #define CKF_PROTECTED_AUTHENTICATION_PATH 0x00000100UL #define CKF_DUAL_CRYPTO_OPERATIONS 0x00000200UL #define CKF_TOKEN_INITIALIZED 0x00000400UL #define CKF_SECONDARY_AUTHENTICATION 0x00000800UL #define CKF_USER_PIN_COUNT_LOW 0x00010000UL #define CKF_USER_PIN_FINAL_TRY 0x00020000UL #define CKF_USER_PIN_LOCKED 0x00040000UL #define CKF_USER_PIN_TO_BE_CHANGED 0x00080000UL #define CKF_SO_PIN_COUNT_LOW 0x00100000UL #define CKF_SO_PIN_FINAL_TRY 0x00200000UL #define CKF_SO_PIN_LOCKED 0x00400000UL #define CKF_SO_PIN_TO_BE_CHANGED 0x00800000UL #define CKF_ERROR_STATE 0x01000000UL #define CKF_SEED_RANDOM_REQUIRED 0x02000000UL #define CKF_ASYNC_SESSION_SUPPORTED 0x04000000UL /* CKG (GCM) */ #define CKG_NO_GENERATE 0x00000000UL #define CKG_GENERATE 0x00000001UL #define CKG_GENERATE_COUNTER 0x00000002UL #define CKG_GENERATE_RANDOM 0x00000003UL #define CKG_GENERATE_COUNTER_XOR 0x00000004UL /* CKG (MFG) */ #define CKG_MGF1_SHA1 0x00000001UL #define CKG_MGF1_SHA256 0x00000002UL #define CKG_MGF1_SHA384 0x00000003UL #define CKG_MGF1_SHA512 0x00000004UL #define CKG_MGF1_SHA224 0x00000005UL #define CKG_MGF1_SHA3_224 0x00000006UL #define CKG_MGF1_SHA3_256 0x00000007UL #define CKG_MGF1_SHA3_384 0x00000008UL #define CKG_MGF1_SHA3_512 0x00000009UL /* CKH (clock) */ #define CKH_MONOTONIC_COUNTER 0x00000001UL #define CKH_CLOCK 0x00000002UL #define CKH_USER_INTERFACE 0x00000003UL #define CKH_VENDOR_DEFINED 0x80000000UL /* CKH (hedge type) */ #define CKH_HEDGE_PREFERRED 0x00000000UL #define CKH_HEDGE_REQUIRED 0x00000001UL #define CKH_DETERMINISTIC_REQUIRED 0x00000002UL /* CKK */ #define CKK_RSA 0x00000000UL #define CKK_DSA 0x00000001UL #define CKK_DH 0x00000002UL #define CKK_EC 0x00000003UL #define CKK_X9_42_DH 0x00000004UL #define CKK_KEA 0x00000005UL #define CKK_GENERIC_SECRET 0x00000010UL #define CKK_RC2 0x00000011UL #define CKK_RC4 0x00000012UL #define CKK_DES 0x00000013UL #define CKK_DES2 0x00000014UL #define CKK_DES3 0x00000015UL #define CKK_CAST 0x00000016UL #define CKK_CAST3 0x00000017UL #define CKK_CAST128 0x00000018UL #define CKK_RC5 0x00000019UL #define CKK_IDEA 0x0000001AUL #define CKK_SKIPJACK 0x0000001BUL #define CKK_BATON 0x0000001CUL #define CKK_JUNIPER 0x0000001DUL #define CKK_CDMF 0x0000001EUL #define CKK_AES 0x0000001FUL #define CKK_BLOWFISH 0x00000020UL #define CKK_TWOFISH 0x00000021UL #define CKK_SECURID 0x00000022UL #define CKK_HOTP 0x00000023UL #define CKK_ACTI 0x00000024UL #define CKK_CAMELLIA 0x00000025UL #define CKK_ARIA 0x00000026UL #define CKK_MD5_HMAC 0x00000027UL #define CKK_SHA_1_HMAC 0x00000028UL #define CKK_RIPEMD128_HMAC 0x00000029UL #define CKK_RIPEMD160_HMAC 0x0000002AUL #define CKK_SHA256_HMAC 0x0000002BUL #define CKK_SHA384_HMAC 0x0000002CUL #define CKK_SHA512_HMAC 0x0000002DUL #define CKK_SHA224_HMAC 0x0000002EUL #define CKK_SEED 0x0000002FUL #define CKK_GOSTR3410 0x00000030UL #define CKK_GOSTR3411 0x00000031UL #define CKK_GOST28147 0x00000032UL #define CKK_CHACHA20 0x00000033UL #define CKK_POLY1305 0x00000034UL #define CKK_AES_XTS 0x00000035UL #define CKK_SHA3_224_HMAC 0x00000036UL #define CKK_SHA3_256_HMAC 0x00000037UL #define CKK_SHA3_384_HMAC 0x00000038UL #define CKK_SHA3_512_HMAC 0x00000039UL #define CKK_BLAKE2B_160_HMAC 0x0000003AUL #define CKK_BLAKE2B_256_HMAC 0x0000003BUL #define CKK_BLAKE2B_384_HMAC 0x0000003CUL #define CKK_BLAKE2B_512_HMAC 0x0000003DUL #define CKK_SALSA20 0x0000003EUL #define CKK_X2RATCHET 0x0000003FUL #define CKK_EC_EDWARDS 0x00000040UL #define CKK_EC_MONTGOMERY 0x00000041UL #define CKK_HKDF 0x00000042UL #define CKK_SHA512_224_HMAC 0x00000043UL #define CKK_SHA512_256_HMAC 0x00000044UL #define CKK_SHA512_T_HMAC 0x00000045UL #define CKK_HSS 0x00000046UL #define CKK_XMSS 0x00000047UL #define CKK_XMSSMT 0x00000048UL #define CKK_ML_KEM 0x00000049UL #define CKK_ML_DSA 0x0000004AUL #define CKK_SLH_DSA 0x0000004BUL #define CKK_VENDOR_DEFINED 0x80000000UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKK_ECDSA 0x00000003UL #define CKK_CAST5 0x00000018UL #endif /* CKM */ #define CKM_RSA_PKCS_KEY_PAIR_GEN 0x00000000UL #define CKM_RSA_PKCS 0x00000001UL #define CKM_RSA_9796 0x00000002UL #define CKM_RSA_X_509 0x00000003UL #define CKM_MD2_RSA_PKCS 0x00000004UL #define CKM_MD5_RSA_PKCS 0x00000005UL #define CKM_SHA1_RSA_PKCS 0x00000006UL #define CKM_RIPEMD128_RSA_PKCS 0x00000007UL #define CKM_RIPEMD160_RSA_PKCS 0x00000008UL #define CKM_RSA_PKCS_OAEP 0x00000009UL #define CKM_RSA_X9_31_KEY_PAIR_GEN 0x0000000AUL #define CKM_RSA_X9_31 0x0000000BUL #define CKM_SHA1_RSA_X9_31 0x0000000CUL #define CKM_RSA_PKCS_PSS 0x0000000DUL #define CKM_SHA1_RSA_PKCS_PSS 0x0000000EUL #define CKM_ML_KEM_KEY_PAIR_GEN 0x0000000FUL #define CKM_DSA_KEY_PAIR_GEN 0x00000010UL #define CKM_DSA 0x00000011UL #define CKM_DSA_SHA1 0x00000012UL #define CKM_DSA_SHA224 0x00000013UL #define CKM_DSA_SHA256 0x00000014UL #define CKM_DSA_SHA384 0x00000015UL #define CKM_DSA_SHA512 0x00000016UL #define CKM_ML_KEM 0x00000017UL #define CKM_DSA_SHA3_224 0x00000018UL #define CKM_DSA_SHA3_256 0x00000019UL #define CKM_DSA_SHA3_384 0x0000001AUL #define CKM_DSA_SHA3_512 0x0000001BUL #define CKM_ML_DSA_KEY_PAIR_GEN 0x0000001CUL #define CKM_ML_DSA 0x0000001DUL #define CKM_HASH_ML_DSA 0x0000001FUL #define CKM_DH_PKCS_KEY_PAIR_GEN 0x00000020UL #define CKM_DH_PKCS_DERIVE 0x00000021UL #define CKM_HASH_ML_DSA_SHA224 0x00000023UL #define CKM_HASH_ML_DSA_SHA256 0x00000024UL #define CKM_HASH_ML_DSA_SHA384 0x00000025UL #define CKM_HASH_ML_DSA_SHA512 0x00000026UL #define CKM_HASH_ML_DSA_SHA3_224 0x00000027UL #define CKM_HASH_ML_DSA_SHA3_256 0x00000028UL #define CKM_HASH_ML_DSA_SHA3_384 0x00000029UL #define CKM_HASH_ML_DSA_SHA3_512 0x0000002AUL #define CKM_HASH_ML_DSA_SHAKE128 0x0000002BUL #define CKM_HASH_ML_DSA_SHAKE256 0x0000002CUL #define CKM_SLH_DSA_KEY_PAIR_GEN 0x0000002DUL #define CKM_SLH_DSA 0x0000002EUL #define CKM_X9_42_DH_KEY_PAIR_GEN 0x00000030UL #define CKM_X9_42_DH_DERIVE 0x00000031UL #define CKM_X9_42_DH_HYBRID_DERIVE 0x00000032UL #define CKM_X9_42_MQV_DERIVE 0x00000033UL #define CKM_HASH_SLH_DSA 0x00000034UL #define CKM_HASH_SLH_DSA_SHA224 0x00000036UL #define CKM_HASH_SLH_DSA_SHA256 0x00000037UL #define CKM_HASH_SLH_DSA_SHA384 0x00000038UL #define CKM_HASH_SLH_DSA_SHA512 0x00000039UL #define CKM_HASH_SLH_DSA_SHA3_224 0x0000003AUL #define CKM_HASH_SLH_DSA_SHA3_256 0x0000003BUL #define CKM_HASH_SLH_DSA_SHA3_384 0x0000003CUL #define CKM_HASH_SLH_DSA_SHA3_512 0x0000003DUL #define CKM_HASH_SLH_DSA_SHAKE128 0x0000003EUL #define CKM_HASH_SLH_DSA_SHAKE256 0x0000003FUL #define CKM_SHA256_RSA_PKCS 0x00000040UL #define CKM_SHA384_RSA_PKCS 0x00000041UL #define CKM_SHA512_RSA_PKCS 0x00000042UL #define CKM_SHA256_RSA_PKCS_PSS 0x00000043UL #define CKM_SHA384_RSA_PKCS_PSS 0x00000044UL #define CKM_SHA512_RSA_PKCS_PSS 0x00000045UL #define CKM_SHA224_RSA_PKCS 0x00000046UL #define CKM_SHA224_RSA_PKCS_PSS 0x00000047UL #define CKM_SHA512_224 0x00000048UL #define CKM_SHA512_224_HMAC 0x00000049UL #define CKM_SHA512_224_HMAC_GENERAL 0x0000004AUL #define CKM_SHA512_224_KEY_DERIVATION 0x0000004BUL #define CKM_SHA512_256 0x0000004CUL #define CKM_SHA512_256_HMAC 0x0000004DUL #define CKM_SHA512_256_HMAC_GENERAL 0x0000004EUL #define CKM_SHA512_256_KEY_DERIVATION 0x0000004FUL #define CKM_SHA512_T 0x00000050UL #define CKM_SHA512_T_HMAC 0x00000051UL #define CKM_SHA512_T_HMAC_GENERAL 0x00000052UL #define CKM_SHA512_T_KEY_DERIVATION 0x00000053UL #define CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE 0x00000056UL #define CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH 0x00000057UL #define CKM_SHA3_256_RSA_PKCS 0x00000060UL #define CKM_SHA3_384_RSA_PKCS 0x00000061UL #define CKM_SHA3_512_RSA_PKCS 0x00000062UL #define CKM_SHA3_256_RSA_PKCS_PSS 0x00000063UL #define CKM_SHA3_384_RSA_PKCS_PSS 0x00000064UL #define CKM_SHA3_512_RSA_PKCS_PSS 0x00000065UL #define CKM_SHA3_224_RSA_PKCS 0x00000066UL #define CKM_SHA3_224_RSA_PKCS_PSS 0x00000067UL #define CKM_RC2_KEY_GEN 0x00000100UL #define CKM_RC2_ECB 0x00000101UL #define CKM_RC2_CBC 0x00000102UL #define CKM_RC2_MAC 0x00000103UL #define CKM_RC2_MAC_GENERAL 0x00000104UL #define CKM_RC2_CBC_PAD 0x00000105UL #define CKM_RC4_KEY_GEN 0x00000110UL #define CKM_RC4 0x00000111UL #define CKM_DES_KEY_GEN 0x00000120UL #define CKM_DES_ECB 0x00000121UL #define CKM_DES_CBC 0x00000122UL #define CKM_DES_MAC 0x00000123UL #define CKM_DES_MAC_GENERAL 0x00000124UL #define CKM_DES_CBC_PAD 0x00000125UL #define CKM_DES2_KEY_GEN 0x00000130UL #define CKM_DES3_KEY_GEN 0x00000131UL #define CKM_DES3_ECB 0x00000132UL #define CKM_DES3_CBC 0x00000133UL #define CKM_DES3_MAC 0x00000134UL #define CKM_DES3_MAC_GENERAL 0x00000135UL #define CKM_DES3_CBC_PAD 0x00000136UL #define CKM_DES3_CMAC_GENERAL 0x00000137UL #define CKM_DES3_CMAC 0x00000138UL #define CKM_CDMF_KEY_GEN 0x00000140UL #define CKM_CDMF_ECB 0x00000141UL #define CKM_CDMF_CBC 0x00000142UL #define CKM_CDMF_MAC 0x00000143UL #define CKM_CDMF_MAC_GENERAL 0x00000144UL #define CKM_CDMF_CBC_PAD 0x00000145UL #define CKM_DES_OFB64 0x00000150UL #define CKM_DES_OFB8 0x00000151UL #define CKM_DES_CFB64 0x00000152UL #define CKM_DES_CFB8 0x00000153UL #define CKM_MD2 0x00000200UL #define CKM_MD2_HMAC 0x00000201UL #define CKM_MD2_HMAC_GENERAL 0x00000202UL #define CKM_MD5 0x00000210UL #define CKM_MD5_HMAC 0x00000211UL #define CKM_MD5_HMAC_GENERAL 0x00000212UL #define CKM_SHA_1 0x00000220UL #define CKM_SHA_1_HMAC 0x00000221UL #define CKM_SHA_1_HMAC_GENERAL 0x00000222UL #define CKM_RIPEMD128 0x00000230UL #define CKM_RIPEMD128_HMAC 0x00000231UL #define CKM_RIPEMD128_HMAC_GENERAL 0x00000232UL #define CKM_RIPEMD160 0x00000240UL #define CKM_RIPEMD160_HMAC 0x00000241UL #define CKM_RIPEMD160_HMAC_GENERAL 0x00000242UL #define CKM_SHA256 0x00000250UL #define CKM_SHA256_HMAC 0x00000251UL #define CKM_SHA256_HMAC_GENERAL 0x00000252UL #define CKM_SHA224 0x00000255UL #define CKM_SHA224_HMAC 0x00000256UL #define CKM_SHA224_HMAC_GENERAL 0x00000257UL #define CKM_SHA384 0x00000260UL #define CKM_SHA384_HMAC 0x00000261UL #define CKM_SHA384_HMAC_GENERAL 0x00000262UL #define CKM_SHA512 0x00000270UL #define CKM_SHA512_HMAC 0x00000271UL #define CKM_SHA512_HMAC_GENERAL 0x00000272UL #define CKM_SECURID_KEY_GEN 0x00000280UL #define CKM_SECURID 0x00000282UL #define CKM_HOTP_KEY_GEN 0x00000290UL #define CKM_HOTP 0x00000291UL #define CKM_ACTI 0x000002A0UL #define CKM_ACTI_KEY_GEN 0x000002A1UL #define CKM_SHA3_256 0x000002B0UL #define CKM_SHA3_256_HMAC 0x000002B1UL #define CKM_SHA3_256_HMAC_GENERAL 0x000002B2UL #define CKM_SHA3_256_KEY_GEN 0x000002B3UL #define CKM_SHA3_224 0x000002B5UL #define CKM_SHA3_224_HMAC 0x000002B6UL #define CKM_SHA3_224_HMAC_GENERAL 0x000002B7UL #define CKM_SHA3_224_KEY_GEN 0x000002B8UL #define CKM_SHA3_384 0x000002C0UL #define CKM_SHA3_384_HMAC 0x000002C1UL #define CKM_SHA3_384_HMAC_GENERAL 0x000002C2UL #define CKM_SHA3_384_KEY_GEN 0x000002C3UL #define CKM_SHA3_512 0x000002D0UL #define CKM_SHA3_512_HMAC 0x000002D1UL #define CKM_SHA3_512_HMAC_GENERAL 0x000002D2UL #define CKM_SHA3_512_KEY_GEN 0x000002D3UL #define CKM_CAST_KEY_GEN 0x00000300UL #define CKM_CAST_ECB 0x00000301UL #define CKM_CAST_CBC 0x00000302UL #define CKM_CAST_MAC 0x00000303UL #define CKM_CAST_MAC_GENERAL 0x00000304UL #define CKM_CAST_CBC_PAD 0x00000305UL #define CKM_CAST3_KEY_GEN 0x00000310UL #define CKM_CAST3_ECB 0x00000311UL #define CKM_CAST3_CBC 0x00000312UL #define CKM_CAST3_MAC 0x00000313UL #define CKM_CAST3_MAC_GENERAL 0x00000314UL #define CKM_CAST3_CBC_PAD 0x00000315UL #define CKM_CAST128_KEY_GEN 0x00000320UL #define CKM_CAST128_ECB 0x00000321UL #define CKM_CAST128_MAC 0x00000323UL #define CKM_CAST128_CBC 0x00000322UL #define CKM_CAST128_MAC_GENERAL 0x00000324UL #define CKM_CAST128_CBC_PAD 0x00000325UL #define CKM_RC5_KEY_GEN 0x00000330UL #define CKM_RC5_ECB 0x00000331UL #define CKM_RC5_CBC 0x00000332UL #define CKM_RC5_MAC 0x00000333UL #define CKM_RC5_MAC_GENERAL 0x00000334UL #define CKM_RC5_CBC_PAD 0x00000335UL #define CKM_IDEA_KEY_GEN 0x00000340UL #define CKM_IDEA_ECB 0x00000341UL #define CKM_IDEA_CBC 0x00000342UL #define CKM_IDEA_MAC 0x00000343UL #define CKM_IDEA_MAC_GENERAL 0x00000344UL #define CKM_IDEA_CBC_PAD 0x00000345UL #define CKM_GENERIC_SECRET_KEY_GEN 0x00000350UL #define CKM_CONCATENATE_BASE_AND_KEY 0x00000360UL #define CKM_CONCATENATE_BASE_AND_DATA 0x00000362UL #define CKM_CONCATENATE_DATA_AND_BASE 0x00000363UL #define CKM_XOR_BASE_AND_DATA 0x00000364UL #define CKM_EXTRACT_KEY_FROM_KEY 0x00000365UL #define CKM_SSL3_PRE_MASTER_KEY_GEN 0x00000370UL #define CKM_SSL3_MASTER_KEY_DERIVE 0x00000371UL #define CKM_SSL3_KEY_AND_MAC_DERIVE 0x00000372UL #define CKM_SSL3_MASTER_KEY_DERIVE_DH 0x00000373UL #define CKM_TLS_PRE_MASTER_KEY_GEN 0x00000374UL #define CKM_TLS_MASTER_KEY_DERIVE 0x00000375UL #define CKM_TLS_KEY_AND_MAC_DERIVE 0x00000376UL #define CKM_TLS_MASTER_KEY_DERIVE_DH 0x00000377UL #define CKM_TLS_PRF 0x00000378UL #define CKM_SSL3_MD5_MAC 0x00000380UL #define CKM_SSL3_SHA1_MAC 0x00000381UL #define CKM_MD5_KEY_DERIVATION 0x00000390UL #define CKM_MD2_KEY_DERIVATION 0x00000391UL #define CKM_SHA1_KEY_DERIVATION 0x00000392UL #define CKM_SHA256_KEY_DERIVATION 0x00000393UL #define CKM_SHA384_KEY_DERIVATION 0x00000394UL #define CKM_SHA512_KEY_DERIVATION 0x00000395UL #define CKM_SHA224_KEY_DERIVATION 0x00000396UL #define CKM_SHA3_256_KEY_DERIVATION 0x00000397UL #define CKM_SHA3_256_KEY_DERIVE 0x00000397UL #define CKM_SHA3_224_KEY_DERIVATION 0x00000398UL #define CKM_SHA3_224_KEY_DERIVE 0x00000398UL #define CKM_SHA3_384_KEY_DERIVATION 0x00000399UL #define CKM_SHA3_384_KEY_DERIVE 0x00000399UL #define CKM_SHA3_512_KEY_DERIVATION 0x0000039AUL #define CKM_SHA3_512_KEY_DERIVE 0x0000039AUL #define CKM_SHAKE_128_KEY_DERIVATION 0x0000039BUL #define CKM_SHAKE_128_KEY_DERIVE 0x0000039BUL #define CKM_SHAKE_256_KEY_DERIVATION 0x0000039CUL #define CKM_SHAKE_256_KEY_DERIVE 0x0000039CUL #define CKM_PBE_MD2_DES_CBC 0x000003A0UL #define CKM_PBE_MD5_DES_CBC 0x000003A1UL #define CKM_PBE_MD5_CAST_CBC 0x000003A2UL #define CKM_PBE_MD5_CAST3_CBC 0x000003A3UL #define CKM_PBE_MD5_CAST128_CBC 0x000003A4UL #define CKM_PBE_SHA1_CAST128_CBC 0x000003A5UL #define CKM_PBE_SHA1_RC4_128 0x000003A6UL #define CKM_PBE_SHA1_RC4_40 0x000003A7UL #define CKM_PBE_SHA1_DES3_EDE_CBC 0x000003A8UL #define CKM_PBE_SHA1_DES2_EDE_CBC 0x000003A9UL #define CKM_PBE_SHA1_RC2_128_CBC 0x000003AAUL #define CKM_PBE_SHA1_RC2_40_CBC 0x000003ABUL #define CKM_PKCS5_PBKD2 0x000003B0UL #define CKM_PBA_SHA1_WITH_SHA1_HMAC 0x000003C0UL #define CKM_WTLS_PRE_MASTER_KEY_GEN 0x000003D0UL #define CKM_WTLS_MASTER_KEY_DERIVE 0x000003D1UL #define CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC 0x000003D2UL #define CKM_WTLS_PRF 0x000003D3UL #define CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE 0x000003D4UL #define CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE 0x000003D5UL #define CKM_TLS10_MAC_SERVER 0x000003D6UL #define CKM_TLS10_MAC_CLIENT 0x000003D7UL #define CKM_TLS12_MAC 0x000003D8UL #define CKM_TLS12_KDF 0x000003D9UL #define CKM_TLS12_MASTER_KEY_DERIVE 0x000003E0UL #define CKM_TLS12_KEY_AND_MAC_DERIVE 0x000003E1UL #define CKM_TLS12_MASTER_KEY_DERIVE_DH 0x000003E2UL #define CKM_TLS12_KEY_SAFE_DERIVE 0x000003E3UL #define CKM_TLS_MAC 0x000003E4UL #define CKM_TLS_KDF 0x000003E5UL #define CKM_KEY_WRAP_LYNKS 0x00000400UL #define CKM_KEY_WRAP_SET_OAEP 0x00000401UL #define CKM_CMS_SIG 0x00000500UL #define CKM_KIP_DERIVE 0x00000510UL #define CKM_KIP_WRAP 0x00000511UL #define CKM_KIP_MAC 0x00000512UL #define CKM_CAMELLIA_KEY_GEN 0x00000550UL #define CKM_CAMELLIA_ECB 0x00000551UL #define CKM_CAMELLIA_CBC 0x00000552UL #define CKM_CAMELLIA_MAC 0x00000553UL #define CKM_CAMELLIA_MAC_GENERAL 0x00000554UL #define CKM_CAMELLIA_CBC_PAD 0x00000555UL #define CKM_CAMELLIA_ECB_ENCRYPT_DATA 0x00000556UL #define CKM_CAMELLIA_CBC_ENCRYPT_DATA 0x00000557UL #define CKM_CAMELLIA_CTR 0x00000558UL #define CKM_ARIA_KEY_GEN 0x00000560UL #define CKM_ARIA_ECB 0x00000561UL #define CKM_ARIA_CBC 0x00000562UL #define CKM_ARIA_MAC 0x00000563UL #define CKM_ARIA_MAC_GENERAL 0x00000564UL #define CKM_ARIA_CBC_PAD 0x00000565UL #define CKM_ARIA_ECB_ENCRYPT_DATA 0x00000566UL #define CKM_ARIA_CBC_ENCRYPT_DATA 0x00000567UL #define CKM_SEED_KEY_GEN 0x00000650UL #define CKM_SEED_ECB 0x00000651UL #define CKM_SEED_CBC 0x00000652UL #define CKM_SEED_MAC 0x00000653UL #define CKM_SEED_MAC_GENERAL 0x00000654UL #define CKM_SEED_CBC_PAD 0x00000655UL #define CKM_SEED_ECB_ENCRYPT_DATA 0x00000656UL #define CKM_SEED_CBC_ENCRYPT_DATA 0x00000657UL #define CKM_SKIPJACK_KEY_GEN 0x00001000UL #define CKM_SKIPJACK_ECB64 0x00001001UL #define CKM_SKIPJACK_CBC64 0x00001002UL #define CKM_SKIPJACK_OFB64 0x00001003UL #define CKM_SKIPJACK_CFB64 0x00001004UL #define CKM_SKIPJACK_CFB32 0x00001005UL #define CKM_SKIPJACK_CFB16 0x00001006UL #define CKM_SKIPJACK_CFB8 0x00001007UL #define CKM_SKIPJACK_WRAP 0x00001008UL #define CKM_SKIPJACK_PRIVATE_WRAP 0x00001009UL #define CKM_SKIPJACK_RELAYX 0x0000100AUL #define CKM_KEA_KEY_PAIR_GEN 0x00001010UL #define CKM_KEA_KEY_DERIVE 0x00001011UL #define CKM_KEA_DERIVE 0x00001012UL #define CKM_FORTEZZA_TIMESTAMP 0x00001020UL #define CKM_BATON_KEY_GEN 0x00001030UL #define CKM_BATON_ECB128 0x00001031UL #define CKM_BATON_ECB96 0x00001032UL #define CKM_BATON_CBC128 0x00001033UL #define CKM_BATON_COUNTER 0x00001034UL #define CKM_BATON_SHUFFLE 0x00001035UL #define CKM_BATON_WRAP 0x00001036UL #define CKM_EC_KEY_PAIR_GEN 0x00001040UL #define CKM_ECDSA 0x00001041UL #define CKM_ECDSA_SHA1 0x00001042UL #define CKM_ECDSA_SHA224 0x00001043UL #define CKM_ECDSA_SHA256 0x00001044UL #define CKM_ECDSA_SHA384 0x00001045UL #define CKM_ECDSA_SHA512 0x00001046UL #define CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS 0x0000140BUL #define CKM_ECDH1_DERIVE 0x00001050UL #define CKM_ECDH1_COFACTOR_DERIVE 0x00001051UL #define CKM_ECMQV_DERIVE 0x00001052UL #define CKM_ECDH_AES_KEY_WRAP 0x00001053UL #define CKM_RSA_AES_KEY_WRAP 0x00001054UL #define CKM_JUNIPER_KEY_GEN 0x00001060UL #define CKM_JUNIPER_ECB128 0x00001061UL #define CKM_JUNIPER_CBC128 0x00001062UL #define CKM_JUNIPER_COUNTER 0x00001063UL #define CKM_JUNIPER_SHUFFLE 0x00001064UL #define CKM_JUNIPER_WRAP 0x00001065UL #define CKM_FASTHASH 0x00001070UL #define CKM_AES_XTS 0x00001071UL #define CKM_AES_XTS_KEY_GEN 0x00001072UL #define CKM_AES_KEY_GEN 0x00001080UL #define CKM_AES_ECB 0x00001081UL #define CKM_AES_CBC 0x00001082UL #define CKM_AES_MAC 0x00001083UL #define CKM_AES_MAC_GENERAL 0x00001084UL #define CKM_AES_CBC_PAD 0x00001085UL #define CKM_AES_CTR 0x00001086UL #define CKM_AES_GCM 0x00001087UL #define CKM_AES_CCM 0x00001088UL #define CKM_AES_CTS 0x00001089UL #define CKM_AES_CMAC 0x0000108AUL #define CKM_AES_CMAC_GENERAL 0x0000108BUL #define CKM_AES_XCBC_MAC 0x0000108CUL #define CKM_AES_XCBC_MAC_96 0x0000108DUL #define CKM_AES_GMAC 0x0000108EUL #define CKM_BLOWFISH_KEY_GEN 0x00001090UL #define CKM_BLOWFISH_CBC 0x00001091UL #define CKM_TWOFISH_KEY_GEN 0x00001092UL #define CKM_TWOFISH_CBC 0x00001093UL #define CKM_BLOWFISH_CBC_PAD 0x00001094UL #define CKM_TWOFISH_CBC_PAD 0x00001095UL #define CKM_DES_ECB_ENCRYPT_DATA 0x00001100UL #define CKM_DES_CBC_ENCRYPT_DATA 0x00001101UL #define CKM_DES3_ECB_ENCRYPT_DATA 0x00001102UL #define CKM_DES3_CBC_ENCRYPT_DATA 0x00001103UL #define CKM_AES_ECB_ENCRYPT_DATA 0x00001104UL #define CKM_AES_CBC_ENCRYPT_DATA 0x00001105UL #define CKM_GOSTR3410_KEY_PAIR_GEN 0x00001200UL #define CKM_GOSTR3410 0x00001201UL #define CKM_GOSTR3410_WITH_GOSTR3411 0x00001202UL #define CKM_GOSTR3410_KEY_WRAP 0x00001203UL #define CKM_GOSTR3410_DERIVE 0x00001204UL #define CKM_GOSTR3411 0x00001210UL #define CKM_GOSTR3411_HMAC 0x00001211UL #define CKM_GOST28147_KEY_GEN 0x00001220UL #define CKM_GOST28147_ECB 0x00001221UL #define CKM_GOST28147 0x00001222UL #define CKM_GOST28147_MAC 0x00001223UL #define CKM_GOST28147_KEY_WRAP 0x00001224UL #define CKM_CHACHA20_KEY_GEN 0x00001225UL #define CKM_CHACHA20 0x00001226UL #define CKM_POLY1305_KEY_GEN 0x00001227UL #define CKM_POLY1305 0x00001228UL #define CKM_DSA_PARAMETER_GEN 0x00002000UL #define CKM_DH_PKCS_PARAMETER_GEN 0x00002001UL #define CKM_X9_42_DH_PARAMETER_GEN 0x00002002UL #define CKM_DSA_PROBABILISTIC_PARAMETER_GEN 0x00002003UL #define CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN 0x00002004UL #define CKM_DSA_FIPS_G_GEN 0x00002005UL #define CKM_AES_OFB 0x00002104UL #define CKM_AES_CFB64 0x00002105UL #define CKM_AES_CFB8 0x00002106UL #define CKM_AES_CFB128 0x00002107UL #define CKM_AES_CFB1 0x00002108UL #define CKM_AES_KEY_WRAP 0x00002109UL #define CKM_AES_KEY_WRAP_PAD 0x0000210AUL #define CKM_AES_KEY_WRAP_KWP 0x0000210BUL #define CKM_AES_KEY_WRAP_PKCS7 0x0000210CUL #define CKM_RSA_PKCS_TPM_1_1 0x00004001UL #define CKM_RSA_PKCS_OAEP_TPM_1_1 0x00004002UL #define CKM_SHA_1_KEY_GEN 0x00004003UL #define CKM_SHA224_KEY_GEN 0x00004004UL #define CKM_SHA256_KEY_GEN 0x00004005UL #define CKM_SHA384_KEY_GEN 0x00004006UL #define CKM_SHA512_KEY_GEN 0x00004007UL #define CKM_SHA512_224_KEY_GEN 0x00004008UL #define CKM_SHA512_256_KEY_GEN 0x00004009UL #define CKM_SHA512_T_KEY_GEN 0x0000400AUL #define CKM_NULL 0x0000400BUL #define CKM_BLAKE2B_160 0x0000400CUL #define CKM_BLAKE2B_160_HMAC 0x0000400DUL #define CKM_BLAKE2B_160_HMAC_GENERAL 0x0000400EUL #define CKM_BLAKE2B_160_KEY_DERIVE 0x0000400FUL #define CKM_BLAKE2B_160_KEY_GEN 0x00004010UL #define CKM_BLAKE2B_256 0x00004011UL #define CKM_BLAKE2B_256_HMAC 0x00004012UL #define CKM_BLAKE2B_256_HMAC_GENERAL 0x00004013UL #define CKM_BLAKE2B_256_KEY_DERIVE 0x00004014UL #define CKM_BLAKE2B_256_KEY_GEN 0x00004015UL #define CKM_BLAKE2B_384 0x00004016UL #define CKM_BLAKE2B_384_HMAC 0x00004017UL #define CKM_BLAKE2B_384_HMAC_GENERAL 0x00004018UL #define CKM_BLAKE2B_384_KEY_DERIVE 0x00004019UL #define CKM_BLAKE2B_384_KEY_GEN 0x0000401AUL #define CKM_BLAKE2B_512 0x0000401BUL #define CKM_BLAKE2B_512_HMAC 0x0000401CUL #define CKM_BLAKE2B_512_HMAC_GENERAL 0x0000401DUL #define CKM_BLAKE2B_512_KEY_DERIVE 0x0000401EUL #define CKM_BLAKE2B_512_KEY_GEN 0x0000401FUL #define CKM_SALSA20 0x00004020UL #define CKM_CHACHA20_POLY1305 0x00004021UL #define CKM_SALSA20_POLY1305 0x00004022UL #define CKM_X3DH_INITIALIZE 0x00004023UL #define CKM_X3DH_RESPOND 0x00004024UL #define CKM_X2RATCHET_INITIALIZE 0x00004025UL #define CKM_X2RATCHET_RESPOND 0x00004026UL #define CKM_X2RATCHET_ENCRYPT 0x00004027UL #define CKM_X2RATCHET_DECRYPT 0x00004028UL #define CKM_XEDDSA 0x00004029UL #define CKM_HKDF_DERIVE 0x0000402AUL #define CKM_HKDF_DATA 0x0000402BUL #define CKM_HKDF_KEY_GEN 0x0000402CUL #define CKM_SALSA20_KEY_GEN 0x0000402DUL #define CKM_ECDSA_SHA3_224 0x00001047UL #define CKM_ECDSA_SHA3_256 0x00001048UL #define CKM_ECDSA_SHA3_384 0x00001049UL #define CKM_ECDSA_SHA3_512 0x0000104AUL #define CKM_EC_EDWARDS_KEY_PAIR_GEN 0x00001055UL #define CKM_EC_MONTGOMERY_KEY_PAIR_GEN 0x00001056UL #define CKM_EDDSA 0x00001057UL #define CKM_SP800_108_COUNTER_KDF 0x000003ACUL #define CKM_SP800_108_FEEDBACK_KDF 0x000003ADUL #define CKM_SP800_108_DOUBLE_PIPELINE_KDF 0x000003AEUL #define CKM_IKE2_PRF_PLUS_DERIVE 0x0000402EUL #define CKM_IKE_PRF_DERIVE 0x0000402FUL #define CKM_IKE1_PRF_DERIVE 0x00004030UL #define CKM_IKE1_EXTENDED_DERIVE 0x00004031UL #define CKM_HSS_KEY_PAIR_GEN 0x00004032UL #define CKM_HSS 0x00004033UL #define CKM_XMSS_KEY_PAIR_GEN 0x00004034UL #define CKM_XMSSMT_KEY_PAIR_GEN 0x00004035UL #define CKM_XMSS 0x00004036UL #define CKM_XMSSMT 0x00004037UL #define CKM_ECDH_X_AES_KEY_WRAP 0x00004038UL #define CKM_ECDH_COF_AES_KEY_WRAP 0x00004039UL #define CKM_PUB_KEY_FROM_PRIV_KEY 0x0000403AUL #define CKM_VENDOR_DEFINED 0x80000000UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKM_CAST5_KEY_GEN 0x00000320UL #define CKM_CAST5_ECB 0x00000321UL #define CKM_CAST5_CBC 0x00000322UL #define CKM_CAST5_MAC 0x00000323UL #define CKM_CAST5_MAC_GENERAL 0x00000324UL #define CKM_CAST5_CBC_PAD 0x00000325UL #define CKM_PBE_MD5_CAST5_CBC 0x000003A4UL #define CKM_PBE_SHA1_CAST5_CBC 0x000003A5UL #define CKM_ECDSA_KEY_PAIR_GEN 0x00001040UL #define CKM_DSA_PROBABLISTIC_PARAMETER_GEN 0x00002003UL #endif /* CKN */ #define CKN_SURRENDER 0UL #define CKN_OTP_CHANGED 1UL /* CKO */ #define CKO_DATA 0x00000000UL #define CKO_CERTIFICATE 0x00000001UL #define CKO_PUBLIC_KEY 0x00000002UL #define CKO_PRIVATE_KEY 0x00000003UL #define CKO_SECRET_KEY 0x00000004UL #define CKO_HW_FEATURE 0x00000005UL #define CKO_DOMAIN_PARAMETERS 0x00000006UL #define CKO_MECHANISM 0x00000007UL #define CKO_OTP_KEY 0x00000008UL #define CKO_PROFILE 0x00000009UL #define CKO_VALIDATION 0x0000000AUL #define CKO_TRUST 0x0000000BUL #define CKO_VENDOR_DEFINED 0x80000000UL /* CKP (profile) */ #define CKP_INVALID_ID 0x00000000UL #define CKP_BASELINE_PROVIDER 0x00000001UL #define CKP_EXTENDED_PROVIDER 0x00000002UL #define CKP_AUTHENTICATION_TOKEN 0x00000003UL #define CKP_PUBLIC_CERTIFICATES_TOKEN 0x00000004UL #define CKP_COMPLETE_PROVIDER 0x00000005UL #define CKP_HKDF_TLS_TOKEN 0x00000006UL #define CKP_VENDOR_DEFINED 0x80000000UL /* CKP (PBKD2) */ #define CKP_PKCS5_PBKD2_HMAC_SHA1 0x00000001UL #define CKP_PKCS5_PBKD2_HMAC_GOSTR3411 0x00000002UL #define CKP_PKCS5_PBKD2_HMAC_SHA224 0x00000003UL #define CKP_PKCS5_PBKD2_HMAC_SHA256 0x00000004UL #define CKP_PKCS5_PBKD2_HMAC_SHA384 0x00000005UL #define CKP_PKCS5_PBKD2_HMAC_SHA512 0x00000006UL #define CKP_PKCS5_PBKD2_HMAC_SHA512_224 0x00000007UL #define CKP_PKCS5_PBKD2_HMAC_SHA512_256 0x00000008UL /* CKP (ML-DSA) */ #define CKP_ML_DSA_44 0x00000001UL #define CKP_ML_DSA_65 0x00000002UL #define CKP_ML_DSA_87 0x00000003UL /* CKP (ML_KEM) */ #define CKP_ML_KEM_512 0x00000001UL #define CKP_ML_KEM_768 0x00000002UL #define CKP_ML_KEM_1024 0x00000003UL /* CKP (SLH-DSA) */ #define CKP_SLH_DSA_SHA2_128S 0x00000001UL #define CKP_SLH_DSA_SHAKE_128S 0x00000002UL #define CKP_SLH_DSA_SHA2_128F 0x00000003UL #define CKP_SLH_DSA_SHAKE_128F 0x00000004UL #define CKP_SLH_DSA_SHA2_192S 0x00000005UL #define CKP_SLH_DSA_SHAKE_192S 0x00000006UL #define CKP_SLH_DSA_SHA2_192F 0x00000007UL #define CKP_SLH_DSA_SHAKE_192F 0x00000008UL #define CKP_SLH_DSA_SHA2_256S 0x00000009UL #define CKP_SLH_DSA_SHAKE_256S 0x0000000AUL #define CKP_SLH_DSA_SHA2_256F 0x0000000BUL #define CKP_SLH_DSA_SHAKE_256F 0x0000000CUL /* CKR */ #define CKR_OK 0x00000000UL #define CKR_CANCEL 0x00000001UL #define CKR_HOST_MEMORY 0x00000002UL #define CKR_SLOT_ID_INVALID 0x00000003UL #define CKR_GENERAL_ERROR 0x00000005UL #define CKR_FUNCTION_FAILED 0x00000006UL #define CKR_ARGUMENTS_BAD 0x00000007UL #define CKR_NO_EVENT 0x00000008UL #define CKR_NEED_TO_CREATE_THREADS 0x00000009UL #define CKR_CANT_LOCK 0x0000000AUL #define CKR_ATTRIBUTE_READ_ONLY 0x00000010UL #define CKR_ATTRIBUTE_SENSITIVE 0x00000011UL #define CKR_ATTRIBUTE_TYPE_INVALID 0x00000012UL #define CKR_ATTRIBUTE_VALUE_INVALID 0x00000013UL #define CKR_ACTION_PROHIBITED 0x0000001BUL #define CKR_DATA_INVALID 0x00000020UL #define CKR_DATA_LEN_RANGE 0x00000021UL #define CKR_DEVICE_ERROR 0x00000030UL #define CKR_DEVICE_MEMORY 0x00000031UL #define CKR_DEVICE_REMOVED 0x00000032UL #define CKR_ENCRYPTED_DATA_INVALID 0x00000040UL #define CKR_ENCRYPTED_DATA_LEN_RANGE 0x00000041UL #define CKR_AEAD_DECRYPT_FAILED 0x00000042UL #define CKR_FUNCTION_CANCELED 0x00000050UL #define CKR_FUNCTION_NOT_PARALLEL 0x00000051UL #define CKR_FUNCTION_NOT_SUPPORTED 0x00000054UL #define CKR_KEY_HANDLE_INVALID 0x00000060UL #define CKR_KEY_SIZE_RANGE 0x00000062UL #define CKR_KEY_TYPE_INCONSISTENT 0x00000063UL #define CKR_KEY_NOT_NEEDED 0x00000064UL #define CKR_KEY_CHANGED 0x00000065UL #define CKR_KEY_NEEDED 0x00000066UL #define CKR_KEY_INDIGESTIBLE 0x00000067UL #define CKR_KEY_FUNCTION_NOT_PERMITTED 0x00000068UL #define CKR_KEY_NOT_WRAPPABLE 0x00000069UL #define CKR_KEY_UNEXTRACTABLE 0x0000006AUL #define CKR_MECHANISM_INVALID 0x00000070UL #define CKR_MECHANISM_PARAM_INVALID 0x00000071UL #define CKR_OBJECT_HANDLE_INVALID 0x00000082UL #define CKR_OPERATION_ACTIVE 0x00000090UL #define CKR_OPERATION_NOT_INITIALIZED 0x00000091UL #define CKR_PIN_INCORRECT 0x000000A0UL #define CKR_PIN_INVALID 0x000000A1UL #define CKR_PIN_LEN_RANGE 0x000000A2UL #define CKR_PIN_EXPIRED 0x000000A3UL #define CKR_PIN_LOCKED 0x000000A4UL #define CKR_SESSION_CLOSED 0x000000B0UL #define CKR_SESSION_COUNT 0x000000B1UL #define CKR_SESSION_HANDLE_INVALID 0x000000B3UL #define CKR_SESSION_PARALLEL_NOT_SUPPORTED 0x000000B4UL #define CKR_SESSION_READ_ONLY 0x000000B5UL #define CKR_SESSION_EXISTS 0x000000B6UL #define CKR_SESSION_READ_ONLY_EXISTS 0x000000B7UL #define CKR_SESSION_READ_WRITE_SO_EXISTS 0x000000B8UL #define CKR_SIGNATURE_INVALID 0x000000C0UL #define CKR_SIGNATURE_LEN_RANGE 0x000000C1UL #define CKR_TEMPLATE_INCOMPLETE 0x000000D0UL #define CKR_TEMPLATE_INCONSISTENT 0x000000D1UL #define CKR_TOKEN_NOT_PRESENT 0x000000E0UL #define CKR_TOKEN_NOT_RECOGNIZED 0x000000E1UL #define CKR_TOKEN_WRITE_PROTECTED 0x000000E2UL #define CKR_UNWRAPPING_KEY_HANDLE_INVALID 0x000000F0UL #define CKR_UNWRAPPING_KEY_SIZE_RANGE 0x000000F1UL #define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT 0x000000F2UL #define CKR_USER_ALREADY_LOGGED_IN 0x00000100UL #define CKR_USER_NOT_LOGGED_IN 0x00000101UL #define CKR_USER_PIN_NOT_INITIALIZED 0x00000102UL #define CKR_USER_TYPE_INVALID 0x00000103UL #define CKR_USER_ANOTHER_ALREADY_LOGGED_IN 0x00000104UL #define CKR_USER_TOO_MANY_TYPES 0x00000105UL #define CKR_WRAPPED_KEY_INVALID 0x00000110UL #define CKR_WRAPPED_KEY_LEN_RANGE 0x00000112UL #define CKR_WRAPPING_KEY_HANDLE_INVALID 0x00000113UL #define CKR_WRAPPING_KEY_SIZE_RANGE 0x00000114UL #define CKR_WRAPPING_KEY_TYPE_INCONSISTENT 0x00000115UL #define CKR_RANDOM_SEED_NOT_SUPPORTED 0x00000120UL #define CKR_RANDOM_NO_RNG 0x00000121UL #define CKR_DOMAIN_PARAMS_INVALID 0x00000130UL #define CKR_CURVE_NOT_SUPPORTED 0x00000140UL #define CKR_BUFFER_TOO_SMALL 0x00000150UL #define CKR_SAVED_STATE_INVALID 0x00000160UL #define CKR_INFORMATION_SENSITIVE 0x00000170UL #define CKR_STATE_UNSAVEABLE 0x00000180UL #define CKR_CRYPTOKI_NOT_INITIALIZED 0x00000190UL #define CKR_CRYPTOKI_ALREADY_INITIALIZED 0x00000191UL #define CKR_MUTEX_BAD 0x000001A0UL #define CKR_MUTEX_NOT_LOCKED 0x000001A1UL #define CKR_NEW_PIN_MODE 0x000001B0UL #define CKR_NEXT_OTP 0x000001B1UL #define CKR_EXCEEDED_MAX_ITERATIONS 0x000001B5UL #define CKR_FIPS_SELF_TEST_FAILED 0x000001B6UL #define CKR_LIBRARY_LOAD_FAILED 0x000001B7UL #define CKR_PIN_TOO_WEAK 0x000001B8UL #define CKR_PUBLIC_KEY_INVALID 0x000001B9UL #define CKR_FUNCTION_REJECTED 0x00000200UL #define CKR_TOKEN_RESOURCE_EXCEEDED 0x00000201UL #define CKR_OPERATION_CANCEL_FAILED 0x00000202UL #define CKR_KEY_EXHAUSTED 0x00000203UL #define CKR_PENDING 0x00000204UL #define CKR_SESSION_ASYNC_NOT_SUPPORTED 0x00000205UL #define CKR_SEED_RANDOM_REQUIRED 0x00000206UL #define CKR_OPERATION_NOT_VALIDATED 0x00000207UL #define CKR_TOKEN_NOT_INITIALIZED 0x00000208UL #define CKR_PARAMETER_SET_NOT_SUPPORTED 0x00000209UL #define CKR_VENDOR_DEFINED 0x80000000UL /* CKS */ #define CKS_RO_PUBLIC_SESSION 0UL #define CKS_RO_USER_FUNCTIONS 1UL #define CKS_RW_PUBLIC_SESSION 2UL #define CKS_RW_USER_FUNCTIONS 3UL #define CKS_RW_SO_FUNCTIONS 4UL /* CKS (validation) */ #define CKS_LAST_VALIDATION_OK 0x00000001UL /* CKT (trust) */ #define CKT_TRUST_UNKNOWN 0x00000000UL #define CKT_TRUSTED 0x00000001UL #define CKT_TRUST_ANCHOR 0x00000002UL #define CKT_NOT_TRUSTED 0x00000003UL #define CKT_TRUST_MUST_VERIFY_TRUST 0x00000004UL /* CKU */ #define CKU_SO 0UL #define CKU_USER 1UL #define CKU_CONTEXT_SPECIFIC 2UL /* CKV (validation authority) */ #define CKV_AUTHORITY_TYPE_UNSPECIFIED 0x00000000UL #define CKV_AUTHORITY_TYPE_NIST_CMVP 0x00000001UL #define CKV_AUTHORITY_TYPE_COMMON_CRITERIA 0x00000002UL /* CKV (validation type) */ #define CKV_TYPE_UNSPECIFIED 0x00000000UL #define CKV_TYPE_SOFTWARE 0x00000001UL #define CKV_TYPE_HARDWARE 0x00000002UL #define CKV_TYPE_FIRMWARE 0x00000003UL #define CKV_TYPE_HYBRID 0x00000004UL /* CKZ (data) */ #define CKZ_DATA_SPECIFIED 0x00000001UL /* CKZ (salt) */ #define CKZ_SALT_SPECIFIED 0x00000001UL /* Sundry structures type definition in alphabetical order */ #define STRUCTDEF(__name__) \ struct __name__; \ typedef struct __name__ __name__; \ typedef struct __name__ * __name__ ## _PTR; \ typedef struct __name__ ** __name__ ## _PTR_PTR; STRUCTDEF(CK_ATTRIBUTE); STRUCTDEF(CK_C_INITIALIZE_ARGS); STRUCTDEF(CK_DATE); STRUCTDEF(CK_DERIVED_KEY); STRUCTDEF(CK_FUNCTION_LIST); STRUCTDEF(CK_FUNCTION_LIST_3_0); STRUCTDEF(CK_FUNCTION_LIST_3_2); STRUCTDEF(CK_INFO); STRUCTDEF(CK_INTERFACE); STRUCTDEF(CK_MECHANISM); STRUCTDEF(CK_MECHANISM_INFO); STRUCTDEF(CK_SESSION_INFO); STRUCTDEF(CK_SLOT_INFO); STRUCTDEF(CK_TOKEN_INFO); STRUCTDEF(CK_VERSION); /* Function type definitions */ typedef CK_RV (* CK_NOTIFY)(CK_SESSION_HANDLE, CK_NOTIFICATION, void *); typedef CK_RV (* CK_CREATEMUTEX)(void **); typedef CK_RV (* CK_DESTROYMUTEX)(void *); typedef CK_RV (* CK_LOCKMUTEX)(void *); typedef CK_RV (* CK_UNLOCKMUTEX)(void *); #if defined(_WIN32) #pragma pack(push, cryptoki, 1) #endif /* General Structure definitions */ struct CK_ATTRIBUTE { CK_ATTRIBUTE_TYPE type; void * pValue; CK_ULONG ulValueLen; }; struct CK_C_INITIALIZE_ARGS { CK_CREATEMUTEX CreateMutex; CK_DESTROYMUTEX DestroyMutex; CK_LOCKMUTEX LockMutex; CK_UNLOCKMUTEX UnlockMutex; CK_FLAGS flags; void * pReserved; }; struct CK_DATE{ CK_CHAR year[4]; CK_CHAR month[2]; CK_CHAR day[2]; }; struct CK_DERIVED_KEY { CK_ATTRIBUTE * pTemplate; CK_ULONG ulAttributeCount; CK_OBJECT_HANDLE * phKey; }; struct CK_VERSION { CK_BYTE major; CK_BYTE minor; }; struct CK_INFO { struct CK_VERSION cryptokiVersion; CK_UTF8CHAR manufacturerID[32]; CK_FLAGS flags; CK_UTF8CHAR libraryDescription[32]; struct CK_VERSION libraryVersion; }; struct CK_INTERFACE { CK_UTF8CHAR * pInterfaceName; void * pFunctionList; CK_FLAGS flags; }; struct CK_MECHANISM { CK_MECHANISM_TYPE mechanism; void * pParameter; CK_ULONG ulParameterLen; }; struct CK_MECHANISM_INFO { CK_ULONG ulMinKeySize; CK_ULONG ulMaxKeySize; CK_FLAGS flags; }; struct CK_SESSION_INFO { CK_SLOT_ID slotID; CK_STATE state; CK_FLAGS flags; CK_ULONG ulDeviceError; }; struct CK_SLOT_INFO { CK_UTF8CHAR slotDescription[64]; CK_UTF8CHAR manufacturerID[32]; CK_FLAGS flags; CK_VERSION hardwareVersion; CK_VERSION firmwareVersion; }; struct CK_TOKEN_INFO { CK_UTF8CHAR label[32]; CK_UTF8CHAR manufacturerID[32]; CK_UTF8CHAR model[16]; CK_CHAR serialNumber[16]; CK_FLAGS flags; CK_ULONG ulMaxSessionCount; CK_ULONG ulSessionCount; CK_ULONG ulMaxRwSessionCount; CK_ULONG ulRwSessionCount; CK_ULONG ulMaxPinLen; CK_ULONG ulMinPinLen; CK_ULONG ulTotalPublicMemory; CK_ULONG ulFreePublicMemory; CK_ULONG ulTotalPrivateMemory; CK_ULONG ulFreePrivateMemory; CK_VERSION hardwareVersion; CK_VERSION firmwareVersion; CK_CHAR utcTime[16]; }; /* Param Structure definitions in alphabetical order */ STRUCTDEF(CK_AES_CBC_ENCRYPT_DATA_PARAMS); STRUCTDEF(CK_AES_CCM_PARAMS); STRUCTDEF(CK_AES_CTR_PARAMS); STRUCTDEF(CK_AES_GCM_PARAMS); STRUCTDEF(CK_ARIA_CBC_ENCRYPT_DATA_PARAMS); STRUCTDEF(CK_ASYNC_DATA); STRUCTDEF(CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS); STRUCTDEF(CK_CAMELLIA_CTR_PARAMS); STRUCTDEF(CK_CCM_MESSAGE_PARAMS); STRUCTDEF(CK_CCM_PARAMS); STRUCTDEF(CK_CCM_WRAP_PARAMS); STRUCTDEF(CK_CHACHA20_PARAMS); STRUCTDEF(CK_CMS_SIG_PARAMS); STRUCTDEF(CK_DES_CBC_ENCRYPT_DATA_PARAMS); STRUCTDEF(CK_DSA_PARAMETER_GEN_PARAM); STRUCTDEF(CK_ECDH_AES_KEY_WRAP_PARAMS); STRUCTDEF(CK_ECDH1_DERIVE_PARAMS); STRUCTDEF(CK_ECDH2_DERIVE_PARAMS); STRUCTDEF(CK_ECMQV_DERIVE_PARAMS); STRUCTDEF(CK_EDDSA_PARAMS); STRUCTDEF(CK_GCM_MESSAGE_PARAMS); STRUCTDEF(CK_GCM_PARAMS); STRUCTDEF(CK_GCM_WRAP_PARAMS); STRUCTDEF(CK_GOSTR3410_DERIVE_PARAMS); STRUCTDEF(CK_GOSTR3410_KEY_WRAP_PARAMS); STRUCTDEF(CK_HASH_SIGN_ADDITIONAL_CONTEXT); STRUCTDEF(CK_HKDF_PARAMS); STRUCTDEF(CK_IKE_PRF_DERIVE_PARAMS); STRUCTDEF(CK_IKE1_EXTENDED_DERIVE_PARAMS); STRUCTDEF(CK_IKE1_PRF_DERIVE_PARAMS); STRUCTDEF(CK_IKE2_PRF_PLUS_DERIVE_PARAMS); STRUCTDEF(CK_KEA_DERIVE_PARAMS); STRUCTDEF(CK_KEY_DERIVATION_STRING_DATA); STRUCTDEF(CK_KEY_WRAP_SET_OAEP_PARAMS); STRUCTDEF(CK_KIP_PARAMS); STRUCTDEF(CK_OTP_PARAM); STRUCTDEF(CK_OTP_PARAMS); STRUCTDEF(CK_OTP_SIGNATURE_INFO); STRUCTDEF(CK_PBE_PARAMS); STRUCTDEF(CK_PKCS5_PBKD2_PARAMS); STRUCTDEF(CK_PKCS5_PBKD2_PARAMS2); STRUCTDEF(CK_PRF_DATA_PARAM); STRUCTDEF(CK_RC2_CBC_PARAMS); STRUCTDEF(CK_RC2_MAC_GENERAL_PARAMS); STRUCTDEF(CK_RC5_CBC_PARAMS); STRUCTDEF(CK_RC5_MAC_GENERAL_PARAMS); STRUCTDEF(CK_RC5_PARAMS); STRUCTDEF(CK_RSA_AES_KEY_WRAP_PARAMS); STRUCTDEF(CK_RSA_PKCS_OAEP_PARAMS); STRUCTDEF(CK_RSA_PKCS_PSS_PARAMS); STRUCTDEF(CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS); STRUCTDEF(CK_SALSA20_CHACHA20_POLY1305_PARAMS); STRUCTDEF(CK_SALSA20_PARAMS); STRUCTDEF(CK_SEED_CBC_ENCRYPT_DATA_PARAMS); STRUCTDEF(CK_SIGN_ADDITIONAL_CONTEXT); STRUCTDEF(CK_SKIPJACK_PRIVATE_WRAP_PARAMS); STRUCTDEF(CK_SKIPJACK_RELAYX_PARAMS); STRUCTDEF(CK_SP800_108_COUNTER_FORMAT); STRUCTDEF(CK_SP800_108_DKM_LENGTH_FORMAT); STRUCTDEF(CK_SP800_108_FEEDBACK_KDF_PARAMS); STRUCTDEF(CK_SP800_108_KDF_PARAMS); STRUCTDEF(CK_TLS12_EXTENDED_MASTER_KEY_DERIVE_PARAMS); STRUCTDEF(CK_X2RATCHET_INITIALIZE_PARAMS); STRUCTDEF(CK_X2RATCHET_RESPOND_PARAMS); STRUCTDEF(CK_X3DH_INITIATE_PARAMS); STRUCTDEF(CK_X3DH_RESPOND_PARAMS); STRUCTDEF(CK_X9_42_DH1_DERIVE_PARAMS); STRUCTDEF(CK_X9_42_DH2_DERIVE_PARAMS); STRUCTDEF(CK_X9_42_MQV_DERIVE_PARAMS); STRUCTDEF(CK_XEDDSA_PARAMS); STRUCTDEF(specifiedParams); struct CK_AES_CBC_ENCRYPT_DATA_PARAMS { CK_BYTE iv[16]; CK_BYTE * pData; CK_ULONG length; }; struct CK_AES_CCM_PARAMS { CK_ULONG ulDataLen; CK_BYTE * pNonce; CK_ULONG ulNonceLen; CK_BYTE * pAAD; CK_ULONG ulAADLen; CK_ULONG ulMACLen; }; struct CK_AES_CTR_PARAMS { CK_ULONG ulCounterBits; CK_BYTE cb[16]; }; struct CK_AES_GCM_PARAMS { CK_BYTE * pIv; CK_ULONG ulIvLen; CK_ULONG ulIvBits; CK_BYTE * pAAD; CK_ULONG ulAADLen; CK_ULONG ulTagBits; }; struct CK_ARIA_CBC_ENCRYPT_DATA_PARAMS { CK_BYTE iv[16]; CK_BYTE * pData; CK_ULONG length; }; struct CK_ASYNC_DATA { CK_ULONG ulVersion; CK_BYTE * pValue; CK_ULONG ulValue; CK_OBJECT_HANDLE hObject; CK_OBJECT_HANDLE hAdditionalObject; }; struct CK_CAMELLIA_CBC_ENCRYPT_DATA_PARAMS { CK_BYTE iv[16]; CK_BYTE * pData; CK_ULONG length; }; struct CK_CAMELLIA_CTR_PARAMS { CK_ULONG ulCounterBits; CK_BYTE cb[16]; }; struct CK_CCM_MESSAGE_PARAMS { CK_ULONG ulDataLen; CK_BYTE * pNonce; CK_ULONG ulNonceLen; CK_ULONG ulNonceFixedBits; CK_GENERATOR_FUNCTION nonceGenerator; CK_BYTE * pMAC; CK_ULONG ulMACLen; }; struct CK_CCM_PARAMS { CK_ULONG ulDataLen; CK_BYTE * pNonce; CK_ULONG ulNonceLen; CK_BYTE * pAAD; CK_ULONG ulAADLen; CK_ULONG ulMACLen; }; struct CK_CCM_WRAP_PARAMS { CK_ULONG ulDataLen; CK_BYTE * pNonce; CK_ULONG ulNonceLen; CK_ULONG ulNonceFixedBits; CK_GENERATOR_FUNCTION nonceGenerator; CK_BYTE * pAAD; CK_ULONG ulAADLen; CK_ULONG ulMACLen; }; struct CK_CHACHA20_PARAMS { CK_BYTE * pBlockCounter; CK_ULONG blockCounterBits; CK_BYTE * pNonce; CK_ULONG ulNonceBits; }; struct CK_CMS_SIG_PARAMS { CK_OBJECT_HANDLE certificateHandle; CK_MECHANISM * pSigningMechanism; CK_MECHANISM * pDigestMechanism; CK_UTF8CHAR * pContentType; CK_BYTE * pRequestedAttributes; CK_ULONG ulRequestedAttributesLen; CK_BYTE * pRequiredAttributes; CK_ULONG ulRequiredAttributesLen; }; struct CK_DES_CBC_ENCRYPT_DATA_PARAMS { CK_BYTE iv[8]; CK_BYTE * pData; CK_ULONG length; }; struct CK_DSA_PARAMETER_GEN_PARAM { CK_MECHANISM_TYPE hash; CK_BYTE * pSeed; CK_ULONG ulSeedLen; CK_ULONG ulIndex; }; struct CK_ECDH_AES_KEY_WRAP_PARAMS { CK_ULONG ulAESKeyBits; CK_EC_KDF_TYPE kdf; CK_ULONG ulSharedDataLen; CK_BYTE * pSharedData; }; struct CK_ECDH1_DERIVE_PARAMS { CK_EC_KDF_TYPE kdf; CK_ULONG ulSharedDataLen; CK_BYTE * pSharedData; CK_ULONG ulPublicDataLen; CK_BYTE * pPublicData; }; struct CK_ECDH2_DERIVE_PARAMS { CK_EC_KDF_TYPE kdf; CK_ULONG ulSharedDataLen; CK_BYTE * pSharedData; CK_ULONG ulPublicDataLen; CK_BYTE * pPublicData; CK_ULONG ulPrivateDataLen; CK_OBJECT_HANDLE hPrivateData; CK_ULONG ulPublicDataLen2; CK_BYTE * pPublicData2; }; struct CK_ECMQV_DERIVE_PARAMS { CK_EC_KDF_TYPE kdf; CK_ULONG ulSharedDataLen; CK_BYTE * pSharedData; CK_ULONG ulPublicDataLen; CK_BYTE * pPublicData; CK_ULONG ulPrivateDataLen; CK_OBJECT_HANDLE hPrivateData; CK_ULONG ulPublicDataLen2; CK_BYTE * pPublicData2; CK_OBJECT_HANDLE publicKey; }; struct CK_EDDSA_PARAMS { CK_BBOOL phFlag; CK_ULONG ulContextDataLen; CK_BYTE * pContextData; }; struct CK_GCM_MESSAGE_PARAMS { CK_BYTE * pIv; CK_ULONG ulIvLen; CK_ULONG ulIvFixedBits; CK_GENERATOR_FUNCTION ivGenerator; CK_BYTE * pTag; CK_ULONG ulTagBits; }; struct CK_GCM_PARAMS { CK_BYTE * pIv; CK_ULONG ulIvLen; CK_ULONG ulIvBits; CK_BYTE * pAAD; CK_ULONG ulAADLen; CK_ULONG ulTagBits; }; struct CK_GCM_WRAP_PARAMS { CK_BYTE * pIv; CK_ULONG ulIvLen; CK_ULONG ulIvFixedBits; CK_GENERATOR_FUNCTION ivGenerator; CK_BYTE * pAAD; CK_ULONG ulAADLen; CK_ULONG ulTagBits; }; struct CK_GOSTR3410_DERIVE_PARAMS { CK_EC_KDF_TYPE kdf; CK_BYTE * pPublicData; CK_ULONG ulPublicDataLen; CK_BYTE * pUKM; CK_ULONG ulUKMLen; }; struct CK_GOSTR3410_KEY_WRAP_PARAMS { CK_BYTE * pWrapOID; CK_ULONG ulWrapOIDLen; CK_BYTE * pUKM; CK_ULONG ulUKMLen; CK_OBJECT_HANDLE hKey; }; struct CK_HASH_SIGN_ADDITIONAL_CONTEXT { CK_HEDGE_TYPE hedgeVariant; CK_BYTE * pContext; CK_ULONG ulContextLen; CK_MECHANISM_TYPE hash; }; struct CK_HKDF_PARAMS { CK_BBOOL bExtract; CK_BBOOL bExpand; CK_MECHANISM_TYPE prfHashMechanism; CK_ULONG ulSaltType; CK_BYTE * pSalt; CK_ULONG ulSaltLen; CK_OBJECT_HANDLE hSaltKey; CK_BYTE * pInfo; CK_ULONG ulInfoLen; }; struct CK_IKE_PRF_DERIVE_PARAMS { CK_MECHANISM_TYPE prfMechanism; CK_BBOOL bDataAsKey; CK_BBOOL bRekey; CK_BYTE * pNi; CK_ULONG ulNiLen; CK_BYTE * pNr; CK_ULONG ulNrLen; CK_OBJECT_HANDLE hNewKey; }; struct CK_IKE1_EXTENDED_DERIVE_PARAMS { CK_MECHANISM_TYPE prfMechanism; CK_BBOOL bHasKeygxy; CK_OBJECT_HANDLE hKeygxy; CK_BYTE * pExtraData; CK_ULONG ulExtraDataLen; }; struct CK_IKE1_PRF_DERIVE_PARAMS { CK_MECHANISM_TYPE prfMechanism; CK_BBOOL bHasPrevKey; CK_OBJECT_HANDLE hKeygxy; CK_OBJECT_HANDLE hPrevKey; CK_BYTE * pCKYi; CK_ULONG ulCKYiLen; CK_BYTE * pCKYr; CK_ULONG ulCKYrLen; CK_BYTE keyNumber; }; struct CK_IKE2_PRF_PLUS_DERIVE_PARAMS { CK_MECHANISM_TYPE prfMechanism; CK_BBOOL bHasSeedKey; CK_OBJECT_HANDLE hSeedKey; CK_BYTE * pSeedData; CK_ULONG ulSeedDataLen; }; struct CK_KEA_DERIVE_PARAMS { CK_BBOOL isSender; CK_ULONG ulRandomLen; CK_BYTE * RandomA; CK_BYTE * RandomB; CK_ULONG ulPublicDataLen; CK_BYTE * PublicData; }; struct CK_KEY_DERIVATION_STRING_DATA { CK_BYTE * pData; CK_ULONG ulLen; }; struct CK_KEY_WRAP_SET_OAEP_PARAMS { CK_BYTE bBC; CK_BYTE * pX; CK_ULONG ulXLen; }; struct CK_KIP_PARAMS { CK_MECHANISM * pMechanism; CK_OBJECT_HANDLE hKey; CK_BYTE * pSeed; CK_ULONG ulSeedLen; }; struct CK_OTP_PARAM { CK_OTP_PARAM_TYPE type; void * pValue; CK_ULONG ulValueLen; }; struct CK_OTP_PARAMS { CK_OTP_PARAM * pParams; CK_ULONG ulCount; }; struct CK_OTP_SIGNATURE_INFO { CK_OTP_PARAM * pParams; CK_ULONG ulCount; }; struct CK_PBE_PARAMS { CK_BYTE * pInitVector; CK_UTF8CHAR * pPassword; CK_ULONG ulPasswordLen; CK_BYTE * pSalt; CK_ULONG ulSaltLen; CK_ULONG ulIteration; }; struct CK_PKCS5_PBKD2_PARAMS { CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE saltSource; void * pSaltSourceData; CK_ULONG ulSaltSourceDataLen; CK_ULONG iterations; CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE prf; void * pPrfData; CK_ULONG ulPrfDataLen; CK_UTF8CHAR * pPassword; CK_ULONG * ulPasswordLen; }; struct CK_PKCS5_PBKD2_PARAMS2 { CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE saltSource; void * pSaltSourceData; CK_ULONG ulSaltSourceDataLen; CK_ULONG iterations; CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE prf; void * pPrfData; CK_ULONG ulPrfDataLen; CK_UTF8CHAR * pPassword; CK_ULONG ulPasswordLen; }; struct CK_PRF_DATA_PARAM { CK_PRF_DATA_TYPE type; void * pValue; CK_ULONG ulValueLen; }; struct CK_RC2_CBC_PARAMS { CK_ULONG ulEffectiveBits; CK_BYTE iv[8]; }; struct CK_RC2_MAC_GENERAL_PARAMS { CK_ULONG ulEffectiveBits; CK_ULONG ulMacLength; }; struct CK_RC5_CBC_PARAMS { CK_ULONG ulWordsize; CK_ULONG ulRounds; CK_BYTE * pIv; CK_ULONG ulIvLen; }; struct CK_RC5_MAC_GENERAL_PARAMS { CK_ULONG ulWordsize; CK_ULONG ulRounds; CK_ULONG ulMacLength; }; struct CK_RC5_PARAMS { CK_ULONG ulWordsize; CK_ULONG ulRounds; }; struct CK_RSA_AES_KEY_WRAP_PARAMS { CK_ULONG ulAESKeyBits; CK_RSA_PKCS_OAEP_PARAMS * pOAEPParams; }; struct CK_RSA_PKCS_OAEP_PARAMS { CK_MECHANISM_TYPE hashAlg; CK_RSA_PKCS_MGF_TYPE mgf; CK_RSA_PKCS_OAEP_SOURCE_TYPE source; void * pSourceData; CK_ULONG ulSourceDataLen; }; struct CK_RSA_PKCS_PSS_PARAMS { CK_MECHANISM_TYPE hashAlg; CK_RSA_PKCS_MGF_TYPE mgf; CK_ULONG sLen; }; struct CK_SALSA20_CHACHA20_POLY1305_MSG_PARAMS { CK_BYTE * pNonce; CK_ULONG ulNonceLen; CK_BYTE * pTag; }; struct CK_SALSA20_CHACHA20_POLY1305_PARAMS { CK_BYTE * pNonce; CK_ULONG ulNonceLen; CK_BYTE * pAAD; CK_ULONG ulAADLen; }; struct CK_SALSA20_PARAMS { CK_BYTE * pBlockCounter; CK_BYTE * pNonce; CK_ULONG ulNonceBits; }; struct CK_SEED_CBC_ENCRYPT_DATA_PARAMS { CK_BYTE iv[16]; CK_BYTE * pData; CK_ULONG length; }; struct CK_SIGN_ADDITIONAL_CONTEXT { CK_HEDGE_TYPE hedgeVariant; CK_BYTE * pContext; CK_ULONG ulContextLen; }; struct CK_SKIPJACK_PRIVATE_WRAP_PARAMS { CK_ULONG ulPasswordLen; CK_BYTE * pPassword; CK_ULONG ulPublicDataLen; CK_BYTE * pPublicData; CK_ULONG ulPAndGLen; CK_ULONG ulQLen; CK_ULONG ulRandomLen; CK_BYTE * pRandomA; CK_BYTE * pPrimeP; CK_BYTE * pBaseG; CK_BYTE * pSubprimeQ; }; struct CK_SKIPJACK_RELAYX_PARAMS { CK_ULONG ulOldWrappedXLen; CK_BYTE * pOldWrappedX; CK_ULONG ulOldPasswordLen; CK_BYTE * pOldPassword; CK_ULONG ulOldPublicDataLen; CK_BYTE * pOldPublicData; CK_ULONG ulOldRandomLen; CK_BYTE * pOldRandomA; CK_ULONG ulNewPasswordLen; CK_BYTE * pNewPassword; CK_ULONG ulNewPublicDataLen; CK_BYTE * pNewPublicData; CK_ULONG ulNewRandomLen; CK_BYTE * pNewRandomA; }; struct CK_SP800_108_COUNTER_FORMAT { CK_BBOOL bLittleEndian; CK_ULONG ulWidthInBits; }; struct CK_SP800_108_DKM_LENGTH_FORMAT { CK_SP800_108_DKM_LENGTH_METHOD dkmLengthMethod; CK_BBOOL bLittleEndian; CK_ULONG ulWidthInBits; }; typedef CK_MECHANISM_TYPE CK_SP800_108_PRF_TYPE; struct CK_SP800_108_FEEDBACK_KDF_PARAMS { CK_SP800_108_PRF_TYPE prfType; CK_ULONG ulNumberOfDataParams; CK_PRF_DATA_PARAM * pDataParams; CK_ULONG ulIVLen; CK_BYTE * pIV; CK_ULONG ulAdditionalDerivedKeys; CK_DERIVED_KEY * pAdditionalDerivedKeys; }; struct CK_TLS12_EXTENDED_MASTER_KEY_DERIVE_PARAMS { CK_MECHANISM_TYPE prfHashMechanism; CK_BYTE * pSessionHash; CK_ULONG ulSessionHashLen; CK_VERSION * pVersion; }; struct CK_SP800_108_KDF_PARAMS { CK_SP800_108_PRF_TYPE prfType; CK_ULONG ulNumberOfDataParams; CK_PRF_DATA_PARAM * pDataParams; CK_ULONG ulAdditionalDerivedKeys; CK_DERIVED_KEY * pAdditionalDerivedKeys; }; struct CK_X2RATCHET_INITIALIZE_PARAMS { CK_BYTE * sk; CK_OBJECT_HANDLE peer_public_prekey; CK_OBJECT_HANDLE peer_public_identity; CK_OBJECT_HANDLE own_public_identity; CK_BBOOL bEncryptedHeader; CK_ULONG eCurve; CK_MECHANISM_TYPE aeadMechanism; CK_X2RATCHET_KDF_TYPE kdfMechanism; }; struct CK_X2RATCHET_RESPOND_PARAMS { CK_BYTE * sk; CK_OBJECT_HANDLE own_prekey; CK_OBJECT_HANDLE initiator_identity; CK_OBJECT_HANDLE own_public_identity; CK_BBOOL bEncryptedHeader; CK_ULONG eCurve; CK_MECHANISM_TYPE aeadMechanism; CK_X2RATCHET_KDF_TYPE kdfMechanism; }; struct CK_X3DH_INITIATE_PARAMS { CK_X3DH_KDF_TYPE kdf; CK_OBJECT_HANDLE pPeer_identity; CK_OBJECT_HANDLE pPeer_prekey; CK_BYTE * pPrekey_signature; CK_BYTE * pOnetime_key; CK_OBJECT_HANDLE pOwn_identity; CK_OBJECT_HANDLE pOwn_ephemeral; }; struct CK_X3DH_RESPOND_PARAMS { CK_X3DH_KDF_TYPE kdf; CK_BYTE * pIdentity_id; CK_BYTE * pPrekey_id; CK_BYTE * pOnetime_id; CK_OBJECT_HANDLE pInitiator_identity; CK_BYTE * pInitiator_ephemeral; }; struct CK_X9_42_DH1_DERIVE_PARAMS { CK_X9_42_DH_KDF_TYPE kdf; CK_ULONG ulOtherInfoLen; CK_BYTE * pOtherInfo; CK_ULONG ulPublicDataLen; CK_BYTE * pPublicData; }; struct CK_X9_42_DH2_DERIVE_PARAMS { CK_X9_42_DH_KDF_TYPE kdf; CK_ULONG ulOtherInfoLen; CK_BYTE * pOtherInfo; CK_ULONG ulPublicDataLen; CK_BYTE * pPublicData; CK_ULONG ulPrivateDataLen; CK_OBJECT_HANDLE hPrivateData; CK_ULONG ulPublicDataLen2; CK_BYTE * pPublicData2; }; struct CK_X9_42_MQV_DERIVE_PARAMS { CK_X9_42_DH_KDF_TYPE kdf; CK_ULONG ulOtherInfoLen; CK_BYTE * OtherInfo; CK_ULONG ulPublicDataLen; CK_BYTE * PublicData; CK_ULONG ulPrivateDataLen; CK_OBJECT_HANDLE hPrivateData; CK_ULONG ulPublicDataLen2; CK_BYTE * PublicData2; CK_OBJECT_HANDLE publicKey; }; struct CK_XEDDSA_PARAMS { CK_XEDDSA_HASH_TYPE hash; }; /* TLS related structure definitions */ STRUCTDEF(CK_SSL3_KEY_MAT_OUT); STRUCTDEF(CK_SSL3_KEY_MAT_PARAMS); STRUCTDEF(CK_SSL3_MASTER_KEY_DERIVE_PARAMS); STRUCTDEF(CK_SSL3_RANDOM_DATA); STRUCTDEF(CK_TLS_KDF_PARAMS); STRUCTDEF(CK_TLS_MAC_PARAMS); STRUCTDEF(CK_TLS_PRF_PARAMS); STRUCTDEF(CK_TLS12_KEY_MAT_PARAMS); STRUCTDEF(CK_TLS12_MASTER_KEY_DERIVE_PARAMS); STRUCTDEF(CK_WTLS_KEY_MAT_OUT); STRUCTDEF(CK_WTLS_KEY_MAT_PARAMS); STRUCTDEF(CK_WTLS_MASTER_KEY_DERIVE_PARAMS); STRUCTDEF(CK_WTLS_PRF_PARAMS); STRUCTDEF(CK_WTLS_RANDOM_DATA); struct CK_SSL3_KEY_MAT_OUT { CK_OBJECT_HANDLE hClientMacSecret; CK_OBJECT_HANDLE hServerMacSecret; CK_OBJECT_HANDLE hClientKey; CK_OBJECT_HANDLE hServerKey; CK_BYTE * pIVClient; CK_BYTE * pIVServer; }; struct CK_SSL3_RANDOM_DATA { CK_BYTE * pClientRandom; CK_ULONG ulClientRandomLen; CK_BYTE * pServerRandom; CK_ULONG ulServerRandomLen; }; struct CK_SSL3_KEY_MAT_PARAMS { CK_ULONG ulMacSizeInBits; CK_ULONG ulKeySizeInBits; CK_ULONG ulIVSizeInBits; CK_BBOOL bIsExport; CK_SSL3_RANDOM_DATA RandomInfo; CK_SSL3_KEY_MAT_OUT * pReturnedKeyMaterial; }; struct CK_SSL3_MASTER_KEY_DERIVE_PARAMS { CK_SSL3_RANDOM_DATA RandomInfo; CK_VERSION * pVersion; }; struct CK_TLS_KDF_PARAMS { CK_MECHANISM_TYPE prfMechanism; CK_BYTE * pLabel; CK_ULONG ulLabelLength; CK_SSL3_RANDOM_DATA RandomInfo; CK_BYTE * pContextData; CK_ULONG ulContextDataLength; }; struct CK_TLS_MAC_PARAMS { CK_MECHANISM_TYPE prfHashMechanism; CK_ULONG ulMacLength; CK_ULONG ulServerOrClient; }; struct CK_TLS_PRF_PARAMS { CK_BYTE * pSeed; CK_ULONG ulSeedLen; CK_BYTE * pLabel; CK_ULONG ulLabelLen; CK_BYTE * pOutput; CK_ULONG * pulOutputLen; }; struct CK_TLS12_KEY_MAT_PARAMS { CK_ULONG ulMacSizeInBits; CK_ULONG ulKeySizeInBits; CK_ULONG ulIVSizeInBits; CK_BBOOL bIsExport; CK_SSL3_RANDOM_DATA RandomInfo; CK_SSL3_KEY_MAT_OUT * pReturnedKeyMaterial; CK_MECHANISM_TYPE prfHashMechanism; }; struct CK_TLS12_MASTER_KEY_DERIVE_PARAMS { CK_SSL3_RANDOM_DATA RandomInfo; CK_VERSION * pVersion; CK_MECHANISM_TYPE prfHashMechanism; }; struct CK_WTLS_KEY_MAT_OUT { CK_OBJECT_HANDLE hMacSecret; CK_OBJECT_HANDLE hKey; CK_BYTE * pIV; }; struct CK_WTLS_RANDOM_DATA { CK_BYTE * pClientRandom; CK_ULONG ulClientRandomLen; CK_BYTE * pServerRandom; CK_ULONG ulServerRandomLen; }; struct CK_WTLS_KEY_MAT_PARAMS { CK_MECHANISM_TYPE DigestMechanism; CK_ULONG ulMacSizeInBits; CK_ULONG ulKeySizeInBits; CK_ULONG ulIVSizeInBits; CK_ULONG ulSequenceNumber; CK_BBOOL bIsExport; CK_WTLS_RANDOM_DATA RandomInfo; CK_WTLS_KEY_MAT_OUT * pReturnedKeyMaterial; }; struct CK_WTLS_MASTER_KEY_DERIVE_PARAMS { CK_MECHANISM_TYPE DigestMechanism; CK_WTLS_RANDOM_DATA RandomInfo; CK_BYTE * pVersion; }; struct CK_WTLS_PRF_PARAMS { CK_MECHANISM_TYPE DigestMechanism; CK_BYTE * pSeed; CK_ULONG ulSeedLen; CK_BYTE * pLabel; CK_ULONG ulLabelLen; CK_BYTE * pOutput; CK_ULONG * pulOutputLen; }; /* PKCS11 Functions */ extern CK_RV C_Initialize(void *); extern CK_RV C_Finalize(void *); extern CK_RV C_GetInfo(CK_INFO *); extern CK_RV C_GetFunctionList(CK_FUNCTION_LIST **); extern CK_RV C_GetSlotList(CK_BBOOL, CK_SLOT_ID *, CK_ULONG *); extern CK_RV C_GetSlotInfo(CK_SLOT_ID, CK_SLOT_INFO *); extern CK_RV C_GetTokenInfo(CK_SLOT_ID, CK_TOKEN_INFO *); extern CK_RV C_GetMechanismList(CK_SLOT_ID, CK_MECHANISM_TYPE *, CK_ULONG *); extern CK_RV C_GetMechanismInfo(CK_SLOT_ID, CK_MECHANISM_TYPE, CK_MECHANISM_INFO *); extern CK_RV C_InitToken(CK_SLOT_ID, CK_UTF8CHAR *, CK_ULONG, CK_UTF8CHAR *); extern CK_RV C_InitPIN(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG); extern CK_RV C_SetPIN(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG, CK_UTF8CHAR *, CK_ULONG); extern CK_RV C_OpenSession(CK_SLOT_ID, CK_FLAGS, void *, CK_NOTIFY, CK_SESSION_HANDLE *); extern CK_RV C_CloseSession(CK_SESSION_HANDLE); extern CK_RV C_CloseAllSessions(CK_SLOT_ID); extern CK_RV C_GetSessionInfo(CK_SESSION_HANDLE, CK_SESSION_INFO *); extern CK_RV C_GetOperationState(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); extern CK_RV C_SetOperationState(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_OBJECT_HANDLE, CK_OBJECT_HANDLE); extern CK_RV C_Login(CK_SESSION_HANDLE, CK_USER_TYPE, CK_UTF8CHAR *, CK_ULONG); extern CK_RV C_Logout(CK_SESSION_HANDLE); extern CK_RV C_CreateObject(CK_SESSION_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); extern CK_RV C_CopyObject(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); extern CK_RV C_DestroyObject(CK_SESSION_HANDLE, CK_OBJECT_HANDLE); extern CK_RV C_GetObjectSize(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ULONG *); extern CK_RV C_GetAttributeValue(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG); extern CK_RV C_SetAttributeValue(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG); extern CK_RV C_FindObjectsInit(CK_SESSION_HANDLE, CK_ATTRIBUTE *, CK_ULONG); extern CK_RV C_FindObjects(CK_SESSION_HANDLE, CK_OBJECT_HANDLE *, CK_ULONG, CK_ULONG *); extern CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE); extern CK_RV C_EncryptInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_Encrypt(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_EncryptUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_EncryptFinal(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); extern CK_RV C_DecryptInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_Decrypt(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_DecryptUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_DecryptFinal(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); extern CK_RV C_DigestInit(CK_SESSION_HANDLE, CK_MECHANISM *); extern CK_RV C_Digest(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_DigestUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_DigestKey(CK_SESSION_HANDLE, CK_OBJECT_HANDLE); extern CK_RV C_DigestFinal(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); extern CK_RV C_SignInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_Sign(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_SignUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_SignFinal(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); extern CK_RV C_SignRecoverInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_SignRecover(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_VerifyInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_Verify(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG); extern CK_RV C_VerifyUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_VerifyFinal(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_VerifyRecover(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_GenerateKey(CK_SESSION_HANDLE, CK_MECHANISM *, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); extern CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE, CK_MECHANISM *, CK_ATTRIBUTE *, CK_ULONG, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *, CK_OBJECT_HANDLE *); extern CK_RV C_WrapKey(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG *); extern CK_RV C_UnwrapKey(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); extern CK_RV C_DeriveKey(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); extern CK_RV C_SeedRandom(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_GenerateRandom(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE); extern CK_RV C_CancelFunction(CK_SESSION_HANDLE); extern CK_RV C_WaitForSlotEvent(CK_FLAGS, CK_SLOT_ID *, void *); extern CK_RV C_GetInterfaceList(CK_INTERFACE *, CK_ULONG *); extern CK_RV C_GetInterface(CK_UTF8CHAR *, CK_VERSION *, CK_INTERFACE **, CK_FLAGS); extern CK_RV C_LoginUser(CK_SESSION_HANDLE, CK_USER_TYPE, CK_UTF8CHAR *, CK_ULONG, CK_UTF8CHAR *, CK_ULONG); extern CK_RV C_SessionCancel(CK_SESSION_HANDLE, CK_FLAGS); extern CK_RV C_MessageEncryptInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_EncryptMessage(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_EncryptMessageBegin(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG); extern CK_RV C_EncryptMessageNext(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *, CK_FLAGS); extern CK_RV C_MessageEncryptFinal(CK_SESSION_HANDLE); extern CK_RV C_MessageDecryptInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_DecryptMessage(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_DecryptMessageBegin(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG); extern CK_RV C_DecryptMessageNext(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *, CK_FLAGS); extern CK_RV C_MessageDecryptFinal(CK_SESSION_HANDLE); extern CK_RV C_MessageSignInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_SignMessage(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_SignMessageBegin(CK_SESSION_HANDLE, void *, CK_ULONG); extern CK_RV C_SignMessageNext(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_MessageSignFinal(CK_SESSION_HANDLE); extern CK_RV C_MessageVerifyInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); extern CK_RV C_VerifyMessage(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG); extern CK_RV C_VerifyMessageBegin(CK_SESSION_HANDLE, void *, CK_ULONG); extern CK_RV C_VerifyMessageNext(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG); extern CK_RV C_MessageVerifyFinal(CK_SESSION_HANDLE); extern CK_RV C_EncapsulateKey(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_BYTE *, CK_ULONG *, CK_OBJECT_HANDLE *); extern CK_RV C_DecapsulateKey(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_OBJECT_HANDLE *); extern CK_RV C_VerifySignatureInit(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_VerifySignature(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_VerifySignatureUpdate(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); extern CK_RV C_VerifySignatureFinal(CK_SESSION_HANDLE); extern CK_RV C_GetSessionValidationFlags(CK_SESSION_HANDLE, CK_SESSION_VALIDATION_FLAGS_TYPE, CK_FLAGS *); extern CK_RV C_AsyncComplete(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ASYNC_DATA *); extern CK_RV C_AsyncGetID(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG *); extern CK_RV C_AsyncJoin(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG, CK_BYTE *, CK_ULONG); extern CK_RV C_WrapKeyAuthenticated(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); extern CK_RV C_UnwrapKeyAuthenticated(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG, CK_ATTRIBUTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_Initialize)(void *); typedef CK_RV (* CK_C_Finalize)(void *); typedef CK_RV (* CK_C_GetInfo)(CK_INFO *); typedef CK_RV (* CK_C_GetFunctionList)(CK_FUNCTION_LIST **); typedef CK_RV (* CK_C_GetSlotList)(CK_BBOOL, CK_SLOT_ID *, CK_ULONG *); typedef CK_RV (* CK_C_GetSlotInfo)(CK_SLOT_ID, CK_SLOT_INFO *); typedef CK_RV (* CK_C_GetTokenInfo)(CK_SLOT_ID, CK_TOKEN_INFO *); typedef CK_RV (* CK_C_GetMechanismList)(CK_SLOT_ID, CK_MECHANISM_TYPE *, CK_ULONG *); typedef CK_RV (* CK_C_GetMechanismInfo)(CK_SLOT_ID, CK_MECHANISM_TYPE, CK_MECHANISM_INFO *); typedef CK_RV (* CK_C_InitToken)(CK_SLOT_ID, CK_UTF8CHAR *, CK_ULONG, CK_UTF8CHAR *); typedef CK_RV (* CK_C_InitPIN)(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG); typedef CK_RV (* CK_C_SetPIN)(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG, CK_UTF8CHAR *, CK_ULONG); typedef CK_RV (* CK_C_OpenSession)(CK_SLOT_ID, CK_FLAGS, void *, CK_NOTIFY, CK_SESSION_HANDLE *); typedef CK_RV (* CK_C_CloseSession)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_CloseAllSessions)(CK_SLOT_ID); typedef CK_RV (* CK_C_GetSessionInfo)(CK_SESSION_HANDLE, CK_SESSION_INFO *); typedef CK_RV (* CK_C_GetOperationState)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_SetOperationState)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_OBJECT_HANDLE, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_Login)(CK_SESSION_HANDLE, CK_USER_TYPE, CK_UTF8CHAR *, CK_ULONG); typedef CK_RV (* CK_C_Logout)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_CreateObject)(CK_SESSION_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_CopyObject)(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_DestroyObject)(CK_SESSION_HANDLE, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_GetObjectSize)(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ULONG *); typedef CK_RV (* CK_C_GetAttributeValue)(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG); typedef CK_RV (* CK_C_SetAttributeValue)(CK_SESSION_HANDLE, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG); typedef CK_RV (* CK_C_FindObjectsInit)(CK_SESSION_HANDLE, CK_ATTRIBUTE *, CK_ULONG); typedef CK_RV (* CK_C_FindObjects)(CK_SESSION_HANDLE, CK_OBJECT_HANDLE *, CK_ULONG, CK_ULONG *); typedef CK_RV (* CK_C_FindObjectsFinal)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_EncryptInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_Encrypt)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_EncryptUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_EncryptFinal)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DecryptInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_Decrypt)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DecryptUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DecryptFinal)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DigestInit)(CK_SESSION_HANDLE, CK_MECHANISM *); typedef CK_RV (* CK_C_Digest)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DigestUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_DigestKey)(CK_SESSION_HANDLE, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_DigestFinal)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_SignInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_Sign)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_SignUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_SignFinal)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_SignRecoverInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_SignRecover)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_VerifyInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_Verify)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_VerifyUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_VerifyFinal)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_VerifyRecoverInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_VerifyRecover)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DigestEncryptUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DecryptDigestUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_SignEncryptUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DecryptVerifyUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_GenerateKey)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_GenerateKeyPair)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_ATTRIBUTE *, CK_ULONG, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_WrapKey)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_UnwrapKey)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_DeriveKey)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_SeedRandom)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_GenerateRandom)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_GetFunctionStatus)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_CancelFunction)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_WaitForSlotEvent)(CK_FLAGS, CK_SLOT_ID *, void *); typedef CK_RV (* CK_C_GetInterfaceList)(CK_INTERFACE *, CK_ULONG *); typedef CK_RV (* CK_C_GetInterface)(CK_UTF8CHAR *, CK_VERSION *, CK_INTERFACE **, CK_FLAGS); typedef CK_RV (* CK_C_LoginUser)(CK_SESSION_HANDLE, CK_USER_TYPE, CK_UTF8CHAR *, CK_ULONG, CK_UTF8CHAR *, CK_ULONG); typedef CK_RV (* CK_C_SessionCancel)(CK_SESSION_HANDLE, CK_FLAGS); typedef CK_RV (* CK_C_MessageEncryptInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_EncryptMessage)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_EncryptMessageBegin)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_EncryptMessageNext)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *, CK_FLAGS); typedef CK_RV (* CK_C_MessageEncryptFinal)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_MessageDecryptInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_DecryptMessage)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_DecryptMessageBegin)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_DecryptMessageNext)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *, CK_FLAGS); typedef CK_RV (* CK_C_MessageDecryptFinal)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_MessageSignInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_SignMessage)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_SignMessageBegin)(CK_SESSION_HANDLE, void *, CK_ULONG); typedef CK_RV (* CK_C_SignMessageNext)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_MessageSignFinal)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_MessageVerifyInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE); typedef CK_RV (* CK_C_VerifyMessage)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_VerifyMessageBegin)(CK_SESSION_HANDLE, void *, CK_ULONG); typedef CK_RV (* CK_C_VerifyMessageNext)(CK_SESSION_HANDLE, void *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_MessageVerifyFinal)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_EncapsulateKey)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_BYTE *, CK_ULONG *, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_DecapsulateKey)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_ATTRIBUTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_OBJECT_HANDLE *); typedef CK_RV (* CK_C_VerifySignatureInit)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_VerifySignature)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_VerifySignatureUpdate)(CK_SESSION_HANDLE, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_VerifySignatureFinal)(CK_SESSION_HANDLE); typedef CK_RV (* CK_C_GetSessionValidationFlags)(CK_SESSION_HANDLE, CK_SESSION_VALIDATION_FLAGS_TYPE, CK_FLAGS *); typedef CK_RV (* CK_C_AsyncComplete)(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ASYNC_DATA *); typedef CK_RV (* CK_C_AsyncGetID)(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG *); typedef CK_RV (* CK_C_AsyncJoin)(CK_SESSION_HANDLE, CK_UTF8CHAR *, CK_ULONG, CK_BYTE *, CK_ULONG); typedef CK_RV (* CK_C_WrapKeyAuthenticated)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG, CK_BYTE *, CK_ULONG *); typedef CK_RV (* CK_C_UnwrapKeyAuthenticated)(CK_SESSION_HANDLE, CK_MECHANISM *, CK_OBJECT_HANDLE, CK_BYTE *, CK_ULONG, CK_ATTRIBUTE *, CK_ULONG, CK_BYTE *, CK_ULONG, CK_OBJECT_HANDLE *); struct CK_FUNCTION_LIST_3_2 { CK_VERSION version; CK_C_Initialize C_Initialize; CK_C_Finalize C_Finalize; CK_C_GetInfo C_GetInfo; CK_C_GetFunctionList C_GetFunctionList; CK_C_GetSlotList C_GetSlotList; CK_C_GetSlotInfo C_GetSlotInfo; CK_C_GetTokenInfo C_GetTokenInfo; CK_C_GetMechanismList C_GetMechanismList; CK_C_GetMechanismInfo C_GetMechanismInfo; CK_C_InitToken C_InitToken; CK_C_InitPIN C_InitPIN; CK_C_SetPIN C_SetPIN; CK_C_OpenSession C_OpenSession; CK_C_CloseSession C_CloseSession; CK_C_CloseAllSessions C_CloseAllSessions; CK_C_GetSessionInfo C_GetSessionInfo; CK_C_GetOperationState C_GetOperationState; CK_C_SetOperationState C_SetOperationState; CK_C_Login C_Login; CK_C_Logout C_Logout; CK_C_CreateObject C_CreateObject; CK_C_CopyObject C_CopyObject; CK_C_DestroyObject C_DestroyObject; CK_C_GetObjectSize C_GetObjectSize; CK_C_GetAttributeValue C_GetAttributeValue; CK_C_SetAttributeValue C_SetAttributeValue; CK_C_FindObjectsInit C_FindObjectsInit; CK_C_FindObjects C_FindObjects; CK_C_FindObjectsFinal C_FindObjectsFinal; CK_C_EncryptInit C_EncryptInit; CK_C_Encrypt C_Encrypt; CK_C_EncryptUpdate C_EncryptUpdate; CK_C_EncryptFinal C_EncryptFinal; CK_C_DecryptInit C_DecryptInit; CK_C_Decrypt C_Decrypt; CK_C_DecryptUpdate C_DecryptUpdate; CK_C_DecryptFinal C_DecryptFinal; CK_C_DigestInit C_DigestInit; CK_C_Digest C_Digest; CK_C_DigestUpdate C_DigestUpdate; CK_C_DigestKey C_DigestKey; CK_C_DigestFinal C_DigestFinal; CK_C_SignInit C_SignInit; CK_C_Sign C_Sign; CK_C_SignUpdate C_SignUpdate; CK_C_SignFinal C_SignFinal; CK_C_SignRecoverInit C_SignRecoverInit; CK_C_SignRecover C_SignRecover; CK_C_VerifyInit C_VerifyInit; CK_C_Verify C_Verify; CK_C_VerifyUpdate C_VerifyUpdate; CK_C_VerifyFinal C_VerifyFinal; CK_C_VerifyRecoverInit C_VerifyRecoverInit; CK_C_VerifyRecover C_VerifyRecover; CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; CK_C_SignEncryptUpdate C_SignEncryptUpdate; CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; CK_C_GenerateKey C_GenerateKey; CK_C_GenerateKeyPair C_GenerateKeyPair; CK_C_WrapKey C_WrapKey; CK_C_UnwrapKey C_UnwrapKey; CK_C_DeriveKey C_DeriveKey; CK_C_SeedRandom C_SeedRandom; CK_C_GenerateRandom C_GenerateRandom; CK_C_GetFunctionStatus C_GetFunctionStatus; CK_C_CancelFunction C_CancelFunction; CK_C_WaitForSlotEvent C_WaitForSlotEvent; CK_C_GetInterfaceList C_GetInterfaceList; CK_C_GetInterface C_GetInterface; CK_C_LoginUser C_LoginUser; CK_C_SessionCancel C_SessionCancel; CK_C_MessageEncryptInit C_MessageEncryptInit; CK_C_EncryptMessage C_EncryptMessage; CK_C_EncryptMessageBegin C_EncryptMessageBegin; CK_C_EncryptMessageNext C_EncryptMessageNext; CK_C_MessageEncryptFinal C_MessageEncryptFinal; CK_C_MessageDecryptInit C_MessageDecryptInit; CK_C_DecryptMessage C_DecryptMessage; CK_C_DecryptMessageBegin C_DecryptMessageBegin; CK_C_DecryptMessageNext C_DecryptMessageNext; CK_C_MessageDecryptFinal C_MessageDecryptFinal; CK_C_MessageSignInit C_MessageSignInit; CK_C_SignMessage C_SignMessage; CK_C_SignMessageBegin C_SignMessageBegin; CK_C_SignMessageNext C_SignMessageNext; CK_C_MessageSignFinal C_MessageSignFinal; CK_C_MessageVerifyInit C_MessageVerifyInit; CK_C_VerifyMessage C_VerifyMessage; CK_C_VerifyMessageBegin C_VerifyMessageBegin; CK_C_VerifyMessageNext C_VerifyMessageNext; CK_C_MessageVerifyFinal C_MessageVerifyFinal; CK_C_EncapsulateKey C_EncapsulateKey; CK_C_DecapsulateKey C_DecapsulateKey; CK_C_VerifySignatureInit C_VerifySignatureInit; CK_C_VerifySignature C_VerifySignature; CK_C_VerifySignatureUpdate C_VerifySignatureUpdate; CK_C_VerifySignatureFinal C_VerifySignatureFinal; CK_C_GetSessionValidationFlags C_GetSessionValidationFlags; CK_C_AsyncComplete C_AsyncComplete; CK_C_AsyncGetID C_AsyncGetID; CK_C_AsyncJoin C_AsyncJoin; CK_C_WrapKeyAuthenticated C_WrapKeyAuthenticated ; CK_C_UnwrapKeyAuthenticated C_UnwrapKeyAuthenticated ; }; struct CK_FUNCTION_LIST_3_0 { CK_VERSION version; CK_C_Initialize C_Initialize; CK_C_Finalize C_Finalize; CK_C_GetInfo C_GetInfo; CK_C_GetFunctionList C_GetFunctionList; CK_C_GetSlotList C_GetSlotList; CK_C_GetSlotInfo C_GetSlotInfo; CK_C_GetTokenInfo C_GetTokenInfo; CK_C_GetMechanismList C_GetMechanismList; CK_C_GetMechanismInfo C_GetMechanismInfo; CK_C_InitToken C_InitToken; CK_C_InitPIN C_InitPIN; CK_C_SetPIN C_SetPIN; CK_C_OpenSession C_OpenSession; CK_C_CloseSession C_CloseSession; CK_C_CloseAllSessions C_CloseAllSessions; CK_C_GetSessionInfo C_GetSessionInfo; CK_C_GetOperationState C_GetOperationState; CK_C_SetOperationState C_SetOperationState; CK_C_Login C_Login; CK_C_Logout C_Logout; CK_C_CreateObject C_CreateObject; CK_C_CopyObject C_CopyObject; CK_C_DestroyObject C_DestroyObject; CK_C_GetObjectSize C_GetObjectSize; CK_C_GetAttributeValue C_GetAttributeValue; CK_C_SetAttributeValue C_SetAttributeValue; CK_C_FindObjectsInit C_FindObjectsInit; CK_C_FindObjects C_FindObjects; CK_C_FindObjectsFinal C_FindObjectsFinal; CK_C_EncryptInit C_EncryptInit; CK_C_Encrypt C_Encrypt; CK_C_EncryptUpdate C_EncryptUpdate; CK_C_EncryptFinal C_EncryptFinal; CK_C_DecryptInit C_DecryptInit; CK_C_Decrypt C_Decrypt; CK_C_DecryptUpdate C_DecryptUpdate; CK_C_DecryptFinal C_DecryptFinal; CK_C_DigestInit C_DigestInit; CK_C_Digest C_Digest; CK_C_DigestUpdate C_DigestUpdate; CK_C_DigestKey C_DigestKey; CK_C_DigestFinal C_DigestFinal; CK_C_SignInit C_SignInit; CK_C_Sign C_Sign; CK_C_SignUpdate C_SignUpdate; CK_C_SignFinal C_SignFinal; CK_C_SignRecoverInit C_SignRecoverInit; CK_C_SignRecover C_SignRecover; CK_C_VerifyInit C_VerifyInit; CK_C_Verify C_Verify; CK_C_VerifyUpdate C_VerifyUpdate; CK_C_VerifyFinal C_VerifyFinal; CK_C_VerifyRecoverInit C_VerifyRecoverInit; CK_C_VerifyRecover C_VerifyRecover; CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; CK_C_SignEncryptUpdate C_SignEncryptUpdate; CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; CK_C_GenerateKey C_GenerateKey; CK_C_GenerateKeyPair C_GenerateKeyPair; CK_C_WrapKey C_WrapKey; CK_C_UnwrapKey C_UnwrapKey; CK_C_DeriveKey C_DeriveKey; CK_C_SeedRandom C_SeedRandom; CK_C_GenerateRandom C_GenerateRandom; CK_C_GetFunctionStatus C_GetFunctionStatus; CK_C_CancelFunction C_CancelFunction; CK_C_WaitForSlotEvent C_WaitForSlotEvent; CK_C_GetInterfaceList C_GetInterfaceList; CK_C_GetInterface C_GetInterface; CK_C_LoginUser C_LoginUser; CK_C_SessionCancel C_SessionCancel; CK_C_MessageEncryptInit C_MessageEncryptInit; CK_C_EncryptMessage C_EncryptMessage; CK_C_EncryptMessageBegin C_EncryptMessageBegin; CK_C_EncryptMessageNext C_EncryptMessageNext; CK_C_MessageEncryptFinal C_MessageEncryptFinal; CK_C_MessageDecryptInit C_MessageDecryptInit; CK_C_DecryptMessage C_DecryptMessage; CK_C_DecryptMessageBegin C_DecryptMessageBegin; CK_C_DecryptMessageNext C_DecryptMessageNext; CK_C_MessageDecryptFinal C_MessageDecryptFinal; CK_C_MessageSignInit C_MessageSignInit; CK_C_SignMessage C_SignMessage; CK_C_SignMessageBegin C_SignMessageBegin; CK_C_SignMessageNext C_SignMessageNext; CK_C_MessageSignFinal C_MessageSignFinal; CK_C_MessageVerifyInit C_MessageVerifyInit; CK_C_VerifyMessage C_VerifyMessage; CK_C_VerifyMessageBegin C_VerifyMessageBegin; CK_C_VerifyMessageNext C_VerifyMessageNext; CK_C_MessageVerifyFinal C_MessageVerifyFinal; }; struct CK_FUNCTION_LIST { CK_VERSION version; CK_C_Initialize C_Initialize; CK_C_Finalize C_Finalize; CK_C_GetInfo C_GetInfo; CK_C_GetFunctionList C_GetFunctionList; CK_C_GetSlotList C_GetSlotList; CK_C_GetSlotInfo C_GetSlotInfo; CK_C_GetTokenInfo C_GetTokenInfo; CK_C_GetMechanismList C_GetMechanismList; CK_C_GetMechanismInfo C_GetMechanismInfo; CK_C_InitToken C_InitToken; CK_C_InitPIN C_InitPIN; CK_C_SetPIN C_SetPIN; CK_C_OpenSession C_OpenSession; CK_C_CloseSession C_CloseSession; CK_C_CloseAllSessions C_CloseAllSessions; CK_C_GetSessionInfo C_GetSessionInfo; CK_C_GetOperationState C_GetOperationState; CK_C_SetOperationState C_SetOperationState; CK_C_Login C_Login; CK_C_Logout C_Logout; CK_C_CreateObject C_CreateObject; CK_C_CopyObject C_CopyObject; CK_C_DestroyObject C_DestroyObject; CK_C_GetObjectSize C_GetObjectSize; CK_C_GetAttributeValue C_GetAttributeValue; CK_C_SetAttributeValue C_SetAttributeValue; CK_C_FindObjectsInit C_FindObjectsInit; CK_C_FindObjects C_FindObjects; CK_C_FindObjectsFinal C_FindObjectsFinal; CK_C_EncryptInit C_EncryptInit; CK_C_Encrypt C_Encrypt; CK_C_EncryptUpdate C_EncryptUpdate; CK_C_EncryptFinal C_EncryptFinal; CK_C_DecryptInit C_DecryptInit; CK_C_Decrypt C_Decrypt; CK_C_DecryptUpdate C_DecryptUpdate; CK_C_DecryptFinal C_DecryptFinal; CK_C_DigestInit C_DigestInit; CK_C_Digest C_Digest; CK_C_DigestUpdate C_DigestUpdate; CK_C_DigestKey C_DigestKey; CK_C_DigestFinal C_DigestFinal; CK_C_SignInit C_SignInit; CK_C_Sign C_Sign; CK_C_SignUpdate C_SignUpdate; CK_C_SignFinal C_SignFinal; CK_C_SignRecoverInit C_SignRecoverInit; CK_C_SignRecover C_SignRecover; CK_C_VerifyInit C_VerifyInit; CK_C_Verify C_Verify; CK_C_VerifyUpdate C_VerifyUpdate; CK_C_VerifyFinal C_VerifyFinal; CK_C_VerifyRecoverInit C_VerifyRecoverInit; CK_C_VerifyRecover C_VerifyRecover; CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; CK_C_SignEncryptUpdate C_SignEncryptUpdate; CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; CK_C_GenerateKey C_GenerateKey; CK_C_GenerateKeyPair C_GenerateKeyPair; CK_C_WrapKey C_WrapKey; CK_C_UnwrapKey C_UnwrapKey; CK_C_DeriveKey C_DeriveKey; CK_C_SeedRandom C_SeedRandom; CK_C_GenerateRandom C_GenerateRandom; CK_C_GetFunctionStatus C_GetFunctionStatus; CK_C_CancelFunction C_CancelFunction; CK_C_WaitForSlotEvent C_WaitForSlotEvent; }; #if defined(_WIN32) #pragma pack(pop, cryptoki) #endif // clang-format on #endif ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/pkcs11lib.cpp0000644000175100017510000005537715246574333015661 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2008-2025 Ludovic Rousseau // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #include "stdafx.h" #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" #include "utility.h" #include #include "dyn_generic.h" CPKCS11Lib::CPKCS11Lib(void): m_hLib(0), m_pFunc(NULL) { } CPKCS11Lib::~CPKCS11Lib(void) { } CK_RV CPKCS11Lib::Load(const char* szLib) { CK_RV rv; SYS_dyn_LoadLibrary((void**)&m_hLib, szLib); if (!m_hLib) return -1; CK_C_GetFunctionList pC_GetFunctionList; SYS_dyn_GetAddress(m_hLib, (function_ptr *)&pC_GetFunctionList, "C_GetFunctionList"); if (!pC_GetFunctionList) { SYS_dyn_CloseLibrary((void**)&m_hLib); return -4; } rv = pC_GetFunctionList(&m_pFunc); if (CKR_OK != rv || !m_pFunc) { SYS_dyn_CloseLibrary((void**)&m_hLib); return rv; } rv = C_Initialize(); if (CKR_OK != rv && CKR_CRYPTOKI_ALREADY_INITIALIZED != rv) return rv; return CKR_OK; } bool CPKCS11Lib::Unload() { bool bRes = false; if (m_hLib && m_pFunc) C_Finalize(); if (m_hLib) { bRes = true; SYS_dyn_CloseLibrary((void**)&m_hLib); } m_hLib = 0; m_pFunc = NULL; return bRes; } /* duplicate a reference to a library */ void CPKCS11Lib::Duplicate(CPKCS11Lib *ref) { m_hLib = ref->m_hLib; m_pFunc = ref->m_pFunc; } CK_RV CPKCS11Lib::C_Initialize() { CK_RV rv; CK_C_INITIALIZE_ARGS args = { .CreateMutex = NULL, .DestroyMutex = NULL, .LockMutex = NULL, .UnlockMutex = NULL, .flags = CKF_OS_LOCKING_OK, .pReserved = NULL, }; rv = m_pFunc->C_Initialize(&args); return rv; } CK_RV CPKCS11Lib::C_Finalize() { CK_RV rv; rv = m_pFunc->C_Finalize(NULL); return rv; } CK_RV CPKCS11Lib::C_GetInfo(CK_INFO* pInfo) { CK_RV rv; if (!m_pFunc) rv = CKR_CRYPTOKI_NOT_INITIALIZED; else rv = m_pFunc->C_GetInfo(pInfo); return rv; } CK_RV CPKCS11Lib::C_GetSlotList( unsigned char tokenPresent, vector& slotList) { CK_RV rv; CK_ULONG i; slotList.clear(); CK_ULONG ulSlotCount; rv = m_pFunc->C_GetSlotList(tokenPresent, NULL, &ulSlotCount); if (CKR_OK == rv) { CK_SLOT_ID_PTR ck_slotList; ck_slotList = (CK_SLOT_ID_PTR)malloc(ulSlotCount * sizeof(CK_SLOT_ID)); rv = m_pFunc->C_GetSlotList(tokenPresent, ck_slotList, &ulSlotCount); if (CKR_OK == rv) for(i=0; iC_GetSlotInfo(slotID, pInfo); return rv; } CK_RV CPKCS11Lib::C_GetTokenInfo ( CK_SLOT_ID slotID, CK_TOKEN_INFO* pInfo) { CK_RV rv; rv = m_pFunc->C_GetTokenInfo(slotID, pInfo); return rv; } CK_RV CPKCS11Lib::C_InitToken( CK_SLOT_ID slotID, vector pin, const char* pLabel) { CK_RV rv; CK_ULONG ulPinLen = 0; CK_BYTE* pPin = Vector2Buffer(pin, ulPinLen); rv = m_pFunc->C_InitToken(slotID, (CK_UTF8CHAR_PTR) pPin, ulPinLen, (CK_CHAR*)pLabel); return rv; } CK_RV CPKCS11Lib::C_InitPIN( CK_SESSION_HANDLE hSession, vector pin) { CK_RV rv; CK_ULONG ulPinLen = 0; CK_BYTE* pPin = Vector2Buffer(pin, ulPinLen); rv = m_pFunc->C_InitPIN(hSession, (CK_UTF8CHAR_PTR) pPin, ulPinLen); return rv; } CK_RV CPKCS11Lib::C_SetPIN( CK_SESSION_HANDLE hSession, vector OldPin, vector NewPin) { CK_RV rv; CK_ULONG ulOldLen = 0; CK_BYTE* pOldPin = Vector2Buffer(OldPin, ulOldLen); CK_ULONG ulNewLen = 0; CK_BYTE* pNewPin = Vector2Buffer(NewPin, ulNewLen); rv = m_pFunc->C_SetPIN(hSession, (CK_UTF8CHAR_PTR)pOldPin, ulOldLen, (CK_UTF8CHAR_PTR)pNewPin, ulNewLen); return rv; } CK_RV CPKCS11Lib::C_OpenSession( CK_SLOT_ID slotID, CK_FLAGS flags, CK_SESSION_HANDLE& outhSession) { CK_RV rv; rv = m_pFunc->C_OpenSession(slotID, flags, NULL, NULL, &outhSession); return rv; } CK_RV CPKCS11Lib::C_CloseSession( CK_SESSION_HANDLE hSession) { CK_RV rv; rv = m_pFunc->C_CloseSession(hSession); return rv; } CK_RV CPKCS11Lib::C_CloseAllSessions( CK_SLOT_ID slotID) { CK_RV rv; rv = m_pFunc->C_CloseAllSessions(slotID); return rv; } CK_RV CPKCS11Lib::C_GetSessionInfo( CK_SESSION_HANDLE hSession, CK_SESSION_INFO* pInfo) { CK_RV rv; rv = m_pFunc->C_GetSessionInfo(hSession, pInfo); return rv; } CK_RV CPKCS11Lib::C_Login( CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, vector pin) { CK_RV rv; CK_ULONG ulPinLen = 0; CK_BYTE* pPin = Vector2Buffer(pin, ulPinLen); rv = m_pFunc->C_Login(hSession, userType, (CK_UTF8CHAR_PTR)pPin, ulPinLen); return rv; } CK_RV CPKCS11Lib::C_Logout( CK_SESSION_HANDLE hSession) { CK_RV rv; rv = m_pFunc->C_Logout(hSession); return rv; } CK_RV CPKCS11Lib::C_CreateObject( CK_SESSION_HANDLE hSession, vector Template, CK_OBJECT_HANDLE& outhObject) { CK_RV rv; CK_ULONG ulCount = 0; CK_OBJECT_HANDLE hObj = static_cast(outhObject); CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_CreateObject(hSession, pTemplate, ulCount, &hObj); if (pTemplate) DestroyTemplate(pTemplate, ulCount); outhObject = static_cast(hObj); return rv; } CK_RV CPKCS11Lib::C_DestroyObject( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) { CK_RV rv; rv = m_pFunc->C_DestroyObject(hSession, (CK_OBJECT_HANDLE)hObject); return rv; } CK_RV CPKCS11Lib::C_GetObjectSize( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ULONG* pulSize) { CK_RV rv; rv = m_pFunc->C_GetObjectSize(hSession, (CK_OBJECT_HANDLE)hObject, pulSize); return rv; } CK_RV CPKCS11Lib::C_GetAttributeValue ( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, vector &Template) { CK_RV rv; CK_ULONG ulCount = 0, i; CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_GetAttributeValue(hSession, (CK_OBJECT_HANDLE)hObject, pTemplate, ulCount); for (i=0; i Template) { CK_RV rv; CK_ULONG ulCount = 0; CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_SetAttributeValue(hSession, (CK_OBJECT_HANDLE)hObject, pTemplate, ulCount); if (pTemplate) DestroyTemplate(pTemplate, ulCount); return rv; } CK_RV CPKCS11Lib::C_FindObjectsInit( CK_SESSION_HANDLE hSession, vector &Template) { CK_RV rv; CK_ULONG ulCount = 0; CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_FindObjectsInit(hSession, pTemplate, ulCount); if (pTemplate) DestroyTemplate(pTemplate, ulCount); return rv; } CK_RV CPKCS11Lib::C_FindObjects( CK_SESSION_HANDLE hSession, vector& objectList) { CK_RV rv; CK_ULONG i; if (!objectList.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulObjectsMax = (CK_ULONG) objectList.size(); CK_ULONG ulObjects = 0; CK_OBJECT_HANDLE_PTR pList = new CK_OBJECT_HANDLE[ulObjectsMax]; objectList.clear(); rv = m_pFunc->C_FindObjects(hSession, pList, ulObjectsMax, &ulObjects); if (CKR_OK == rv && ulObjects) { for (i=0; i(pList[i])); } if (pList) delete [] pList; return rv; } CK_RV CPKCS11Lib::C_FindObjectsFinal( CK_SESSION_HANDLE hSession) { CK_RV rv; rv = m_pFunc->C_FindObjectsFinal(hSession); return rv; } CK_RV CPKCS11Lib::C_EncryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CK_RV rv; rv = m_pFunc->C_EncryptInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); return rv; } CK_RV CPKCS11Lib::C_Encrypt( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outEncryptedData, ulOutDataLen); rv = m_pFunc->C_Encrypt(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outEncryptedData, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_EncryptUpdate( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = static_cast( inData.size() ); CK_BYTE* pInData = inData.data(); CK_ULONG ulOutDataLen = 0; // the # first call get the encrypted size rv = m_pFunc->C_EncryptUpdate(hSession, pInData, ulInDataLen, nullptr, &ulOutDataLen); if (CKR_OK == rv) { // The second call get the actual encrypted data outEncryptedData.resize(ulOutDataLen); rv = m_pFunc->C_EncryptUpdate(hSession, pInData, ulInDataLen, outEncryptedData.data(), &ulOutDataLen); outEncryptedData.erase(outEncryptedData.begin() + ulOutDataLen, outEncryptedData.end()); } return rv; } CK_RV CPKCS11Lib::C_EncryptFinal( CK_SESSION_HANDLE hSession, vector &outEncryptedData) { CK_RV rv; CK_ULONG ulOutDataLen = 0; // The first call to get the encrypted size rv = m_pFunc->C_EncryptFinal(hSession, nullptr, &ulOutDataLen); if (CKR_OK == rv) { // The second call to get the actual encrypted data // Always use a buffer with an extra byte, since C_EncryptFinal may return zero data, // in which case one still have to make the second call with a non-null output buffer // in order to terminate the encryption operation outEncryptedData.resize(ulOutDataLen + 1); rv = m_pFunc->C_EncryptFinal(hSession, outEncryptedData.data(), &ulOutDataLen); outEncryptedData.erase(outEncryptedData.begin() + ulOutDataLen, outEncryptedData.end()); } return rv; } CK_RV CPKCS11Lib::C_DecryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CK_RV rv; rv = m_pFunc->C_DecryptInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); return rv; } CK_RV CPKCS11Lib::C_Decrypt( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData) { CK_RV rv; if (!inEncryptedData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inEncryptedData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outData, ulOutDataLen); rv = m_pFunc->C_Decrypt(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outData, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_DecryptUpdate( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData) { CK_RV rv; if (!inEncryptedData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = static_cast( inEncryptedData.size() ); CK_BYTE* pInData = inEncryptedData.data(); CK_ULONG ulOutDataLen = 0; // The first call to get the decrypted size rv = m_pFunc->C_DecryptUpdate(hSession, pInData, ulInDataLen, nullptr, &ulOutDataLen); if (CKR_OK == rv) { // The second call to get the actual decrypted data outData.resize(ulOutDataLen); rv = m_pFunc->C_DecryptUpdate(hSession, pInData, ulInDataLen, outData.data(), &ulOutDataLen); outData.erase(outData.begin() + ulOutDataLen, outData.end()); } return rv; } CK_RV CPKCS11Lib::C_DecryptFinal( CK_SESSION_HANDLE hSession, vector &outData) { CK_RV rv; CK_ULONG ulOutDataLen = 0; // The first call to get the decrypted size rv = m_pFunc->C_DecryptFinal(hSession, nullptr, &ulOutDataLen); if (CKR_OK == rv) { // The second call to get the actual decrypted data outData.resize(ulOutDataLen + 1); rv = m_pFunc->C_DecryptFinal(hSession, outData.data(), &ulOutDataLen); outData.erase(outData.begin() + ulOutDataLen, outData.end()); } return rv; } CK_RV CPKCS11Lib::C_DigestInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism) { CK_RV rv; rv = m_pFunc->C_DigestInit(hSession, pMechanism); return rv; } CK_RV CPKCS11Lib::C_Digest( CK_SESSION_HANDLE hSession, vector inData, vector &outDigest) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outDigest, ulOutDataLen); rv = m_pFunc->C_Digest(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outDigest, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_DigestUpdate( CK_SESSION_HANDLE hSession, vector inData) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); rv = m_pFunc->C_DigestUpdate(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_DigestKey ( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey) { CK_RV rv; rv = m_pFunc->C_DigestKey(hSession, (CK_OBJECT_HANDLE)hKey); return rv; } CK_RV CPKCS11Lib::C_DigestFinal( CK_SESSION_HANDLE hSession, vector &outDigest) { CK_RV rv; CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outDigest, ulOutDataLen); rv = m_pFunc->C_DigestFinal(hSession, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outDigest, true); if (pOutData) delete []pOutData; return rv; } CK_RV CPKCS11Lib::C_SignInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CK_RV rv; rv = m_pFunc->C_SignInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); return rv; } CK_RV CPKCS11Lib::C_Sign( CK_SESSION_HANDLE hSession, vector inData, vector &outSignature) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outSignature, ulOutDataLen); rv = m_pFunc->C_Sign(hSession, pInData, ulInDataLen, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outSignature, true); if (pOutData) delete []pOutData; if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_SignUpdate( CK_SESSION_HANDLE hSession, vector inData) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); rv = m_pFunc->C_SignUpdate(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_SignFinal ( CK_SESSION_HANDLE hSession, vector &outSignature) { CK_RV rv; CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(outSignature, ulOutDataLen); rv = m_pFunc->C_SignFinal(hSession, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, outSignature, true); if (pOutData) delete []pOutData; return rv; } CK_RV CPKCS11Lib::C_VerifyInit ( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey) { CK_RV rv; rv = m_pFunc->C_VerifyInit(hSession, pMechanism, (CK_OBJECT_HANDLE)hKey); return rv; } CK_RV CPKCS11Lib::C_Verify( CK_SESSION_HANDLE hSession, vector inData, vector inSignature) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; if (!inSignature.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); CK_ULONG ulInSignatureLen = 0; CK_BYTE* pInSignature = Vector2Buffer(inSignature, ulInSignatureLen); rv = m_pFunc->C_Verify(hSession, pInData, ulInDataLen, pInSignature, ulInSignatureLen); if (pInData) delete []pInData; if (pInSignature) delete []pInSignature; return rv; } CK_RV CPKCS11Lib::C_VerifyUpdate( CK_SESSION_HANDLE hSession, vector inData) { CK_RV rv; if (!inData.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(inData, ulInDataLen); rv = m_pFunc->C_VerifyUpdate(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_VerifyFinal( CK_SESSION_HANDLE hSession, vector inSignature) { CK_RV rv; if (!inSignature.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInSignatureLen = 0; CK_BYTE* pInSignature = Vector2Buffer(inSignature, ulInSignatureLen); rv = m_pFunc->C_VerifyFinal(hSession, pInSignature, ulInSignatureLen); if (pInSignature) delete []pInSignature; return rv; } CK_RV CPKCS11Lib::C_GenerateKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector Template, CK_OBJECT_HANDLE& outhKey) { CK_RV rv; CK_ULONG ulCount = 0; CK_OBJECT_HANDLE hKey = static_cast(outhKey); CK_ATTRIBUTE * pTemplate = AttrVector2Template(Template, ulCount); rv = m_pFunc->C_GenerateKey(hSession, pMechanism, pTemplate, ulCount, &hKey); if (pTemplate) DestroyTemplate(pTemplate, ulCount); outhKey = static_cast(hKey); return rv; } CK_RV CPKCS11Lib::C_GenerateKeyPair( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector PublicKeyTemplate, vector PrivateKeyTemplate, CK_OBJECT_HANDLE& outhPublicKey, CK_OBJECT_HANDLE& outhPrivateKey) { CK_RV rv; CK_ULONG ulPublicKeyAttributeCount = 0, ulPrivateKeyAttributeCount = 0; CK_OBJECT_HANDLE hPublicKey = static_cast(outhPublicKey); CK_OBJECT_HANDLE hPrivateKey = static_cast(outhPrivateKey); CK_ATTRIBUTE * pPublicKeyTemplate = AttrVector2Template(PublicKeyTemplate, ulPublicKeyAttributeCount); CK_ATTRIBUTE * pPrivateKeyTemplate = AttrVector2Template(PrivateKeyTemplate, ulPrivateKeyAttributeCount); rv = m_pFunc->C_GenerateKeyPair(hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, &hPublicKey, &hPrivateKey); if (pPublicKeyTemplate) DestroyTemplate(pPublicKeyTemplate, ulPublicKeyAttributeCount); if (pPrivateKeyTemplate) DestroyTemplate(pPrivateKeyTemplate, ulPrivateKeyAttributeCount); outhPublicKey = static_cast(hPublicKey); outhPrivateKey = static_cast(hPrivateKey); return rv; } CK_RV CPKCS11Lib::C_WrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hWrappingKey, CK_OBJECT_HANDLE hKey, vector &WrappedKey) { CK_RV rv; CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(WrappedKey, ulOutDataLen); rv = m_pFunc->C_WrapKey(hSession, pMechanism, (CK_OBJECT_HANDLE)hWrappingKey, (CK_OBJECT_HANDLE)hKey, pOutData, &ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, WrappedKey, true); if (pOutData) delete []pOutData; return rv; } CK_RV CPKCS11Lib::C_UnwrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hUnwrappingKey, vector WrappedKey, vector Template, CK_OBJECT_HANDLE& outhKey) { CK_RV rv; CK_OBJECT_HANDLE hKey = static_cast(outhKey); if (!WrappedKey.size()) return CKR_ARGUMENTS_BAD; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(WrappedKey, ulInDataLen); CK_ULONG ulAttributeCount = 0; CK_ATTRIBUTE* pTemplate = AttrVector2Template(Template, ulAttributeCount); rv = m_pFunc->C_UnwrapKey(hSession, pMechanism, (CK_OBJECT_HANDLE)hUnwrappingKey, pInData, ulInDataLen, pTemplate, ulAttributeCount, &hKey); if (pInData) delete []pInData; if (pTemplate) DestroyTemplate(pTemplate, ulAttributeCount); outhKey = static_cast(hKey); return rv; } CK_RV CPKCS11Lib::C_DeriveKey( CK_SESSION_HANDLE hSession, CK_MECHANISM *pMechanism, CK_OBJECT_HANDLE hBaseKey, vector Template, CK_OBJECT_HANDLE & outKey) { CK_RV rv; CK_OBJECT_HANDLE hKey = static_cast(outKey); CK_ULONG ulAttributeCount = 0; CK_ATTRIBUTE* pTemplate = AttrVector2Template(Template, ulAttributeCount); rv = m_pFunc->C_DeriveKey(hSession, pMechanism, hBaseKey, pTemplate, ulAttributeCount, &hKey); if (pTemplate) DestroyTemplate(pTemplate, ulAttributeCount); outKey = static_cast(hKey); return rv; } CK_RV CPKCS11Lib::C_SeedRandom( CK_SESSION_HANDLE hSession, vector Seed) { CK_RV rv; CK_ULONG ulInDataLen = 0; CK_BYTE* pInData = Vector2Buffer(Seed, ulInDataLen); rv = m_pFunc->C_SeedRandom(hSession, pInData, ulInDataLen); if (pInData) delete []pInData; return rv; } CK_RV CPKCS11Lib::C_GenerateRandom( CK_SESSION_HANDLE hSession, vector &RandomData) { CK_RV rv; CK_ULONG ulOutDataLen = 0; CK_BYTE* pOutData = Vector2Buffer(RandomData, ulOutDataLen); rv = m_pFunc->C_GenerateRandom(hSession, pOutData, ulOutDataLen); if (CKR_OK == rv) Buffer2Vector(pOutData, ulOutDataLen, RandomData, true); if (pOutData) delete []pOutData; return rv; } CK_RV CPKCS11Lib::C_WaitForSlotEvent( CK_FLAGS flags, unsigned long* pSlot) { CK_RV rv; rv = m_pFunc->C_WaitForSlotEvent(flags, pSlot, NULL); return rv; } CK_RV CPKCS11Lib::C_GetMechanismList( unsigned long slotID, vector &mechanismList) { CK_RV rv; CK_ULONG i; mechanismList.clear(); CK_MECHANISM_TYPE ck_mechanismList[1024]; CK_ULONG ulCount = sizeof(ck_mechanismList)/sizeof(ck_mechanismList[0]); rv = m_pFunc->C_GetMechanismList(slotID, ck_mechanismList, &ulCount); if (CKR_OK == rv) for(i=0; iC_GetMechanismInfo(slotID, type, pInfo); return rv; } /////////////////////////////////////////////////////////////////////////////// ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/pkcs11lib.h0000644000175100017510000001600115246574333015303 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2008-2025 Ludovic Rousseau // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #pragma once #ifndef SWIG typedef CK_ATTRIBUTE CK_ATTRIBUTE_INTERNAL; #ifdef WIN32 #pragma warning(disable: 4800 4244) #include #endif #include using namespace std; #endif class CPKCS11Lib { #ifdef WIN32 HMODULE m_hLib; #else void *m_hLib; #endif CK_FUNCTION_LIST* m_pFunc; public: CPKCS11Lib(void); ~CPKCS11Lib(void); CK_RV Load(const char* szLib); bool Unload(); void Duplicate(CPKCS11Lib *ref); CK_RV C_Initialize(); CK_RV C_Finalize(); CK_RV C_GetInfo(CK_INFO* pInfo); CK_RV C_GetSlotList(unsigned char tokenPresent, vector& slotList); CK_RV C_GetSlotInfo(unsigned long slotID,CK_SLOT_INFO* pInfo); CK_RV C_GetTokenInfo(unsigned long slotID,CK_TOKEN_INFO* pInfo); #ifdef SWIG %apply (char *STRING, int LENGTH) { (char* pPin, unsigned long ulPinLen), (char* pOldPin, unsigned long ulOldLen), (char* pNewPin, unsigned long ulNewLen) }; %apply (char *STRING) { (char* pLabel) }; #endif CK_RV C_InitToken(unsigned long slotID, vector pin, const char* pLabel); CK_RV C_InitPIN( CK_SESSION_HANDLE hSession, vector pin); CK_RV C_SetPIN( CK_SESSION_HANDLE hSession, vector OldPin, vector NewPin); CK_RV C_OpenSession( unsigned long slotID, unsigned long flags, CK_SESSION_HANDLE& outhSession); CK_RV C_CloseSession(CK_SESSION_HANDLE hSession); CK_RV C_CloseAllSessions(unsigned long slotID); CK_RV C_GetSessionInfo( CK_SESSION_HANDLE hSession, CK_SESSION_INFO* pInfo); CK_RV C_Login( CK_SESSION_HANDLE hSession, unsigned long userType, vector pin); #ifdef SWIG %clear (char* pPin, unsigned long ulPinLen), (char* pOldPin, unsigned long ulOldLen), (char* pNewPin, unsigned long ulNewLen) ; %clear (char* pLabel); #endif CK_RV C_Logout(CK_SESSION_HANDLE hSession); CK_RV C_CreateObject( CK_SESSION_HANDLE hSession, vector Template, CK_OBJECT_HANDLE& outhObject); CK_RV C_DestroyObject( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject); CK_RV C_GetObjectSize( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, unsigned long* pulSize); CK_RV C_GetAttributeValue( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, vector &Template); CK_RV C_SetAttributeValue( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, vector Template); CK_RV C_FindObjectsInit( CK_SESSION_HANDLE hSession, vector &Template); CK_RV C_FindObjects( CK_SESSION_HANDLE hSession, vector &objectsList); CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession); CK_RV C_EncryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Encrypt( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData); CK_RV C_EncryptUpdate( CK_SESSION_HANDLE hSession, vector inData, vector &outEncryptedData); CK_RV C_EncryptFinal( CK_SESSION_HANDLE hSession, vector &outEncryptedData); CK_RV C_DecryptInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Decrypt( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData); CK_RV C_DecryptUpdate( CK_SESSION_HANDLE hSession, vector inEncryptedData, vector &outData); CK_RV C_DecryptFinal( CK_SESSION_HANDLE hSession, vector &outData); CK_RV C_DigestInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism); CK_RV C_Digest( CK_SESSION_HANDLE hSession, vector inData, vector &outDigest); CK_RV C_DigestUpdate( CK_SESSION_HANDLE hSession, vector inData); CK_RV C_DigestKey( CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey); CK_RV C_DigestFinal( CK_SESSION_HANDLE hSession, vector &outDigest); CK_RV C_SignInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Sign( CK_SESSION_HANDLE hSession, vector inData, vector &outSignature); CK_RV C_SignUpdate( CK_SESSION_HANDLE hSession, vector inData); CK_RV C_SignFinal( CK_SESSION_HANDLE hSession, vector &outSignature); CK_RV C_VerifyInit( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hKey); CK_RV C_Verify( CK_SESSION_HANDLE hSession, vector inData, vector inSignature); CK_RV C_VerifyUpdate( CK_SESSION_HANDLE hSession, vector inData); CK_RV C_VerifyFinal( CK_SESSION_HANDLE hSession, vector inSignature); CK_RV C_GenerateKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector Template, CK_OBJECT_HANDLE & outhKey); CK_RV C_GenerateKeyPair( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, vector PublicKeyTemplate, vector PrivateKeyTemplate, CK_OBJECT_HANDLE& outhPublicKey, CK_OBJECT_HANDLE& outhPrivateKey ); CK_RV C_WrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hWrappingKey, CK_OBJECT_HANDLE hKey, vector &WrappedKey); CK_RV C_UnwrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM* pMechanism, CK_OBJECT_HANDLE hUnwrappingKey, vector WrappedKey, vector Template, CK_OBJECT_HANDLE & outhKey); CK_RV C_DeriveKey( CK_SESSION_HANDLE hSession, CK_MECHANISM *pMechanism, CK_OBJECT_HANDLE hBaseKey, vector Template, CK_OBJECT_HANDLE & outkey); CK_RV C_SeedRandom( CK_SESSION_HANDLE hSession, vector Seed); CK_RV C_GenerateRandom( CK_SESSION_HANDLE hSession, vector &RandomData); CK_RV C_WaitForSlotEvent( unsigned long flags, unsigned long * INOUT); CK_RV C_GetMechanismList( unsigned long slotID, vector &mechanismList); CK_RV C_GetMechanismInfo( unsigned long slotID, unsigned long type, CK_MECHANISM_INFO* pInfo); }; ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/pykcs11.cpp0000644000175100017510000000217015246574333015342 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2017-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. // PyKCS11.cpp : Defines the entry point for the DLL application. #if defined(WIN32) || defined(_WIN32) #include BOOL WINAPI DllMain( HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { return TRUE; } #endif ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9760623 pykcs11-1.5.20/src/pykcs11.egg-info/0000755000175100017510000000000015246574336016333 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9472435 pykcs11-1.5.20/src/pykcs11.egg-info/PKG-INFO0000644000175100017510000000302015246574336017423 0ustar00runnerrunnerMetadata-Version: 2.4 Name: pykcs11 Version: 1.5.20 Summary: A Full PKCS#11 wrapper for Python Home-page: https://github.com/LudovicRousseau/PyKCS11 Download-URL: http://sourceforge.net/projects/pkcs11wrap/files/pykcs11/ Author: Giuseppe Amato (Midori) Author-email: paipai@tiscali.it Maintainer: Ludovic Rousseau Maintainer-email: ludovic.rousseau@free.fr License: GPL-2.0-or-later Keywords: crypto,pki,pkcs11,c++ Platform: Win32 Unix Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Natural Language :: English Classifier: Operating System :: Microsoft :: Windows Classifier: Operating System :: OS Independent Classifier: Operating System :: Unix Classifier: Programming Language :: C Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Topic :: Security :: Cryptography Classifier: Topic :: Software Development :: Libraries :: Python Modules License-File: COPYING Dynamic: author Dynamic: author-email Dynamic: classifier Dynamic: description Dynamic: download-url Dynamic: home-page Dynamic: keywords Dynamic: license Dynamic: license-file Dynamic: maintainer Dynamic: maintainer-email Dynamic: platform Dynamic: summary A complete PKCS#11 wrapper for Python. You can use any PKCS#11 (aka CryptoKi) module such as the PSM which comes as part of mozilla or the various modules supplied by vendors of hardware crypto tokens, and almost all PKCS#11 functions and data types. The wrapper has been generated with the help of the SWIG compiler. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9601748 pykcs11-1.5.20/src/pykcs11.egg-info/SOURCES.txt0000644000175100017510000000271715246574336020226 0ustar00runnerrunnerCOPYING Changes.txt MANIFEST.in Makefile README.md dev-requirements.txt get_PYKCS11LIB.py pyproject.toml run_test.py setup.py tox.ini docs/Makefile docs/api.rst docs/conf.py docs/generate.sh docs/index.rst docs/license.rst docs/samples.rst samples/destroy_by_ID.py samples/dumpit.py samples/ec_generate.py samples/ec_signature.py samples/encrypt.py samples/events.py samples/generate.py samples/genkeypair_import_cert.py samples/getinfo.py samples/modulus.py samples/rsa_encrypt.py samples/signature.py samples/unblock.py samples/LowLevel/InitTokenPin.py samples/LowLevel/dumpit.py samples/LowLevel/rand.py samples/LowLevel/test.py samples/LowLevel/test1.py src/ck_attribute_smart.cpp src/ck_attribute_smart.h src/dyn_generic.h src/dyn_unix.c src/dyn_win32.c src/pkcs11lib.cpp src/pkcs11lib.h src/pykcs11.cpp src/pykcs11.i src/pykcs11string.cpp src/pykcs11string.h src/stdafx.h src/utility.cpp src/utility.h src/PyKCS11/__init__.py src/PyKCS11/constants.py src/opensc/pkcs11.h src/pykcs11.egg-info/PKG-INFO src/pykcs11.egg-info/SOURCES.txt src/pykcs11.egg-info/dependency_links.txt src/pykcs11.egg-info/top_level.txt test/test_CK.py test/test_LowLevel.py test/test_asymetric.py test/test_asymetric_ECC.py test/test_asymetric_gost.py test/test_ckbytelist.py test/test_derive.py test/test_digest.py test/test_exception.py test/test_gc.py test/test_info.py test/test_init.py test/test_load.py test/test_objects.py test/test_pin.py test/test_random.py test/test_symetric.py test/test_wrap.py././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1788541149.947597 pykcs11-1.5.20/src/pykcs11.egg-info/dependency_links.txt0000644000175100017510000000000115246574336022401 0ustar00runnerrunner ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9479773 pykcs11-1.5.20/src/pykcs11.egg-info/top_level.txt0000644000175100017510000000001015246574336021054 0ustar00runnerrunnerPyKCS11 ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/pykcs11.i0000644000175100017510000016150015246574333015013 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2015-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. %module LowLevel %{ #include #include #include #include "opensc/pkcs11.h" #ifdef WIN32 #pragma warning(disable: 4800 4244) #endif #include #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" using namespace std; %} %inline %{ using namespace std; %} %include cdata.i %include cpointer.i %include typemaps.i %include std_vector.i %template(ckulonglist) vector; %template(ckbytelist) vector; %template(ckattrlist) vector; %pointer_class(unsigned long, CK_SESSION_HANDLE); %pointer_class(unsigned long, CK_OBJECT_HANDLE); #if SWIGPYTHON %typemap(out) PyKCS11String { #ifdef Py_USING_UNICODE $result = PyBytes_FromStringAndSize((const char*)($1.m_str.c_str()),(int)($1.m_str.size())); #else $result = PyUnicode_Decode((const char*)($1.m_str.c_str()),(int)($1.m_str.size()), "utf-8", "ignore"); #endif } %typemap(out) CK_RV { $result = PyLong_FromLong((long)$1); } #else #endif typedef struct CK_VERSION { %immutable; unsigned char major; unsigned char minor; %mutable; } CK_VERSION; typedef struct CK_INFO { %immutable; CK_VERSION cryptokiVersion; unsigned char manufacturerID[32]; unsigned long flags; unsigned char libraryDescription[32]; CK_VERSION libraryVersion; %mutable; } CK_INFO; %extend CK_INFO { PyKCS11String GetManufacturerID() { return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } PyKCS11String GetLibraryDescription() { return PyKCS11String(self->libraryDescription, sizeof(self->libraryDescription)); } PyKCS11String GetLibraryVersion() { char szVal[10]; snprintf(szVal, sizeof szVal, "%d.%d", self->libraryVersion.major, self->libraryVersion.minor); return PyKCS11String(szVal); } }; typedef struct CK_SLOT_INFO { %immutable; //unsigned char slotDescription[64]; //unsigned char manufacturerID[32]; unsigned long flags; CK_VERSION hardwareVersion; CK_VERSION firmwareVersion; %mutable; } CK_SLOT_INFO; %extend CK_SLOT_INFO { PyKCS11String GetManufacturerID() { return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } PyKCS11String GetSlotDescription() { return PyKCS11String(self->slotDescription, sizeof(self->slotDescription)); } PyKCS11String GetHardwareVersion() { char szVal[10]; snprintf(szVal, sizeof szVal, "%d.%02d", self->hardwareVersion.major, self->hardwareVersion.minor); return PyKCS11String(szVal); } PyKCS11String GetFirmwareVersion() { char szVal[10]; snprintf(szVal, sizeof szVal, "%d.%02d", self->firmwareVersion.major, self->firmwareVersion.minor); return PyKCS11String(szVal); } }; typedef struct CK_TOKEN_INFO { %immutable; //unsigned char label[32]; //unsigned char manufacturerID[32]; //unsigned char model[16]; //unsigned char serialNumber[16]; unsigned long flags; unsigned long ulMaxSessionCount; unsigned long ulSessionCount; unsigned long ulMaxRwSessionCount; unsigned long ulRwSessionCount; unsigned long ulMaxPinLen; unsigned long ulMinPinLen; unsigned long ulTotalPublicMemory; unsigned long ulFreePublicMemory; unsigned long ulTotalPrivateMemory; unsigned long ulFreePrivateMemory; CK_VERSION hardwareVersion; CK_VERSION firmwareVersion; //unsigned char utcTime[16]; %mutable; } CK_TOKEN_INFO; %extend CK_TOKEN_INFO { PyKCS11String GetLabel() { return PyKCS11String(self->label, sizeof(self->label)); } PyKCS11String GetManufacturerID() { return PyKCS11String(self->manufacturerID, sizeof(self->manufacturerID)); } PyKCS11String GetModel() { return PyKCS11String(self->model, sizeof(self->model)); } PyKCS11String GetSerialNumber() { return PyKCS11String(self->serialNumber, sizeof(self->serialNumber)); } PyKCS11String GetFirmwareVersion() { char szVal[10]; snprintf(szVal, sizeof szVal, "%d.%02d", self->firmwareVersion.major, self->firmwareVersion.minor); return PyKCS11String(szVal); } PyKCS11String GetUtcTime() { return PyKCS11String(self->utcTime, sizeof(self->utcTime)); } }; typedef struct CK_SESSION_INFO { %immutable; unsigned long slotID; unsigned long state; unsigned long flags; unsigned long ulDeviceError; %mutable; } CK_SESSION_INFO; typedef struct CK_DATE{ //unsigned char year[4]; //unsigned char month[2]; // unsigned char day[2]; } CK_DATE; %extend CK_DATE { PyKCS11String GetYear() { char szVal[10]; memcpy(szVal, self->year, sizeof(self->year) ); return PyKCS11String(szVal); } PyKCS11String GetMonth() { char szVal[10]; memcpy(szVal, self->month, sizeof(self->month) ); return PyKCS11String(szVal); } PyKCS11String GetDay() { char szVal[10]; memcpy(szVal, self->day, sizeof(self->day) ); return PyKCS11String(szVal); } }; %typemap(in) void* { vector *vect; // If the value being set is of ckbytelist type: if (SWIG_IsOK(SWIG_ConvertPtr($input, (void **)&vect, $descriptor(vector *), 0))) { // Get the data from the vector // Only set value if not null if (vect) arg2 = vect->data(); else arg2 = NULL; } else { // If the value isn't a ckbytelist, then it must be a pointer to a mechanism parameter int res2 = -1; do { // Add mechanism parameters here res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_RSA_PKCS_OAEP_PARAMS*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_RSA_PKCS_PSS_PARAMS*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_GCM_PARAMS*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_ECDH1_DERIVE_PARAMS*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_AES_CTR_PARAMS*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_KEY_DERIVATION_STRING_DATA*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_EXTRACT_PARAMS*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_EDDSA_PARAMS*), 0); if( SWIG_IsOK( res2 ) ) break; res2 = SWIG_ConvertPtr($input, &arg2, $descriptor(CK_OBJECT_HANDLE*), 0); if( SWIG_IsOK( res2 ) ) break; } while(0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "unsupported CK_MECHANISM Parameter type."); } } } // typemap for CK_BYTE_PTR (unsigned char*) mechanism parameters %typemap(in) unsigned char* { vector *vect; // If the value being set is of ckbytelist type: int res = SWIG_ConvertPtr($input, (void **)&vect, $descriptor(vector *), 0); if (SWIG_IsOK(res)) { // Get the data from the vector // Only set value if not null if (vect) arg2 = vect->data(); else arg2 = NULL; } else { // If a mechanism parameter has a 'CK_BYTE_PTR' as a member, it must be represented as a ckbytelist SWIG_exception_fail(SWIG_ArgError(res), "CK_BYTE_PTR members of CK_* mechanism params must be represented as ckbytelist type"); } } // typemap for CK_BYTE static arrays %typemap(in) unsigned char[ANY](unsigned char out[$1_dim0]) { vector *vect; // Expect a value of ckbytelist type: int res = SWIG_ConvertPtr($input, (void **)&vect, $descriptor(vector *), 0); if (SWIG_IsOK(res)) { if (vect->size() != $1_dim0) { SWIG_exception_fail(SWIG_ValueError, "Expected a ckbytelist with $1_dim0 elements"); } for (size_t i = 0; i < $1_dim0; i++) { out[i] = (*vect)[i]; } } else { // If a mechanism parameter has a CK_BYTE array as a member, it must be represented as a ckbytelist SWIG_exception_fail(SWIG_ArgError(res), "CK_BYTE arrays of CK_* mechanism params must be represented as ckbytelist type"); } $1 = &out[0]; } typedef struct CK_MECHANISM { unsigned long mechanism; void* pParameter; unsigned long ulParameterLen; } CK_MECHANISM; %extend CK_MECHANISM { CK_MECHANISM() { CK_MECHANISM* m = new CK_MECHANISM(); m->ulParameterLen = m->mechanism = 0; m->pParameter = NULL; return m; } }; // For all complex mechanism parameters which has 'void *' as a member, it must a ckbytelist %typemap(in) void* { vector *vect; int res = SWIG_ConvertPtr($input, (void **)&vect, $descriptor(vector *), 0); if (SWIG_IsOK(res)) { // Get the data from the vector // Only set value if not null if (vect) arg2 = vect->data(); else arg2 = NULL; } else { SWIG_exception_fail(SWIG_ArgError(res), "void * members of CK_* mechanism params must be represented as ckbytelist type"); } } %constant int CK_OBJECT_HANDLE_LENGTH = sizeof(CK_OBJECT_HANDLE); typedef struct CK_GCM_PARAMS { unsigned char * pIv; unsigned long ulIvLen; unsigned long ulIvBits; unsigned char * pAAD; unsigned long ulAADLen; unsigned long ulTagBits; } CK_GCM_PARAMS; %extend CK_GCM_PARAMS { CK_GCM_PARAMS() { CK_GCM_PARAMS *p = new CK_GCM_PARAMS(); p->pIv = p->pAAD = NULL; p->ulIvLen = p->ulIvBits = p->ulAADLen = p->ulTagBits = 0; return p; } }; %constant int CK_GCM_PARAMS_LENGTH = sizeof(CK_GCM_PARAMS); typedef struct CK_AES_CTR_PARAMS { unsigned long ulCounterBits; unsigned char cb[16]; } CK_AES_CTR_PARAMS; %extend CK_AES_CTR_PARAMS { CK_AES_CTR_PARAMS() { CK_AES_CTR_PARAMS *p = new CK_AES_CTR_PARAMS(); p->ulCounterBits = 128; memset(p->cb, 0, sizeof(p->cb)); return p; } }; %constant int CK_AES_CTR_PARAMS_LENGTH = sizeof(CK_AES_CTR_PARAMS); typedef struct CK_RSA_PKCS_OAEP_PARAMS { unsigned long hashAlg; unsigned long mgf; unsigned long source; void* pSourceData; unsigned long ulSourceDataLen; } CK_RSA_PKCS_OAEP_PARAMS; %extend CK_RSA_PKCS_OAEP_PARAMS { CK_RSA_PKCS_OAEP_PARAMS() { CK_RSA_PKCS_OAEP_PARAMS* p = new CK_RSA_PKCS_OAEP_PARAMS(); p->hashAlg = 0; p->mgf = 0; p->source = 0; p->pSourceData = NULL; p->ulSourceDataLen = 0; return p; } }; %constant int CK_RSA_PKCS_OAEP_PARAMS_LENGTH = sizeof(CK_RSA_PKCS_OAEP_PARAMS); typedef struct CK_RSA_PKCS_PSS_PARAMS { unsigned long hashAlg; unsigned long mgf; unsigned long sLen; } CK_RSA_PKCS_PSS_PARAMS; %extend CK_RSA_PKCS_PSS_PARAMS { CK_RSA_PKCS_PSS_PARAMS() { CK_RSA_PKCS_PSS_PARAMS *p = new CK_RSA_PKCS_PSS_PARAMS(); p->hashAlg = 0; p->mgf = 0; p->sLen = 0; return p; } }; %constant int CK_RSA_PKCS_PSS_PARAMS_LENGTH = sizeof(CK_RSA_PKCS_PSS_PARAMS); typedef struct CK_ECDH1_DERIVE_PARAMS { unsigned long kdf; unsigned long ulSharedDataLen; unsigned char* pSharedData; unsigned long ulPublicDataLen; unsigned char* pPublicData; } CK_ECDH1_DERIVE_PARAMS; %extend CK_ECDH1_DERIVE_PARAMS { CK_ECDH1_DERIVE_PARAMS() { CK_ECDH1_DERIVE_PARAMS *p = new CK_ECDH1_DERIVE_PARAMS(); p->kdf = CKD_NULL; p->pSharedData = NULL; p->ulSharedDataLen = 0; p->pPublicData = NULL; p->ulPublicDataLen = 0; return p; } }; %constant int CK_ECDH1_DERIVE_PARAMS_LENGTH = sizeof(CK_ECDH1_DERIVE_PARAMS); typedef struct CK_KEY_DERIVATION_STRING_DATA { unsigned char * pData; unsigned long ulLen; } CK_KEY_DERIVATION_STRING_DATA; %extend CK_KEY_DERIVATION_STRING_DATA { CK_KEY_DERIVATION_STRING_DATA() { CK_KEY_DERIVATION_STRING_DATA *p = new CK_KEY_DERIVATION_STRING_DATA(); p->ulLen = 0; p->pData = NULL; return p; } }; %constant int CK_KEY_DERIVATION_STRING_DATA_LENGTH = sizeof(CK_KEY_DERIVATION_STRING_DATA); %pointer_class(unsigned long, CK_EXTRACT_PARAMS); %constant int CK_EXTRACT_PARAMS_LENGTH = sizeof(CK_EXTRACT_PARAMS); typedef struct CK_EDDSA_PARAMS { unsigned char phFlag; unsigned long ulContextDataLen; unsigned char * pContextData; } CK_EDDSA_PARAMS; %extend CK_EDDSA_PARAMS { CK_EDDSA_PARAMS() { CK_EDDSA_PARAMS *p = new CK_EDDSA_PARAMS(); p->phFlag = 0; p->ulContextDataLen = 0; p->pContextData = NULL; return p; } }; %constant int CK_EDDSA_PARAMS_LENGTH = sizeof(CK_EDDSA_PARAMS); typedef struct CK_MECHANISM_INFO { %immutable; unsigned long ulMinKeySize; unsigned long ulMaxKeySize; unsigned long flags; %mutable; } CK_MECHANISM_INFO; typedef unsigned long CK_RV; /* use deprecated symbols for now */ #define PKCS11_DEPRECATED #define FALSE 0 #define TRUE !(FALSE) #define CK_TRUE 1 #define CK_FALSE 0 #define CK_UNAVAILABLE_INFORMATION (~0UL) #define CK_EFFECTIVELY_INFINITE 0 #define CK_INVALID_HANDLE 0 /* domain specific values and constants */ /* CK (certificate) */ #define CK_CERTIFICATE_CATEGORY_UNSPECIFIED 0UL #define CK_CERTIFICATE_CATEGORY_TOKEN_USER 1UL #define CK_CERTIFICATE_CATEGORY_AUTHORITY 2UL #define CK_CERTIFICATE_CATEGORY_OTHER_ENTITY 3UL /* CK (OTP) */ #define CK_OTP_VALUE 0UL #define CK_OTP_PIN 1UL #define CK_OTP_CHALLENGE 2UL #define CK_OTP_TIME 3UL #define CK_OTP_COUNTER 4UL #define CK_OTP_FLAGS 5UL #define CK_OTP_OUTPUT_LENGTH 6UL #define CK_OTP_OUTPUT_FORMAT 7UL /* CK (OTP format) */ #define CK_OTP_FORMAT_DECIMAL 0UL #define CK_OTP_FORMAT_HEXADECIMAL 1UL #define CK_OTP_FORMAT_ALPHANUMERIC 2UL #define CK_OTP_FORMAT_BINARY 3UL /* CK (OTP requirement) */ #define CK_OTP_PARAM_IGNORED 0UL #define CK_OTP_PARAM_OPTIONAL 1UL #define CK_OTP_PARAM_MANDATORY 2UL /* CK (security) */ #define CK_SECURITY_DOMAIN_UNSPECIFIED 0UL #define CK_SECURITY_DOMAIN_MANUFACTURER 1UL #define CK_SECURITY_DOMAIN_OPERATOR 2UL #define CK_SECURITY_DOMAIN_THIRD_PARTY 3UL /* CK (SP800 KDF) */ #define CK_SP800_108_ITERATION_VARIABLE 0x00000001UL #define CK_SP800_108_OPTIONAL_COUNTER 0x00000002UL #define CK_SP800_108_COUNTER 0x00000002UL #define CK_SP800_108_DKM_LENGTH 0x00000003UL #define CK_SP800_108_BYTE_ARRAY 0x00000004UL #define CK_SP800_108_KEY_HANDLE 0x00000005UL /* CK (SP800 DKM) */ #define CK_SP800_108_DKM_LENGTH_SUM_OF_KEYS 0x00000001UL #define CK_SP800_108_DKM_LENGTH_SUM_OF_SEGMENTS 0x00000002UL /* CKA */ #define CKA_CLASS 0x00000000UL #define CKA_TOKEN 0x00000001UL #define CKA_PRIVATE 0x00000002UL #define CKA_LABEL 0x00000003UL #define CKA_UNIQUE_ID 0x00000004UL #define CKA_APPLICATION 0x00000010UL #define CKA_VALUE 0x00000011UL #define CKA_OBJECT_ID 0x00000012UL #define CKA_CERTIFICATE_TYPE 0x00000080UL #define CKA_ISSUER 0x00000081UL #define CKA_SERIAL_NUMBER 0x00000082UL #define CKA_AC_ISSUER 0x00000083UL #define CKA_OWNER 0x00000084UL #define CKA_ATTR_TYPES 0x00000085UL #define CKA_TRUSTED 0x00000086UL #define CKA_CERTIFICATE_CATEGORY 0x00000087UL #define CKA_JAVA_MIDP_SECURITY_DOMAIN 0x00000088UL #define CKA_URL 0x00000089UL #define CKA_HASH_OF_SUBJECT_PUBLIC_KEY 0x0000008AUL #define CKA_HASH_OF_ISSUER_PUBLIC_KEY 0x0000008BUL #define CKA_NAME_HASH_ALGORITHM 0x0000008CUL #define CKA_CHECK_VALUE 0x00000090UL #define CKA_KEY_TYPE 0x00000100UL #define CKA_SUBJECT 0x00000101UL #define CKA_ID 0x00000102UL #define CKA_SENSITIVE 0x00000103UL #define CKA_ENCRYPT 0x00000104UL #define CKA_DECRYPT 0x00000105UL #define CKA_WRAP 0x00000106UL #define CKA_UNWRAP 0x00000107UL #define CKA_SIGN 0x00000108UL #define CKA_SIGN_RECOVER 0x00000109UL #define CKA_VERIFY 0x0000010AUL #define CKA_VERIFY_RECOVER 0x0000010BUL #define CKA_DERIVE 0x0000010CUL #define CKA_START_DATE 0x00000110UL #define CKA_END_DATE 0x00000111UL #define CKA_MODULUS 0x00000120UL #define CKA_MODULUS_BITS 0x00000121UL #define CKA_PUBLIC_EXPONENT 0x00000122UL #define CKA_PRIVATE_EXPONENT 0x00000123UL #define CKA_PRIME_1 0x00000124UL #define CKA_PRIME_2 0x00000125UL #define CKA_EXPONENT_1 0x00000126UL #define CKA_EXPONENT_2 0x00000127UL #define CKA_COEFFICIENT 0x00000128UL #define CKA_PUBLIC_KEY_INFO 0x00000129UL #define CKA_PRIME 0x00000130UL #define CKA_SUBPRIME 0x00000131UL #define CKA_BASE 0x00000132UL #define CKA_PRIME_BITS 0x00000133UL #define CKA_SUBPRIME_BITS 0x00000134UL #define CKA_SUB_PRIME_BITS 0x00000134UL #define CKA_VALUE_BITS 0x00000160UL #define CKA_VALUE_LEN 0x00000161UL #define CKA_EXTRACTABLE 0x00000162UL #define CKA_LOCAL 0x00000163UL #define CKA_NEVER_EXTRACTABLE 0x00000164UL #define CKA_ALWAYS_SENSITIVE 0x00000165UL #define CKA_KEY_GEN_MECHANISM 0x00000166UL #define CKA_MODIFIABLE 0x00000170UL #define CKA_COPYABLE 0x00000171UL #define CKA_DESTROYABLE 0x00000172UL #define CKA_EC_PARAMS 0x00000180UL #define CKA_EC_POINT 0x00000181UL #define CKA_ALWAYS_AUTHENTICATE 0x00000202UL #define CKA_WRAP_WITH_TRUSTED 0x00000210UL #define CKA_OTP_FORMAT 0x00000220UL #define CKA_OTP_LENGTH 0x00000221UL #define CKA_OTP_TIME_INTERVAL 0x00000222UL #define CKA_OTP_USER_FRIENDLY_MODE 0x00000223UL #define CKA_OTP_CHALLENGE_REQUIREMENT 0x00000224UL #define CKA_OTP_TIME_REQUIREMENT 0x00000225UL #define CKA_OTP_COUNTER_REQUIREMENT 0x00000226UL #define CKA_OTP_PIN_REQUIREMENT 0x00000227UL #define CKA_OTP_COUNTER 0x0000022EUL #define CKA_OTP_TIME 0x0000022FUL #define CKA_OTP_USER_IDENTIFIER 0x0000022AUL #define CKA_OTP_SERVICE_IDENTIFIER 0x0000022BUL #define CKA_OTP_SERVICE_LOGO 0x0000022CUL #define CKA_OTP_SERVICE_LOGO_TYPE 0x0000022DUL #define CKA_GOSTR3410_PARAMS 0x00000250UL #define CKA_GOSTR3411_PARAMS 0x00000251UL #define CKA_GOST28147_PARAMS 0x00000252UL #define CKA_HW_FEATURE_TYPE 0x00000300UL #define CKA_RESET_ON_INIT 0x00000301UL #define CKA_HAS_RESET 0x00000302UL #define CKA_PIXEL_X 0x00000400UL #define CKA_PIXEL_Y 0x00000401UL #define CKA_RESOLUTION 0x00000402UL #define CKA_CHAR_ROWS 0x00000403UL #define CKA_CHAR_COLUMNS 0x00000404UL #define CKA_COLOR 0x00000405UL #define CKA_BITS_PER_PIXEL 0x00000406UL #define CKA_CHAR_SETS 0x00000480UL #define CKA_ENCODING_METHODS 0x00000481UL #define CKA_MIME_TYPES 0x00000482UL #define CKA_MECHANISM_TYPE 0x00000500UL #define CKA_REQUIRED_CMS_ATTRIBUTES 0x00000501UL #define CKA_DEFAULT_CMS_ATTRIBUTES 0x00000502UL #define CKA_SUPPORTED_CMS_ATTRIBUTES 0x00000503UL #define CKA_PROFILE_ID 0x00000601UL #define CKA_X2RATCHET_BAG 0x00000602UL #define CKA_X2RATCHET_BAGSIZE 0x00000603UL #define CKA_X2RATCHET_BOBS1STMSG 0x00000604UL #define CKA_X2RATCHET_CKR 0x00000605UL #define CKA_X2RATCHET_CKS 0x00000606UL #define CKA_X2RATCHET_DHP 0x00000607UL #define CKA_X2RATCHET_DHR 0x00000608UL #define CKA_X2RATCHET_DHS 0x00000609UL #define CKA_X2RATCHET_HKR 0x0000060AUL #define CKA_X2RATCHET_HKS 0x0000060BUL #define CKA_X2RATCHET_ISALICE 0x0000060CUL #define CKA_X2RATCHET_NHKR 0x0000060DUL #define CKA_X2RATCHET_NHKS 0x0000060EUL #define CKA_X2RATCHET_NR 0x0000060FUL #define CKA_X2RATCHET_NS 0x00000610UL #define CKA_X2RATCHET_PNS 0x00000611UL #define CKA_X2RATCHET_RK 0x00000612UL #define CKA_HSS_LEVELS 0x00000617UL #define CKA_HSS_LMS_TYPE 0x00000618UL #define CKA_HSS_LMOTS_TYPE 0x00000619UL #define CKA_HSS_LMS_TYPES 0x0000061AUL #define CKA_HSS_LMOTS_TYPES 0x0000061BUL #define CKA_HSS_KEYS_REMAINING 0x0000061CUL #define CKA_PARAMETER_SET 0x0000061DUL #define CKA_OBJECT_VALIDATION_FLAGS 0x0000061EUL #define CKA_VALIDATION_TYPE 0x0000061FUL #define CKA_VALIDATION_VERSION 0x00000620UL #define CKA_VALIDATION_LEVEL 0x00000621UL #define CKA_VALIDATION_MODULE_ID 0x00000622UL #define CKA_VALIDATION_FLAG 0x00000623UL #define CKA_VALIDATION_AUTHORITY_TYPE 0x00000624UL #define CKA_VALIDATION_COUNTRY 0x00000625UL #define CKA_VALIDATION_CERTIFICATE_IDENTIFIER 0x00000626UL #define CKA_VALIDATION_CERTIFICATE_URI 0x00000627UL #define CKA_VALIDATION_VENDOR_URI 0x00000628UL #define CKA_VALIDATION_PROFILE 0x00000629UL #define CKA_ENCAPSULATE_TEMPLATE 0x0000062AUL #define CKA_DECAPSULATE_TEMPLATE 0x0000062BUL #define CKA_TRUST_SERVER_AUTH 0x0000062CUL #define CKA_TRUST_CLIENT_AUTH 0x0000062DUL #define CKA_TRUST_CODE_SIGNING 0x0000062EUL #define CKA_TRUST_EMAIL_PROTECTION 0x0000062FUL #define CKA_TRUST_IPSEC_IKE 0x00000630UL #define CKA_TRUST_TIME_STAMPING 0x00000631UL #define CKA_TRUST_OCSP_SIGNING 0x00000632UL #define CKA_ENCAPSULATE 0x00000633UL #define CKA_DECAPSULATE 0x00000634UL #define CKA_HASH_OF_CERTIFICATE 0x00000635UL #define CKA_PUBLIC_CRC64_VALUE 0x00000636UL #define CKA_SEED 0x00000637UL #define CKA_VENDOR_DEFINED 0x80000000UL /* Array attributes */ #define CKA_WRAP_TEMPLATE 0x40000211UL #define CKA_UNWRAP_TEMPLATE 0x40000212UL #define CKA_DERIVE_TEMPLATE 0x40000213UL #define CKA_ALLOWED_MECHANISMS 0x40000600UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKA_ECDSA_PARAMS 0x00000180UL #define CKA_SECONDARY_AUTH 0x00000200UL #define CKA_AUTH_PIN_FLAGS 0x00000201UL #endif /* CKC */ #define CKC_X_509 0x00000000UL #define CKC_X_509_ATTR_CERT 0x00000001UL #define CKC_WTLS 0x00000002UL #define CKC_VENDOR_DEFINED 0x80000000UL /* CKD */ #define CKD_NULL 0x00000001UL #define CKD_SHA1_KDF 0x00000002UL #define CKD_SHA1_KDF_ASN1 0x00000003UL #define CKD_SHA1_KDF_CONCATENATE 0x00000004UL #define CKD_SHA224_KDF 0x00000005UL #define CKD_SHA256_KDF 0x00000006UL #define CKD_SHA384_KDF 0x00000007UL #define CKD_SHA512_KDF 0x00000008UL #define CKD_CPDIVERSIFY_KDF 0x00000009UL #define CKD_SHA3_224_KDF 0x0000000AUL #define CKD_SHA3_256_KDF 0x0000000BUL #define CKD_SHA3_384_KDF 0x0000000CUL #define CKD_SHA3_512_KDF 0x0000000DUL #define CKD_SHA1_KDF_SP800 0x0000000EUL #define CKD_SHA224_KDF_SP800 0x0000000FUL #define CKD_SHA256_KDF_SP800 0x00000010UL #define CKD_SHA384_KDF_SP800 0x00000011UL #define CKD_SHA512_KDF_SP800 0x00000012UL #define CKD_SHA3_224_KDF_SP800 0x00000013UL #define CKD_SHA3_256_KDF_SP800 0x00000014UL #define CKD_SHA3_384_KDF_SP800 0x00000015UL #define CKD_SHA3_512_KDF_SP800 0x00000016UL #define CKD_BLAKE2B_160_KDF 0x00000017UL #define CKD_BLAKE2B_256_KDF 0x00000018UL #define CKD_BLAKE2B_384_KDF 0x00000019UL #define CKD_BLAKE2B_512_KDF 0x0000001AUL /* CFK (array attributes) */ #define CKF_ARRAY_ATTRIBUTE 0x40000000UL /* CKF (capabilities) */ #define CKF_LIBRARY_CANT_CREATE_OS_THREADS 0x00000001UL #define CKF_OS_LOCKING_OK 0x00000002UL /* CKF (HKDF) */ #define CKF_HKDF_SALT_NULL 0x00000001UL #define CKF_HKDF_SALT_DATA 0x00000002UL #define CKF_HKDF_SALT_KEY 0x00000004UL /* CKF (interface) */ #define CKF_INTERFACE_FORK_SAFE 0x00000001UL /* CKF (mechanism) */ #define CKF_HW 0x00000001UL #define CKF_MESSAGE_ENCRYPT 0x00000002UL #define CKF_MESSAGE_DECRYPT 0x00000004UL #define CKF_MESSAGE_SIGN 0x00000008UL #define CKF_MESSAGE_VERIFY 0x00000010UL #define CKF_MULTI_MESSAGE 0x00000020UL #define CKF_MULTI_MESSGE 0x00000020UL #define CKF_FIND_OBJECTS 0x00000040UL #define CKF_ENCRYPT 0x00000100UL #define CKF_DECRYPT 0x00000200UL #define CKF_DIGEST 0x00000400UL #define CKF_SIGN 0x00000800UL #define CKF_SIGN_RECOVER 0x00001000UL #define CKF_VERIFY 0x00002000UL #define CKF_VERIFY_RECOVER 0x00004000UL #define CKF_GENERATE 0x00008000UL #define CKF_GENERATE_KEY_PAIR 0x00010000UL #define CKF_WRAP 0x00020000UL #define CKF_UNWRAP 0x00040000UL #define CKF_DERIVE 0x00080000UL #define CKF_EC_F_P 0x00100000UL #define CKF_EC_F_2M 0x00200000UL #define CKF_EC_ECPARAMETERS 0x00400000UL #define CKF_EC_OID 0x00800000UL #define CKF_EC_UNCOMPRESS 0x01000000UL #define CKF_EC_COMPRESS 0x02000000UL #define CKF_EC_CURVENAME 0x04000000UL #define CKF_ENCAPSULATE 0x10000000UL #define CKF_DECAPSULATE 0x20000000UL #define CKF_EXTENSION 0x80000000UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKF_EC_NAMEDCURVE 0x00800000U #endif /* CKF (message) */ #define CKF_END_OF_MESSAGE 0x00000001UL /* CKF (OTP) */ #define CKF_NEXT_OTP 0x00000001UL #define CKF_EXCLUDE_TIME 0x00000002UL #define CKF_EXCLUDE_COUNTER 0x00000004UL #define CKF_EXCLUDE_CHALLENGE 0x00000008UL #define CKF_EXCLUDE_PIN 0x00000010UL #define CKF_USER_FRIENDLY_OTP 0x00000020UL /* CKF (parameters to functions) */ #define CKF_DONT_BLOCK 1 /* CKF (session) */ #define CKF_RW_SESSION 0x00000002UL #define CKF_SERIAL_SESSION 0x00000004UL #define CKF_ASYNC_SESSION 0x00000008UL /* CFK (slot) */ #define CKF_TOKEN_PRESENT 0x00000001UL #define CKF_REMOVABLE_DEVICE 0x00000002UL #define CKF_HW_SLOT 0x00000004UL /* CKF (token) */ #define CKF_RNG 0x00000001UL #define CKF_WRITE_PROTECTED 0x00000002UL #define CKF_LOGIN_REQUIRED 0x00000004UL #define CKF_USER_PIN_INITIALIZED 0x00000008UL #define CKF_RESTORE_KEY_NOT_NEEDED 0x00000020UL #define CKF_CLOCK_ON_TOKEN 0x00000040UL #define CKF_PROTECTED_AUTHENTICATION_PATH 0x00000100UL #define CKF_DUAL_CRYPTO_OPERATIONS 0x00000200UL #define CKF_TOKEN_INITIALIZED 0x00000400UL #define CKF_SECONDARY_AUTHENTICATION 0x00000800UL #define CKF_USER_PIN_COUNT_LOW 0x00010000UL #define CKF_USER_PIN_FINAL_TRY 0x00020000UL #define CKF_USER_PIN_LOCKED 0x00040000UL #define CKF_USER_PIN_TO_BE_CHANGED 0x00080000UL #define CKF_SO_PIN_COUNT_LOW 0x00100000UL #define CKF_SO_PIN_FINAL_TRY 0x00200000UL #define CKF_SO_PIN_LOCKED 0x00400000UL #define CKF_SO_PIN_TO_BE_CHANGED 0x00800000UL #define CKF_ERROR_STATE 0x01000000UL #define CKF_SEED_RANDOM_REQUIRED 0x02000000UL #define CKF_ASYNC_SESSION_SUPPORTED 0x04000000UL /* CKG (GCM) */ #define CKG_NO_GENERATE 0x00000000UL #define CKG_GENERATE 0x00000001UL #define CKG_GENERATE_COUNTER 0x00000002UL #define CKG_GENERATE_RANDOM 0x00000003UL #define CKG_GENERATE_COUNTER_XOR 0x00000004UL /* CKG (MFG) */ #define CKG_MGF1_SHA1 0x00000001UL #define CKG_MGF1_SHA256 0x00000002UL #define CKG_MGF1_SHA384 0x00000003UL #define CKG_MGF1_SHA512 0x00000004UL #define CKG_MGF1_SHA224 0x00000005UL #define CKG_MGF1_SHA3_224 0x00000006UL #define CKG_MGF1_SHA3_256 0x00000007UL #define CKG_MGF1_SHA3_384 0x00000008UL #define CKG_MGF1_SHA3_512 0x00000009UL /* CKH (clock) */ #define CKH_MONOTONIC_COUNTER 0x00000001UL #define CKH_CLOCK 0x00000002UL #define CKH_USER_INTERFACE 0x00000003UL #define CKH_VENDOR_DEFINED 0x80000000UL /* CKH (hedge type) */ #define CKH_HEDGE_PREFERRED 0x00000000UL #define CKH_HEDGE_REQUIRED 0x00000001UL #define CKH_DETERMINISTIC_REQUIRED 0x00000002UL /* CKK */ #define CKK_RSA 0x00000000UL #define CKK_DSA 0x00000001UL #define CKK_DH 0x00000002UL #define CKK_EC 0x00000003UL #define CKK_X9_42_DH 0x00000004UL #define CKK_KEA 0x00000005UL #define CKK_GENERIC_SECRET 0x00000010UL #define CKK_RC2 0x00000011UL #define CKK_RC4 0x00000012UL #define CKK_DES 0x00000013UL #define CKK_DES2 0x00000014UL #define CKK_DES3 0x00000015UL #define CKK_CAST 0x00000016UL #define CKK_CAST3 0x00000017UL #define CKK_CAST128 0x00000018UL #define CKK_RC5 0x00000019UL #define CKK_IDEA 0x0000001AUL #define CKK_SKIPJACK 0x0000001BUL #define CKK_BATON 0x0000001CUL #define CKK_JUNIPER 0x0000001DUL #define CKK_CDMF 0x0000001EUL #define CKK_AES 0x0000001FUL #define CKK_BLOWFISH 0x00000020UL #define CKK_TWOFISH 0x00000021UL #define CKK_SECURID 0x00000022UL #define CKK_HOTP 0x00000023UL #define CKK_ACTI 0x00000024UL #define CKK_CAMELLIA 0x00000025UL #define CKK_ARIA 0x00000026UL #define CKK_MD5_HMAC 0x00000027UL #define CKK_SHA_1_HMAC 0x00000028UL #define CKK_RIPEMD128_HMAC 0x00000029UL #define CKK_RIPEMD160_HMAC 0x0000002AUL #define CKK_SHA256_HMAC 0x0000002BUL #define CKK_SHA384_HMAC 0x0000002CUL #define CKK_SHA512_HMAC 0x0000002DUL #define CKK_SHA224_HMAC 0x0000002EUL #define CKK_SEED 0x0000002FUL #define CKK_GOSTR3410 0x00000030UL #define CKK_GOSTR3411 0x00000031UL #define CKK_GOST28147 0x00000032UL #define CKK_CHACHA20 0x00000033UL #define CKK_POLY1305 0x00000034UL #define CKK_AES_XTS 0x00000035UL #define CKK_SHA3_224_HMAC 0x00000036UL #define CKK_SHA3_256_HMAC 0x00000037UL #define CKK_SHA3_384_HMAC 0x00000038UL #define CKK_SHA3_512_HMAC 0x00000039UL #define CKK_BLAKE2B_160_HMAC 0x0000003AUL #define CKK_BLAKE2B_256_HMAC 0x0000003BUL #define CKK_BLAKE2B_384_HMAC 0x0000003CUL #define CKK_BLAKE2B_512_HMAC 0x0000003DUL #define CKK_SALSA20 0x0000003EUL #define CKK_X2RATCHET 0x0000003FUL #define CKK_EC_EDWARDS 0x00000040UL #define CKK_EC_MONTGOMERY 0x00000041UL #define CKK_HKDF 0x00000042UL #define CKK_SHA512_224_HMAC 0x00000043UL #define CKK_SHA512_256_HMAC 0x00000044UL #define CKK_SHA512_T_HMAC 0x00000045UL #define CKK_HSS 0x00000046UL #define CKK_XMSS 0x00000047UL #define CKK_XMSSMT 0x00000048UL #define CKK_ML_KEM 0x00000049UL #define CKK_ML_DSA 0x0000004AUL #define CKK_SLH_DSA 0x0000004BUL #define CKK_VENDOR_DEFINED 0x80000000UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKK_ECDSA 0x00000003UL #define CKK_CAST5 0x00000018UL #endif /* CKM */ #define CKM_RSA_PKCS_KEY_PAIR_GEN 0x00000000UL #define CKM_RSA_PKCS 0x00000001UL #define CKM_RSA_9796 0x00000002UL #define CKM_RSA_X_509 0x00000003UL #define CKM_MD2_RSA_PKCS 0x00000004UL #define CKM_MD5_RSA_PKCS 0x00000005UL #define CKM_SHA1_RSA_PKCS 0x00000006UL #define CKM_RIPEMD128_RSA_PKCS 0x00000007UL #define CKM_RIPEMD160_RSA_PKCS 0x00000008UL #define CKM_RSA_PKCS_OAEP 0x00000009UL #define CKM_RSA_X9_31_KEY_PAIR_GEN 0x0000000AUL #define CKM_RSA_X9_31 0x0000000BUL #define CKM_SHA1_RSA_X9_31 0x0000000CUL #define CKM_RSA_PKCS_PSS 0x0000000DUL #define CKM_SHA1_RSA_PKCS_PSS 0x0000000EUL #define CKM_ML_KEM_KEY_PAIR_GEN 0x0000000FUL #define CKM_DSA_KEY_PAIR_GEN 0x00000010UL #define CKM_DSA 0x00000011UL #define CKM_DSA_SHA1 0x00000012UL #define CKM_DSA_SHA224 0x00000013UL #define CKM_DSA_SHA256 0x00000014UL #define CKM_DSA_SHA384 0x00000015UL #define CKM_DSA_SHA512 0x00000016UL #define CKM_ML_KEM 0x00000017UL #define CKM_DSA_SHA3_224 0x00000018UL #define CKM_DSA_SHA3_256 0x00000019UL #define CKM_DSA_SHA3_384 0x0000001AUL #define CKM_DSA_SHA3_512 0x0000001BUL #define CKM_ML_DSA_KEY_PAIR_GEN 0x0000001CUL #define CKM_ML_DSA 0x0000001DUL #define CKM_HASH_ML_DSA 0x0000001FUL #define CKM_DH_PKCS_KEY_PAIR_GEN 0x00000020UL #define CKM_DH_PKCS_DERIVE 0x00000021UL #define CKM_HASH_ML_DSA_SHA224 0x00000023UL #define CKM_HASH_ML_DSA_SHA256 0x00000024UL #define CKM_HASH_ML_DSA_SHA384 0x00000025UL #define CKM_HASH_ML_DSA_SHA512 0x00000026UL #define CKM_HASH_ML_DSA_SHA3_224 0x00000027UL #define CKM_HASH_ML_DSA_SHA3_256 0x00000028UL #define CKM_HASH_ML_DSA_SHA3_384 0x00000029UL #define CKM_HASH_ML_DSA_SHA3_512 0x0000002AUL #define CKM_HASH_ML_DSA_SHAKE128 0x0000002BUL #define CKM_HASH_ML_DSA_SHAKE256 0x0000002CUL #define CKM_SLH_DSA_KEY_PAIR_GEN 0x0000002DUL #define CKM_SLH_DSA 0x0000002EUL #define CKM_X9_42_DH_KEY_PAIR_GEN 0x00000030UL #define CKM_X9_42_DH_DERIVE 0x00000031UL #define CKM_X9_42_DH_HYBRID_DERIVE 0x00000032UL #define CKM_X9_42_MQV_DERIVE 0x00000033UL #define CKM_HASH_SLH_DSA 0x00000034UL #define CKM_HASH_SLH_DSA_SHA224 0x00000036UL #define CKM_HASH_SLH_DSA_SHA256 0x00000037UL #define CKM_HASH_SLH_DSA_SHA384 0x00000038UL #define CKM_HASH_SLH_DSA_SHA512 0x00000039UL #define CKM_HASH_SLH_DSA_SHA3_224 0x0000003AUL #define CKM_HASH_SLH_DSA_SHA3_256 0x0000003BUL #define CKM_HASH_SLH_DSA_SHA3_384 0x0000003CUL #define CKM_HASH_SLH_DSA_SHA3_512 0x0000003DUL #define CKM_HASH_SLH_DSA_SHAKE128 0x0000003EUL #define CKM_HASH_SLH_DSA_SHAKE256 0x0000003FUL #define CKM_SHA256_RSA_PKCS 0x00000040UL #define CKM_SHA384_RSA_PKCS 0x00000041UL #define CKM_SHA512_RSA_PKCS 0x00000042UL #define CKM_SHA256_RSA_PKCS_PSS 0x00000043UL #define CKM_SHA384_RSA_PKCS_PSS 0x00000044UL #define CKM_SHA512_RSA_PKCS_PSS 0x00000045UL #define CKM_SHA224_RSA_PKCS 0x00000046UL #define CKM_SHA224_RSA_PKCS_PSS 0x00000047UL #define CKM_SHA512_224 0x00000048UL #define CKM_SHA512_224_HMAC 0x00000049UL #define CKM_SHA512_224_HMAC_GENERAL 0x0000004AUL #define CKM_SHA512_224_KEY_DERIVATION 0x0000004BUL #define CKM_SHA512_256 0x0000004CUL #define CKM_SHA512_256_HMAC 0x0000004DUL #define CKM_SHA512_256_HMAC_GENERAL 0x0000004EUL #define CKM_SHA512_256_KEY_DERIVATION 0x0000004FUL #define CKM_SHA512_T 0x00000050UL #define CKM_SHA512_T_HMAC 0x00000051UL #define CKM_SHA512_T_HMAC_GENERAL 0x00000052UL #define CKM_SHA512_T_KEY_DERIVATION 0x00000053UL #define CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE 0x00000056UL #define CKM_TLS12_EXTENDED_MASTER_KEY_DERIVE_DH 0x00000057UL #define CKM_SHA3_256_RSA_PKCS 0x00000060UL #define CKM_SHA3_384_RSA_PKCS 0x00000061UL #define CKM_SHA3_512_RSA_PKCS 0x00000062UL #define CKM_SHA3_256_RSA_PKCS_PSS 0x00000063UL #define CKM_SHA3_384_RSA_PKCS_PSS 0x00000064UL #define CKM_SHA3_512_RSA_PKCS_PSS 0x00000065UL #define CKM_SHA3_224_RSA_PKCS 0x00000066UL #define CKM_SHA3_224_RSA_PKCS_PSS 0x00000067UL #define CKM_RC2_KEY_GEN 0x00000100UL #define CKM_RC2_ECB 0x00000101UL #define CKM_RC2_CBC 0x00000102UL #define CKM_RC2_MAC 0x00000103UL #define CKM_RC2_MAC_GENERAL 0x00000104UL #define CKM_RC2_CBC_PAD 0x00000105UL #define CKM_RC4_KEY_GEN 0x00000110UL #define CKM_RC4 0x00000111UL #define CKM_DES_KEY_GEN 0x00000120UL #define CKM_DES_ECB 0x00000121UL #define CKM_DES_CBC 0x00000122UL #define CKM_DES_MAC 0x00000123UL #define CKM_DES_MAC_GENERAL 0x00000124UL #define CKM_DES_CBC_PAD 0x00000125UL #define CKM_DES2_KEY_GEN 0x00000130UL #define CKM_DES3_KEY_GEN 0x00000131UL #define CKM_DES3_ECB 0x00000132UL #define CKM_DES3_CBC 0x00000133UL #define CKM_DES3_MAC 0x00000134UL #define CKM_DES3_MAC_GENERAL 0x00000135UL #define CKM_DES3_CBC_PAD 0x00000136UL #define CKM_DES3_CMAC_GENERAL 0x00000137UL #define CKM_DES3_CMAC 0x00000138UL #define CKM_CDMF_KEY_GEN 0x00000140UL #define CKM_CDMF_ECB 0x00000141UL #define CKM_CDMF_CBC 0x00000142UL #define CKM_CDMF_MAC 0x00000143UL #define CKM_CDMF_MAC_GENERAL 0x00000144UL #define CKM_CDMF_CBC_PAD 0x00000145UL #define CKM_DES_OFB64 0x00000150UL #define CKM_DES_OFB8 0x00000151UL #define CKM_DES_CFB64 0x00000152UL #define CKM_DES_CFB8 0x00000153UL #define CKM_MD2 0x00000200UL #define CKM_MD2_HMAC 0x00000201UL #define CKM_MD2_HMAC_GENERAL 0x00000202UL #define CKM_MD5 0x00000210UL #define CKM_MD5_HMAC 0x00000211UL #define CKM_MD5_HMAC_GENERAL 0x00000212UL #define CKM_SHA_1 0x00000220UL #define CKM_SHA_1_HMAC 0x00000221UL #define CKM_SHA_1_HMAC_GENERAL 0x00000222UL #define CKM_RIPEMD128 0x00000230UL #define CKM_RIPEMD128_HMAC 0x00000231UL #define CKM_RIPEMD128_HMAC_GENERAL 0x00000232UL #define CKM_RIPEMD160 0x00000240UL #define CKM_RIPEMD160_HMAC 0x00000241UL #define CKM_RIPEMD160_HMAC_GENERAL 0x00000242UL #define CKM_SHA256 0x00000250UL #define CKM_SHA256_HMAC 0x00000251UL #define CKM_SHA256_HMAC_GENERAL 0x00000252UL #define CKM_SHA224 0x00000255UL #define CKM_SHA224_HMAC 0x00000256UL #define CKM_SHA224_HMAC_GENERAL 0x00000257UL #define CKM_SHA384 0x00000260UL #define CKM_SHA384_HMAC 0x00000261UL #define CKM_SHA384_HMAC_GENERAL 0x00000262UL #define CKM_SHA512 0x00000270UL #define CKM_SHA512_HMAC 0x00000271UL #define CKM_SHA512_HMAC_GENERAL 0x00000272UL #define CKM_SECURID_KEY_GEN 0x00000280UL #define CKM_SECURID 0x00000282UL #define CKM_HOTP_KEY_GEN 0x00000290UL #define CKM_HOTP 0x00000291UL #define CKM_ACTI 0x000002A0UL #define CKM_ACTI_KEY_GEN 0x000002A1UL #define CKM_SHA3_256 0x000002B0UL #define CKM_SHA3_256_HMAC 0x000002B1UL #define CKM_SHA3_256_HMAC_GENERAL 0x000002B2UL #define CKM_SHA3_256_KEY_GEN 0x000002B3UL #define CKM_SHA3_224 0x000002B5UL #define CKM_SHA3_224_HMAC 0x000002B6UL #define CKM_SHA3_224_HMAC_GENERAL 0x000002B7UL #define CKM_SHA3_224_KEY_GEN 0x000002B8UL #define CKM_SHA3_384 0x000002C0UL #define CKM_SHA3_384_HMAC 0x000002C1UL #define CKM_SHA3_384_HMAC_GENERAL 0x000002C2UL #define CKM_SHA3_384_KEY_GEN 0x000002C3UL #define CKM_SHA3_512 0x000002D0UL #define CKM_SHA3_512_HMAC 0x000002D1UL #define CKM_SHA3_512_HMAC_GENERAL 0x000002D2UL #define CKM_SHA3_512_KEY_GEN 0x000002D3UL #define CKM_CAST_KEY_GEN 0x00000300UL #define CKM_CAST_ECB 0x00000301UL #define CKM_CAST_CBC 0x00000302UL #define CKM_CAST_MAC 0x00000303UL #define CKM_CAST_MAC_GENERAL 0x00000304UL #define CKM_CAST_CBC_PAD 0x00000305UL #define CKM_CAST3_KEY_GEN 0x00000310UL #define CKM_CAST3_ECB 0x00000311UL #define CKM_CAST3_CBC 0x00000312UL #define CKM_CAST3_MAC 0x00000313UL #define CKM_CAST3_MAC_GENERAL 0x00000314UL #define CKM_CAST3_CBC_PAD 0x00000315UL #define CKM_CAST128_KEY_GEN 0x00000320UL #define CKM_CAST128_ECB 0x00000321UL #define CKM_CAST128_MAC 0x00000323UL #define CKM_CAST128_CBC 0x00000322UL #define CKM_CAST128_MAC_GENERAL 0x00000324UL #define CKM_CAST128_CBC_PAD 0x00000325UL #define CKM_RC5_KEY_GEN 0x00000330UL #define CKM_RC5_ECB 0x00000331UL #define CKM_RC5_CBC 0x00000332UL #define CKM_RC5_MAC 0x00000333UL #define CKM_RC5_MAC_GENERAL 0x00000334UL #define CKM_RC5_CBC_PAD 0x00000335UL #define CKM_IDEA_KEY_GEN 0x00000340UL #define CKM_IDEA_ECB 0x00000341UL #define CKM_IDEA_CBC 0x00000342UL #define CKM_IDEA_MAC 0x00000343UL #define CKM_IDEA_MAC_GENERAL 0x00000344UL #define CKM_IDEA_CBC_PAD 0x00000345UL #define CKM_GENERIC_SECRET_KEY_GEN 0x00000350UL #define CKM_CONCATENATE_BASE_AND_KEY 0x00000360UL #define CKM_CONCATENATE_BASE_AND_DATA 0x00000362UL #define CKM_CONCATENATE_DATA_AND_BASE 0x00000363UL #define CKM_XOR_BASE_AND_DATA 0x00000364UL #define CKM_EXTRACT_KEY_FROM_KEY 0x00000365UL #define CKM_SSL3_PRE_MASTER_KEY_GEN 0x00000370UL #define CKM_SSL3_MASTER_KEY_DERIVE 0x00000371UL #define CKM_SSL3_KEY_AND_MAC_DERIVE 0x00000372UL #define CKM_SSL3_MASTER_KEY_DERIVE_DH 0x00000373UL #define CKM_TLS_PRE_MASTER_KEY_GEN 0x00000374UL #define CKM_TLS_MASTER_KEY_DERIVE 0x00000375UL #define CKM_TLS_KEY_AND_MAC_DERIVE 0x00000376UL #define CKM_TLS_MASTER_KEY_DERIVE_DH 0x00000377UL #define CKM_TLS_PRF 0x00000378UL #define CKM_SSL3_MD5_MAC 0x00000380UL #define CKM_SSL3_SHA1_MAC 0x00000381UL #define CKM_MD5_KEY_DERIVATION 0x00000390UL #define CKM_MD2_KEY_DERIVATION 0x00000391UL #define CKM_SHA1_KEY_DERIVATION 0x00000392UL #define CKM_SHA256_KEY_DERIVATION 0x00000393UL #define CKM_SHA384_KEY_DERIVATION 0x00000394UL #define CKM_SHA512_KEY_DERIVATION 0x00000395UL #define CKM_SHA224_KEY_DERIVATION 0x00000396UL #define CKM_SHA3_256_KEY_DERIVATION 0x00000397UL #define CKM_SHA3_256_KEY_DERIVE 0x00000397UL #define CKM_SHA3_224_KEY_DERIVATION 0x00000398UL #define CKM_SHA3_224_KEY_DERIVE 0x00000398UL #define CKM_SHA3_384_KEY_DERIVATION 0x00000399UL #define CKM_SHA3_384_KEY_DERIVE 0x00000399UL #define CKM_SHA3_512_KEY_DERIVATION 0x0000039AUL #define CKM_SHA3_512_KEY_DERIVE 0x0000039AUL #define CKM_SHAKE_128_KEY_DERIVATION 0x0000039BUL #define CKM_SHAKE_128_KEY_DERIVE 0x0000039BUL #define CKM_SHAKE_256_KEY_DERIVATION 0x0000039CUL #define CKM_SHAKE_256_KEY_DERIVE 0x0000039CUL #define CKM_PBE_MD2_DES_CBC 0x000003A0UL #define CKM_PBE_MD5_DES_CBC 0x000003A1UL #define CKM_PBE_MD5_CAST_CBC 0x000003A2UL #define CKM_PBE_MD5_CAST3_CBC 0x000003A3UL #define CKM_PBE_MD5_CAST128_CBC 0x000003A4UL #define CKM_PBE_SHA1_CAST128_CBC 0x000003A5UL #define CKM_PBE_SHA1_RC4_128 0x000003A6UL #define CKM_PBE_SHA1_RC4_40 0x000003A7UL #define CKM_PBE_SHA1_DES3_EDE_CBC 0x000003A8UL #define CKM_PBE_SHA1_DES2_EDE_CBC 0x000003A9UL #define CKM_PBE_SHA1_RC2_128_CBC 0x000003AAUL #define CKM_PBE_SHA1_RC2_40_CBC 0x000003ABUL #define CKM_PKCS5_PBKD2 0x000003B0UL #define CKM_PBA_SHA1_WITH_SHA1_HMAC 0x000003C0UL #define CKM_WTLS_PRE_MASTER_KEY_GEN 0x000003D0UL #define CKM_WTLS_MASTER_KEY_DERIVE 0x000003D1UL #define CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC 0x000003D2UL #define CKM_WTLS_PRF 0x000003D3UL #define CKM_WTLS_SERVER_KEY_AND_MAC_DERIVE 0x000003D4UL #define CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE 0x000003D5UL #define CKM_TLS10_MAC_SERVER 0x000003D6UL #define CKM_TLS10_MAC_CLIENT 0x000003D7UL #define CKM_TLS12_MAC 0x000003D8UL #define CKM_TLS12_KDF 0x000003D9UL #define CKM_TLS12_MASTER_KEY_DERIVE 0x000003E0UL #define CKM_TLS12_KEY_AND_MAC_DERIVE 0x000003E1UL #define CKM_TLS12_MASTER_KEY_DERIVE_DH 0x000003E2UL #define CKM_TLS12_KEY_SAFE_DERIVE 0x000003E3UL #define CKM_TLS_MAC 0x000003E4UL #define CKM_TLS_KDF 0x000003E5UL #define CKM_KEY_WRAP_LYNKS 0x00000400UL #define CKM_KEY_WRAP_SET_OAEP 0x00000401UL #define CKM_CMS_SIG 0x00000500UL #define CKM_KIP_DERIVE 0x00000510UL #define CKM_KIP_WRAP 0x00000511UL #define CKM_KIP_MAC 0x00000512UL #define CKM_CAMELLIA_KEY_GEN 0x00000550UL #define CKM_CAMELLIA_ECB 0x00000551UL #define CKM_CAMELLIA_CBC 0x00000552UL #define CKM_CAMELLIA_MAC 0x00000553UL #define CKM_CAMELLIA_MAC_GENERAL 0x00000554UL #define CKM_CAMELLIA_CBC_PAD 0x00000555UL #define CKM_CAMELLIA_ECB_ENCRYPT_DATA 0x00000556UL #define CKM_CAMELLIA_CBC_ENCRYPT_DATA 0x00000557UL #define CKM_CAMELLIA_CTR 0x00000558UL #define CKM_ARIA_KEY_GEN 0x00000560UL #define CKM_ARIA_ECB 0x00000561UL #define CKM_ARIA_CBC 0x00000562UL #define CKM_ARIA_MAC 0x00000563UL #define CKM_ARIA_MAC_GENERAL 0x00000564UL #define CKM_ARIA_CBC_PAD 0x00000565UL #define CKM_ARIA_ECB_ENCRYPT_DATA 0x00000566UL #define CKM_ARIA_CBC_ENCRYPT_DATA 0x00000567UL #define CKM_SEED_KEY_GEN 0x00000650UL #define CKM_SEED_ECB 0x00000651UL #define CKM_SEED_CBC 0x00000652UL #define CKM_SEED_MAC 0x00000653UL #define CKM_SEED_MAC_GENERAL 0x00000654UL #define CKM_SEED_CBC_PAD 0x00000655UL #define CKM_SEED_ECB_ENCRYPT_DATA 0x00000656UL #define CKM_SEED_CBC_ENCRYPT_DATA 0x00000657UL #define CKM_SKIPJACK_KEY_GEN 0x00001000UL #define CKM_SKIPJACK_ECB64 0x00001001UL #define CKM_SKIPJACK_CBC64 0x00001002UL #define CKM_SKIPJACK_OFB64 0x00001003UL #define CKM_SKIPJACK_CFB64 0x00001004UL #define CKM_SKIPJACK_CFB32 0x00001005UL #define CKM_SKIPJACK_CFB16 0x00001006UL #define CKM_SKIPJACK_CFB8 0x00001007UL #define CKM_SKIPJACK_WRAP 0x00001008UL #define CKM_SKIPJACK_PRIVATE_WRAP 0x00001009UL #define CKM_SKIPJACK_RELAYX 0x0000100AUL #define CKM_KEA_KEY_PAIR_GEN 0x00001010UL #define CKM_KEA_KEY_DERIVE 0x00001011UL #define CKM_KEA_DERIVE 0x00001012UL #define CKM_FORTEZZA_TIMESTAMP 0x00001020UL #define CKM_BATON_KEY_GEN 0x00001030UL #define CKM_BATON_ECB128 0x00001031UL #define CKM_BATON_ECB96 0x00001032UL #define CKM_BATON_CBC128 0x00001033UL #define CKM_BATON_COUNTER 0x00001034UL #define CKM_BATON_SHUFFLE 0x00001035UL #define CKM_BATON_WRAP 0x00001036UL #define CKM_EC_KEY_PAIR_GEN 0x00001040UL #define CKM_ECDSA 0x00001041UL #define CKM_ECDSA_SHA1 0x00001042UL #define CKM_ECDSA_SHA224 0x00001043UL #define CKM_ECDSA_SHA256 0x00001044UL #define CKM_ECDSA_SHA384 0x00001045UL #define CKM_ECDSA_SHA512 0x00001046UL #define CKM_EC_KEY_PAIR_GEN_W_EXTRA_BITS 0x0000140BUL #define CKM_ECDH1_DERIVE 0x00001050UL #define CKM_ECDH1_COFACTOR_DERIVE 0x00001051UL #define CKM_ECMQV_DERIVE 0x00001052UL #define CKM_ECDH_AES_KEY_WRAP 0x00001053UL #define CKM_RSA_AES_KEY_WRAP 0x00001054UL #define CKM_JUNIPER_KEY_GEN 0x00001060UL #define CKM_JUNIPER_ECB128 0x00001061UL #define CKM_JUNIPER_CBC128 0x00001062UL #define CKM_JUNIPER_COUNTER 0x00001063UL #define CKM_JUNIPER_SHUFFLE 0x00001064UL #define CKM_JUNIPER_WRAP 0x00001065UL #define CKM_FASTHASH 0x00001070UL #define CKM_AES_XTS 0x00001071UL #define CKM_AES_XTS_KEY_GEN 0x00001072UL #define CKM_AES_KEY_GEN 0x00001080UL #define CKM_AES_ECB 0x00001081UL #define CKM_AES_CBC 0x00001082UL #define CKM_AES_MAC 0x00001083UL #define CKM_AES_MAC_GENERAL 0x00001084UL #define CKM_AES_CBC_PAD 0x00001085UL #define CKM_AES_CTR 0x00001086UL #define CKM_AES_GCM 0x00001087UL #define CKM_AES_CCM 0x00001088UL #define CKM_AES_CTS 0x00001089UL #define CKM_AES_CMAC 0x0000108AUL #define CKM_AES_CMAC_GENERAL 0x0000108BUL #define CKM_AES_XCBC_MAC 0x0000108CUL #define CKM_AES_XCBC_MAC_96 0x0000108DUL #define CKM_AES_GMAC 0x0000108EUL #define CKM_BLOWFISH_KEY_GEN 0x00001090UL #define CKM_BLOWFISH_CBC 0x00001091UL #define CKM_TWOFISH_KEY_GEN 0x00001092UL #define CKM_TWOFISH_CBC 0x00001093UL #define CKM_BLOWFISH_CBC_PAD 0x00001094UL #define CKM_TWOFISH_CBC_PAD 0x00001095UL #define CKM_DES_ECB_ENCRYPT_DATA 0x00001100UL #define CKM_DES_CBC_ENCRYPT_DATA 0x00001101UL #define CKM_DES3_ECB_ENCRYPT_DATA 0x00001102UL #define CKM_DES3_CBC_ENCRYPT_DATA 0x00001103UL #define CKM_AES_ECB_ENCRYPT_DATA 0x00001104UL #define CKM_AES_CBC_ENCRYPT_DATA 0x00001105UL #define CKM_GOSTR3410_KEY_PAIR_GEN 0x00001200UL #define CKM_GOSTR3410 0x00001201UL #define CKM_GOSTR3410_WITH_GOSTR3411 0x00001202UL #define CKM_GOSTR3410_KEY_WRAP 0x00001203UL #define CKM_GOSTR3410_DERIVE 0x00001204UL #define CKM_GOSTR3411 0x00001210UL #define CKM_GOSTR3411_HMAC 0x00001211UL #define CKM_GOST28147_KEY_GEN 0x00001220UL #define CKM_GOST28147_ECB 0x00001221UL #define CKM_GOST28147 0x00001222UL #define CKM_GOST28147_MAC 0x00001223UL #define CKM_GOST28147_KEY_WRAP 0x00001224UL #define CKM_CHACHA20_KEY_GEN 0x00001225UL #define CKM_CHACHA20 0x00001226UL #define CKM_POLY1305_KEY_GEN 0x00001227UL #define CKM_POLY1305 0x00001228UL #define CKM_DSA_PARAMETER_GEN 0x00002000UL #define CKM_DH_PKCS_PARAMETER_GEN 0x00002001UL #define CKM_X9_42_DH_PARAMETER_GEN 0x00002002UL #define CKM_DSA_PROBABILISTIC_PARAMETER_GEN 0x00002003UL #define CKM_DSA_SHAWE_TAYLOR_PARAMETER_GEN 0x00002004UL #define CKM_DSA_FIPS_G_GEN 0x00002005UL #define CKM_AES_OFB 0x00002104UL #define CKM_AES_CFB64 0x00002105UL #define CKM_AES_CFB8 0x00002106UL #define CKM_AES_CFB128 0x00002107UL #define CKM_AES_CFB1 0x00002108UL #define CKM_AES_KEY_WRAP 0x00002109UL #define CKM_AES_KEY_WRAP_PAD 0x0000210AUL #define CKM_AES_KEY_WRAP_KWP 0x0000210BUL #define CKM_AES_KEY_WRAP_PKCS7 0x0000210CUL #define CKM_RSA_PKCS_TPM_1_1 0x00004001UL #define CKM_RSA_PKCS_OAEP_TPM_1_1 0x00004002UL #define CKM_SHA_1_KEY_GEN 0x00004003UL #define CKM_SHA224_KEY_GEN 0x00004004UL #define CKM_SHA256_KEY_GEN 0x00004005UL #define CKM_SHA384_KEY_GEN 0x00004006UL #define CKM_SHA512_KEY_GEN 0x00004007UL #define CKM_SHA512_224_KEY_GEN 0x00004008UL #define CKM_SHA512_256_KEY_GEN 0x00004009UL #define CKM_SHA512_T_KEY_GEN 0x0000400AUL #define CKM_NULL 0x0000400BUL #define CKM_BLAKE2B_160 0x0000400CUL #define CKM_BLAKE2B_160_HMAC 0x0000400DUL #define CKM_BLAKE2B_160_HMAC_GENERAL 0x0000400EUL #define CKM_BLAKE2B_160_KEY_DERIVE 0x0000400FUL #define CKM_BLAKE2B_160_KEY_GEN 0x00004010UL #define CKM_BLAKE2B_256 0x00004011UL #define CKM_BLAKE2B_256_HMAC 0x00004012UL #define CKM_BLAKE2B_256_HMAC_GENERAL 0x00004013UL #define CKM_BLAKE2B_256_KEY_DERIVE 0x00004014UL #define CKM_BLAKE2B_256_KEY_GEN 0x00004015UL #define CKM_BLAKE2B_384 0x00004016UL #define CKM_BLAKE2B_384_HMAC 0x00004017UL #define CKM_BLAKE2B_384_HMAC_GENERAL 0x00004018UL #define CKM_BLAKE2B_384_KEY_DERIVE 0x00004019UL #define CKM_BLAKE2B_384_KEY_GEN 0x0000401AUL #define CKM_BLAKE2B_512 0x0000401BUL #define CKM_BLAKE2B_512_HMAC 0x0000401CUL #define CKM_BLAKE2B_512_HMAC_GENERAL 0x0000401DUL #define CKM_BLAKE2B_512_KEY_DERIVE 0x0000401EUL #define CKM_BLAKE2B_512_KEY_GEN 0x0000401FUL #define CKM_SALSA20 0x00004020UL #define CKM_CHACHA20_POLY1305 0x00004021UL #define CKM_SALSA20_POLY1305 0x00004022UL #define CKM_X3DH_INITIALIZE 0x00004023UL #define CKM_X3DH_RESPOND 0x00004024UL #define CKM_X2RATCHET_INITIALIZE 0x00004025UL #define CKM_X2RATCHET_RESPOND 0x00004026UL #define CKM_X2RATCHET_ENCRYPT 0x00004027UL #define CKM_X2RATCHET_DECRYPT 0x00004028UL #define CKM_XEDDSA 0x00004029UL #define CKM_HKDF_DERIVE 0x0000402AUL #define CKM_HKDF_DATA 0x0000402BUL #define CKM_HKDF_KEY_GEN 0x0000402CUL #define CKM_SALSA20_KEY_GEN 0x0000402DUL #define CKM_ECDSA_SHA3_224 0x00001047UL #define CKM_ECDSA_SHA3_256 0x00001048UL #define CKM_ECDSA_SHA3_384 0x00001049UL #define CKM_ECDSA_SHA3_512 0x0000104AUL #define CKM_EC_EDWARDS_KEY_PAIR_GEN 0x00001055UL #define CKM_EC_MONTGOMERY_KEY_PAIR_GEN 0x00001056UL #define CKM_EDDSA 0x00001057UL #define CKM_SP800_108_COUNTER_KDF 0x000003ACUL #define CKM_SP800_108_FEEDBACK_KDF 0x000003ADUL #define CKM_SP800_108_DOUBLE_PIPELINE_KDF 0x000003AEUL #define CKM_IKE2_PRF_PLUS_DERIVE 0x0000402EUL #define CKM_IKE_PRF_DERIVE 0x0000402FUL #define CKM_IKE1_PRF_DERIVE 0x00004030UL #define CKM_IKE1_EXTENDED_DERIVE 0x00004031UL #define CKM_HSS_KEY_PAIR_GEN 0x00004032UL #define CKM_HSS 0x00004033UL #define CKM_XMSS_KEY_PAIR_GEN 0x00004034UL #define CKM_XMSSMT_KEY_PAIR_GEN 0x00004035UL #define CKM_XMSS 0x00004036UL #define CKM_XMSSMT 0x00004037UL #define CKM_ECDH_X_AES_KEY_WRAP 0x00004038UL #define CKM_ECDH_COF_AES_KEY_WRAP 0x00004039UL #define CKM_PUB_KEY_FROM_PRIV_KEY 0x0000403AUL #define CKM_VENDOR_DEFINED 0x80000000UL /* Deprecated */ #ifdef PKCS11_DEPRECATED #define CKM_CAST5_KEY_GEN 0x00000320UL #define CKM_CAST5_ECB 0x00000321UL #define CKM_CAST5_CBC 0x00000322UL #define CKM_CAST5_MAC 0x00000323UL #define CKM_CAST5_MAC_GENERAL 0x00000324UL #define CKM_CAST5_CBC_PAD 0x00000325UL #define CKM_PBE_MD5_CAST5_CBC 0x000003A4UL #define CKM_PBE_SHA1_CAST5_CBC 0x000003A5UL #define CKM_ECDSA_KEY_PAIR_GEN 0x00001040UL #define CKM_DSA_PROBABLISTIC_PARAMETER_GEN 0x00002003UL #endif /* CKN */ #define CKN_SURRENDER 0UL #define CKN_OTP_CHANGED 1UL /* CKO */ #define CKO_DATA 0x00000000UL #define CKO_CERTIFICATE 0x00000001UL #define CKO_PUBLIC_KEY 0x00000002UL #define CKO_PRIVATE_KEY 0x00000003UL #define CKO_SECRET_KEY 0x00000004UL #define CKO_HW_FEATURE 0x00000005UL #define CKO_DOMAIN_PARAMETERS 0x00000006UL #define CKO_MECHANISM 0x00000007UL #define CKO_OTP_KEY 0x00000008UL #define CKO_PROFILE 0x00000009UL #define CKO_VALIDATION 0x0000000AUL #define CKO_TRUST 0x0000000BUL #define CKO_VENDOR_DEFINED 0x80000000UL /* CKP (profile) */ #define CKP_INVALID_ID 0x00000000UL #define CKP_BASELINE_PROVIDER 0x00000001UL #define CKP_EXTENDED_PROVIDER 0x00000002UL #define CKP_AUTHENTICATION_TOKEN 0x00000003UL #define CKP_PUBLIC_CERTIFICATES_TOKEN 0x00000004UL #define CKP_COMPLETE_PROVIDER 0x00000005UL #define CKP_HKDF_TLS_TOKEN 0x00000006UL #define CKP_VENDOR_DEFINED 0x80000000UL /* CKP (PBKD2) */ #define CKP_PKCS5_PBKD2_HMAC_SHA1 0x00000001UL #define CKP_PKCS5_PBKD2_HMAC_GOSTR3411 0x00000002UL #define CKP_PKCS5_PBKD2_HMAC_SHA224 0x00000003UL #define CKP_PKCS5_PBKD2_HMAC_SHA256 0x00000004UL #define CKP_PKCS5_PBKD2_HMAC_SHA384 0x00000005UL #define CKP_PKCS5_PBKD2_HMAC_SHA512 0x00000006UL #define CKP_PKCS5_PBKD2_HMAC_SHA512_224 0x00000007UL #define CKP_PKCS5_PBKD2_HMAC_SHA512_256 0x00000008UL /* CKP (ML-DSA) */ #define CKP_ML_DSA_44 0x00000001UL #define CKP_ML_DSA_65 0x00000002UL #define CKP_ML_DSA_87 0x00000003UL /* CKP (ML_KEM) */ #define CKP_ML_KEM_512 0x00000001UL #define CKP_ML_KEM_768 0x00000002UL #define CKP_ML_KEM_1024 0x00000003UL /* CKP (SLH-DSA) */ #define CKP_SLH_DSA_SHA2_128S 0x00000001UL #define CKP_SLH_DSA_SHAKE_128S 0x00000002UL #define CKP_SLH_DSA_SHA2_128F 0x00000003UL #define CKP_SLH_DSA_SHAKE_128F 0x00000004UL #define CKP_SLH_DSA_SHA2_192S 0x00000005UL #define CKP_SLH_DSA_SHAKE_192S 0x00000006UL #define CKP_SLH_DSA_SHA2_192F 0x00000007UL #define CKP_SLH_DSA_SHAKE_192F 0x00000008UL #define CKP_SLH_DSA_SHA2_256S 0x00000009UL #define CKP_SLH_DSA_SHAKE_256S 0x0000000AUL #define CKP_SLH_DSA_SHA2_256F 0x0000000BUL #define CKP_SLH_DSA_SHAKE_256F 0x0000000CUL /* CKR */ #define CKR_OK 0x00000000UL #define CKR_CANCEL 0x00000001UL #define CKR_HOST_MEMORY 0x00000002UL #define CKR_SLOT_ID_INVALID 0x00000003UL #define CKR_GENERAL_ERROR 0x00000005UL #define CKR_FUNCTION_FAILED 0x00000006UL #define CKR_ARGUMENTS_BAD 0x00000007UL #define CKR_NO_EVENT 0x00000008UL #define CKR_NEED_TO_CREATE_THREADS 0x00000009UL #define CKR_CANT_LOCK 0x0000000AUL #define CKR_ATTRIBUTE_READ_ONLY 0x00000010UL #define CKR_ATTRIBUTE_SENSITIVE 0x00000011UL #define CKR_ATTRIBUTE_TYPE_INVALID 0x00000012UL #define CKR_ATTRIBUTE_VALUE_INVALID 0x00000013UL #define CKR_ACTION_PROHIBITED 0x0000001BUL #define CKR_DATA_INVALID 0x00000020UL #define CKR_DATA_LEN_RANGE 0x00000021UL #define CKR_DEVICE_ERROR 0x00000030UL #define CKR_DEVICE_MEMORY 0x00000031UL #define CKR_DEVICE_REMOVED 0x00000032UL #define CKR_ENCRYPTED_DATA_INVALID 0x00000040UL #define CKR_ENCRYPTED_DATA_LEN_RANGE 0x00000041UL #define CKR_AEAD_DECRYPT_FAILED 0x00000042UL #define CKR_FUNCTION_CANCELED 0x00000050UL #define CKR_FUNCTION_NOT_PARALLEL 0x00000051UL #define CKR_FUNCTION_NOT_SUPPORTED 0x00000054UL #define CKR_KEY_HANDLE_INVALID 0x00000060UL #define CKR_KEY_SIZE_RANGE 0x00000062UL #define CKR_KEY_TYPE_INCONSISTENT 0x00000063UL #define CKR_KEY_NOT_NEEDED 0x00000064UL #define CKR_KEY_CHANGED 0x00000065UL #define CKR_KEY_NEEDED 0x00000066UL #define CKR_KEY_INDIGESTIBLE 0x00000067UL #define CKR_KEY_FUNCTION_NOT_PERMITTED 0x00000068UL #define CKR_KEY_NOT_WRAPPABLE 0x00000069UL #define CKR_KEY_UNEXTRACTABLE 0x0000006AUL #define CKR_MECHANISM_INVALID 0x00000070UL #define CKR_MECHANISM_PARAM_INVALID 0x00000071UL #define CKR_OBJECT_HANDLE_INVALID 0x00000082UL #define CKR_OPERATION_ACTIVE 0x00000090UL #define CKR_OPERATION_NOT_INITIALIZED 0x00000091UL #define CKR_PIN_INCORRECT 0x000000A0UL #define CKR_PIN_INVALID 0x000000A1UL #define CKR_PIN_LEN_RANGE 0x000000A2UL #define CKR_PIN_EXPIRED 0x000000A3UL #define CKR_PIN_LOCKED 0x000000A4UL #define CKR_SESSION_CLOSED 0x000000B0UL #define CKR_SESSION_COUNT 0x000000B1UL #define CKR_SESSION_HANDLE_INVALID 0x000000B3UL #define CKR_SESSION_PARALLEL_NOT_SUPPORTED 0x000000B4UL #define CKR_SESSION_READ_ONLY 0x000000B5UL #define CKR_SESSION_EXISTS 0x000000B6UL #define CKR_SESSION_READ_ONLY_EXISTS 0x000000B7UL #define CKR_SESSION_READ_WRITE_SO_EXISTS 0x000000B8UL #define CKR_SIGNATURE_INVALID 0x000000C0UL #define CKR_SIGNATURE_LEN_RANGE 0x000000C1UL #define CKR_TEMPLATE_INCOMPLETE 0x000000D0UL #define CKR_TEMPLATE_INCONSISTENT 0x000000D1UL #define CKR_TOKEN_NOT_PRESENT 0x000000E0UL #define CKR_TOKEN_NOT_RECOGNIZED 0x000000E1UL #define CKR_TOKEN_WRITE_PROTECTED 0x000000E2UL #define CKR_UNWRAPPING_KEY_HANDLE_INVALID 0x000000F0UL #define CKR_UNWRAPPING_KEY_SIZE_RANGE 0x000000F1UL #define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT 0x000000F2UL #define CKR_USER_ALREADY_LOGGED_IN 0x00000100UL #define CKR_USER_NOT_LOGGED_IN 0x00000101UL #define CKR_USER_PIN_NOT_INITIALIZED 0x00000102UL #define CKR_USER_TYPE_INVALID 0x00000103UL #define CKR_USER_ANOTHER_ALREADY_LOGGED_IN 0x00000104UL #define CKR_USER_TOO_MANY_TYPES 0x00000105UL #define CKR_WRAPPED_KEY_INVALID 0x00000110UL #define CKR_WRAPPED_KEY_LEN_RANGE 0x00000112UL #define CKR_WRAPPING_KEY_HANDLE_INVALID 0x00000113UL #define CKR_WRAPPING_KEY_SIZE_RANGE 0x00000114UL #define CKR_WRAPPING_KEY_TYPE_INCONSISTENT 0x00000115UL #define CKR_RANDOM_SEED_NOT_SUPPORTED 0x00000120UL #define CKR_RANDOM_NO_RNG 0x00000121UL #define CKR_DOMAIN_PARAMS_INVALID 0x00000130UL #define CKR_CURVE_NOT_SUPPORTED 0x00000140UL #define CKR_BUFFER_TOO_SMALL 0x00000150UL #define CKR_SAVED_STATE_INVALID 0x00000160UL #define CKR_INFORMATION_SENSITIVE 0x00000170UL #define CKR_STATE_UNSAVEABLE 0x00000180UL #define CKR_CRYPTOKI_NOT_INITIALIZED 0x00000190UL #define CKR_CRYPTOKI_ALREADY_INITIALIZED 0x00000191UL #define CKR_MUTEX_BAD 0x000001A0UL #define CKR_MUTEX_NOT_LOCKED 0x000001A1UL #define CKR_NEW_PIN_MODE 0x000001B0UL #define CKR_NEXT_OTP 0x000001B1UL #define CKR_EXCEEDED_MAX_ITERATIONS 0x000001B5UL #define CKR_FIPS_SELF_TEST_FAILED 0x000001B6UL #define CKR_LIBRARY_LOAD_FAILED 0x000001B7UL #define CKR_PIN_TOO_WEAK 0x000001B8UL #define CKR_PUBLIC_KEY_INVALID 0x000001B9UL #define CKR_FUNCTION_REJECTED 0x00000200UL #define CKR_TOKEN_RESOURCE_EXCEEDED 0x00000201UL #define CKR_OPERATION_CANCEL_FAILED 0x00000202UL #define CKR_KEY_EXHAUSTED 0x00000203UL #define CKR_PENDING 0x00000204UL #define CKR_SESSION_ASYNC_NOT_SUPPORTED 0x00000205UL #define CKR_SEED_RANDOM_REQUIRED 0x00000206UL #define CKR_OPERATION_NOT_VALIDATED 0x00000207UL #define CKR_TOKEN_NOT_INITIALIZED 0x00000208UL #define CKR_PARAMETER_SET_NOT_SUPPORTED 0x00000209UL #define CKR_VENDOR_DEFINED 0x80000000UL /* CKS */ #define CKS_RO_PUBLIC_SESSION 0UL #define CKS_RO_USER_FUNCTIONS 1UL #define CKS_RW_PUBLIC_SESSION 2UL #define CKS_RW_USER_FUNCTIONS 3UL #define CKS_RW_SO_FUNCTIONS 4UL /* CKS (validation) */ #define CKS_LAST_VALIDATION_OK 0x00000001UL /* CKT (trust) */ #define CKT_TRUST_UNKNOWN 0x00000000UL #define CKT_TRUSTED 0x00000001UL #define CKT_TRUST_ANCHOR 0x00000002UL #define CKT_NOT_TRUSTED 0x00000003UL #define CKT_TRUST_MUST_VERIFY_TRUST 0x00000004UL /* CKU */ #define CKU_SO 0UL #define CKU_USER 1UL #define CKU_CONTEXT_SPECIFIC 2UL /* CKV (validation authority) */ #define CKV_AUTHORITY_TYPE_UNSPECIFIED 0x00000000UL #define CKV_AUTHORITY_TYPE_NIST_CMVP 0x00000001UL #define CKV_AUTHORITY_TYPE_COMMON_CRITERIA 0x00000002UL /* CKV (validation type) */ #define CKV_TYPE_UNSPECIFIED 0x00000000UL #define CKV_TYPE_SOFTWARE 0x00000001UL #define CKV_TYPE_HARDWARE 0x00000002UL #define CKV_TYPE_FIRMWARE 0x00000003UL #define CKV_TYPE_HYBRID 0x00000004UL /* CKZ (data) */ #define CKZ_DATA_SPECIFIED 0x00000001UL /* CKZ (salt) */ #define CKZ_SALT_SPECIFIED 0x00000001UL %include "pkcs11lib.h" class CK_ATTRIBUTE_SMART { public: void Reset(); void ResetValue(); void Reserve(long len); unsigned long GetType() const; void SetType(unsigned long attrType); int GetLen() const; bool IsString() const; bool IsBool() const; bool IsNum() const; bool IsAttributeList() const; bool IsBin() const; PyKCS11String GetString() const; void SetString(unsigned long attrType, const char* szValue); long GetNum() const; void SetNum(unsigned long attrType, unsigned long ulValue); bool GetBool() const; void SetBool(unsigned long attrType, bool bValue); void SetList(unsigned long attrType, const vector& val); vector GetBin(); void SetBin(unsigned long attrType, const vector& pBuf); }; ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/pykcs11string.cpp0000644000175100017510000000272715246574333016601 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2017-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #include "stdafx.h" #include "pykcs11string.h" PyKCS11String::PyKCS11String() {} PyKCS11String::PyKCS11String(unsigned char* pBuf, int len) { int i; if (m_str.max_size() < (size_t)len) m_str.reserve(len); for (i=0; i < len; i++) m_str.push_back((char)pBuf[i]); } PyKCS11String::PyKCS11String(const char* str):m_str(str) { } PyKCS11String::PyKCS11String(basic_string str):m_str(str) { } PyKCS11String::PyKCS11String(vector bin_str) { if (m_str.max_size() < bin_str.size()) m_str.reserve(bin_str.size()); size_t iSize = bin_str.size(); size_t i; for (i=0; i < iSize; i++) m_str.push_back(bin_str[i]); } ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/pykcs11string.h0000644000175100017510000000223715246574333016242 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2017-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #pragma once #include #include using namespace std; typedef struct PyKCS11String { PyKCS11String(); PyKCS11String(unsigned char* pBuf, int len); PyKCS11String(const char* str); PyKCS11String(basic_string str); PyKCS11String(vector bin_str); basic_string m_str; }PyKCS11String; ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/stdafx.h0000644000175100017510000000252215246574333015006 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2017 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. // stdafx.h : include file for standard system include files, // or project specific include files that are used frequently, but // are changed infrequently // #pragma once #include #include #include #include using namespace std; #ifdef WIN32 #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers // Windows Header Files: #include #endif #include "opensc/pkcs11.h" // TODO: reference additional headers your program requires here ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5957735 pykcs11-1.5.20/src/utility.cpp0000644000175100017510000000470315246574333015556 0ustar00runnerrunner// Copyright (C) 2004 Midori (midori -- a-t -- paipai dot net) // Copyright (C) 2017-2025 Ludovic Rousseau (ludovic.rousseau@free.fr) // // This file is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program 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 // General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. #include "stdafx.h" #include #include "pykcs11string.h" #include "ck_attribute_smart.h" #include "pkcs11lib.h" #include "utility.h" using namespace std; unsigned char * Vector2Buffer(vector &Buf, CK_ULONG &Len) { Len = (CK_ULONG)Buf.size(); if (!Len) return NULL; CK_ULONG i; unsigned char *pBuf = new unsigned char[Len]; for (i = 0; i &Buf, bool bAllocIfNull) { Buf.clear(); if (!pBuf & bAllocIfNull) Buf = vector(Len); else { Buf.reserve(Len); CK_ULONG i; for (i = 0; i &Attr, CK_ULONG &Len) { Len = (CK_ULONG) Attr.size(); if (!Len) return NULL; CK_ULONG i; CK_ATTRIBUTE_PTR pTemplate = new CK_ATTRIBUTE[Len]; for (i=0; i< Len; i++) { pTemplate[i].type = Attr[i].GetType(); pTemplate[i].pValue = Vector2Buffer(Attr[i].GetBin(), pTemplate[i].ulValueLen); } return pTemplate; } void Template2AttrVector(CK_ATTRIBUTE_PTR pTemplate, CK_ULONG Len, vector &Attr) { CK_ULONG i; for (i=0; i &Buf, CK_ULONG &Len); CK_ATTRIBUTE_PTR AttrVector2Template(vector &Attr, CK_ULONG &Len); void Template2AttrVector(CK_ATTRIBUTE_PTR pTemplate, CK_ULONG Len, vector &Attr); void DestroyTemplate(CK_ATTRIBUTE_PTR &pTemplate, CK_ULONG Len); void Buffer2Vector(unsigned char* pBuf, CK_ULONG Len, vector &Buf, bool bAllocIfNull); #endif //_UTILITY_H__DEFINED_ ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541149.9793406 pykcs11-1.5.20/test/0000755000175100017510000000000015246574336013536 5ustar00runnerrunner././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_CK.py0000644000175100017510000000150415246574333015441 0ustar00runnerrunner#! /usr/bin/env python # execute using: # python test/test_CK.py # pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest import PyKCS11 class TestUtil(unittest.TestCase): def test_CKM(self): self.assertEqual(PyKCS11.CKM_RSA_PKCS_KEY_PAIR_GEN, 0x00000000) self.assertEqual( PyKCS11.CKM[PyKCS11.CKM_RSA_PKCS_KEY_PAIR_GEN], "CKM_RSA_PKCS_KEY_PAIR_GEN" ) self.assertEqual(PyKCS11.CKM_VENDOR_DEFINED, 0x80000000) def test_CKR(self): self.assertEqual(PyKCS11.CKR_VENDOR_DEFINED, 0x80000000) def test_CKH(self): self.assertEqual(PyKCS11.CKH_USER_INTERFACE, 3) self.assertEqual(PyKCS11.CKH["CKH_USER_INTERFACE"], 3) if __name__ == "__main__": unittest.main() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_LowLevel.py0000644000175100017510000001224215246574333016676 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import os import platform import unittest import PyKCS11.LowLevel from PyKCS11 import ckbytelist class TestUtil(unittest.TestCase): def test_LowLevel(self): a = PyKCS11.LowLevel.CPKCS11Lib() self.assertIsNotNone(a) # File not found self.assertEqual(a.Load("NoFile"), -1) # C_GetFunctionList() not found if platform.system() == "Linux": # GNU/Linux lib = "libc.so.6" elif platform.system() == "Darwin": # macOS lib = "/usr/lib/libSystem.B.dylib" else: # Windows lib = "WinSCard.dll" self.assertEqual(a.Load(lib), -4) info = PyKCS11.LowLevel.CK_INFO() self.assertIsNotNone(info) slotInfo = PyKCS11.LowLevel.CK_SLOT_INFO() self.assertIsNotNone(slotInfo) lib = os.getenv("PYKCS11LIB") if lib is None: raise Exception("Define PYKCS11LIB") session = PyKCS11.LowLevel.CK_SESSION_HANDLE() self.assertIsNotNone(session) sessionInfo = PyKCS11.LowLevel.CK_SESSION_INFO() self.assertIsNotNone(sessionInfo) tokenInfo = PyKCS11.LowLevel.CK_TOKEN_INFO() self.assertIsNotNone(tokenInfo) slotList = PyKCS11.LowLevel.ckulonglist() self.assertIsNotNone(slotList) longList = PyKCS11.LowLevel.ckulonglist(1) longList[0] = 42 self.assertEqual(longList[0], 42) longList[0] = 0x80000000 self.assertEqual(longList[0], 2147483648) longList[0] = 0xFFFFFFFF self.assertEqual(longList[0], 4294967295) # negative numbers are not allowed with self.assertRaises(TypeError): longList[0] = -1 a.Load(lib) self.assertEqual(a.C_GetInfo(info), PyKCS11.LowLevel.CKR_OK) manufacturerID = info.GetManufacturerID() self.assertEqual(manufacturerID, "SoftHSM".ljust(32)) del info a.C_GetSlotList(0, slotList) slot = slotList[0] self.assertEqual(a.C_GetSlotInfo(slot, slotInfo), PyKCS11.LowLevel.CKR_OK) self.assertEqual( a.C_OpenSession( slot, PyKCS11.LowLevel.CKF_SERIAL_SESSION | PyKCS11.LowLevel.CKF_RW_SESSION, session, ), PyKCS11.LowLevel.CKR_OK, ) self.assertEqual( a.C_GetSessionInfo(session, sessionInfo), PyKCS11.LowLevel.CKR_OK ) self.assertEqual(a.C_GetTokenInfo(slot, tokenInfo), PyKCS11.LowLevel.CKR_OK) label = tokenInfo.GetLabel() manufacturerID = tokenInfo.GetManufacturerID() flags = tokenInfo.flags model = tokenInfo.GetModel() pin = ckbytelist("1234") self.assertEqual( a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin), PyKCS11.LowLevel.CKR_OK ) self.assertEqual(a.C_Logout(session), PyKCS11.LowLevel.CKR_OK) self.assertEqual(a.C_CloseSession(session), PyKCS11.LowLevel.CKR_OK) self.assertEqual( a.C_OpenSession(slotList[0], PyKCS11.LowLevel.CKF_SERIAL_SESSION, session), PyKCS11.LowLevel.CKR_OK, ) self.assertEqual( a.C_Login(session, PyKCS11.LowLevel.CKU_USER, pin), PyKCS11.LowLevel.CKR_OK ) SearchResult = PyKCS11.LowLevel.ckulonglist(10) SearchTemplate = PyKCS11.LowLevel.ckattrlist(2) SearchTemplate[0].SetNum( PyKCS11.LowLevel.CKA_CLASS, PyKCS11.LowLevel.CKO_CERTIFICATE ) SearchTemplate[1].SetBool(PyKCS11.LowLevel.CKA_TOKEN, True) self.assertEqual( a.C_FindObjectsInit(session, SearchTemplate), PyKCS11.LowLevel.CKR_OK ) self.assertEqual( a.C_FindObjects(session, SearchResult), PyKCS11.LowLevel.CKR_OK ) self.assertEqual(a.C_FindObjectsFinal(session), PyKCS11.LowLevel.CKR_OK) for x in SearchResult: print("object: " + hex(x.value())) valTemplate = PyKCS11.LowLevel.ckattrlist(2) valTemplate[0].SetType(PyKCS11.LowLevel.CKA_LABEL) # valTemplate[0].Reserve(128) valTemplate[1].SetType(PyKCS11.LowLevel.CKA_CLASS) # valTemplate[1].Reserve(4) print( "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) ) print( "CKA_LABEL Len: ", valTemplate[0].GetLen(), " CKA_CLASS Len: ", valTemplate[1].GetLen(), ) print( "C_GetAttributeValue(): " + hex(a.C_GetAttributeValue(session, x, valTemplate)) ) print("\tCKO_CERTIFICATE: " + valTemplate[0].GetString()) print("\tCKA_TOKEN: " + str(valTemplate[1].GetNum())) self.assertEqual(a.C_Logout(session), PyKCS11.LowLevel.CKR_OK) self.assertEqual(a.C_CloseSession(session), PyKCS11.LowLevel.CKR_OK) self.assertEqual(a.C_Finalize(), PyKCS11.LowLevel.CKR_OK) a.Unload() if __name__ == "__main__": unittest.main() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_asymetric.py0000644000175100017510000001651515246574333017154 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version info = self.pkcs11.getInfo() self.SoftHSMversion = info.libraryVersion[0] self.manufacturer = info.manufacturerID self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") keyID = (0x22,) pubTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_MODULUS_BITS, 0x0400), (PyKCS11.CKA_PUBLIC_EXPONENT, (0x01, 0x00, 0x01)), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "My Public Key"), (PyKCS11.CKA_ID, keyID), ] privTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_ID, keyID), ] self.pubKey, self.privKey = self.session.generateKeyPair( pubTemplate, privTemplate ) self.assertIsNotNone(self.pubKey) self.assertIsNotNone(self.privKey) def tearDown(self): self.session.destroyObject(self.pubKey) self.session.destroyObject(self.privKey) self.session.logout() self.pkcs11.closeAllSessions(self.slot) self.pkcs11.unload() del self.pkcs11 def test_sign_integer(self): toSign = 1234567890 mecha = PyKCS11.Mechanism(PyKCS11.CKM_SHA1_RSA_PKCS, None) # sign/verify try: self.session.sign(self.privKey, toSign, mecha) except PyKCS11.PyKCS11Error as e: self.assertEqual(e.value, -3) def test_sign_PKCS(self): toSign = "Hello world" mecha = PyKCS11.Mechanism(PyKCS11.CKM_SHA1_RSA_PKCS, None) # sign/verify signature = self.session.sign(self.privKey, toSign, mecha) result = self.session.verify(self.pubKey, toSign, signature, mecha) self.assertTrue(result) def test_sign_PKCS_SHA256(self): toSign = "Hello world" mecha = PyKCS11.Mechanism(PyKCS11.CKM_SHA256_RSA_PKCS, None) # sign/verify signature = self.session.sign(self.privKey, toSign, mecha) result = self.session.verify(self.pubKey, toSign, signature, mecha) self.assertTrue(result) def test_sign_X509(self): toSign = "Hello world" mecha = PyKCS11.Mechanism(PyKCS11.CKM_RSA_X_509, None) if self.SoftHSMversion < 2: self.skipTest("RSA X.509 only supported by SoftHSM >= 2") # sign/verify signature = self.session.sign(self.privKey, toSign, mecha) result = self.session.verify(self.pubKey, toSign, signature, mecha) self.assertTrue(result) def test_encrypt_PKCS(self): # encrypt/decrypt using CMK_RSA_PKCS (default) dataIn = "Hello world" encrypted = self.session.encrypt(self.pubKey, dataIn) decrypted = self.session.decrypt(self.privKey, encrypted) # convert in a string text = "".join(map(chr, decrypted)) self.assertEqual(dataIn, text) def test_encrypt_X509(self): if self.SoftHSMversion < 2: self.skipTest("RSA X.509 only supported by SoftHSM >= 2") # encrypt/decrypt using CKM_RSA_X_509 dataIn = "Hello world!" mecha = PyKCS11.Mechanism(PyKCS11.CKM_RSA_X_509, None) encrypted = self.session.encrypt(self.pubKey, dataIn, mecha=mecha) decrypted = self.session.decrypt(self.privKey, encrypted, mecha=mecha) # remove padding NUL bytes padding_length = 0 for e in decrypted: if e != 0: break padding_length += 1 decrypted = list(decrypted)[padding_length:] # convert in a string text = "".join(map(chr, decrypted)) self.assertEqual(dataIn, text) def test_RSA_OAEP(self): if self.SoftHSMversion < 2: self.skipTest("RSA OAEP only supported by SoftHSM >= 2") # RSA OAEP plainText = "A test string" mech = PyKCS11.RSAOAEPMechanism(PyKCS11.CKM_SHA_1, PyKCS11.CKG_MGF1_SHA1) cipherText = self.session.encrypt(self.pubKey, plainText, mech) decrypted = self.session.decrypt(self.privKey, cipherText, mech) text = "".join(map(chr, decrypted)) self.assertEqual(text, plainText) def test_RSA_OAEPwithAAD(self): # AAD is "Additional Authentication Data" # (pSourceData of CK_RSA_PKCS_OAEP_PARAMS struct) if self.SoftHSMversion < 2: self.skipTest("RSA OAEP only supported by SoftHSM >= 2") if self.manufacturer.startswith("SoftHSM"): # SoftHSM indicates in syslog: # "SoftHSM.cpp(12412): pSourceData must be NULL" # and returns CKR_ARGUMENTS_BAD self.skipTest("'AAD' not (yet) supported.") plainText = "A test string" # RSA OAEP aad = b"sample aad" mech = PyKCS11.RSAOAEPMechanism(PyKCS11.CKM_SHA_1, PyKCS11.CKG_MGF1_SHA1, aad) cipherText = self.session.encrypt(self.pubKey, plainText, mech) decrypted = self.session.decrypt(self.privKey, cipherText, mech) text = bytes(decrypted).decode("utf-8") self.assertEqual(text, plainText) def test_RSA_PSS_SHA1(self): if self.SoftHSMversion < 2: self.skipTest("RSA PSS only supported by SoftHSM >= 2") # RSA PSS toSign = "test_RSA_sign_PSS SHA1" mech = PyKCS11.RSA_PSS_Mechanism( PyKCS11.CKM_SHA1_RSA_PKCS_PSS, PyKCS11.CKM_SHA_1, PyKCS11.CKG_MGF1_SHA1, 20, # size of SHA1 result ) signature = self.session.sign(self.privKey, toSign, mech) result = self.session.verify(self.pubKey, toSign, signature, mech) self.assertTrue(result) def test_RSA_PSS_SHA256(self): if self.SoftHSMversion < 2: self.skipTest("RSA PSS only supported by SoftHSM >= 2") # RSA PSS toSign = "test_RSA_sign_PSS SHA256" mech = PyKCS11.RSA_PSS_Mechanism( PyKCS11.CKM_SHA256_RSA_PKCS_PSS, PyKCS11.CKM_SHA256, PyKCS11.CKG_MGF1_SHA256, 32, # size of SHA256 result ) signature = self.session.sign(self.privKey, toSign, mech) result = self.session.verify(self.pubKey, toSign, signature, mech) self.assertTrue(result) def test_pubKey(self): # test CK_OBJECT_HANDLE.__repr__() text = str(self.pubKey) self.assertIsNotNone(text) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_asymetric_ECC.py0000644000175100017510000003335715246574333017631 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import binascii import unittest from asn1crypto.core import OctetString from asn1crypto.keys import ECDomainParameters, NamedCurve, PrivateKeyAlgorithmId from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version self.SoftHSMversion = self.pkcs11.getInfo().libraryVersion[0] if self.SoftHSMversion < 2: self.pkcs11.unload() self.skipTest("ECDSA only supported by SoftHSM >= 2") self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") # Select the curve to be used for the keys curve = "secp256r1" # Setup the domain parameters, unicode conversion needed # for the curve string domain_params = ECDomainParameters(name="named", value=NamedCurve(curve)) ec_params = domain_params.dump() keyID = (0x22,) label = "test" ec_public_tmpl = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_EC_PARAMS, ec_params), (PyKCS11.CKA_LABEL, label), (PyKCS11.CKA_ID, keyID), ] ec_priv_tmpl = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, label), (PyKCS11.CKA_ID, keyID), ] self.pubKey, self.privKey = self.session.generateKeyPair( ec_public_tmpl, ec_priv_tmpl, mecha=PyKCS11.MechanismECGENERATEKEYPAIR ) self.assertIsNotNone(self.pubKey) self.assertIsNotNone(self.privKey) # test CK_OBJECT_HANDLE.__repr__() text = str(self.pubKey) self.assertIsNotNone(text) def tearDown(self): self.session.destroyObject(self.pubKey) self.session.destroyObject(self.privKey) self.session.logout() self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_sign_integer(self): toSign = 1234567890 mecha = PyKCS11.Mechanism(PyKCS11.CKM_ECDSA, None) # sign/verify with self.assertRaises(PyKCS11.PyKCS11Error) as cm: self.session.sign(self.privKey, toSign, mecha) # should return PyKCS11.PyKCS11Error: Unknown format () self.assertEqual(cm.exception.value, -3) def test_sign_text(self): toSign = "Hello World!" mecha = PyKCS11.Mechanism(PyKCS11.CKM_ECDSA, None) # sign/verify signature = self.session.sign(self.privKey, toSign, mecha) result = self.session.verify(self.pubKey, toSign, signature, mecha) self.assertTrue(result) class TestEDDSA(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() self.manufacturer = self.pkcs11.getInfo().manufacturerID self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] for m in ["CKM_EC_EDWARDS_KEY_PAIR_GEN", "CKM_EDDSA"]: if not m in self.pkcs11.getMechanismList(self.slot): self.pkcs11.unload() self.skipTest(f"{m} is not supported by the token") self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") self.ec_base_tmpl = [ (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_EC_EDWARDS), (PyKCS11.CKA_LABEL, "test"), (PyKCS11.CKA_ID, (0x33,)), ] self.ec_public_tmpl = self.ec_base_tmpl + [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), ] self.ec_priv_tmpl = self.ec_base_tmpl + [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), ] # see https://docs.oasis-open.org/pkcs11/pkcs11-curr/v3.0/os/pkcs11-curr-v3.0-os.html#_Toc30061191 self.schemes = { # scheme : ("curve", phFlag) "Ed25519": ("ed25519", None), "Ed25519ctx": ("ed25519", False), "Ed25519ph": ("ed25519", True), "Ed448": ("ed448", False), "Ed448ph": ("ed448", True), } def tearDown(self): self.session.logout() self.pkcs11.closeAllSessions(self.slot) self.pkcs11.unload() del self.pkcs11 def _get_eddsa_mechanism(self, phf=None, ctx=None): if phf is None: return PyKCS11.EDDSA_Mechanism() elif ctx is None: return PyKCS11.EDDSA_Mechanism(phFlag=phf) else: return PyKCS11.EDDSA_Mechanism(phFlag=phf, contextData=ctx) def _generate_edwards_key_pair(self, curve): # Setup the domain parameters, unicode conversion needed # for the curve string ec_params = PrivateKeyAlgorithmId(curve).dump() ec_public_tmpl = self.ec_public_tmpl + [(PyKCS11.CKA_EC_PARAMS, ec_params)] pubKey, privKey = self.session.generateKeyPair( ec_public_tmpl, self.ec_priv_tmpl, mecha=PyKCS11.Mechanism(PyKCS11.CKM_EC_EDWARDS_KEY_PAIR_GEN, None), ) self.assertIsNotNone(pubKey) self.assertIsNotNone(privKey) # test CK_OBJECT_HANDLE.__repr__() text = str(pubKey) self.assertIsNotNone(text) return (pubKey, privKey) def test_sign_integer(self): toSign = 1234567890 mecha = PyKCS11.EDDSA_Mechanism() pubKey, privKey = self._generate_edwards_key_pair("ed25519") # sign/verify with self.assertRaises(PyKCS11.PyKCS11Error) as cm: self.session.sign(privKey, toSign, mecha) # should return PyKCS11.PyKCS11Error: Unknown format () self.assertEqual(cm.exception.value, -3) self.session.destroyObject(pubKey) self.session.destroyObject(privKey) def test_sign_text(self): toSign = ctxData = "Hello World!" schemes = [ # Ed25519 ("ed25519", None, None), # Ed25519ctx ("ed25519", False, None), ("ed25519", False, ctxData), # Ed25519ph ("ed25519", True, None), ("ed25519", True, ctxData), # Ed448 ("ed448", False, None), ("ed448", False, ctxData), # Ed448ph ("ed448", True, None), ("ed448", True, ctxData), ] for curve, phflag, context in schemes: with self.subTest(curve=curve, phflag=phflag, context=context): mech = self._get_eddsa_mechanism(phflag, context) pubKey, privKey = self._generate_edwards_key_pair(curve) # sign/verify signature = self.session.sign(privKey, toSign, mech) self.assertTrue(self.session.verify(pubKey, toSign, signature, mech)) self.session.destroyObject(pubKey) self.session.destroyObject(privKey) def test_sign_test_vectors(self): # test vectors from RFC 8032, Sec. 7 test_vectors = [ # Ed25519 { "scheme": "Ed25519", "secret": "c5aa8df43f9f837bedb7442f31dcb7b1" "66d38535076f094b85ce3a2e0b4458f7", "public": "fc51cd8e6218a1a38da47ed00230f058" "0816ed13ba3303ac5deb911548908025", "message": "af82", "signature": "6291d657deec24024827e69c3abe01a3" "0ce548a284743a445e3680d7db5ac3ac" "18ff9b538d16f290ae67f760984dc659" "4a7c15e9716ed28dc027beceea1ec40a", }, # Ed25519ctx { "scheme": "Ed25519ctx", "secret": "0305334e381af78f141cb666f6199f57" "bc3495335a256a95bd2a55bf546663f6", "public": "dfc9425e4f968f7f0c29f0259cf5f9ae" "d6851c2bb4ad8bfb860cfee0ab248292", "message": "f726936d19c800494e3fdaff20b276a8", "context": "666f6f", "signature": "55a4cc2f70a54e04288c5f4cd1e45a7b" "b520b36292911876cada7323198dd87a" "8b36950b95130022907a7fb7c4e9b2d5" "f6cca685a587b4b21f4b888e4e7edb0d", }, # Ed25519ph { "scheme": "Ed25519ph", "secret": "833fe62409237b9d62ec77587520911e" "9a759cec1d19755b7da901b96dca3d42", "public": "ec172b93ad5e563bf4932c70e1245034" "c35467ef2efd4d64ebf819683467e2bf", "message": "616263", "signature": "98a70222f0b8121aa9d30f813d683f80" "9e462b469c7ff87639499bb94e6dae41" "31f85042463c2a355a2003d062adf5aa" "a10b8c61e636062aaad11c2a26083406", }, # Ed448 { "scheme": "Ed448", "secret": "c4eab05d357007c632f3dbb48489924d" "552b08fe0c353a0d4a1f00acda2c463a" "fbea67c5e8d2877c5e3bc397a659949e" "f8021e954e0a12274e", "public": "43ba28f430cdff456ae531545f7ecd0a" "c834a55d9358c0372bfa0c6c6798c086" "6aea01eb00742802b8438ea4cb82169c" "235160627b4c3a9480", "message": "03", "context": "666f6f", "signature": "d4f8f6131770dd46f40867d6fd5d5055" "de43541f8c5e35abbcd001b32a89f7d2" "151f7647f11d8ca2ae279fb842d60721" "7fce6e042f6815ea000c85741de5c8da" "1144a6a1aba7f96de42505d7a7298524" "fda538fccbbb754f578c1cad10d54d0d" "5428407e85dcbc98a49155c13764e66c" "3c00", }, # Ed448ph { "scheme": "Ed448ph", "secret": "833fe62409237b9d62ec77587520911e" "9a759cec1d19755b7da901b96dca3d42" "ef7822e0d5104127dc05d6dbefde69e3" "ab2cec7c867c6e2c49", "public": "259b71c19f83ef77a7abd26524cbdb31" "61b590a48f7d17de3ee0ba9c52beb743" "c09428a131d6b1b57303d90d8132c276" "d5ed3d5d01c0f53880", "message": "616263", "context": "666f6f", "signature": "c32299d46ec8ff02b54540982814dce9" "a05812f81962b649d528095916a2aa48" "1065b1580423ef927ecf0af5888f90da" "0f6a9a85ad5dc3f280d91224ba9911a3" "653d00e484e2ce232521481c8658df30" "4bb7745a73514cdb9bf3e15784ab7128" "4f8d0704a608c54a6b62d97beb511d13" "2100", }, ] def verify_test_vector(t): curve = self.schemes[t["scheme"]][0] phflag = self.schemes[t["scheme"]][1] ec_params = PrivateKeyAlgorithmId(curve).dump() ec_point = OctetString(binascii.unhexlify(t["public"])).dump() ec_public_tmpl = self.ec_public_tmpl + [ (PyKCS11.CKA_EC_PARAMS, ec_params), (PyKCS11.CKA_EC_POINT, ec_point), ] ec_priv_tmpl = self.ec_priv_tmpl + [ (PyKCS11.CKA_EC_PARAMS, ec_params), (PyKCS11.CKA_VALUE, binascii.unhexlify(t["secret"])), ] prk = self.session.createObject(ec_priv_tmpl) pbk = self.session.createObject(ec_public_tmpl) if "context" in t: context = binascii.unhexlify(t["context"]) mech = self._get_eddsa_mechanism(phflag, context) else: mech = self._get_eddsa_mechanism(phflag) message = binascii.unhexlify(t["message"]) signature = self.session.sign(prk, message, mech) signatureStr = binascii.hexlify(bytes(signature)).decode("ascii") self.assertSequenceEqual(signatureStr, t["signature"]) self.assertTrue(self.session.verify(pbk, message, signature, mech)) self.session.destroyObject(prk) self.session.destroyObject(pbk) for t in test_vectors: with self.subTest(t=t): if ( self.manufacturer.startswith("SoftHSM") and not "Ed25519" == t["scheme"] ): # SoftHSM just silently ignores CK_EDDSA_PARAMS, # which means that the only supported scheme is Ed25519 self.skipTest( f"SoftHSM does not support {t['scheme']} signature scheme" ) verify_test_vector(t) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_asymetric_gost.py0000644000175100017510000000603115246574333020200 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version self.SoftHSMversion = self.pkcs11.getInfo().libraryVersion[0] self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") def tearDown(self): self.session.logout() self.pkcs11.closeAllSessions(self.slot) self.pkcs11.unload() del self.pkcs11 def test_gost(self): if self.SoftHSMversion < 2: self.skipTest("generateKeyPair() only supported by SoftHSM >= 2") # values from SoftHSMv2 param_a = (0x06, 0x07, 0x2A, 0x85, 0x03, 0x02, 0x02, 0x23, 0x01) param_b = (0x06, 0x07, 0x2A, 0x85, 0x03, 0x02, 0x02, 0x1E, 0x01) keyID = (0x23,) pubTemplate = [ (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "My Public Key"), (PyKCS11.CKA_ID, keyID), (PyKCS11.CKA_GOSTR3410_PARAMS, param_a), (PyKCS11.CKA_GOSTR3411_PARAMS, param_b), ] privTemplate = [ (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_ID, keyID), ] # test generate gost key pair gen_mechanism = PyKCS11.Mechanism(PyKCS11.CKM_GOSTR3410_KEY_PAIR_GEN, None) try: self.pubKey, self.privKey = self.session.generateKeyPair( pubTemplate, privTemplate, gen_mechanism ) except PyKCS11.PyKCS11Error as e: if e.value == PyKCS11.CKR_MECHANISM_INVALID: self.skipTest("GOST not supported by SoftHSMv2 on Windows?") else: raise self.assertIsNotNone(self.pubKey) self.assertIsNotNone(self.privKey) # test sign GOSTR3410_WITH_GOSTR3411 toSign = "Hello world" mecha = PyKCS11.Mechanism(PyKCS11.CKM_GOSTR3410_WITH_GOSTR3411, None) # sign/verify signature = self.session.sign(self.privKey, toSign, mecha) result = self.session.verify(self.pubKey, toSign, signature, mecha) self.assertTrue(result) # test CK_OBJECT_HANDLE.__repr__() text = str(self.pubKey) self.assertIsNotNone(text) self.session.destroyObject(self.pubKey) self.session.destroyObject(self.privKey) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_ckbytelist.py0000644000175100017510000000623115246574333017323 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest import PyKCS11 class Testutil(unittest.TestCase): def test_empty(self): ck = PyKCS11.ckbytelist() self.assertSequenceEqual(ck, []) def test_resize(self): ck = PyKCS11.ckbytelist() ck.resize(5) self.assertSequenceEqual(ck, [0, 0, 0, 0, 0]) def test_data(self): ck = PyKCS11.ckbytelist([0] * 5) for index in range(5): ck[index] = index self.assertSequenceEqual(ck, [0, 1, 2, 3, 4]) def test_append(self): ck = PyKCS11.ckbytelist() for index in range(5): ck.append(index) self.assertSequenceEqual(ck, [0, 1, 2, 3, 4]) def test_length0(self): ck = PyKCS11.ckbytelist() self.assertEqual(len(ck), 0) def test_length5(self): ck = PyKCS11.ckbytelist([0] * 5) self.assertEqual(len(ck), 5) def test_string(self): ck = PyKCS11.ckbytelist() ck.resize(5) for index in range(5): ck[index] = index self.assertEqual(str(ck), "[0, 1, 2, 3, 4]") def test_init_list0(self): ck = PyKCS11.ckbytelist([]) self.assertSequenceEqual(ck, []) def test_init_list1(self): ck = PyKCS11.ckbytelist([1]) self.assertSequenceEqual(ck, [1]) def test_init_list5(self): ck = PyKCS11.ckbytelist([0, 1, 2, 3, 4]) self.assertSequenceEqual(ck, [0, 1, 2, 3, 4]) def test_init_str(self): ck = PyKCS11.ckbytelist("ABC") self.assertSequenceEqual(ck, [65, 66, 67]) def test_init_bytes(self): ck = PyKCS11.ckbytelist(b"ABC") self.assertSequenceEqual(ck, [65, 66, 67]) def test_init_ckbytelist(self): ck1 = PyKCS11.ckbytelist(b"ABC") ck2 = PyKCS11.ckbytelist(ck1) self.assertSequenceEqual(ck2, [65, 66, 67]) def test_unknown_format(self): with self.assertRaises(PyKCS11.PyKCS11Error) as cm: PyKCS11.ckbytelist({}) the_exception = cm.exception self.assertEqual(the_exception.value, -3) # Python 3 and later type_str = "" self.assertEqual(the_exception.text, type_str) self.assertEqual(str(the_exception), f"Unknown format ({type_str})") def test_concat(self): a = PyKCS11.ckbytelist("ABC") b = PyKCS11.ckbytelist("DEF") c = a + b self.assertSequenceEqual(c, [65, 66, 67] + [68, 69, 70]) def test_add(self): a = PyKCS11.ckbytelist("ABC") b = PyKCS11.ckbytelist("DEF") a += b self.assertSequenceEqual(a, [65, 66, 67] + [68, 69, 70]) def test_lowlevel(self): ck = PyKCS11.LowLevel.ckbytelist() self.assertSequenceEqual(ck, []) ck = PyKCS11.LowLevel.ckbytelist([0, 1, 2, 3, 4]) self.assertSequenceEqual(ck, [0, 1, 2, 3, 4]) with self.assertRaises(TypeError): ck = PyKCS11.LowLevel.ckbytelist("ABC") ck = PyKCS11.LowLevel.ckbytelist(b"ABC") self.assertSequenceEqual(ck, [65, 66, 67]) if __name__ == "__main__": unittest.main() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_derive.py0000644000175100017510000003640215246574333016427 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from asn1crypto.keys import ECDomainParameters, NamedCurve from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version info = self.pkcs11.getInfo() self.SoftHSMversion = info.libraryVersion self.manufacturer = info.manufacturerID self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") # common templates used in derive test cases self.aesKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_FALSE), (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "DeriveTestBaseAes256Key"), (PyKCS11.CKA_DERIVE, PyKCS11.CK_TRUE), ] self.genericKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_GENERIC_SECRET), (PyKCS11.CKA_TOKEN, PyKCS11.CK_FALSE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_FALSE), (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "DeriveTestGenericKey"), ] # generate a common symmetric base key for tests keyID = (0x01,) baseKeyTemplate = self.aesKeyTemplate + [(PyKCS11.CKA_ID, keyID)] mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_KEY_GEN, None) self.baseKey = self.session.generateKey(baseKeyTemplate, mechanism) self.assertIsNotNone(self.baseKey) # Select the curve to be used for the keys curve = "secp256r1" # Setup the domain parameters, unicode conversion needed # for the curve string domain_params = ECDomainParameters(name="named", value=NamedCurve(curve)) self.ecParams = domain_params.dump() keyID = (0x01,) baseKeyPubTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_EC_PARAMS, self.ecParams), (PyKCS11.CKA_LABEL, "TestBaseKeyP256"), (PyKCS11.CKA_ID, keyID), ] baseKeyPvtTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "TestBaseKeyP256"), (PyKCS11.CKA_ID, keyID), (PyKCS11.CKA_DERIVE, PyKCS11.CK_TRUE), ] mechanism = PyKCS11.Mechanism(PyKCS11.CKM_EC_KEY_PAIR_GEN, None) self.baseEcPubKey, self.baseEcPvtKey = self.session.generateKeyPair( baseKeyPubTemplate, baseKeyPvtTemplate, mechanism ) self.assertIsNotNone(self.baseEcPubKey) self.assertIsNotNone(self.baseEcPvtKey) def tearDown(self): self.session.destroyObject(self.baseEcPubKey) self.session.destroyObject(self.baseEcPvtKey) self.session.logout() self.pkcs11.closeAllSessions(self.slot) self.pkcs11.unload() del self.pkcs11 def getCkaValue(self, key): return list(self.session.getAttributeValue(key, [PyKCS11.CKA_VALUE])[0]) def test_deriveKey_ECDH1_DERIVE(self): if self.SoftHSMversion[0] < 2: self.skipTest("generateKeyPair() only supported by SoftHSM >= 2") keyID = (0x11,) pubTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_TOKEN, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_EC_PARAMS, self.ecParams), (PyKCS11.CKA_LABEL, "testKeyP256"), (PyKCS11.CKA_ID, keyID), ] pvtTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_ECDSA), (PyKCS11.CKA_TOKEN, PyKCS11.CK_FALSE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "testKeyP256"), (PyKCS11.CKA_ID, keyID), (PyKCS11.CKA_DERIVE, PyKCS11.CK_TRUE), ] mechanism = PyKCS11.Mechanism(PyKCS11.CKM_EC_KEY_PAIR_GEN, None) pubKey, pvtKey = self.session.generateKeyPair( pubTemplate, pvtTemplate, mechanism ) self.assertIsNotNone(pubKey) self.assertIsNotNone(pvtKey) keyID = (0x22,) derivedAESKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_FALSE), (PyKCS11.CKA_SENSITIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), (PyKCS11.CKA_VALUE_LEN, 24), (PyKCS11.CKA_LABEL, "derivedAESKey"), (PyKCS11.CKA_ID, keyID), ] # derive key 1 : self.basePvtKey + pubKey attrs = self.session.getAttributeValue(pubKey, [PyKCS11.CKA_EC_POINT], True) mechanism = PyKCS11.ECDH1_DERIVE_Mechanism(bytes(attrs[0])) derivedKey = self.session.deriveKey( self.baseEcPvtKey, derivedAESKeyTemplate, mechanism ) self.assertIsNotNone(derivedKey) # derive key 2 : pvtKey + self.basePubKey attrs = self.session.getAttributeValue( self.baseEcPubKey, [PyKCS11.CKA_EC_POINT], True ) mechanism = PyKCS11.ECDH1_DERIVE_Mechanism(bytes(attrs[0])) derivedKey2 = self.session.deriveKey(pvtKey, derivedAESKeyTemplate, mechanism) self.assertIsNotNone(derivedKey2) DataIn = b"Sample data to test ecdh1 derive" mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_CBC, "1234567812345678") DataOut = self.session.encrypt(derivedKey, DataIn, mechanism) DataCheck = self.session.decrypt(derivedKey2, DataOut, mechanism) # match check values self.assertSequenceEqual(DataIn, DataCheck) # cleanup self.session.destroyObject(derivedKey) self.session.destroyObject(derivedKey2) self.session.destroyObject(pubKey) self.session.destroyObject(pvtKey) def test_deriveKey_CKM_CONCATENATE_BASE_AND_KEY(self): # This mechanism is not supported in the current release of # SoftHSM (2.6.1), however available in develop branch, # see https://github.com/opendnssec/SoftHSMv2/commit/fa595c07a185656382c18ea2a6a12cad825d48b4 if self.SoftHSMversion <= (2, 6): self.skipTest( "CKM_CONCATENATE_BASE_AND_KEY is not supported by SoftHSM <= 2.6" ) # generate a key to concatenate with keyID = (0x11,) concatenateKeyTemplate = self.aesKeyTemplate + [(PyKCS11.CKA_ID, keyID)] key_gen_mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_KEY_GEN, None) concKey = self.session.generateKey(concatenateKeyTemplate, key_gen_mechanism) self.assertIsNotNone(concKey) # concatenate two keys keyID = (0x22,) derivedKeyTemplate = self.genericKeyTemplate + [ (PyKCS11.CKA_VALUE_LEN, 64), (PyKCS11.CKA_ID, keyID), ] mechanism = PyKCS11.CONCATENATE_BASE_AND_KEY_Mechanism(concKey) derivedKey = self.session.deriveKey(self.baseKey, derivedKeyTemplate, mechanism) self.assertIsNotNone(derivedKey) # check derived key's value baseKeyValue = self.getCkaValue(self.baseKey) concKeyValue = self.getCkaValue(concKey) derivedKeyValue = self.getCkaValue(derivedKey) # match: check values self.assertSequenceEqual(baseKeyValue + concKeyValue, derivedKeyValue) # check that mechanism shares ownership of temporary key mechanism = PyKCS11.CONCATENATE_BASE_AND_KEY_Mechanism( self.session.generateKey(concatenateKeyTemplate, key_gen_mechanism) ) derivedKey = self.session.deriveKey(self.baseKey, derivedKeyTemplate, mechanism) self.assertIsNotNone(derivedKey) # cleanup self.session.destroyObject(derivedKey) self.session.destroyObject(concKey) def test_deriveKey_CKM_CONCATENATE_BASE_AND_DATA(self): # This mechanism is not supported in the current release of # SoftHSM (2.6.1), however available in develop branch, # see https://github.com/opendnssec/SoftHSMv2/commit/dba00d73e1b69f65b68397d235e7f73bbf59ab6a if self.SoftHSMversion <= (2, 6): self.skipTest( "CKM_CONCATENATE_BASE_AND_DATA is not supported by SoftHSM <= 2.6" ) # generate data to concatenate with concData = list(self.session.generateRandom(32)) # concatenate key with data keyID = (0x22,) derivedKeyTemplate = self.genericKeyTemplate + [ (PyKCS11.CKA_VALUE_LEN, 64), (PyKCS11.CKA_ID, keyID), ] mechanism = PyKCS11.CONCATENATE_BASE_AND_DATA_Mechanism(concData) derivedKey = self.session.deriveKey(self.baseKey, derivedKeyTemplate, mechanism) self.assertIsNotNone(derivedKey) # check derived key's value baseKeyValue = self.getCkaValue(self.baseKey) derivedKeyValue = self.getCkaValue(derivedKey) # match: check values self.assertSequenceEqual(baseKeyValue + concData, derivedKeyValue) # cleanup self.session.destroyObject(derivedKey) def test_deriveKey_CKM_CONCATENATE_DATA_AND_BASE(self): # This mechanism is not supported in the current release of # SoftHSM (2.6.1), however available in develop branch, # see https://github.com/opendnssec/SoftHSMv2/commit/fae0d9f769ac30d25f563c5fc6c417e9199e4403 if self.SoftHSMversion <= (2, 6): self.skipTest( "CKM_CONCATENATE_DATA_AND_BASE is not supported by SoftHSM <= 2.6" ) # generate data to concatenate with concData = list(self.session.generateRandom(32)) # concatenate data with key keyID = (0x22,) derivedKeyTemplate = self.genericKeyTemplate + [ (PyKCS11.CKA_VALUE_LEN, 64), (PyKCS11.CKA_ID, keyID), ] mechanism = PyKCS11.CONCATENATE_DATA_AND_BASE_Mechanism(concData) derivedKey = self.session.deriveKey(self.baseKey, derivedKeyTemplate, mechanism) self.assertIsNotNone(derivedKey) # check derived key's value baseKeyValue = self.getCkaValue(self.baseKey) derivedKeyValue = self.getCkaValue(derivedKey) # match: check values self.assertSequenceEqual(concData + baseKeyValue, derivedKeyValue) # cleanup self.session.destroyObject(derivedKey) def test_deriveKey_CKM_XOR_BASE_AND_DATA(self): if self.manufacturer.startswith("SoftHSM"): self.skipTest("SoftHSM does not support CKM_XOR_BASE_AND_DATA") # generate data to xor with xorData = list(self.session.generateRandom(32)) # xor key with data keyID = (0x22,) derivedKeyTemplate = self.genericKeyTemplate + [ (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_ID, keyID), ] mechanism = PyKCS11.XOR_BASE_AND_DATA_Mechanism(xorData) derivedKey = self.session.deriveKey(self.baseKey, derivedKeyTemplate, mechanism) self.assertIsNotNone(derivedKey) # check derived key's value baseKeyValue = self.getCkaValue(self.baseKey) derivedKeyValue = self.getCkaValue(derivedKey) expectedValue = map(lambda x, y: x ^ y, baseKeyValue, xorData) # match: check values self.assertSequenceEqual(list(expectedValue), derivedKeyValue) # cleanup self.session.destroyObject(derivedKey) def test_deriveKey_CKM_EXTRACT_KEY_FROM_KEY(self): if self.manufacturer.startswith("SoftHSM"): self.skipTest("SoftHSM does not support CKM_EXTRACT_KEY_FROM_KEY") # sample from the PKCS#11 specification 3.0, section 2.43.7 # see https://docs.oasis-open.org/pkcs11/pkcs11-curr/v3.0/os/pkcs11-curr-v3.0-os.html#_Toc30061466 # # We give an example of how this mechanism works. Suppose a # token has a secret key with the 4-byte value 0x329F84A9. We # will derive a 2-byte secret key from this key, starting at bit # position 21 (i.e., the value of the parameter to the # CKM_EXTRACT_KEY_FROM_KEY mechanism is 21). # 1. We write the key’s value in binary: 0011 0010 1001 1111 # 1000 0100 1010 1001. We regard this binary string as # holding the 32 bits of the key, labeled as b0, b1, …, b31. # 2. We then extract 16 consecutive bits (i.e., 2 bytes) # from this binary string, starting at bit b21. We obtain # the binary string 1001 0101 0010 0110. # 3. The value of the new key is thus 0x9526. baseKeyTemplate = self.genericKeyTemplate + [ (PyKCS11.CKA_DERIVE, PyKCS11.CK_TRUE), (PyKCS11.CKA_VALUE, [0x32, 0x9F, 0x84, 0xA9]), ] # create a base key baseKey = self.session.createObject(baseKeyTemplate) expectedDerivedKeyValue = [0x95, 0x26] derivedKeyTemplate = self.genericKeyTemplate + [ (PyKCS11.CKA_VALUE_LEN, len(expectedDerivedKeyValue)) ] # extract bytes from the base key mechanism = PyKCS11.EXTRACT_KEY_FROM_KEY_Mechanism(21) derivedKey = self.session.deriveKey(baseKey, derivedKeyTemplate, mechanism) self.assertIsNotNone(derivedKey) derivedKeyValue = self.getCkaValue(derivedKey) # match: check derived key value self.assertSequenceEqual(expectedDerivedKeyValue, derivedKeyValue) self.session.destroyObject(baseKey) self.session.destroyObject(derivedKey) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_digest.py0000644000175100017510000000225215246574333016424 0ustar00runnerrunner#! /usr/bin/env python # pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 # SHA1 of "abc" SHA1_abc = [ 0xA9, 0x99, 0x3E, 0x36, 0x47, 0x6, 0x81, 0x6A, 0xBA, 0x3E, 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D, ] class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession(self.slot, PyKCS11.CKF_SERIAL_SESSION) def tearDown(self): self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_digest(self): digest = self.session.digest("abc") self.assertSequenceEqual(digest, SHA1_abc) def test_digestSession(self): digestSession = self.session.digestSession() digestSession.update("abc") digest = digestSession.final() self.assertSequenceEqual(digest, SHA1_abc) if __name__ == "__main__": unittest.main() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_exception.py0000644000175100017510000000302415246574333017141 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest import PyKCS11 class Testutil(unittest.TestCase): def test_empty(self): e = PyKCS11.PyKCS11Error(0) self.assertEqual(e.value, 0) def test_CKR_OK(self): e = PyKCS11.PyKCS11Error(PyKCS11.CKR_OK) self.assertEqual(e.value, 0) self.assertEqual(str(e), "CKR_OK (0x00000000)") def test_CKR_PIN_INVALID(self): e = PyKCS11.PyKCS11Error(PyKCS11.CKR_PIN_INVALID) self.assertEqual(e.value, 0xA1) self.assertEqual(str(e), "CKR_PIN_INVALID (0x000000A1)") def test_Load(self): e = PyKCS11.PyKCS11Error(-1, "Pouet") self.assertEqual(e.value, -1) self.assertEqual(str(e), "Load (Pouet)") def test_raise(self): with self.assertRaises(PyKCS11.PyKCS11Error): raise PyKCS11.PyKCS11Error(0) def test_unknown(self): e = PyKCS11.PyKCS11Error(PyKCS11.CKR_VENDOR_DEFINED - 1) self.assertEqual(str(e), "Unknown error (0x7FFFFFFF)") def test_vendor0(self): e = PyKCS11.PyKCS11Error(PyKCS11.CKR_VENDOR_DEFINED, "Pouet") self.assertEqual(e.value, PyKCS11.CKR_VENDOR_DEFINED) self.assertEqual(str(e), "Vendor error (0x00000000)") def test_vendor10(self): e = PyKCS11.PyKCS11Error(PyKCS11.CKR_VENDOR_DEFINED + 10) self.assertEqual(e.value, PyKCS11.CKR_VENDOR_DEFINED + 10) self.assertEqual(str(e), "Vendor error (0x0000000A)") ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_gc.py0000644000175100017510000000207715246574333015543 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import gc import unittest from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def test_gc(self): res = [] # we must use at least 2 sessions for _ in range(2): p11, session = self.createSession() res.append([p11, session]) for p11, session in res: self.closeSession(session) del p11 # force the call to __del__() on p11 now gc.collect() def createSession(self): pkcs11 = PyKCS11.PyKCS11Lib() pkcs11.load() slot = pkcs11.getSlotList(tokenPresent=True)[0] session = pkcs11.openSession( slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) return (pkcs11, session) def closeSession(self, session): # this call generated a CKR_CRYPTOKI_NOT_INITIALIZED for the # second session because C_Finalize() was already called session.logout() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_info.py0000644000175100017510000000412415246574333016100 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.manufacturerIDs = ("SoftHSM".ljust(32), "SoftHSM project".ljust(32)) def test_getInfo(self): info = self.pkcs11.getInfo() # check the CK_UTF8CHAR to string convertion self.assertEqual(info.manufacturerID, "SoftHSM".ljust(32)) self.assertEqual(info.libraryDescription, "Implementation of PKCS11".ljust(32)) text = str(info) self.assertIsNotNone(text) d = info.to_dict() self.assertEqual(d["manufacturerID"], "SoftHSM".ljust(32)) self.assertEqual(d["libraryDescription"], "Implementation of PKCS11".ljust(32)) def test_getSlotInfo(self): info = self.pkcs11.getSlotInfo(self.slot) self.assertIn(info.manufacturerID, self.manufacturerIDs) text = str(info) self.assertIsNotNone(text) def test_getTokenInfo(self): info = self.pkcs11.getTokenInfo(self.slot) self.assertIn(info.manufacturerID, self.manufacturerIDs) text = str(info) self.assertIsNotNone(text) def test_getSessionInfo(self): self.session = self.pkcs11.openSession(self.slot, PyKCS11.CKF_SERIAL_SESSION) info = self.session.getSessionInfo() text = str(info) self.assertIsNotNone(text) d = info.to_dict() self.assertListEqual(d["flags"], ["CKF_SERIAL_SESSION"]) self.assertEqual(d["ulDeviceError"], 0) self.session.closeSession() def test_getMechanismList(self): mechanisms = self.pkcs11.getMechanismList(self.slot) text = str(mechanisms) self.assertIsNotNone(text) # info for the first mechanism info = self.pkcs11.getMechanismInfo(self.slot, mechanisms[0]) text = str(info) self.assertIsNotNone(text) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_init.py0000644000175100017510000000515115246574333016111 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) def tearDown(self): self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_initPin(self): # use admin pin self.session.login("123456", user_type=PyKCS11.CKU_SO) # change PIN self.session.initPin("4321") self.session.logout() # check new PIN self.session.login("4321") self.session.logout() # reset to old PIN self.session.login("123456", user_type=PyKCS11.CKU_SO) self.session.initPin("1234") self.session.logout() # check old PIN self.session.login("1234") self.session.logout() def test_setPin(self): self.session.login("1234") # change PIN self.session.setPin("1234", "4321") self.session.logout() # test new PIN self.session.login("4321") # revert to old PIN self.session.setPin("4321", "1234") self.session.logout() def test_initToken(self): self.pkcs11.closeAllSessions(self.slot) # use admin PIN self.pkcs11.initToken(self.slot, "123456", "my label") self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("123456", user_type=PyKCS11.CKU_SO) # set user PIN self.session.initPin("1234") self.session.logout() def test_initToken_utf8(self): self.pkcs11.closeAllSessions(self.slot) # Create a label using UTF-8 label = "abcéàç" # padding with spaces up to 32 _bytes_ (not characters) label += " " * (32 - len(label.encode("utf-8"))) # use admin PIN self.pkcs11.initToken(self.slot, "123456", label) self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("123456", user_type=PyKCS11.CKU_SO) # set user PIN self.session.initPin("1234") token_info = self.pkcs11.getTokenInfo(self.slot) self.assertEqual(token_info.label, label) self.session.logout() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_load.py0000644000175100017510000001236615246574333016073 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import gc import os import platform import shutil import unittest from pathlib import Path from tempfile import TemporaryDirectory from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.tmpdir = TemporaryDirectory() self.lib1_name = os.environ["PYKCS11LIB"] # create a tmp copy of the main lib # to use as a different library in tests self.lib2_name = str(Path(self.tmpdir.name) / Path(self.lib1_name).name) shutil.copy(self.lib1_name, self.tmpdir.name) def tearDown(self): del self.pkcs11 if platform.system() != "Windows": self.tmpdir.cleanup() del self.tmpdir del self.lib1_name del self.lib2_name def openSession(self, lib): slot = lib.getSlotList(tokenPresent=True)[0] return lib.openSession(slot, PyKCS11.CKF_SERIAL_SESSION) def test_load(self): # create two instances with default library lib1 = PyKCS11.PyKCS11Lib().load() lib2 = PyKCS11.PyKCS11Lib().load() # expect two instances with the same library loaded self.assertTrue(hasattr(lib1, "pkcs11dll_filename")) self.assertTrue(hasattr(lib2, "pkcs11dll_filename")) self.assertEqual(len(lib1._loaded_libs), 1) self.assertEqual(len(lib2._loaded_libs), 1) self.openSession(lib1) # unload the first library del lib1 gc.collect() # one instance remaining, the library is still in use self.openSession(lib2) self.assertEqual(len(lib2._loaded_libs), 1) # unload the second library del lib2 gc.collect() self.assertEqual(len(self.pkcs11._loaded_libs), 0) def test_multiple_load(self): # load two different libraries lib1 = PyKCS11.PyKCS11Lib().load(self.lib1_name) lib2 = PyKCS11.PyKCS11Lib().load(self.lib2_name) # _loaded_libs is shared across all instances # check the value in self.pkcs11 self.assertEqual(len(self.pkcs11._loaded_libs), 2) lib1 = PyKCS11.PyKCS11Lib() # unload lib1 self.assertEqual(len(self.pkcs11._loaded_libs), 1) lib2 = PyKCS11.PyKCS11Lib() # unload lib2 self.assertEqual(len(self.pkcs11._loaded_libs), 0) def test_invalid_load(self): # Library not found lib = "nolib" with self.assertRaises(PyKCS11.PyKCS11Error) as cm: self.pkcs11.load(lib) the_exception = cm.exception self.assertEqual(the_exception.value, -1) self.assertEqual(the_exception.text, lib) self.assertEqual(str(the_exception), f"Load ({lib})") self.assertEqual(len(self.pkcs11._loaded_libs), 0) # C_GetFunctionList() not found if platform.system() == "Linux": # GNU/Linux lib = "libc.so.6" elif platform.system() == "Darwin": # macOS lib = "/usr/lib/libSystem.B.dylib" else: # Windows lib = "WinSCard.dll" with self.assertRaises(PyKCS11.PyKCS11Error) as cm: self.pkcs11.load(lib) the_exception = cm.exception self.assertEqual(the_exception.value, -4) self.assertEqual(the_exception.text, lib) self.assertEqual(str(the_exception), f"C_GetFunctionList() not found ({lib})") self.assertEqual(len(self.pkcs11._loaded_libs), 0) # try to load the improper lib another time with self.assertRaises(PyKCS11.PyKCS11Error) as cm: self.pkcs11.load(lib) the_exception = cm.exception self.assertEqual(the_exception.value, -4) self.assertEqual(the_exception.text, lib) self.assertEqual(str(the_exception), f"C_GetFunctionList() not found ({lib})") self.assertEqual(len(self.pkcs11._loaded_libs), 0) # finally, load a valid library self.pkcs11.load() self.assertEqual(len(self.pkcs11._loaded_libs), 1) def test_specific_load(self): # load two different libraries sequentially self.pkcs11.load(self.lib1_name) self.pkcs11.load(self.lib2_name) # the second load should've unloaded the first library self.assertEqual(len(self.pkcs11._loaded_libs), 1) self.assertEqual(self.pkcs11.pkcs11dll_filename, self.lib2_name) # reload the first library self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load(self.lib1_name) # try to open a session self.assertIsNotNone(self.openSession(self.pkcs11)) def test_unload(self): self.pkcs11.load().unload() # no pkcs11dll_filename should remain after unload self.assertIsNone(self.pkcs11.pkcs11dll_filename) self.pkcs11.load() self.openSession(self.pkcs11) # one library has been loaded self.assertEqual(len(self.pkcs11._loaded_libs), 1) self.assertIsNotNone(self.pkcs11.pkcs11dll_filename) self.pkcs11.unload() gc.collect() # manually unloaded the library using gc.collect() self.assertEqual(len(self.pkcs11._loaded_libs), 0) self.assertIsNone(self.pkcs11.pkcs11dll_filename) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_objects.py0000644000175100017510000002132315246574333016576 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 # those shortcuts make the testing code more readable CK_FALSE = PyKCS11.CK_FALSE CK_TRUE = PyKCS11.CK_TRUE class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version self.SoftHSMversion = self.pkcs11.getInfo().libraryVersion[0] self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") def tearDown(self): self.session.logout() self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_objects(self): if self.SoftHSMversion < 2: self.skipTest("generateKey() only supported by SoftHSM >= 2") AESKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_LABEL, "TestAESKey"), (PyKCS11.CKA_ID, (0x01,)), ] # generate AES key AESKey = self.session.generateKey(AESKeyTemplate) self.assertIsNotNone(AESKey) # find the first secret key symKey = self.session.findObjects( [(PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY)] )[0] # test object handle text = str(symKey) self.assertIsNotNone(text) # test createObject() template = [(PyKCS11.CKA_CLASS, PyKCS11.CKO_DATA), (PyKCS11.CKA_LABEL, "data")] handle = self.session.createObject(template) self.assertIsNotNone(handle) self.session.destroyObject(handle) # test getAttributeValue # attributes as define by AESKeyTemplate all_attributes = [ PyKCS11.CKA_CLASS, PyKCS11.CKA_KEY_TYPE, PyKCS11.CKA_TOKEN, PyKCS11.CKA_LABEL, PyKCS11.CKA_ID, ] values = self.session.getAttributeValue(AESKey, all_attributes) self.assertEqual( values, [ PyKCS11.CKO_SECRET_KEY, PyKCS11.CKK_AES, PyKCS11.CK_TRUE, "TestAESKey", (0x01,), ], ) # clean up self.session.destroyObject(AESKey) template = [(PyKCS11.CKA_HW_FEATURE_TYPE, PyKCS11.CKH_USER_INTERFACE)] o = self.session.findObjects(template) self.assertListEqual(o, []) def test_BoolAttributes(self): # dictionary of attributes expected to be bool and their expected values boolAttributes = { PyKCS11.CKA_TOKEN: PyKCS11.CK_FALSE, PyKCS11.CKA_PRIVATE: PyKCS11.CK_FALSE, # The attributes below are defaulted to CK_TRUE # ( according to the PKCS#11 standard ) PyKCS11.CKA_MODIFIABLE: PyKCS11.CK_TRUE, PyKCS11.CKA_COPYABLE: PyKCS11.CK_TRUE, PyKCS11.CKA_DESTROYABLE: PyKCS11.CK_TRUE, } CkoDataTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_DATA), (PyKCS11.CKA_TOKEN, PyKCS11.CK_FALSE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_LABEL, "TestData"), ] # create a CKO_DATA object ckoData = self.session.createObject(CkoDataTemplate) self.assertIsNotNone(ckoData) attrValues = self.session.getAttributeValue( ckoData, list(boolAttributes.keys()) ) # check that attributes are of bool type # and have expected values for i, attr in enumerate(boolAttributes): self.assertIsInstance(attrValues[i], bool) self.assertEqual(attrValues[i], boolAttributes[attr]) # clean up self.session.destroyObject(ckoData) class TestGetSetAttributeValues(unittest.TestCase): def setUp(self) -> None: self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version self.SoftHSMversion = self.pkcs11.getInfo().libraryVersion[0] if self.SoftHSMversion < 2: self.skipTest("generateKey() only supported by SoftHSM >= 2") self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") AESKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, CK_TRUE), (PyKCS11.CKA_PRIVATE, CK_FALSE), (PyKCS11.CKA_ENCRYPT, CK_TRUE), (PyKCS11.CKA_DECRYPT, CK_TRUE), (PyKCS11.CKA_SIGN, CK_FALSE), (PyKCS11.CKA_VERIFY, CK_FALSE), (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_LABEL, "TestAESKey"), (PyKCS11.CKA_ID, (0x01,)), ] # generate AES key self.AESKey = self.session.generateKey(AESKeyTemplate) self.assertIsNotNone(self.AESKey) def tearDown(self): self.session.destroyObject(self.AESKey) self.session.logout() self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_getAttributeValue(self): # attributes as defined by AESKeyTemplate in setUp all_attributes = [ PyKCS11.CKA_CLASS, PyKCS11.CKA_KEY_TYPE, PyKCS11.CKA_TOKEN, PyKCS11.CKA_LABEL, PyKCS11.CKA_ID, ] values = self.session.getAttributeValue(self.AESKey, all_attributes) self.assertEqual( values, [ PyKCS11.CKO_SECRET_KEY, PyKCS11.CKK_AES, CK_TRUE, "TestAESKey", (0x01,), ], ) def test_setAttributeValue_with_single_binary_attribute(self): # test setAttributeValue with a binary attribute _ATTR = PyKCS11.CKA_SIGN # which attribute to test with. use a binary attribute old_state = self.session.getAttributeValue(self.AESKey, [_ATTR])[0] new_state = CK_TRUE if old_state == CK_FALSE else CK_FALSE # switch the state # pylint: disable=assignment-from-no-return rv = self.session.setAttributeValue(self.AESKey, [(_ATTR, new_state)]) assert rv is None # test to see if object is really modified test_state = self.session.getAttributeValue(self.AESKey, [_ATTR])[0] assert test_state == new_state assert test_state != old_state def test_setAttributeValue_with_a_list_of_attributes(self): # which binary attributes to flip? attributes_to_switch = [ PyKCS11.CKA_SIGN, PyKCS11.CKA_ENCRYPT, PyKCS11.CKA_DECRYPT, PyKCS11.CKA_VERIFY, PyKCS11.CKA_WRAP, PyKCS11.CKA_UNWRAP, ] old_attributes = self.session.getAttributeValue( self.AESKey, attributes_to_switch ) flipped_attributes = [] for i, attr in enumerate(attributes_to_switch): new_value = CK_TRUE if old_attributes[i] == CK_FALSE else CK_FALSE flipped_attributes.append((attr, new_value)) # pylint: disable=assignment-from-no-return rv = self.session.setAttributeValue(self.AESKey, flipped_attributes) assert rv is None new_attributes = self.session.getAttributeValue( self.AESKey, attributes_to_switch ) for new, old in zip(new_attributes, old_attributes): assert new != old assert (new == CK_TRUE and old == CK_FALSE) or ( new == CK_FALSE and old == CK_TRUE ) def test_setAttributeValue_with_label_attribute(self): # test setAttributeValue with the text field `CKA_Label` by appending some text old_label = self.session.getAttributeValue(self.AESKey, [PyKCS11.CKA_LABEL])[0] new_label = old_label + "-mod" self.session.setAttributeValue(self.AESKey, [(PyKCS11.CKA_LABEL, new_label)]) test_label = self.session.getAttributeValue(self.AESKey, [PyKCS11.CKA_LABEL])[0] assert new_label != old_label assert test_label == new_label assert test_label != old_label ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_pin.py0000644000175100017510000000365515246574333015743 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 # use OpenSC PKCS#11 Spy to check what PIN value is sent to the PKCS#11 # library class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) def tearDown(self): self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_login(self): self.session.login("1234") self.session.logout() def test_wrong(self): with self.assertRaises(PyKCS11.PyKCS11Error) as cm: self.session.login("wrong PIN") the_exception = cm.exception self.assertEqual(the_exception.value, PyKCS11.CKR_PIN_INCORRECT) self.assertEqual(str(the_exception), "CKR_PIN_INCORRECT (0x000000A0)") def test_ckbytelist(self): pin = PyKCS11.ckbytelist("1234") self.session.login(pin) self.session.logout() def test_binary(self): with self.assertRaises(PyKCS11.PyKCS11Error) as cm: pin = PyKCS11.ckbytelist([1, 2, 3, 4]) self.session.login(pin) the_exception = cm.exception self.assertEqual(the_exception.value, PyKCS11.CKR_PIN_INCORRECT) self.assertEqual(str(the_exception), "CKR_PIN_INCORRECT (0x000000A0)") def test_null(self): # SoftHSM2 does not support pinpad (pin = NULL) with self.assertRaises(PyKCS11.PyKCS11Error) as cm: self.session.login(None) the_exception = cm.exception self.assertEqual(the_exception.value, PyKCS11.CKR_ARGUMENTS_BAD) self.assertEqual(str(the_exception), "CKR_ARGUMENTS_BAD (0x00000007)") ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_random.py0000644000175100017510000000153015246574333016423 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession(self.slot, PyKCS11.CKF_SERIAL_SESSION) def tearDown(self): self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_seedRandom(self): seed = [1, 2, 3, 4] self.session.seedRandom(seed) def test_generateRandom(self): rnd = self.session.generateRandom() self.assertEqual(len(rnd), 16) rnd = self.session.generateRandom(32) self.assertEqual(len(rnd), 32) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_symetric.py0000644000175100017510000002033415246574333017005 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import logging import unittest from PyKCS11 import PyKCS11 test_logger = logging.getLogger("test_logger") test_logger.setLevel(logging.DEBUG) class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version self.SoftHSMversion = self.pkcs11.getInfo().libraryVersion self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") self.aesKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_LABEL, "TestAESKey"), ] self.aesBlockSize = 16 def tearDown(self): self.session.logout() self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_symetric(self): # AES CBC with IV mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_CBC, "1234567812345678") self.assertIsNotNone(mechanism) if self.SoftHSMversion < (2, 0): self.skipTest("generateKey() only supported by SoftHSM >= 2.0") keyID = (0x01,) AESKeyTemplate = self.aesKeyTemplate + [(PyKCS11.CKA_ID, keyID)] AESKey = self.session.generateKey(AESKeyTemplate) self.assertIsNotNone(AESKey) # buffer of 32 bytes 0x00 DataIn = [0] * 32 # print("DataIn:", DataIn) # AES CBC with IV mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_CBC, "1234567812345678") # find the first secret key symKey = self.session.findObjects( [(PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_ID, keyID)] )[0] DataOut = self.session.encrypt(symKey, DataIn, mechanism) # print("DataOut", DataOut) DataCheck = self.session.decrypt(symKey, DataOut, mechanism) # print("DataCheck:", DataCheck) self.assertSequenceEqual(DataIn, DataCheck) # AES ECB with previous IV as Data mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_ECB) # same as '1234567812345678' (the IV) but as a list DataECBIn = [49, 50, 51, 52, 53, 54, 55, 56, 49, 50, 51, 52, 53, 54, 55, 56] # print("DataECBIn:", DataECBIn) DataECBOut = self.session.encrypt(symKey, DataECBIn, mechanism) # print("DataECBOut:", DataECBOut) DataECBCheck = self.session.decrypt(symKey, DataECBOut, mechanism) # print("DataECBCheck:", DataECBCheck) self.assertSequenceEqual(DataECBIn, DataECBCheck) # check the AES CBC computation is the same as the AES ECB # 1st block self.assertSequenceEqual(DataOut[:16], DataECBOut) # since the input is full of 0 we just pass the previous output DataECBOut2 = self.session.encrypt(symKey, DataECBOut, mechanism) # print("DataECBOut2", DataECBOut2) # 2nd block self.assertSequenceEqual(DataOut[16:], DataECBOut2) # AES CTR with IV mechanism = PyKCS11.AES_CTR_Mechanism(128, "1234567812345678") DataOut = self.session.encrypt(symKey, DataIn, mechanism) # print("DataOut", DataOut) DataCheck = self.session.decrypt(symKey, DataOut, mechanism) # print("DataCheck:", DataCheck) self.assertSequenceEqual(DataIn, DataCheck) # # test CK_GCM_PARAMS # if self.SoftHSMversion <= (2, 2): self.skipTest("CKM_AES_GCM only supported by SoftHSM > 2.2") AES_GCM_IV_SIZE = 12 AES_GCM_TAG_SIZE = 16 iv = [42] * AES_GCM_IV_SIZE aad = "plaintext aad" tagBits = AES_GCM_TAG_SIZE * 8 mechanism = PyKCS11.AES_GCM_Mechanism(iv, aad, tagBits) test_logger.info(mechanism._source_iv) DataOut = self.session.encrypt(symKey, DataIn, mechanism) # print("DataOut", DataOut) # mechanism._source_iv[0] = 12 test_logger.info(mechanism._source_iv) DataCheck = self.session.decrypt(symKey, DataOut, mechanism) # print("DataCheck:", DataCheck) test_logger.info(mechanism._source_iv) self.assertSequenceEqual(DataIn, DataCheck) self.session.destroyObject(AESKey) def test_multi_part_symmetric(self): iv = self.session.generateRandom(self.aesBlockSize) aesMechanisms = { "CKM_AES_ECB": PyKCS11.Mechanism(PyKCS11.CKM_AES_ECB), "CKM_AES_CBC": PyKCS11.Mechanism(PyKCS11.CKM_AES_CBC, iv), "CKM_AES_CTR": PyKCS11.AES_CTR_Mechanism(128, iv), } keyID = (0x02,) aesKey = self.session.generateKey( self.aesKeyTemplate + [(PyKCS11.CKA_ID, keyID)] ) self.assertIsNotNone(aesKey) for mechName in aesMechanisms: with self.subTest(mechName=mechName): if not mechName in self.pkcs11.getMechanismList(self.slot): self.skipTest(f"{mechName} is not supported by the token") self._run_multipart_encrypt_decrypt(aesMechanisms[mechName], aesKey) self.session.destroyObject(aesKey) def _run_multipart_encrypt_decrypt(self, mechanism, key): self.assertIsNotNone(mechanism) self.session.encryptInit(mechanism, key) data = self.session.generateRandom(self.aesBlockSize * 8) encData = [] dataPos = 0 # encrypt data using parts of different length, # but each of them must be a multiple of the block size for m in [1, 2, 3, 4]: # total 8 blocks dataPart = list(data[dataPos : dataPos + m * self.aesBlockSize]) encData += self.session.encryptUpdate(dataPart) dataPos += m * self.aesBlockSize encData += self.session.encryptFinal() self.session.decryptInit(mechanism, key) decData = [] dataPos = 0 for m in [3, 1, 2, 4]: # total 8 blocks encPart = list(encData[dataPos : dataPos + m * self.aesBlockSize]) decData += self.session.decryptUpdate(encPart) dataPos += m * self.aesBlockSize decData += self.session.decryptFinal() self.assertSequenceEqual(data, decData) # initiate another encryption to check that # the previous operation has been terminated self.session.encryptInit(mechanism, key) self.session.encryptFinal() def test_multi_part_aead(self): if "CKM_AES_GCM" not in self.pkcs11.getMechanismList(self.slot): self.skipTest("CKM_AES_GCM is not supported by the token") keyID = (0x03,) aesKey = self.session.generateKey( self.aesKeyTemplate + [(PyKCS11.CKA_ID, keyID)] ) self.assertIsNotNone(aesKey) AES_GCM_IV_SIZE = 12 AES_GCM_TAG_SIZE = 16 iv = self.session.generateRandom(AES_GCM_IV_SIZE) aad = "plaintext aad" tagBits = AES_GCM_TAG_SIZE * 8 mechanism = PyKCS11.AES_GCM_Mechanism(iv, aad, tagBits) self.session.encryptInit(mechanism, aesKey) data = self.session.generateRandom() encData = self.session.encryptUpdate(data) tag = self.session.encryptFinal() self.assertTrue(tag) self.session.decryptInit(mechanism, aesKey) decData = self.session.decryptUpdate(encData) # check: since CKM_AES_GCM is an AEAD cipher, no data should be returned until decryptFinal() # see https://docs.oasis-open.org/pkcs11/pkcs11-curr/v3.0/os/pkcs11-curr-v3.0-os.html#_Toc30061258 self.assertFalse(decData) decData += self.session.decryptUpdate(tag) self.assertFalse(decData) decData += self.session.decryptFinal() self.assertSequenceEqual(data, list(decData)) self.session.destroyObject(aesKey) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/test/test_wrap.py0000644000175100017510000002722715246574333016127 0ustar00runnerrunner# pylint: disable=missing-module-docstring # pylint: disable=missing-class-docstring # pylint: disable=missing-function-docstring import unittest from PyKCS11 import PyKCS11 class TestUtil(unittest.TestCase): def setUp(self): self.pkcs11 = PyKCS11.PyKCS11Lib() self.pkcs11.load() # get SoftHSM major version self.SoftHSMversion = self.pkcs11.getInfo().libraryVersion[0] self.slot = self.pkcs11.getSlotList(tokenPresent=True)[0] self.session = self.pkcs11.openSession( self.slot, PyKCS11.CKF_SERIAL_SESSION | PyKCS11.CKF_RW_SESSION ) self.session.login("1234") def tearDown(self): self.session.logout() self.pkcs11.closeAllSessions(self.slot) del self.pkcs11 def test_wrapKey(self): keyID = (0x01,) AESKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_LABEL, "TestAESKey"), (PyKCS11.CKA_ID, keyID), ] if self.SoftHSMversion < 2: self.skipTest("generateKey() only supported by SoftHSM >= 2") self.wrapKey = self.session.generateKey(AESKeyTemplate) self.assertIsNotNone(self.wrapKey) keyID = (0x02,) # make the key extractable AESKeyTemplate.append((PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE)) self.AESKey = self.session.generateKey(AESKeyTemplate) self.assertIsNotNone(self.AESKey) # buffer of 32 bytes 0x42 DataIn = [42] * 32 mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_ECB) DataOut = self.session.encrypt(self.AESKey, DataIn, mechanism) # print("DataOut", DataOut) DataCheck = self.session.decrypt(self.AESKey, DataOut, mechanism) # print("DataCheck:", DataCheck) # check we can encrypt/decrypt with the AES key self.assertSequenceEqual(DataIn, DataCheck) # wrap using CKM_AES_KEY_WRAP mechanismWrap = PyKCS11.Mechanism(PyKCS11.CKM_AES_KEY_WRAP) wrapped = self.session.wrapKey(self.wrapKey, self.AESKey, mechanismWrap) self.assertIsNotNone(wrapped) # destroy the original key self.session.destroyObject(self.AESKey) # unwrap template = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), ] unwrapped = self.session.unwrapKey( self.wrapKey, wrapped, template, mechanismWrap ) self.assertIsNotNone(unwrapped) DataCheck = self.session.decrypt(unwrapped, DataOut, mechanism) # print("DataCheck:", DataCheck) # check we can decrypt with the unwrapped AES key self.assertSequenceEqual(DataIn, DataCheck) # cleanup self.session.destroyObject(unwrapped) self.session.destroyObject(self.wrapKey) def test_wrapKey_OAEP(self): if self.SoftHSMversion < 2: self.skipTest("generateKey() only supported by SoftHSM >= 2") keyID = (0x22,) pubTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_MODULUS_BITS, 0x0400), (PyKCS11.CKA_PUBLIC_EXPONENT, (0x01, 0x00, 0x01)), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_LABEL, "My Public Key"), (PyKCS11.CKA_ID, keyID), ] privTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN_RECOVER, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_ID, keyID), ] self.pubKey, self.privKey = self.session.generateKeyPair( pubTemplate, privTemplate ) self.assertIsNotNone(self.pubKey) self.assertIsNotNone(self.privKey) keyID = (0x02,) AESKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_LABEL, "TestAESKey"), (PyKCS11.CKA_ID, keyID), ] # make the key extractable AESKeyTemplate.append((PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE)) self.AESKey = self.session.generateKey(AESKeyTemplate) self.assertIsNotNone(self.AESKey) # buffer of 32 bytes 0x42 DataIn = [42] * 32 mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_ECB) DataOut = self.session.encrypt(self.AESKey, DataIn, mechanism) # print("DataOut", DataOut) DataCheck = self.session.decrypt(self.AESKey, DataOut, mechanism) # print("DataCheck:", DataCheck) # check we can encrypt/decrypt with the AES key self.assertSequenceEqual(DataIn, DataCheck) # wrap using CKM_RSA_PKCS_OAEP + CKG_MGF1_SHA1 mechanismWrap = PyKCS11.RSAOAEPMechanism( PyKCS11.CKM_SHA_1, PyKCS11.CKG_MGF1_SHA1 ) wrapped = self.session.wrapKey(self.pubKey, self.AESKey, mechanismWrap) self.assertIsNotNone(wrapped) # destroy the original key self.session.destroyObject(self.AESKey) # unwrap template = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), ] unwrapped = self.session.unwrapKey( self.privKey, wrapped, template, mechanismWrap ) self.assertIsNotNone(unwrapped) DataCheck = self.session.decrypt(unwrapped, DataOut, mechanism) # print("DataCheck:", DataCheck) # check we can decrypt with the unwrapped AES key self.assertSequenceEqual(DataIn, DataCheck) # cleanup self.session.destroyObject(unwrapped) self.session.destroyObject(self.pubKey) self.session.destroyObject(self.privKey) def test_wrapKey_UNWRAP_TEMPLATE(self): keyID = (0x01,) pubTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PUBLIC_KEY), (PyKCS11.CKA_LABEL, "RSA Public Key"), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_RSA), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_TRUE), (PyKCS11.CKA_MODULUS_BITS, 2048), (PyKCS11.CKA_PUBLIC_EXPONENT, (0x01, 0x00, 0x01)), (PyKCS11.CKA_ID, keyID), (PyKCS11.CKA_WRAP, PyKCS11.CK_TRUE), ] unwrap_template = [ (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_FALSE), ] privTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_PRIVATE_KEY), (PyKCS11.CKA_LABEL, "RSA Private Key"), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_RSA), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_TRUE), (PyKCS11.CKA_ID, keyID), (PyKCS11.CKA_UNWRAP, PyKCS11.CK_TRUE), (PyKCS11.CKA_UNWRAP_TEMPLATE, unwrap_template), ] if self.SoftHSMversion < 2: self.skipTest("generateKey() only supported by SoftHSM >= 2") self.pubKey, self.privKey = self.session.generateKeyPair( pubTemplate, privTemplate ) self.assertIsNotNone(self.pubKey) self.assertIsNotNone(self.privKey) keyID = (0x02,) AESKeyTemplate = [ (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_PRIVATE, PyKCS11.CK_FALSE), (PyKCS11.CKA_ENCRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_DECRYPT, PyKCS11.CK_TRUE), (PyKCS11.CKA_SIGN, PyKCS11.CK_FALSE), (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE), (PyKCS11.CKA_VERIFY, PyKCS11.CK_FALSE), (PyKCS11.CKA_VALUE_LEN, 32), (PyKCS11.CKA_LABEL, "TestAESKey"), (PyKCS11.CKA_ID, keyID), ] # make the key extractable AESKeyTemplate.append((PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_TRUE)) self.AESKey = self.session.generateKey(AESKeyTemplate) self.assertIsNotNone(self.AESKey) # buffer of 32 bytes 0x42 DataIn = [42] * 32 mechanism = PyKCS11.Mechanism(PyKCS11.CKM_AES_ECB) DataOut = self.session.encrypt(self.AESKey, DataIn, mechanism) # print("DataOut", DataOut) DataCheck = self.session.decrypt(self.AESKey, DataOut, mechanism) # print("DataCheck:", DataCheck) # check we can encrypt/decrypt with the AES key self.assertSequenceEqual(DataIn, DataCheck) # wrap mechanismWrap = PyKCS11.RSAOAEPMechanism( PyKCS11.CKM_SHA_1, PyKCS11.CKG_MGF1_SHA1 ) wrapped = self.session.wrapKey(self.pubKey, self.AESKey, mechanismWrap) self.assertIsNotNone(wrapped) # destroy the original key self.session.destroyObject(self.AESKey) # unwrap template = [ (PyKCS11.CKA_TOKEN, PyKCS11.CK_TRUE), (PyKCS11.CKA_CLASS, PyKCS11.CKO_SECRET_KEY), (PyKCS11.CKA_KEY_TYPE, PyKCS11.CKK_AES), (PyKCS11.CKA_EXTRACTABLE, PyKCS11.CK_FALSE), ] unwrapped = self.session.unwrapKey( self.privKey, wrapped, template, mechanismWrap ) self.assertIsNotNone(unwrapped) DataCheck = self.session.decrypt(unwrapped, DataOut, mechanism) # print("DataCheck:", DataCheck) # check we can decrypt with the unwrapped AES key self.assertSequenceEqual(DataIn, DataCheck) attributes = self.session.getAttributeValue( unwrapped, [PyKCS11.CKA_EXTRACTABLE] ) self.assertSequenceEqual(attributes, [False]) # cleanup self.session.destroyObject(unwrapped) self.session.destroyObject(self.pubKey) self.session.destroyObject(self.privKey) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1788541146.5977924 pykcs11-1.5.20/tox.ini0000644000175100017510000000314615246574333014073 0ustar00runnerrunner# Tox (https://tox.readthedocs.io/) is a tool for running tests # in multiple virtualenvs. This configuration file will run the # test suite on all supported python versions. To use it, "pip install tox" # and then run "tox" from this directory. [tox] envlist = pylint build coverage_erase py{3.9, 3.10, 3.11, 3.12, 3.13, 3.14, 3.13t, 3.14t} coverage_report skip_missing_interpreters = True labels = build=build-py{3.9, 3.10, 3.11, 3.12, 3.13, 3.14, 3.13t, 3.14t} [testenv] description = run the tests with pytest depends = py{3.9, 3.10, 3.11, 3.12, 3.13, 3.14, 3.13t, 3.14t}: coverage_erase deps = pytest>=6 -r{toxinidir}/dev-requirements.txt setenv = file|tox.env commands = coverage run -m pytest {tty:--color=yes} {posargs} [testenv:py313t] basepython = python3.13t [testenv:py314t] basepython = python3.14t [testenv:build] description = Build sdist and wheel files skip_install = True deps = build commands = python -m build [testenv:coverage_erase] description = Erase existing coverage reports skip_install = True deps = coverage commands = - coverage erase [testenv:coverage_report{,-ci}] depends = py{3.9, 3.10, 3.11, 3.12, 3.13, 3.14, 3.13t, 3.14t} description = !ci: Generate HTML and console reports ci: Generate an XML report skip_install = True deps = coverage commands_pre = - coverage combine commands = # Locally, generate an HTML and a console report !ci: - coverage html !ci: coverage report # In CI, simply generate an XML report ci: - coverage xml [testenv:pylint] deps = pylint commands = pylint PyKCS11