mirror of
https://github.com/OpenVoiceOS/OpenVoiceOS
synced 2025-03-02 10:37:51 +01:00
Add pre-installed python packages within rootfs overlay
TODO: This is just a quick fix and need to be changed to buildroot packages in the upcoming days/weeks/months.
This commit is contained in:
j1nx
parent
f2c133bf5c
commit
be8496d4b6
@ -0,0 +1,142 @@
|
||||
Metadata-Version: 2.1
|
||||
Name: Adafruit-Blinka
|
||||
Version: 8.6.0
|
||||
Summary: CircuitPython APIs for non-CircuitPython versions of Python such as CPython on Linux and MicroPython.
|
||||
Home-page: https://github.com/adafruit/Adafruit_Blinka
|
||||
Author: Adafruit Industries
|
||||
Author-email: circuitpython@adafruit.com
|
||||
License: MIT
|
||||
Platform: UNKNOWN
|
||||
Classifier: License :: OSI Approved :: MIT License
|
||||
Classifier: Programming Language :: Python
|
||||
Classifier: Programming Language :: Python :: 3
|
||||
Classifier: Programming Language :: Python :: 3.7
|
||||
Classifier: Programming Language :: Python :: Implementation :: MicroPython
|
||||
Requires-Python: >=3.7.0
|
||||
Description-Content-Type: text/x-rst
|
||||
License-File: LICENSE
|
||||
|
||||
|
||||
Introduction
|
||||
============
|
||||
|
||||
.. image:: https://readthedocs.org/projects/adafruit-micropython-blinka/badge/?version=latest
|
||||
:target: https://circuitpython.readthedocs.io/projects/blinka/en/latest/
|
||||
:alt: Documentation Status
|
||||
|
||||
.. image:: https://img.shields.io/discord/327254708534116352.svg
|
||||
:target: https://adafru.it/discord
|
||||
:alt: Discord
|
||||
|
||||
.. image:: https://travis-ci.com/adafruit/Adafruit_Blinka.svg?branch=master
|
||||
:target: https://travis-ci.com/adafruit/Adafruit_Blinka
|
||||
:alt: Build Status
|
||||
|
||||
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
|
||||
:target: https://github.com/psf/black
|
||||
:alt: Code Style: Black
|
||||
|
||||
This repository contains a selection of packages emulating the CircuitPython API
|
||||
for devices or hosts running CPython or MicroPython. Working code exists to emulate these CircuitPython packages:
|
||||
|
||||
* **analogio** - analog input/output pins, using pin identities from board+microcontroller packages
|
||||
* **bitbangio** - software-driven interfaces for I2C, SPI
|
||||
* **board** - breakout-specific pin identities
|
||||
* **busio** - hardware-driven interfaces for I2C, SPI, UART
|
||||
* **digitalio** - digital input/output pins, using pin identities from board+microcontroller packages
|
||||
* **keypad** - support for scanning keys and key matrices
|
||||
* **microcontroller** - chip-specific pin identities
|
||||
* **micropython** - MicroPython-specific module
|
||||
* **neopixel_write** - low-level interface to NeoPixels
|
||||
* **pulseio** - contains classes that provide access to basic pulse IO (PWM)
|
||||
* **pwmio** - contains classes that provide access to basic pulse IO (PWM)
|
||||
* **rainbowio** - provides the colorwheel() function
|
||||
* **usb_hid** - act as a hid-device using usb_gadget kernel driver
|
||||
|
||||
For details, see the `Blinka API reference
|
||||
<https://circuitpython.readthedocs.io/projects/blinka/en/latest/index.html>`_.
|
||||
|
||||
Dependencies
|
||||
=============
|
||||
|
||||
The emulation described above is intended to provide a
|
||||
CircuitPython-like API for devices which are running CPython or
|
||||
Micropython. Since corresponding packages should be built-in to any
|
||||
standard CircuitPython image, they have no value on a device already
|
||||
running CircuitPython and would likely conflict in unhappy ways.
|
||||
|
||||
The test suites in the test/src folder under **testing.universal** are by design
|
||||
intended to run on *either* CircuitPython *or* CPython/Micropython+compatibility layer to prove conformance.
|
||||
|
||||
Installing from PyPI
|
||||
=====================
|
||||
|
||||
On supported GNU/Linux systems like the Raspberry Pi, you can install the driver locally `from
|
||||
PyPI <https://pypi.org/project/Adafruit-Blinka/>`_. To install for current user:
|
||||
|
||||
.. code-block:: shell
|
||||
|
||||
pip3 install Adafruit-Blinka
|
||||
|
||||
To install system-wide (this may be required in some cases):
|
||||
|
||||
.. code-block:: shell
|
||||
|
||||
sudo pip3 install Adafruit-Blinka
|
||||
|
||||
To install in a virtual environment in your current project:
|
||||
|
||||
.. code-block:: shell
|
||||
|
||||
mkdir project-name && cd project-name
|
||||
python3 -m venv .env
|
||||
source .env/bin/activate
|
||||
pip3 install Adafruit-Blinka
|
||||
|
||||
Usage Example
|
||||
=============
|
||||
|
||||
At the time of writing (`git:7fc1f8ab <https://github.com/cefn/Adafruit_Micropython_Blinka/tree/7fc1f8ab477124628a5afebbf6826005955805f9>`_),
|
||||
the following sequence runs through some basic testing of the digitalio compatibility layer...
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from testing import test_module_name
|
||||
test_module_name("testing.universal.digitalio")
|
||||
|
||||
An example log from running the suites is `here <https://github.com/cefn/Adafruit_Micropython_Blinka/issues/2#issuecomment-366713394>`_ .
|
||||
|
||||
Contributing
|
||||
============
|
||||
|
||||
Contributions are welcome! Please read our `Code of Conduct
|
||||
<https://github.com/adafruit/Adafruit_Blinka/blob/master/CODE_OF_CONDUCT.md>`_
|
||||
before contributing to help this project stay welcoming.
|
||||
|
||||
Building locally
|
||||
================
|
||||
|
||||
Sphinx documentation
|
||||
-----------------------
|
||||
|
||||
Sphinx is used to build the documentation based on rST files and comments in the code. First,
|
||||
install dependencies (feel free to reuse the virtual environment from above):
|
||||
|
||||
.. code-block:: shell
|
||||
|
||||
python3 -m venv .env
|
||||
source .env/bin/activate
|
||||
pip install Sphinx sphinx-rtd-theme Adafruit-PlatformDetect
|
||||
|
||||
Now, once you have the virtual environment activated:
|
||||
|
||||
.. code-block:: shell
|
||||
|
||||
cd docs
|
||||
sphinx-build -E -W -b html . _build/html
|
||||
|
||||
This will output the documentation to ``docs/_build/html``. Open the index.html in your browser to
|
||||
view them. It will also (due to -W) error out on any warning like Travis will. This is a good way to
|
||||
locally verify it will pass.
|
||||
|
||||
|
||||
@ -0,0 +1,330 @@
|
||||
.gitignore
|
||||
.gitmodules
|
||||
.pre-commit-config.yaml
|
||||
.pylintrc
|
||||
.readthedocs.yaml
|
||||
CODE_OF_CONDUCT.md
|
||||
LICENSE
|
||||
README.rst
|
||||
README.rst.license
|
||||
requirements.txt
|
||||
requirements.txt.license
|
||||
setup.cfg
|
||||
setup.py
|
||||
.github/workflows/build.yml
|
||||
.github/workflows/release.yml
|
||||
LICENSES/CC-BY-4.0.txt
|
||||
LICENSES/MIT.txt
|
||||
LICENSES/Unlicense.txt
|
||||
docs/api.rst
|
||||
docs/api.rst.license
|
||||
docs/conf.py
|
||||
docs/examples.rst
|
||||
docs/examples.rst.license
|
||||
docs/index.rst
|
||||
docs/index.rst.license
|
||||
docs/requirements.txt
|
||||
docs/_static/favicon.ico
|
||||
docs/_static/favicon.ico.license
|
||||
examples/analog_in.py
|
||||
examples/bbb_digitalio.py
|
||||
examples/mcps_busio_i2c.py
|
||||
examples/pb_digitalio.py
|
||||
examples/pi_busio_i2c.py
|
||||
examples/pi_busio_spi.py
|
||||
examples/pi_digitalio.py
|
||||
examples/piblinka.py
|
||||
src/__version__.py
|
||||
src/analogio.py
|
||||
src/bitbangio.py
|
||||
src/board.py
|
||||
src/busio.py
|
||||
src/digitalio.py
|
||||
src/keypad.py
|
||||
src/micropython.py
|
||||
src/neopixel_write.py
|
||||
src/onewireio.py
|
||||
src/pulseio.py
|
||||
src/pwmio.py
|
||||
src/rainbowio.py
|
||||
src/usb_hid.py
|
||||
src/Adafruit_Blinka.egg-info/PKG-INFO
|
||||
src/Adafruit_Blinka.egg-info/SOURCES.txt
|
||||
src/Adafruit_Blinka.egg-info/dependency_links.txt
|
||||
src/Adafruit_Blinka.egg-info/requires.txt
|
||||
src/Adafruit_Blinka.egg-info/top_level.txt
|
||||
src/adafruit_blinka/__init__.py
|
||||
src/adafruit_blinka/agnostic/__init__.py
|
||||
src/adafruit_blinka/agnostic/time.py
|
||||
src/adafruit_blinka/board/__init__.py
|
||||
src/adafruit_blinka/board/binho_nova.py
|
||||
src/adafruit_blinka/board/clockworkcpi3.py
|
||||
src/adafruit_blinka/board/coral_dev_board.py
|
||||
src/adafruit_blinka/board/coral_dev_board_mini.py
|
||||
src/adafruit_blinka/board/dragonboard_410c.py
|
||||
src/adafruit_blinka/board/feather_huzzah.py
|
||||
src/adafruit_blinka/board/feather_u2if.py
|
||||
src/adafruit_blinka/board/ftdi_ft2232h.py
|
||||
src/adafruit_blinka/board/ftdi_ft232h.py
|
||||
src/adafruit_blinka/board/giantboard.py
|
||||
src/adafruit_blinka/board/greatfet_one.py
|
||||
src/adafruit_blinka/board/hifive_unleashed.py
|
||||
src/adafruit_blinka/board/itsybitsy_u2if.py
|
||||
src/adafruit_blinka/board/lichee_rv.py
|
||||
src/adafruit_blinka/board/macropad_u2if.py
|
||||
src/adafruit_blinka/board/microchip_mcp2221.py
|
||||
src/adafruit_blinka/board/nodemcu.py
|
||||
src/adafruit_blinka/board/pico_u2if.py
|
||||
src/adafruit_blinka/board/pine64.py
|
||||
src/adafruit_blinka/board/pineH64.py
|
||||
src/adafruit_blinka/board/pyboard.py
|
||||
src/adafruit_blinka/board/qt2040_trinkey_u2if.py
|
||||
src/adafruit_blinka/board/qtpy_u2if.py
|
||||
src/adafruit_blinka/board/soPine.py
|
||||
src/adafruit_blinka/board/tritium-h3.py
|
||||
src/adafruit_blinka/board/udoo_x86ultra.py
|
||||
src/adafruit_blinka/board/bananapi/__init__.py
|
||||
src/adafruit_blinka/board/bananapi/bpim2plus.py
|
||||
src/adafruit_blinka/board/bananapi/bpim2zero.py
|
||||
src/adafruit_blinka/board/bananapi/bpim5.py
|
||||
src/adafruit_blinka/board/beagleboard/__init__.py
|
||||
src/adafruit_blinka/board/beagleboard/beaglebone_ai.py
|
||||
src/adafruit_blinka/board/beagleboard/beaglebone_black.py
|
||||
src/adafruit_blinka/board/beagleboard/beaglebone_pocketbeagle.py
|
||||
src/adafruit_blinka/board/beagleboard/beaglev_starlight.py
|
||||
src/adafruit_blinka/board/hardkernel/__init__.py
|
||||
src/adafruit_blinka/board/hardkernel/odroidc2.py
|
||||
src/adafruit_blinka/board/hardkernel/odroidc4.py
|
||||
src/adafruit_blinka/board/hardkernel/odroidn2.py
|
||||
src/adafruit_blinka/board/hardkernel/odroidxu4.py
|
||||
src/adafruit_blinka/board/khadas/__init__.py
|
||||
src/adafruit_blinka/board/khadas/khadasvim3.py
|
||||
src/adafruit_blinka/board/librecomputer/__init__.py
|
||||
src/adafruit_blinka/board/librecomputer/aml_s905x_cc_v1.py
|
||||
src/adafruit_blinka/board/lubancat/__init__.py
|
||||
src/adafruit_blinka/board/lubancat/lubancat_imx6ull.py
|
||||
src/adafruit_blinka/board/lubancat/lubancat_stm32mp157.py
|
||||
src/adafruit_blinka/board/nanopi/__init__.py
|
||||
src/adafruit_blinka/board/nanopi/duo2.py
|
||||
src/adafruit_blinka/board/nanopi/neo.py
|
||||
src/adafruit_blinka/board/nanopi/neoair.py
|
||||
src/adafruit_blinka/board/nvidia/__init__.py
|
||||
src/adafruit_blinka/board/nvidia/clara_agx_xavier.py
|
||||
src/adafruit_blinka/board/nvidia/jetson_nano.py
|
||||
src/adafruit_blinka/board/nvidia/jetson_nx.py
|
||||
src/adafruit_blinka/board/nvidia/jetson_orin.py
|
||||
src/adafruit_blinka/board/nvidia/jetson_tx1.py
|
||||
src/adafruit_blinka/board/nvidia/jetson_tx2.py
|
||||
src/adafruit_blinka/board/nvidia/jetson_tx2_nx.py
|
||||
src/adafruit_blinka/board/nvidia/jetson_xavier.py
|
||||
src/adafruit_blinka/board/onion/__init__.py
|
||||
src/adafruit_blinka/board/onion/omega2.py
|
||||
src/adafruit_blinka/board/orangepi/__init__.py
|
||||
src/adafruit_blinka/board/orangepi/orangepi3.py
|
||||
src/adafruit_blinka/board/orangepi/orangepi4.py
|
||||
src/adafruit_blinka/board/orangepi/orangepipc.py
|
||||
src/adafruit_blinka/board/orangepi/orangepir1.py
|
||||
src/adafruit_blinka/board/orangepi/orangepizero.py
|
||||
src/adafruit_blinka/board/orangepi/orangepizero2.py
|
||||
src/adafruit_blinka/board/orangepi/orangepizeroplus.py
|
||||
src/adafruit_blinka/board/orangepi/orangepizeroplus2h5.py
|
||||
src/adafruit_blinka/board/radxa/__init__.py
|
||||
src/adafruit_blinka/board/radxa/radxazero.py
|
||||
src/adafruit_blinka/board/radxa/rockpi4.py
|
||||
src/adafruit_blinka/board/radxa/rockpie.py
|
||||
src/adafruit_blinka/board/radxa/rockpis.py
|
||||
src/adafruit_blinka/board/raspberrypi/__init__.py
|
||||
src/adafruit_blinka/board/raspberrypi/pico.py
|
||||
src/adafruit_blinka/board/raspberrypi/raspi_1b_rev1.py
|
||||
src/adafruit_blinka/board/raspberrypi/raspi_1b_rev2.py
|
||||
src/adafruit_blinka/board/raspberrypi/raspi_40pin.py
|
||||
src/adafruit_blinka/board/raspberrypi/raspi_4b.py
|
||||
src/adafruit_blinka/board/raspberrypi/raspi_cm.py
|
||||
src/adafruit_blinka/board/siemens/__init__.py
|
||||
src/adafruit_blinka/board/siemens/siemens_iot2050.py
|
||||
src/adafruit_blinka/board/stm32/__init__.py
|
||||
src/adafruit_blinka/board/stm32/osd32mp1_brk.py
|
||||
src/adafruit_blinka/board/stm32/osd32mp1_red.py
|
||||
src/adafruit_blinka/board/stm32/stm32mp157c_dk2.py
|
||||
src/adafruit_blinka/microcontroller/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/D1/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/D1/pin.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/a33/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/a33/pin.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/a64/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/a64/pin.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h3/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h3/pin.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h5/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h5/pin.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h6/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h6/pin.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h616/__init__.py
|
||||
src/adafruit_blinka/microcontroller/allwinner/h616/pin.py
|
||||
src/adafruit_blinka/microcontroller/am335x/__init__.py
|
||||
src/adafruit_blinka/microcontroller/am335x/pin.py
|
||||
src/adafruit_blinka/microcontroller/am335x/sysfs_pwmout.py
|
||||
src/adafruit_blinka/microcontroller/am65xx/__init__.py
|
||||
src/adafruit_blinka/microcontroller/am65xx/analogio.py
|
||||
src/adafruit_blinka/microcontroller/am65xx/i2c.py
|
||||
src/adafruit_blinka/microcontroller/am65xx/pin.py
|
||||
src/adafruit_blinka/microcontroller/am65xx/pwmout.py
|
||||
src/adafruit_blinka/microcontroller/am65xx/spi.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/pin.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/pulseio/PulseIn.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/pulseio/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein.license
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein64
|
||||
src/adafruit_blinka/microcontroller/amlogic/a311d/pulseio/libgpiod_pulsein64.license
|
||||
src/adafruit_blinka/microcontroller/amlogic/meson_g12_common/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/meson_g12_common/pin.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905/pin.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905x/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905x/pin.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905x3/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905x3/pin.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905y2/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s905y2/pin.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s922x/__init__.py
|
||||
src/adafruit_blinka/microcontroller/amlogic/s922x/pin.py
|
||||
src/adafruit_blinka/microcontroller/atheros/__init__.py
|
||||
src/adafruit_blinka/microcontroller/atheros/ar9331/__init__.py
|
||||
src/adafruit_blinka/microcontroller/atheros/ar9331/pin.py
|
||||
src/adafruit_blinka/microcontroller/bcm2711/__init__.py
|
||||
src/adafruit_blinka/microcontroller/bcm2711/pin.py
|
||||
src/adafruit_blinka/microcontroller/bcm283x/__init__.py
|
||||
src/adafruit_blinka/microcontroller/bcm283x/neopixel.py
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pin.py
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pulseio/PulseIn.py
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pulseio/__init__.py
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein.license
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein64
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pulseio/libgpiod_pulsein64.license
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pwmio/PWMOut.py
|
||||
src/adafruit_blinka/microcontroller/bcm283x/pwmio/__init__.py
|
||||
src/adafruit_blinka/microcontroller/dra74x/__init__.py
|
||||
src/adafruit_blinka/microcontroller/dra74x/pin.py
|
||||
src/adafruit_blinka/microcontroller/esp8266/__init__.py
|
||||
src/adafruit_blinka/microcontroller/esp8266/pin.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/__init__.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/ft2232h/__init__.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/ft2232h/pin.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/ft232h/__init__.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/ft232h/pin.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/__init__.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/i2c.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/pin.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/spi.py
|
||||
src/adafruit_blinka/microcontroller/ftdi_mpsse/mpsse/url.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/__init__.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/i2c.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/libgpiod_pin.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/periphery_pin.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/spi.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/sysfs_analogin.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/sysfs_analogout.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/sysfs_pin.py
|
||||
src/adafruit_blinka/microcontroller/generic_linux/sysfs_pwmout.py
|
||||
src/adafruit_blinka/microcontroller/generic_micropython/__init__.py
|
||||
src/adafruit_blinka/microcontroller/generic_micropython/i2c.py
|
||||
src/adafruit_blinka/microcontroller/generic_micropython/spi.py
|
||||
src/adafruit_blinka/microcontroller/hfu540/__init__.py
|
||||
src/adafruit_blinka/microcontroller/hfu540/pin.py
|
||||
src/adafruit_blinka/microcontroller/mcp2221/__init__.py
|
||||
src/adafruit_blinka/microcontroller/mcp2221/analogio.py
|
||||
src/adafruit_blinka/microcontroller/mcp2221/i2c.py
|
||||
src/adafruit_blinka/microcontroller/mcp2221/mcp2221.py
|
||||
src/adafruit_blinka/microcontroller/mcp2221/pin.py
|
||||
src/adafruit_blinka/microcontroller/mips24kec/__init__.py
|
||||
src/adafruit_blinka/microcontroller/mips24kec/pin.py
|
||||
src/adafruit_blinka/microcontroller/mt8167/__init__.py
|
||||
src/adafruit_blinka/microcontroller/mt8167/pin.py
|
||||
src/adafruit_blinka/microcontroller/nova/__init__.py
|
||||
src/adafruit_blinka/microcontroller/nova/i2c.py
|
||||
src/adafruit_blinka/microcontroller/nova/pin.py
|
||||
src/adafruit_blinka/microcontroller/nova/pwmout.py
|
||||
src/adafruit_blinka/microcontroller/nova/spi.py
|
||||
src/adafruit_blinka/microcontroller/nova/uart.py
|
||||
src/adafruit_blinka/microcontroller/nxp_imx6ull/__init__.py
|
||||
src/adafruit_blinka/microcontroller/nxp_imx6ull/pin.py
|
||||
src/adafruit_blinka/microcontroller/nxp_imx8m/__init__.py
|
||||
src/adafruit_blinka/microcontroller/nxp_imx8m/pin.py
|
||||
src/adafruit_blinka/microcontroller/nxp_lpc4330/__init__.py
|
||||
src/adafruit_blinka/microcontroller/nxp_lpc4330/analogio.py
|
||||
src/adafruit_blinka/microcontroller/nxp_lpc4330/i2c.py
|
||||
src/adafruit_blinka/microcontroller/nxp_lpc4330/pin.py
|
||||
src/adafruit_blinka/microcontroller/nxp_lpc4330/pwmout.py
|
||||
src/adafruit_blinka/microcontroller/nxp_lpc4330/spi.py
|
||||
src/adafruit_blinka/microcontroller/nxp_lpc4330/uart.py
|
||||
src/adafruit_blinka/microcontroller/pentium/__init__.py
|
||||
src/adafruit_blinka/microcontroller/pentium/n3710/__init__.py
|
||||
src/adafruit_blinka/microcontroller/pentium/n3710/pin.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/PWMOut.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/__init__.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/rk3308/__init__.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/rk3308/pin.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/rk3328/__init__.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/rk3328/pin.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/rk3399/__init__.py
|
||||
src/adafruit_blinka/microcontroller/rockchip/rk3399/pin.py
|
||||
src/adafruit_blinka/microcontroller/rp2040/__init__.py
|
||||
src/adafruit_blinka/microcontroller/rp2040/i2c.py
|
||||
src/adafruit_blinka/microcontroller/rp2040/pin.py
|
||||
src/adafruit_blinka/microcontroller/rp2040/spi.py
|
||||
src/adafruit_blinka/microcontroller/rp2040/uart.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/__init__.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/analogio.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/i2c.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/neopixel.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/pin.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/pwmio.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/rp2040_u2if.py
|
||||
src/adafruit_blinka/microcontroller/rp2040_u2if/spi.py
|
||||
src/adafruit_blinka/microcontroller/sama5/__init__.py
|
||||
src/adafruit_blinka/microcontroller/sama5/pin.py
|
||||
src/adafruit_blinka/microcontroller/samsung/__init__.py
|
||||
src/adafruit_blinka/microcontroller/samsung/exynos5422/__init__.py
|
||||
src/adafruit_blinka/microcontroller/samsung/exynos5422/pin.py
|
||||
src/adafruit_blinka/microcontroller/snapdragon/__init__.py
|
||||
src/adafruit_blinka/microcontroller/snapdragon/apq8016/__init__.py
|
||||
src/adafruit_blinka/microcontroller/snapdragon/apq8016/pin.py
|
||||
src/adafruit_blinka/microcontroller/starfive/__init__.py
|
||||
src/adafruit_blinka/microcontroller/starfive/JH71x0/__init__.py
|
||||
src/adafruit_blinka/microcontroller/starfive/JH71x0/pin.py
|
||||
src/adafruit_blinka/microcontroller/stm32/__init__.py
|
||||
src/adafruit_blinka/microcontroller/stm32/stm32f405/__init__.py
|
||||
src/adafruit_blinka/microcontroller/stm32/stm32f405/pin.py
|
||||
src/adafruit_blinka/microcontroller/stm32/stm32mp157/__init__.py
|
||||
src/adafruit_blinka/microcontroller/stm32/stm32mp157/pin.py
|
||||
src/adafruit_blinka/microcontroller/tegra/__init__.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t186/__init__.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t186/pin.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t194/__init__.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t194/pin.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t210/__init__.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t210/pin.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t234/__init__.py
|
||||
src/adafruit_blinka/microcontroller/tegra/t234/pin.py
|
||||
src/microcontroller/__init__.py
|
||||
src/microcontroller/pin.py
|
||||
src/micropython-stubs/micropython.pyi
|
||||
test/scripts/upload_feather_huzzah_circuitpython_put.sh
|
||||
test/scripts/upload_feather_huzzah_micropython_put.sh
|
||||
test/scripts/upload_pyboard_micropython_cp.sh
|
||||
test/src/unittest.py
|
||||
test/src/testing/__init__.py
|
||||
test/src/testing/adafruit_blinka.py
|
||||
test/src/testing/board/__init__.py
|
||||
test/src/testing/board/i2c.py
|
||||
test/src/testing/microcontroller/__init__.py
|
||||
test/src/testing/universal/__init__.py
|
||||
test/src/testing/universal/digitalio.py
|
||||
test/src/testing/universal/i2c.py
|
||||
test/src/testing/universal/microcontroller.py
|
||||
test/src/testing/universal/uart.py
|
||||
@ -0,0 +1 @@
|
||||
|
||||
@ -0,0 +1,4 @@
|
||||
Adafruit-PlatformDetect>=3.13.0
|
||||
Adafruit-PureIO>=1.1.7
|
||||
pyftdi>=0.40.0
|
||||
adafruit-circuitpython-typing
|
||||
@ -0,0 +1,16 @@
|
||||
adafruit_blinka
|
||||
analogio
|
||||
bitbangio
|
||||
board
|
||||
busio
|
||||
digitalio
|
||||
keypad
|
||||
microcontroller
|
||||
micropython
|
||||
micropython-stubs
|
||||
neopixel_write
|
||||
onewireio
|
||||
pulseio
|
||||
pwmio
|
||||
rainbowio
|
||||
usb_hid
|
||||
@ -0,0 +1,484 @@
|
||||
Metadata-Version: 2.1
|
||||
Name: Automat
|
||||
Version: 20.2.0
|
||||
Summary: Self-service finite-state machines for the programmer on the go.
|
||||
Home-page: https://github.com/glyph/Automat
|
||||
Author: Glyph
|
||||
Author-email: glyph@twistedmatrix.com
|
||||
License: MIT
|
||||
Keywords: fsm finite state machine automata
|
||||
Platform: UNKNOWN
|
||||
Classifier: Intended Audience :: Developers
|
||||
Classifier: License :: OSI Approved :: MIT License
|
||||
Classifier: Operating System :: OS Independent
|
||||
Classifier: Programming Language :: Python
|
||||
Classifier: Programming Language :: Python :: 2
|
||||
Classifier: Programming Language :: Python :: 2.7
|
||||
Classifier: Programming Language :: Python :: 3
|
||||
Classifier: Programming Language :: Python :: 3.5
|
||||
Classifier: Programming Language :: Python :: 3.6
|
||||
Classifier: Programming Language :: Python :: 3.7
|
||||
Classifier: Programming Language :: Python :: 3.8
|
||||
Provides-Extra: visualize
|
||||
License-File: LICENSE
|
||||
|
||||
|
||||
Automat
|
||||
=======
|
||||
|
||||
|
||||
.. image:: https://readthedocs.org/projects/automat/badge/?version=latest
|
||||
:target: http://automat.readthedocs.io/en/latest/
|
||||
:alt: Documentation Status
|
||||
|
||||
|
||||
.. image:: https://travis-ci.org/glyph/automat.svg?branch=master
|
||||
:target: https://travis-ci.org/glyph/automat
|
||||
:alt: Build Status
|
||||
|
||||
|
||||
.. image:: https://coveralls.io/repos/glyph/automat/badge.png
|
||||
:target: https://coveralls.io/r/glyph/automat
|
||||
:alt: Coverage Status
|
||||
|
||||
|
||||
Self-service finite-state machines for the programmer on the go.
|
||||
----------------------------------------------------------------
|
||||
|
||||
Automat is a library for concise, idiomatic Python expression of finite-state
|
||||
automata (particularly deterministic finite-state transducers).
|
||||
|
||||
Read more here, or on `Read the Docs <https://automat.readthedocs.io/>`_\ , or watch the following videos for an overview and presentation
|
||||
|
||||
Overview and presentation by **Glyph Lefkowitz** at the first talk of the first Pyninsula meetup, on February 21st, 2017:
|
||||
|
||||
.. image:: https://img.youtube.com/vi/0wOZBpD1VVk/0.jpg
|
||||
:target: https://www.youtube.com/watch?v=0wOZBpD1VVk
|
||||
:alt: Glyph Lefkowitz - Automat - Pyninsula #0
|
||||
|
||||
|
||||
Presentation by **Clinton Roy** at PyCon Australia, on August 6th 2017:
|
||||
|
||||
.. image:: https://img.youtube.com/vi/TedUKXhu9kE/0.jpg
|
||||
:target: https://www.youtube.com/watch?v=TedUKXhu9kE
|
||||
:alt: Clinton Roy - State Machines - Pycon Australia 2017
|
||||
|
||||
|
||||
Why use state machines?
|
||||
^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Sometimes you have to create an object whose behavior varies with its state,
|
||||
but still wishes to present a consistent interface to its callers.
|
||||
|
||||
For example, let's say you're writing the software for a coffee machine. It
|
||||
has a lid that can be opened or closed, a chamber for water, a chamber for
|
||||
coffee beans, and a button for "brew".
|
||||
|
||||
There are a number of possible states for the coffee machine. It might or
|
||||
might not have water. It might or might not have beans. The lid might be open
|
||||
or closed. The "brew" button should only actually attempt to brew coffee in
|
||||
one of these configurations, and the "open lid" button should only work if the
|
||||
coffee is not, in fact, brewing.
|
||||
|
||||
With diligence and attention to detail, you can implement this correctly using
|
||||
a collection of attributes on an object; ``has_water``\ , ``has_beans``\ ,
|
||||
``is_lid_open`` and so on. However, you have to keep all these attributes
|
||||
consistent. As the coffee maker becomes more complex - perhaps you add an
|
||||
additional chamber for flavorings so you can make hazelnut coffee, for
|
||||
example - you have to keep adding more and more checks and more and more
|
||||
reasoning about which combinations of states are allowed.
|
||||
|
||||
Rather than adding tedious 'if' checks to every single method to make sure that
|
||||
each of these flags are exactly what you expect, you can use a state machine to
|
||||
ensure that if your code runs at all, it will be run with all the required
|
||||
values initialized, because they have to be called in the order you declare
|
||||
them.
|
||||
|
||||
You can read about state machines and their advantages for Python programmers
|
||||
in considerably more detail
|
||||
`in this excellent series of articles from ClusterHQ <https://clusterhq.com/blog/what-is-a-state-machine/>`_.
|
||||
|
||||
What makes Automat different?
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
There are
|
||||
`dozens of libraries on PyPI implementing state machines <https://pypi.org/search/?q=finite+state+machine>`_.
|
||||
So it behooves me to say why yet another one would be a good idea.
|
||||
|
||||
Automat is designed around this principle: while organizing your code around
|
||||
state machines is a good idea, your callers don't, and shouldn't have to, care
|
||||
that you've done so. In Python, the "input" to a stateful system is a method
|
||||
call; the "output" may be a method call, if you need to invoke a side effect,
|
||||
or a return value, if you are just performing a computation in memory. Most
|
||||
other state-machine libraries require you to explicitly create an input object,
|
||||
provide that object to a generic "input" method, and then receive results,
|
||||
sometimes in terms of that library's interfaces and sometimes in terms of
|
||||
classes you define yourself.
|
||||
|
||||
For example, a snippet of the coffee-machine example above might be implemented
|
||||
as follows in naive Python:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
class CoffeeMachine(object):
|
||||
def brew_button(self):
|
||||
if self.has_water and self.has_beans and not self.is_lid_open:
|
||||
self.heat_the_heating_element()
|
||||
# ...
|
||||
|
||||
With Automat, you'd create a class with a ``MethodicalMachine`` attribute:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from automat import MethodicalMachine
|
||||
|
||||
class CoffeeBrewer(object):
|
||||
_machine = MethodicalMachine()
|
||||
|
||||
and then you would break the above logic into two pieces - the ``brew_button``
|
||||
*input*\ , declared like so:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.input()
|
||||
def brew_button(self):
|
||||
"The user pressed the 'brew' button."
|
||||
|
||||
It wouldn't do any good to declare a method *body* on this, however, because
|
||||
input methods don't actually execute their bodies when called; doing actual
|
||||
work is the *output*\ 's job:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.output()
|
||||
def _heat_the_heating_element(self):
|
||||
"Heat up the heating element, which should cause coffee to happen."
|
||||
self._heating_element.turn_on()
|
||||
|
||||
As well as a couple of *states* - and for simplicity's sake let's say that the
|
||||
only two states are ``have_beans`` and ``dont_have_beans``\ :
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.state()
|
||||
def have_beans(self):
|
||||
"In this state, you have some beans."
|
||||
@_machine.state(initial=True)
|
||||
def dont_have_beans(self):
|
||||
"In this state, you don't have any beans."
|
||||
|
||||
``dont_have_beans`` is the ``initial`` state because ``CoffeeBrewer`` starts without beans
|
||||
in it.
|
||||
|
||||
(And another input to put some beans in:)
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.input()
|
||||
def put_in_beans(self):
|
||||
"The user put in some beans."
|
||||
|
||||
Finally, you hook everything together with the ``upon`` method of the functions
|
||||
decorated with ``_machine.state``\ :
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
|
||||
# When we don't have beans, upon putting in beans, we will then have beans
|
||||
# (and produce no output)
|
||||
dont_have_beans.upon(put_in_beans, enter=have_beans, outputs=[])
|
||||
|
||||
# When we have beans, upon pressing the brew button, we will then not have
|
||||
# beans any more (as they have been entered into the brewing chamber) and
|
||||
# our output will be heating the heating element.
|
||||
have_beans.upon(brew_button, enter=dont_have_beans,
|
||||
outputs=[_heat_the_heating_element])
|
||||
|
||||
To *users* of this coffee machine class though, it still looks like a POPO
|
||||
(Plain Old Python Object):
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> coffee_machine = CoffeeMachine()
|
||||
>>> coffee_machine.put_in_beans()
|
||||
>>> coffee_machine.brew_button()
|
||||
|
||||
All of the *inputs* are provided by calling them like methods, all of the
|
||||
*outputs* are automatically invoked when they are produced according to the
|
||||
outputs specified to ``upon`` and all of the states are simply opaque tokens -
|
||||
although the fact that they're defined as methods like inputs and outputs
|
||||
allows you to put docstrings on them easily to document them.
|
||||
|
||||
How do I get the current state of a state machine?
|
||||
--------------------------------------------------
|
||||
|
||||
Don't do that.
|
||||
|
||||
One major reason for having a state machine is that you want the callers of the
|
||||
state machine to just provide the appropriate input to the machine at the
|
||||
appropriate time, and *not have to check themselves* what state the machine is
|
||||
in. So if you are tempted to write some code like this:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
if connection_state_machine.state == "CONNECTED":
|
||||
connection_state_machine.send_message()
|
||||
else:
|
||||
print("not connected")
|
||||
|
||||
Instead, just make your calling code do this:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
connection_state_machine.send_message()
|
||||
|
||||
and then change your state machine to look like this:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.state()
|
||||
def connected(self):
|
||||
"connected"
|
||||
@_machine.state()
|
||||
def not_connected(self):
|
||||
"not connected"
|
||||
@_machine.input()
|
||||
def send_message(self):
|
||||
"send a message"
|
||||
@_machine.output()
|
||||
def _actually_send_message(self):
|
||||
self._transport.send(b"message")
|
||||
@_machine.output()
|
||||
def _report_sending_failure(self):
|
||||
print("not connected")
|
||||
connected.upon(send_message, enter=connected, [_actually_send_message])
|
||||
not_connected.upon(send_message, enter=not_connected, [_report_sending_failure])
|
||||
|
||||
so that the responsibility for knowing which state the state machine is in
|
||||
remains within the state machine itself.
|
||||
|
||||
Input for Inputs and Output for Outputs
|
||||
---------------------------------------
|
||||
|
||||
Quite often you want to be able to pass parameters to your methods, as well as
|
||||
inspecting their results. For example, when you brew the coffee, you might
|
||||
expect a cup of coffee to result, and you would like to see what kind of coffee
|
||||
it is. And if you were to put delicious hand-roasted small-batch artisanal
|
||||
beans into the machine, you would expect a *better* cup of coffee than if you
|
||||
were to use mass-produced beans. You would do this in plain old Python by
|
||||
adding a parameter, so that's how you do it in Automat as well.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.input()
|
||||
def put_in_beans(self, beans):
|
||||
"The user put in some beans."
|
||||
|
||||
However, one important difference here is that *we can't add any
|
||||
implementation code to the input method*. Inputs are purely a declaration of
|
||||
the interface; the behavior must all come from outputs. Therefore, the change
|
||||
in the state of the coffee machine must be represented as an output. We can
|
||||
add an output method like this:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.output()
|
||||
def _save_beans(self, beans):
|
||||
"The beans are now in the machine; save them."
|
||||
self._beans = beans
|
||||
|
||||
and then connect it to the ``put_in_beans`` by changing the transition from
|
||||
``dont_have_beans`` to ``have_beans`` like so:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
dont_have_beans.upon(put_in_beans, enter=have_beans,
|
||||
outputs=[_save_beans])
|
||||
|
||||
Now, when you call:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
coffee_machine.put_in_beans("real good beans")
|
||||
|
||||
the machine will remember the beans for later.
|
||||
|
||||
So how do we get the beans back out again? One of our outputs needs to have a
|
||||
return value. It would make sense if our ``brew_button`` method returned the cup
|
||||
of coffee that it made, so we should add an output. So, in addition to heating
|
||||
the heating element, let's add a return value that describes the coffee. First
|
||||
a new output:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.output()
|
||||
def _describe_coffee(self):
|
||||
return "A cup of coffee made with {}.".format(self._beans)
|
||||
|
||||
Note that we don't need to check first whether ``self._beans`` exists or not,
|
||||
because we can only reach this output method if the state machine says we've
|
||||
gone through a set of states that sets this attribute.
|
||||
|
||||
Now, we need to hook up ``_describe_coffee`` to the process of brewing, so change
|
||||
the brewing transition to:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
have_beans.upon(brew_button, enter=dont_have_beans,
|
||||
outputs=[_heat_the_heating_element,
|
||||
_describe_coffee])
|
||||
|
||||
Now, we can call it:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> coffee_machine.brew_button()
|
||||
[None, 'A cup of coffee made with real good beans.']
|
||||
|
||||
Except... wait a second, what's that ``None`` doing there?
|
||||
|
||||
Since every input can produce multiple outputs, in automat, the default return
|
||||
value from every input invocation is a ``list``. In this case, we have both
|
||||
``_heat_the_heating_element`` and ``_describe_coffee`` outputs, so we're seeing
|
||||
both of their return values. However, this can be customized, with the
|
||||
``collector`` argument to ``upon``\ ; the ``collector`` is a callable which takes an
|
||||
iterable of all the outputs' return values and "collects" a single return value
|
||||
to return to the caller of the state machine.
|
||||
|
||||
In this case, we only care about the last output, so we can adjust the call to
|
||||
``upon`` like this:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
have_beans.upon(brew_button, enter=dont_have_beans,
|
||||
outputs=[_heat_the_heating_element,
|
||||
_describe_coffee],
|
||||
collector=lambda iterable: list(iterable)[-1]
|
||||
)
|
||||
|
||||
And now, we'll get just the return value we want:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> coffee_machine.brew_button()
|
||||
'A cup of coffee made with real good beans.'
|
||||
|
||||
If I can't get the state of the state machine, how can I save it to (a database, an API response, a file on disk...)
|
||||
--------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
There are APIs for serializing the state machine.
|
||||
|
||||
First, you have to decide on a persistent representation of each state, via the
|
||||
``serialized=`` argument to the ``MethodicalMachine.state()`` decorator.
|
||||
|
||||
Let's take this very simple "light switch" state machine, which can be on or
|
||||
off, and flipped to reverse its state:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
class LightSwitch(object):
|
||||
_machine = MethodicalMachine()
|
||||
@_machine.state(serialized="on")
|
||||
def on_state(self):
|
||||
"the switch is on"
|
||||
@_machine.state(serialized="off", initial=True)
|
||||
def off_state(self):
|
||||
"the switch is off"
|
||||
@_machine.input()
|
||||
def flip(self):
|
||||
"flip the switch"
|
||||
on_state.upon(flip, enter=off_state, outputs=[])
|
||||
off_state.upon(flip, enter=on_state, outputs=[])
|
||||
|
||||
In this case, we've chosen a serialized representation for each state via the
|
||||
``serialized`` argument. The on state is represented by the string ``"on"``\ , and
|
||||
the off state is represented by the string ``"off"``.
|
||||
|
||||
Now, let's just add an input that lets us tell if the switch is on or not.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.input()
|
||||
def query_power(self):
|
||||
"return True if powered, False otherwise"
|
||||
@_machine.output()
|
||||
def _is_powered(self):
|
||||
return True
|
||||
@_machine.output()
|
||||
def _not_powered(self):
|
||||
return False
|
||||
on_state.upon(query_power, enter=on_state, outputs=[_is_powered],
|
||||
collector=next)
|
||||
off_state.upon(query_power, enter=off_state, outputs=[_not_powered],
|
||||
collector=next)
|
||||
|
||||
To save the state, we have the ``MethodicalMachine.serializer()`` method. A
|
||||
method decorated with ``@serializer()`` gets an extra argument injected at the
|
||||
beginning of its argument list: the serialized identifier for the state. In
|
||||
this case, either ``"on"`` or ``"off"``. Since state machine output methods can
|
||||
also affect other state on the object, a serializer method is expected to
|
||||
return *all* relevant state for serialization.
|
||||
|
||||
For our simple light switch, such a method might look like this:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.serializer()
|
||||
def save(self, state):
|
||||
return {"is-it-on": state}
|
||||
|
||||
Serializers can be public methods, and they can return whatever you like. If
|
||||
necessary, you can have different serializers - just multiple methods decorated
|
||||
with ``@_machine.serializer()`` - for different formats; return one data-structure
|
||||
for JSON, one for XML, one for a database row, and so on.
|
||||
|
||||
When it comes time to unserialize, though, you generally want a private method,
|
||||
because an unserializer has to take a not-fully-initialized instance and
|
||||
populate it with state. It is expected to *return* the serialized machine
|
||||
state token that was passed to the serializer, but it can take whatever
|
||||
arguments you like. Of course, in order to return that, it probably has to
|
||||
take it somewhere in its arguments, so it will generally take whatever a paired
|
||||
serializer has returned as an argument.
|
||||
|
||||
So our unserializer would look like this:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@_machine.unserializer()
|
||||
def _restore(self, blob):
|
||||
return blob["is-it-on"]
|
||||
|
||||
Generally you will want a classmethod deserialization constructor which you
|
||||
write yourself to call this, so that you know how to create an instance of your
|
||||
own object, like so:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
@classmethod
|
||||
def from_blob(cls, blob):
|
||||
self = cls()
|
||||
self._restore(blob)
|
||||
return self
|
||||
|
||||
Saving and loading our ``LightSwitch`` along with its state-machine state can now
|
||||
be accomplished as follows:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
>>> switch1 = LightSwitch()
|
||||
>>> switch1.query_power()
|
||||
False
|
||||
>>> switch1.flip()
|
||||
[]
|
||||
>>> switch1.query_power()
|
||||
True
|
||||
>>> blob = switch1.save()
|
||||
>>> switch2 = LightSwitch.from_blob(blob)
|
||||
>>> switch2.query_power()
|
||||
True
|
||||
|
||||
More comprehensive (tested, working) examples are present in ``docs/examples``.
|
||||
|
||||
Go forth and machine all the state!
|
||||
|
||||
|
||||
@ -0,0 +1,39 @@
|
||||
.gitignore
|
||||
.travis.yml
|
||||
LICENSE
|
||||
README.md
|
||||
setup.cfg
|
||||
setup.py
|
||||
tox.ini
|
||||
Automat.egg-info/PKG-INFO
|
||||
Automat.egg-info/SOURCES.txt
|
||||
Automat.egg-info/dependency_links.txt
|
||||
Automat.egg-info/entry_points.txt
|
||||
Automat.egg-info/requires.txt
|
||||
Automat.egg-info/top_level.txt
|
||||
automat/__init__.py
|
||||
automat/_core.py
|
||||
automat/_discover.py
|
||||
automat/_introspection.py
|
||||
automat/_methodical.py
|
||||
automat/_visualize.py
|
||||
automat/_test/__init__.py
|
||||
automat/_test/test_core.py
|
||||
automat/_test/test_discover.py
|
||||
automat/_test/test_methodical.py
|
||||
automat/_test/test_trace.py
|
||||
automat/_test/test_visualize.py
|
||||
benchmark/test_transitions.py
|
||||
docs/Makefile
|
||||
docs/about.rst
|
||||
docs/api.rst
|
||||
docs/conf.py
|
||||
docs/debugging.rst
|
||||
docs/index.rst
|
||||
docs/make.bat
|
||||
docs/visualize.rst
|
||||
docs/_static/mystate.machine.MyMachine._machine.dot.png
|
||||
docs/examples/automat_example.py
|
||||
docs/examples/io_coffee_example.py
|
||||
docs/examples/lightswitch.py
|
||||
docs/examples/turnstile_example.py
|
||||
@ -0,0 +1 @@
|
||||
|
||||
@ -0,0 +1,3 @@
|
||||
[console_scripts]
|
||||
automat-visualize = automat._visualize:tool
|
||||
|
||||
@ -0,0 +1,6 @@
|
||||
attrs>=19.2.0
|
||||
six
|
||||
|
||||
[visualize]
|
||||
graphviz>0.5.1
|
||||
Twisted>=16.1.1
|
||||
@ -0,0 +1 @@
|
||||
automat
|
||||
@ -0,0 +1,30 @@
|
||||
Metadata-Version: 2.1
|
||||
Name: Babel
|
||||
Version: 2.9.1
|
||||
Summary: Internationalization utilities
|
||||
Home-page: http://babel.pocoo.org/
|
||||
Author: Armin Ronacher
|
||||
Author-email: armin.ronacher@active-4.com
|
||||
License: BSD
|
||||
Platform: UNKNOWN
|
||||
Classifier: Development Status :: 5 - Production/Stable
|
||||
Classifier: Environment :: Web Environment
|
||||
Classifier: Intended Audience :: Developers
|
||||
Classifier: License :: OSI Approved :: BSD License
|
||||
Classifier: Operating System :: OS Independent
|
||||
Classifier: Programming Language :: Python
|
||||
Classifier: Programming Language :: Python :: 2
|
||||
Classifier: Programming Language :: Python :: 2.7
|
||||
Classifier: Programming Language :: Python :: 3
|
||||
Classifier: Programming Language :: Python :: 3.4
|
||||
Classifier: Programming Language :: Python :: 3.5
|
||||
Classifier: Programming Language :: Python :: 3.6
|
||||
Classifier: Programming Language :: Python :: 3.7
|
||||
Classifier: Programming Language :: Python :: Implementation :: CPython
|
||||
Classifier: Programming Language :: Python :: Implementation :: PyPy
|
||||
Classifier: Topic :: Software Development :: Libraries :: Python Modules
|
||||
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
|
||||
License-File: LICENSE
|
||||
|
||||
A collection of tools for internationalizing Python applications.
|
||||
|
||||
@ -0,0 +1,924 @@
|
||||
AUTHORS
|
||||
CHANGES
|
||||
LICENSE
|
||||
MANIFEST.in
|
||||
Makefile
|
||||
README.rst
|
||||
conftest.py
|
||||
setup.cfg
|
||||
setup.py
|
||||
tox.ini
|
||||
Babel.egg-info/PKG-INFO
|
||||
Babel.egg-info/SOURCES.txt
|
||||
Babel.egg-info/dependency_links.txt
|
||||
Babel.egg-info/entry_points.txt
|
||||
Babel.egg-info/not-zip-safe
|
||||
Babel.egg-info/requires.txt
|
||||
Babel.egg-info/top_level.txt
|
||||
babel/__init__.py
|
||||
babel/_compat.py
|
||||
babel/core.py
|
||||
babel/dates.py
|
||||
babel/global.dat
|
||||
babel/languages.py
|
||||
babel/lists.py
|
||||
babel/localedata.py
|
||||
babel/numbers.py
|
||||
babel/plural.py
|
||||
babel/support.py
|
||||
babel/units.py
|
||||
babel/util.py
|
||||
babel/locale-data/af.dat
|
||||
babel/locale-data/af_NA.dat
|
||||
babel/locale-data/af_ZA.dat
|
||||
babel/locale-data/agq.dat
|
||||
babel/locale-data/agq_CM.dat
|
||||
babel/locale-data/ak.dat
|
||||
babel/locale-data/ak_GH.dat
|
||||
babel/locale-data/am.dat
|
||||
babel/locale-data/am_ET.dat
|
||||
babel/locale-data/ar.dat
|
||||
babel/locale-data/ar_001.dat
|
||||
babel/locale-data/ar_AE.dat
|
||||
babel/locale-data/ar_BH.dat
|
||||
babel/locale-data/ar_DJ.dat
|
||||
babel/locale-data/ar_DZ.dat
|
||||
babel/locale-data/ar_EG.dat
|
||||
babel/locale-data/ar_EH.dat
|
||||
babel/locale-data/ar_ER.dat
|
||||
babel/locale-data/ar_IL.dat
|
||||
babel/locale-data/ar_IQ.dat
|
||||
babel/locale-data/ar_JO.dat
|
||||
babel/locale-data/ar_KM.dat
|
||||
babel/locale-data/ar_KW.dat
|
||||
babel/locale-data/ar_LB.dat
|
||||
babel/locale-data/ar_LY.dat
|
||||
babel/locale-data/ar_MA.dat
|
||||
babel/locale-data/ar_MR.dat
|
||||
babel/locale-data/ar_OM.dat
|
||||
babel/locale-data/ar_PS.dat
|
||||
babel/locale-data/ar_QA.dat
|
||||
babel/locale-data/ar_SA.dat
|
||||
babel/locale-data/ar_SD.dat
|
||||
babel/locale-data/ar_SO.dat
|
||||
babel/locale-data/ar_SS.dat
|
||||
babel/locale-data/ar_SY.dat
|
||||
babel/locale-data/ar_TD.dat
|
||||
babel/locale-data/ar_TN.dat
|
||||
babel/locale-data/ar_YE.dat
|
||||
babel/locale-data/as.dat
|
||||
babel/locale-data/as_IN.dat
|
||||
babel/locale-data/asa.dat
|
||||
babel/locale-data/asa_TZ.dat
|
||||
babel/locale-data/ast.dat
|
||||
babel/locale-data/ast_ES.dat
|
||||
babel/locale-data/az.dat
|
||||
babel/locale-data/az_Cyrl.dat
|
||||
babel/locale-data/az_Cyrl_AZ.dat
|
||||
babel/locale-data/az_Latn.dat
|
||||
babel/locale-data/az_Latn_AZ.dat
|
||||
babel/locale-data/bas.dat
|
||||
babel/locale-data/bas_CM.dat
|
||||
babel/locale-data/be.dat
|
||||
babel/locale-data/be_BY.dat
|
||||
babel/locale-data/bem.dat
|
||||
babel/locale-data/bem_ZM.dat
|
||||
babel/locale-data/bez.dat
|
||||
babel/locale-data/bez_TZ.dat
|
||||
babel/locale-data/bg.dat
|
||||
babel/locale-data/bg_BG.dat
|
||||
babel/locale-data/bm.dat
|
||||
babel/locale-data/bm_ML.dat
|
||||
babel/locale-data/bn.dat
|
||||
babel/locale-data/bn_BD.dat
|
||||
babel/locale-data/bn_IN.dat
|
||||
babel/locale-data/bo.dat
|
||||
babel/locale-data/bo_CN.dat
|
||||
babel/locale-data/bo_IN.dat
|
||||
babel/locale-data/br.dat
|
||||
babel/locale-data/br_FR.dat
|
||||
babel/locale-data/brx.dat
|
||||
babel/locale-data/brx_IN.dat
|
||||
babel/locale-data/bs.dat
|
||||
babel/locale-data/bs_Cyrl.dat
|
||||
babel/locale-data/bs_Cyrl_BA.dat
|
||||
babel/locale-data/bs_Latn.dat
|
||||
babel/locale-data/bs_Latn_BA.dat
|
||||
babel/locale-data/ca.dat
|
||||
babel/locale-data/ca_AD.dat
|
||||
babel/locale-data/ca_ES.dat
|
||||
babel/locale-data/ca_ES_VALENCIA.dat
|
||||
babel/locale-data/ca_FR.dat
|
||||
babel/locale-data/ca_IT.dat
|
||||
babel/locale-data/ccp.dat
|
||||
babel/locale-data/ccp_BD.dat
|
||||
babel/locale-data/ccp_IN.dat
|
||||
babel/locale-data/ce.dat
|
||||
babel/locale-data/ce_RU.dat
|
||||
babel/locale-data/ceb.dat
|
||||
babel/locale-data/ceb_PH.dat
|
||||
babel/locale-data/cgg.dat
|
||||
babel/locale-data/cgg_UG.dat
|
||||
babel/locale-data/chr.dat
|
||||
babel/locale-data/chr_US.dat
|
||||
babel/locale-data/ckb.dat
|
||||
babel/locale-data/ckb_IQ.dat
|
||||
babel/locale-data/ckb_IR.dat
|
||||
babel/locale-data/cs.dat
|
||||
babel/locale-data/cs_CZ.dat
|
||||
babel/locale-data/cu.dat
|
||||
babel/locale-data/cu_RU.dat
|
||||
babel/locale-data/cy.dat
|
||||
babel/locale-data/cy_GB.dat
|
||||
babel/locale-data/da.dat
|
||||
babel/locale-data/da_DK.dat
|
||||
babel/locale-data/da_GL.dat
|
||||
babel/locale-data/dav.dat
|
||||
babel/locale-data/dav_KE.dat
|
||||
babel/locale-data/de.dat
|
||||
babel/locale-data/de_AT.dat
|
||||
babel/locale-data/de_BE.dat
|
||||
babel/locale-data/de_CH.dat
|
||||
babel/locale-data/de_DE.dat
|
||||
babel/locale-data/de_IT.dat
|
||||
babel/locale-data/de_LI.dat
|
||||
babel/locale-data/de_LU.dat
|
||||
babel/locale-data/dje.dat
|
||||
babel/locale-data/dje_NE.dat
|
||||
babel/locale-data/dsb.dat
|
||||
babel/locale-data/dsb_DE.dat
|
||||
babel/locale-data/dua.dat
|
||||
babel/locale-data/dua_CM.dat
|
||||
babel/locale-data/dyo.dat
|
||||
babel/locale-data/dyo_SN.dat
|
||||
babel/locale-data/dz.dat
|
||||
babel/locale-data/dz_BT.dat
|
||||
babel/locale-data/ebu.dat
|
||||
babel/locale-data/ebu_KE.dat
|
||||
babel/locale-data/ee.dat
|
||||
babel/locale-data/ee_GH.dat
|
||||
babel/locale-data/ee_TG.dat
|
||||
babel/locale-data/el.dat
|
||||
babel/locale-data/el_CY.dat
|
||||
babel/locale-data/el_GR.dat
|
||||
babel/locale-data/en.dat
|
||||
babel/locale-data/en_001.dat
|
||||
babel/locale-data/en_150.dat
|
||||
babel/locale-data/en_AE.dat
|
||||
babel/locale-data/en_AG.dat
|
||||
babel/locale-data/en_AI.dat
|
||||
babel/locale-data/en_AS.dat
|
||||
babel/locale-data/en_AT.dat
|
||||
babel/locale-data/en_AU.dat
|
||||
babel/locale-data/en_BB.dat
|
||||
babel/locale-data/en_BE.dat
|
||||
babel/locale-data/en_BI.dat
|
||||
babel/locale-data/en_BM.dat
|
||||
babel/locale-data/en_BS.dat
|
||||
babel/locale-data/en_BW.dat
|
||||
babel/locale-data/en_BZ.dat
|
||||
babel/locale-data/en_CA.dat
|
||||
babel/locale-data/en_CC.dat
|
||||
babel/locale-data/en_CH.dat
|
||||
babel/locale-data/en_CK.dat
|
||||
babel/locale-data/en_CM.dat
|
||||
babel/locale-data/en_CX.dat
|
||||
babel/locale-data/en_CY.dat
|
||||
babel/locale-data/en_DE.dat
|
||||
babel/locale-data/en_DG.dat
|
||||
babel/locale-data/en_DK.dat
|
||||
babel/locale-data/en_DM.dat
|
||||
babel/locale-data/en_ER.dat
|
||||
babel/locale-data/en_FI.dat
|
||||
babel/locale-data/en_FJ.dat
|
||||
babel/locale-data/en_FK.dat
|
||||
babel/locale-data/en_FM.dat
|
||||
babel/locale-data/en_GB.dat
|
||||
babel/locale-data/en_GD.dat
|
||||
babel/locale-data/en_GG.dat
|
||||
babel/locale-data/en_GH.dat
|
||||
babel/locale-data/en_GI.dat
|
||||
babel/locale-data/en_GM.dat
|
||||
babel/locale-data/en_GU.dat
|
||||
babel/locale-data/en_GY.dat
|
||||
babel/locale-data/en_HK.dat
|
||||
babel/locale-data/en_IE.dat
|
||||
babel/locale-data/en_IL.dat
|
||||
babel/locale-data/en_IM.dat
|
||||
babel/locale-data/en_IN.dat
|
||||
babel/locale-data/en_IO.dat
|
||||
babel/locale-data/en_JE.dat
|
||||
babel/locale-data/en_JM.dat
|
||||
babel/locale-data/en_KE.dat
|
||||
babel/locale-data/en_KI.dat
|
||||
babel/locale-data/en_KN.dat
|
||||
babel/locale-data/en_KY.dat
|
||||
babel/locale-data/en_LC.dat
|
||||
babel/locale-data/en_LR.dat
|
||||
babel/locale-data/en_LS.dat
|
||||
babel/locale-data/en_MG.dat
|
||||
babel/locale-data/en_MH.dat
|
||||
babel/locale-data/en_MO.dat
|
||||
babel/locale-data/en_MP.dat
|
||||
babel/locale-data/en_MS.dat
|
||||
babel/locale-data/en_MT.dat
|
||||
babel/locale-data/en_MU.dat
|
||||
babel/locale-data/en_MW.dat
|
||||
babel/locale-data/en_MY.dat
|
||||
babel/locale-data/en_NA.dat
|
||||
babel/locale-data/en_NF.dat
|
||||
babel/locale-data/en_NG.dat
|
||||
babel/locale-data/en_NL.dat
|
||||
babel/locale-data/en_NR.dat
|
||||
babel/locale-data/en_NU.dat
|
||||
babel/locale-data/en_NZ.dat
|
||||
babel/locale-data/en_PG.dat
|
||||
babel/locale-data/en_PH.dat
|
||||
babel/locale-data/en_PK.dat
|
||||
babel/locale-data/en_PN.dat
|
||||
babel/locale-data/en_PR.dat
|
||||
babel/locale-data/en_PW.dat
|
||||
babel/locale-data/en_RW.dat
|
||||
babel/locale-data/en_SB.dat
|
||||
babel/locale-data/en_SC.dat
|
||||
babel/locale-data/en_SD.dat
|
||||
babel/locale-data/en_SE.dat
|
||||
babel/locale-data/en_SG.dat
|
||||
babel/locale-data/en_SH.dat
|
||||
babel/locale-data/en_SI.dat
|
||||
babel/locale-data/en_SL.dat
|
||||
babel/locale-data/en_SS.dat
|
||||
babel/locale-data/en_SX.dat
|
||||
babel/locale-data/en_SZ.dat
|
||||
babel/locale-data/en_TC.dat
|
||||
babel/locale-data/en_TK.dat
|
||||
babel/locale-data/en_TO.dat
|
||||
babel/locale-data/en_TT.dat
|
||||
babel/locale-data/en_TV.dat
|
||||
babel/locale-data/en_TZ.dat
|
||||
babel/locale-data/en_UG.dat
|
||||
babel/locale-data/en_UM.dat
|
||||
babel/locale-data/en_US.dat
|
||||
babel/locale-data/en_US_POSIX.dat
|
||||
babel/locale-data/en_VC.dat
|
||||
babel/locale-data/en_VG.dat
|
||||
babel/locale-data/en_VI.dat
|
||||
babel/locale-data/en_VU.dat
|
||||
babel/locale-data/en_WS.dat
|
||||
babel/locale-data/en_ZA.dat
|
||||
babel/locale-data/en_ZM.dat
|
||||
babel/locale-data/en_ZW.dat
|
||||
babel/locale-data/eo.dat
|
||||
babel/locale-data/eo_001.dat
|
||||
babel/locale-data/es.dat
|
||||
babel/locale-data/es_419.dat
|
||||
babel/locale-data/es_AR.dat
|
||||
babel/locale-data/es_BO.dat
|
||||
babel/locale-data/es_BR.dat
|
||||
babel/locale-data/es_BZ.dat
|
||||
babel/locale-data/es_CL.dat
|
||||
babel/locale-data/es_CO.dat
|
||||
babel/locale-data/es_CR.dat
|
||||
babel/locale-data/es_CU.dat
|
||||
babel/locale-data/es_DO.dat
|
||||
babel/locale-data/es_EA.dat
|
||||
babel/locale-data/es_EC.dat
|
||||
babel/locale-data/es_ES.dat
|
||||
babel/locale-data/es_GQ.dat
|
||||
babel/locale-data/es_GT.dat
|
||||
babel/locale-data/es_HN.dat
|
||||
babel/locale-data/es_IC.dat
|
||||
babel/locale-data/es_MX.dat
|
||||
babel/locale-data/es_NI.dat
|
||||
babel/locale-data/es_PA.dat
|
||||
babel/locale-data/es_PE.dat
|
||||
babel/locale-data/es_PH.dat
|
||||
babel/locale-data/es_PR.dat
|
||||
babel/locale-data/es_PY.dat
|
||||
babel/locale-data/es_SV.dat
|
||||
babel/locale-data/es_US.dat
|
||||
babel/locale-data/es_UY.dat
|
||||
babel/locale-data/es_VE.dat
|
||||
babel/locale-data/et.dat
|
||||
babel/locale-data/et_EE.dat
|
||||
babel/locale-data/eu.dat
|
||||
babel/locale-data/eu_ES.dat
|
||||
babel/locale-data/ewo.dat
|
||||
babel/locale-data/ewo_CM.dat
|
||||
babel/locale-data/fa.dat
|
||||
babel/locale-data/fa_AF.dat
|
||||
babel/locale-data/fa_IR.dat
|
||||
babel/locale-data/ff.dat
|
||||
babel/locale-data/ff_Adlm.dat
|
||||
babel/locale-data/ff_Adlm_BF.dat
|
||||
babel/locale-data/ff_Adlm_CM.dat
|
||||
babel/locale-data/ff_Adlm_GH.dat
|
||||
babel/locale-data/ff_Adlm_GM.dat
|
||||
babel/locale-data/ff_Adlm_GN.dat
|
||||
babel/locale-data/ff_Adlm_GW.dat
|
||||
babel/locale-data/ff_Adlm_LR.dat
|
||||
babel/locale-data/ff_Adlm_MR.dat
|
||||
babel/locale-data/ff_Adlm_NE.dat
|
||||
babel/locale-data/ff_Adlm_NG.dat
|
||||
babel/locale-data/ff_Adlm_SL.dat
|
||||
babel/locale-data/ff_Adlm_SN.dat
|
||||
babel/locale-data/ff_Latn.dat
|
||||
babel/locale-data/ff_Latn_BF.dat
|
||||
babel/locale-data/ff_Latn_CM.dat
|
||||
babel/locale-data/ff_Latn_GH.dat
|
||||
babel/locale-data/ff_Latn_GM.dat
|
||||
babel/locale-data/ff_Latn_GN.dat
|
||||
babel/locale-data/ff_Latn_GW.dat
|
||||
babel/locale-data/ff_Latn_LR.dat
|
||||
babel/locale-data/ff_Latn_MR.dat
|
||||
babel/locale-data/ff_Latn_NE.dat
|
||||
babel/locale-data/ff_Latn_NG.dat
|
||||
babel/locale-data/ff_Latn_SL.dat
|
||||
babel/locale-data/ff_Latn_SN.dat
|
||||
babel/locale-data/fi.dat
|
||||
babel/locale-data/fi_FI.dat
|
||||
babel/locale-data/fil.dat
|
||||
babel/locale-data/fil_PH.dat
|
||||
babel/locale-data/fo.dat
|
||||
babel/locale-data/fo_DK.dat
|
||||
babel/locale-data/fo_FO.dat
|
||||
babel/locale-data/fr.dat
|
||||
babel/locale-data/fr_BE.dat
|
||||
babel/locale-data/fr_BF.dat
|
||||
babel/locale-data/fr_BI.dat
|
||||
babel/locale-data/fr_BJ.dat
|
||||
babel/locale-data/fr_BL.dat
|
||||
babel/locale-data/fr_CA.dat
|
||||
babel/locale-data/fr_CD.dat
|
||||
babel/locale-data/fr_CF.dat
|
||||
babel/locale-data/fr_CG.dat
|
||||
babel/locale-data/fr_CH.dat
|
||||
babel/locale-data/fr_CI.dat
|
||||
babel/locale-data/fr_CM.dat
|
||||
babel/locale-data/fr_DJ.dat
|
||||
babel/locale-data/fr_DZ.dat
|
||||
babel/locale-data/fr_FR.dat
|
||||
babel/locale-data/fr_GA.dat
|
||||
babel/locale-data/fr_GF.dat
|
||||
babel/locale-data/fr_GN.dat
|
||||
babel/locale-data/fr_GP.dat
|
||||
babel/locale-data/fr_GQ.dat
|
||||
babel/locale-data/fr_HT.dat
|
||||
babel/locale-data/fr_KM.dat
|
||||
babel/locale-data/fr_LU.dat
|
||||
babel/locale-data/fr_MA.dat
|
||||
babel/locale-data/fr_MC.dat
|
||||
babel/locale-data/fr_MF.dat
|
||||
babel/locale-data/fr_MG.dat
|
||||
babel/locale-data/fr_ML.dat
|
||||
babel/locale-data/fr_MQ.dat
|
||||
babel/locale-data/fr_MR.dat
|
||||
babel/locale-data/fr_MU.dat
|
||||
babel/locale-data/fr_NC.dat
|
||||
babel/locale-data/fr_NE.dat
|
||||
babel/locale-data/fr_PF.dat
|
||||
babel/locale-data/fr_PM.dat
|
||||
babel/locale-data/fr_RE.dat
|
||||
babel/locale-data/fr_RW.dat
|
||||
babel/locale-data/fr_SC.dat
|
||||
babel/locale-data/fr_SN.dat
|
||||
babel/locale-data/fr_SY.dat
|
||||
babel/locale-data/fr_TD.dat
|
||||
babel/locale-data/fr_TG.dat
|
||||
babel/locale-data/fr_TN.dat
|
||||
babel/locale-data/fr_VU.dat
|
||||
babel/locale-data/fr_WF.dat
|
||||
babel/locale-data/fr_YT.dat
|
||||
babel/locale-data/fur.dat
|
||||
babel/locale-data/fur_IT.dat
|
||||
babel/locale-data/fy.dat
|
||||
babel/locale-data/fy_NL.dat
|
||||
babel/locale-data/ga.dat
|
||||
babel/locale-data/ga_GB.dat
|
||||
babel/locale-data/ga_IE.dat
|
||||
babel/locale-data/gd.dat
|
||||
babel/locale-data/gd_GB.dat
|
||||
babel/locale-data/gl.dat
|
||||
babel/locale-data/gl_ES.dat
|
||||
babel/locale-data/gsw.dat
|
||||
babel/locale-data/gsw_CH.dat
|
||||
babel/locale-data/gsw_FR.dat
|
||||
babel/locale-data/gsw_LI.dat
|
||||
babel/locale-data/gu.dat
|
||||
babel/locale-data/gu_IN.dat
|
||||
babel/locale-data/guz.dat
|
||||
babel/locale-data/guz_KE.dat
|
||||
babel/locale-data/gv.dat
|
||||
babel/locale-data/gv_IM.dat
|
||||
babel/locale-data/ha.dat
|
||||
babel/locale-data/ha_GH.dat
|
||||
babel/locale-data/ha_NE.dat
|
||||
babel/locale-data/ha_NG.dat
|
||||
babel/locale-data/haw.dat
|
||||
babel/locale-data/haw_US.dat
|
||||
babel/locale-data/he.dat
|
||||
babel/locale-data/he_IL.dat
|
||||
babel/locale-data/hi.dat
|
||||
babel/locale-data/hi_IN.dat
|
||||
babel/locale-data/hr.dat
|
||||
babel/locale-data/hr_BA.dat
|
||||
babel/locale-data/hr_HR.dat
|
||||
babel/locale-data/hsb.dat
|
||||
babel/locale-data/hsb_DE.dat
|
||||
babel/locale-data/hu.dat
|
||||
babel/locale-data/hu_HU.dat
|
||||
babel/locale-data/hy.dat
|
||||
babel/locale-data/hy_AM.dat
|
||||
babel/locale-data/ia.dat
|
||||
babel/locale-data/ia_001.dat
|
||||
babel/locale-data/id.dat
|
||||
babel/locale-data/id_ID.dat
|
||||
babel/locale-data/ig.dat
|
||||
babel/locale-data/ig_NG.dat
|
||||
babel/locale-data/ii.dat
|
||||
babel/locale-data/ii_CN.dat
|
||||
babel/locale-data/is.dat
|
||||
babel/locale-data/is_IS.dat
|
||||
babel/locale-data/it.dat
|
||||
babel/locale-data/it_CH.dat
|
||||
babel/locale-data/it_IT.dat
|
||||
babel/locale-data/it_SM.dat
|
||||
babel/locale-data/it_VA.dat
|
||||
babel/locale-data/ja.dat
|
||||
babel/locale-data/ja_JP.dat
|
||||
babel/locale-data/jgo.dat
|
||||
babel/locale-data/jgo_CM.dat
|
||||
babel/locale-data/jmc.dat
|
||||
babel/locale-data/jmc_TZ.dat
|
||||
babel/locale-data/jv.dat
|
||||
babel/locale-data/jv_ID.dat
|
||||
babel/locale-data/ka.dat
|
||||
babel/locale-data/ka_GE.dat
|
||||
babel/locale-data/kab.dat
|
||||
babel/locale-data/kab_DZ.dat
|
||||
babel/locale-data/kam.dat
|
||||
babel/locale-data/kam_KE.dat
|
||||
babel/locale-data/kde.dat
|
||||
babel/locale-data/kde_TZ.dat
|
||||
babel/locale-data/kea.dat
|
||||
babel/locale-data/kea_CV.dat
|
||||
babel/locale-data/khq.dat
|
||||
babel/locale-data/khq_ML.dat
|
||||
babel/locale-data/ki.dat
|
||||
babel/locale-data/ki_KE.dat
|
||||
babel/locale-data/kk.dat
|
||||
babel/locale-data/kk_KZ.dat
|
||||
babel/locale-data/kkj.dat
|
||||
babel/locale-data/kkj_CM.dat
|
||||
babel/locale-data/kl.dat
|
||||
babel/locale-data/kl_GL.dat
|
||||
babel/locale-data/kln.dat
|
||||
babel/locale-data/kln_KE.dat
|
||||
babel/locale-data/km.dat
|
||||
babel/locale-data/km_KH.dat
|
||||
babel/locale-data/kn.dat
|
||||
babel/locale-data/kn_IN.dat
|
||||
babel/locale-data/ko.dat
|
||||
babel/locale-data/ko_KP.dat
|
||||
babel/locale-data/ko_KR.dat
|
||||
babel/locale-data/kok.dat
|
||||
babel/locale-data/kok_IN.dat
|
||||
babel/locale-data/ks.dat
|
||||
babel/locale-data/ks_Arab.dat
|
||||
babel/locale-data/ks_Arab_IN.dat
|
||||
babel/locale-data/ksb.dat
|
||||
babel/locale-data/ksb_TZ.dat
|
||||
babel/locale-data/ksf.dat
|
||||
babel/locale-data/ksf_CM.dat
|
||||
babel/locale-data/ksh.dat
|
||||
babel/locale-data/ksh_DE.dat
|
||||
babel/locale-data/ku.dat
|
||||
babel/locale-data/ku_TR.dat
|
||||
babel/locale-data/kw.dat
|
||||
babel/locale-data/kw_GB.dat
|
||||
babel/locale-data/ky.dat
|
||||
babel/locale-data/ky_KG.dat
|
||||
babel/locale-data/lag.dat
|
||||
babel/locale-data/lag_TZ.dat
|
||||
babel/locale-data/lb.dat
|
||||
babel/locale-data/lb_LU.dat
|
||||
babel/locale-data/lg.dat
|
||||
babel/locale-data/lg_UG.dat
|
||||
babel/locale-data/lkt.dat
|
||||
babel/locale-data/lkt_US.dat
|
||||
babel/locale-data/ln.dat
|
||||
babel/locale-data/ln_AO.dat
|
||||
babel/locale-data/ln_CD.dat
|
||||
babel/locale-data/ln_CF.dat
|
||||
babel/locale-data/ln_CG.dat
|
||||
babel/locale-data/lo.dat
|
||||
babel/locale-data/lo_LA.dat
|
||||
babel/locale-data/lrc.dat
|
||||
babel/locale-data/lrc_IQ.dat
|
||||
babel/locale-data/lrc_IR.dat
|
||||
babel/locale-data/lt.dat
|
||||
babel/locale-data/lt_LT.dat
|
||||
babel/locale-data/lu.dat
|
||||
babel/locale-data/lu_CD.dat
|
||||
babel/locale-data/luo.dat
|
||||
babel/locale-data/luo_KE.dat
|
||||
babel/locale-data/luy.dat
|
||||
babel/locale-data/luy_KE.dat
|
||||
babel/locale-data/lv.dat
|
||||
babel/locale-data/lv_LV.dat
|
||||
babel/locale-data/mai.dat
|
||||
babel/locale-data/mai_IN.dat
|
||||
babel/locale-data/mas.dat
|
||||
babel/locale-data/mas_KE.dat
|
||||
babel/locale-data/mas_TZ.dat
|
||||
babel/locale-data/mer.dat
|
||||
babel/locale-data/mer_KE.dat
|
||||
babel/locale-data/mfe.dat
|
||||
babel/locale-data/mfe_MU.dat
|
||||
babel/locale-data/mg.dat
|
||||
babel/locale-data/mg_MG.dat
|
||||
babel/locale-data/mgh.dat
|
||||
babel/locale-data/mgh_MZ.dat
|
||||
babel/locale-data/mgo.dat
|
||||
babel/locale-data/mgo_CM.dat
|
||||
babel/locale-data/mi.dat
|
||||
babel/locale-data/mi_NZ.dat
|
||||
babel/locale-data/mk.dat
|
||||
babel/locale-data/mk_MK.dat
|
||||
babel/locale-data/ml.dat
|
||||
babel/locale-data/ml_IN.dat
|
||||
babel/locale-data/mn.dat
|
||||
babel/locale-data/mn_MN.dat
|
||||
babel/locale-data/mni.dat
|
||||
babel/locale-data/mni_Beng.dat
|
||||
babel/locale-data/mni_Beng_IN.dat
|
||||
babel/locale-data/mr.dat
|
||||
babel/locale-data/mr_IN.dat
|
||||
babel/locale-data/ms.dat
|
||||
babel/locale-data/ms_BN.dat
|
||||
babel/locale-data/ms_ID.dat
|
||||
babel/locale-data/ms_MY.dat
|
||||
babel/locale-data/ms_SG.dat
|
||||
babel/locale-data/mt.dat
|
||||
babel/locale-data/mt_MT.dat
|
||||
babel/locale-data/mua.dat
|
||||
babel/locale-data/mua_CM.dat
|
||||
babel/locale-data/my.dat
|
||||
babel/locale-data/my_MM.dat
|
||||
babel/locale-data/mzn.dat
|
||||
babel/locale-data/mzn_IR.dat
|
||||
babel/locale-data/naq.dat
|
||||
babel/locale-data/naq_NA.dat
|
||||
babel/locale-data/nb.dat
|
||||
babel/locale-data/nb_NO.dat
|
||||
babel/locale-data/nb_SJ.dat
|
||||
babel/locale-data/nd.dat
|
||||
babel/locale-data/nd_ZW.dat
|
||||
babel/locale-data/nds.dat
|
||||
babel/locale-data/nds_DE.dat
|
||||
babel/locale-data/nds_NL.dat
|
||||
babel/locale-data/ne.dat
|
||||
babel/locale-data/ne_IN.dat
|
||||
babel/locale-data/ne_NP.dat
|
||||
babel/locale-data/nl.dat
|
||||
babel/locale-data/nl_AW.dat
|
||||
babel/locale-data/nl_BE.dat
|
||||
babel/locale-data/nl_BQ.dat
|
||||
babel/locale-data/nl_CW.dat
|
||||
babel/locale-data/nl_NL.dat
|
||||
babel/locale-data/nl_SR.dat
|
||||
babel/locale-data/nl_SX.dat
|
||||
babel/locale-data/nmg.dat
|
||||
babel/locale-data/nmg_CM.dat
|
||||
babel/locale-data/nn.dat
|
||||
babel/locale-data/nn_NO.dat
|
||||
babel/locale-data/nnh.dat
|
||||
babel/locale-data/nnh_CM.dat
|
||||
babel/locale-data/nus.dat
|
||||
babel/locale-data/nus_SS.dat
|
||||
babel/locale-data/nyn.dat
|
||||
babel/locale-data/nyn_UG.dat
|
||||
babel/locale-data/om.dat
|
||||
babel/locale-data/om_ET.dat
|
||||
babel/locale-data/om_KE.dat
|
||||
babel/locale-data/or.dat
|
||||
babel/locale-data/or_IN.dat
|
||||
babel/locale-data/os.dat
|
||||
babel/locale-data/os_GE.dat
|
||||
babel/locale-data/os_RU.dat
|
||||
babel/locale-data/pa.dat
|
||||
babel/locale-data/pa_Arab.dat
|
||||
babel/locale-data/pa_Arab_PK.dat
|
||||
babel/locale-data/pa_Guru.dat
|
||||
babel/locale-data/pa_Guru_IN.dat
|
||||
babel/locale-data/pcm.dat
|
||||
babel/locale-data/pcm_NG.dat
|
||||
babel/locale-data/pl.dat
|
||||
babel/locale-data/pl_PL.dat
|
||||
babel/locale-data/prg.dat
|
||||
babel/locale-data/prg_001.dat
|
||||
babel/locale-data/ps.dat
|
||||
babel/locale-data/ps_AF.dat
|
||||
babel/locale-data/ps_PK.dat
|
||||
babel/locale-data/pt.dat
|
||||
babel/locale-data/pt_AO.dat
|
||||
babel/locale-data/pt_BR.dat
|
||||
babel/locale-data/pt_CH.dat
|
||||
babel/locale-data/pt_CV.dat
|
||||
babel/locale-data/pt_GQ.dat
|
||||
babel/locale-data/pt_GW.dat
|
||||
babel/locale-data/pt_LU.dat
|
||||
babel/locale-data/pt_MO.dat
|
||||
babel/locale-data/pt_MZ.dat
|
||||
babel/locale-data/pt_PT.dat
|
||||
babel/locale-data/pt_ST.dat
|
||||
babel/locale-data/pt_TL.dat
|
||||
babel/locale-data/qu.dat
|
||||
babel/locale-data/qu_BO.dat
|
||||
babel/locale-data/qu_EC.dat
|
||||
babel/locale-data/qu_PE.dat
|
||||
babel/locale-data/rm.dat
|
||||
babel/locale-data/rm_CH.dat
|
||||
babel/locale-data/rn.dat
|
||||
babel/locale-data/rn_BI.dat
|
||||
babel/locale-data/ro.dat
|
||||
babel/locale-data/ro_MD.dat
|
||||
babel/locale-data/ro_RO.dat
|
||||
babel/locale-data/rof.dat
|
||||
babel/locale-data/rof_TZ.dat
|
||||
babel/locale-data/root.dat
|
||||
babel/locale-data/ru.dat
|
||||
babel/locale-data/ru_BY.dat
|
||||
babel/locale-data/ru_KG.dat
|
||||
babel/locale-data/ru_KZ.dat
|
||||
babel/locale-data/ru_MD.dat
|
||||
babel/locale-data/ru_RU.dat
|
||||
babel/locale-data/ru_UA.dat
|
||||
babel/locale-data/rw.dat
|
||||
babel/locale-data/rw_RW.dat
|
||||
babel/locale-data/rwk.dat
|
||||
babel/locale-data/rwk_TZ.dat
|
||||
babel/locale-data/sah.dat
|
||||
babel/locale-data/sah_RU.dat
|
||||
babel/locale-data/saq.dat
|
||||
babel/locale-data/saq_KE.dat
|
||||
babel/locale-data/sat.dat
|
||||
babel/locale-data/sat_Olck.dat
|
||||
babel/locale-data/sat_Olck_IN.dat
|
||||
babel/locale-data/sbp.dat
|
||||
babel/locale-data/sbp_TZ.dat
|
||||
babel/locale-data/sd.dat
|
||||
babel/locale-data/sd_Arab.dat
|
||||
babel/locale-data/sd_Arab_PK.dat
|
||||
babel/locale-data/sd_Deva.dat
|
||||
babel/locale-data/sd_Deva_IN.dat
|
||||
babel/locale-data/se.dat
|
||||
babel/locale-data/se_FI.dat
|
||||
babel/locale-data/se_NO.dat
|
||||
babel/locale-data/se_SE.dat
|
||||
babel/locale-data/seh.dat
|
||||
babel/locale-data/seh_MZ.dat
|
||||
babel/locale-data/ses.dat
|
||||
babel/locale-data/ses_ML.dat
|
||||
babel/locale-data/sg.dat
|
||||
babel/locale-data/sg_CF.dat
|
||||
babel/locale-data/shi.dat
|
||||
babel/locale-data/shi_Latn.dat
|
||||
babel/locale-data/shi_Latn_MA.dat
|
||||
babel/locale-data/shi_Tfng.dat
|
||||
babel/locale-data/shi_Tfng_MA.dat
|
||||
babel/locale-data/si.dat
|
||||
babel/locale-data/si_LK.dat
|
||||
babel/locale-data/sk.dat
|
||||
babel/locale-data/sk_SK.dat
|
||||
babel/locale-data/sl.dat
|
||||
babel/locale-data/sl_SI.dat
|
||||
babel/locale-data/smn.dat
|
||||
babel/locale-data/smn_FI.dat
|
||||
babel/locale-data/sn.dat
|
||||
babel/locale-data/sn_ZW.dat
|
||||
babel/locale-data/so.dat
|
||||
babel/locale-data/so_DJ.dat
|
||||
babel/locale-data/so_ET.dat
|
||||
babel/locale-data/so_KE.dat
|
||||
babel/locale-data/so_SO.dat
|
||||
babel/locale-data/sq.dat
|
||||
babel/locale-data/sq_AL.dat
|
||||
babel/locale-data/sq_MK.dat
|
||||
babel/locale-data/sq_XK.dat
|
||||
babel/locale-data/sr.dat
|
||||
babel/locale-data/sr_Cyrl.dat
|
||||
babel/locale-data/sr_Cyrl_BA.dat
|
||||
babel/locale-data/sr_Cyrl_ME.dat
|
||||
babel/locale-data/sr_Cyrl_RS.dat
|
||||
babel/locale-data/sr_Cyrl_XK.dat
|
||||
babel/locale-data/sr_Latn.dat
|
||||
babel/locale-data/sr_Latn_BA.dat
|
||||
babel/locale-data/sr_Latn_ME.dat
|
||||
babel/locale-data/sr_Latn_RS.dat
|
||||
babel/locale-data/sr_Latn_XK.dat
|
||||
babel/locale-data/su.dat
|
||||
babel/locale-data/su_Latn.dat
|
||||
babel/locale-data/su_Latn_ID.dat
|
||||
babel/locale-data/sv.dat
|
||||
babel/locale-data/sv_AX.dat
|
||||
babel/locale-data/sv_FI.dat
|
||||
babel/locale-data/sv_SE.dat
|
||||
babel/locale-data/sw.dat
|
||||
babel/locale-data/sw_CD.dat
|
||||
babel/locale-data/sw_KE.dat
|
||||
babel/locale-data/sw_TZ.dat
|
||||
babel/locale-data/sw_UG.dat
|
||||
babel/locale-data/ta.dat
|
||||
babel/locale-data/ta_IN.dat
|
||||
babel/locale-data/ta_LK.dat
|
||||
babel/locale-data/ta_MY.dat
|
||||
babel/locale-data/ta_SG.dat
|
||||
babel/locale-data/te.dat
|
||||
babel/locale-data/te_IN.dat
|
||||
babel/locale-data/teo.dat
|
||||
babel/locale-data/teo_KE.dat
|
||||
babel/locale-data/teo_UG.dat
|
||||
babel/locale-data/tg.dat
|
||||
babel/locale-data/tg_TJ.dat
|
||||
babel/locale-data/th.dat
|
||||
babel/locale-data/th_TH.dat
|
||||
babel/locale-data/ti.dat
|
||||
babel/locale-data/ti_ER.dat
|
||||
babel/locale-data/ti_ET.dat
|
||||
babel/locale-data/tk.dat
|
||||
babel/locale-data/tk_TM.dat
|
||||
babel/locale-data/to.dat
|
||||
babel/locale-data/to_TO.dat
|
||||
babel/locale-data/tr.dat
|
||||
babel/locale-data/tr_CY.dat
|
||||
babel/locale-data/tr_TR.dat
|
||||
babel/locale-data/tt.dat
|
||||
babel/locale-data/tt_RU.dat
|
||||
babel/locale-data/twq.dat
|
||||
babel/locale-data/twq_NE.dat
|
||||
babel/locale-data/tzm.dat
|
||||
babel/locale-data/tzm_MA.dat
|
||||
babel/locale-data/ug.dat
|
||||
babel/locale-data/ug_CN.dat
|
||||
babel/locale-data/uk.dat
|
||||
babel/locale-data/uk_UA.dat
|
||||
babel/locale-data/ur.dat
|
||||
babel/locale-data/ur_IN.dat
|
||||
babel/locale-data/ur_PK.dat
|
||||
babel/locale-data/uz.dat
|
||||
babel/locale-data/uz_Arab.dat
|
||||
babel/locale-data/uz_Arab_AF.dat
|
||||
babel/locale-data/uz_Cyrl.dat
|
||||
babel/locale-data/uz_Cyrl_UZ.dat
|
||||
babel/locale-data/uz_Latn.dat
|
||||
babel/locale-data/uz_Latn_UZ.dat
|
||||
babel/locale-data/vai.dat
|
||||
babel/locale-data/vai_Latn.dat
|
||||
babel/locale-data/vai_Latn_LR.dat
|
||||
babel/locale-data/vai_Vaii.dat
|
||||
babel/locale-data/vai_Vaii_LR.dat
|
||||
babel/locale-data/vi.dat
|
||||
babel/locale-data/vi_VN.dat
|
||||
babel/locale-data/vo.dat
|
||||
babel/locale-data/vo_001.dat
|
||||
babel/locale-data/vun.dat
|
||||
babel/locale-data/vun_TZ.dat
|
||||
babel/locale-data/wae.dat
|
||||
babel/locale-data/wae_CH.dat
|
||||
babel/locale-data/wo.dat
|
||||
babel/locale-data/wo_SN.dat
|
||||
babel/locale-data/xh.dat
|
||||
babel/locale-data/xh_ZA.dat
|
||||
babel/locale-data/xog.dat
|
||||
babel/locale-data/xog_UG.dat
|
||||
babel/locale-data/yav.dat
|
||||
babel/locale-data/yav_CM.dat
|
||||
babel/locale-data/yi.dat
|
||||
babel/locale-data/yi_001.dat
|
||||
babel/locale-data/yo.dat
|
||||
babel/locale-data/yo_BJ.dat
|
||||
babel/locale-data/yo_NG.dat
|
||||
babel/locale-data/yue.dat
|
||||
babel/locale-data/yue_Hans.dat
|
||||
babel/locale-data/yue_Hans_CN.dat
|
||||
babel/locale-data/yue_Hant.dat
|
||||
babel/locale-data/yue_Hant_HK.dat
|
||||
babel/locale-data/zgh.dat
|
||||
babel/locale-data/zgh_MA.dat
|
||||
babel/locale-data/zh.dat
|
||||
babel/locale-data/zh_Hans.dat
|
||||
babel/locale-data/zh_Hans_CN.dat
|
||||
babel/locale-data/zh_Hans_HK.dat
|
||||
babel/locale-data/zh_Hans_MO.dat
|
||||
babel/locale-data/zh_Hans_SG.dat
|
||||
babel/locale-data/zh_Hant.dat
|
||||
babel/locale-data/zh_Hant_HK.dat
|
||||
babel/locale-data/zh_Hant_MO.dat
|
||||
babel/locale-data/zh_Hant_TW.dat
|
||||
babel/locale-data/zu.dat
|
||||
babel/locale-data/zu_ZA.dat
|
||||
babel/localtime/__init__.py
|
||||
babel/localtime/_unix.py
|
||||
babel/localtime/_win32.py
|
||||
babel/messages/__init__.py
|
||||
babel/messages/catalog.py
|
||||
babel/messages/checkers.py
|
||||
babel/messages/extract.py
|
||||
babel/messages/frontend.py
|
||||
babel/messages/jslexer.py
|
||||
babel/messages/mofile.py
|
||||
babel/messages/plurals.py
|
||||
babel/messages/pofile.py
|
||||
docs/Makefile
|
||||
docs/changelog.rst
|
||||
docs/cmdline.rst
|
||||
docs/conf.py
|
||||
docs/dates.rst
|
||||
docs/dev.rst
|
||||
docs/index.rst
|
||||
docs/installation.rst
|
||||
docs/intro.rst
|
||||
docs/license.rst
|
||||
docs/locale.rst
|
||||
docs/make.bat
|
||||
docs/messages.rst
|
||||
docs/numbers.rst
|
||||
docs/setup.rst
|
||||
docs/support.rst
|
||||
docs/_static/logo.pdf
|
||||
docs/_static/logo.png
|
||||
docs/_static/logo_small.png
|
||||
docs/_templates/sidebar-about.html
|
||||
docs/_templates/sidebar-links.html
|
||||
docs/_templates/sidebar-logo.html
|
||||
docs/_themes/LICENSE
|
||||
docs/_themes/README
|
||||
docs/_themes/babel/layout.html
|
||||
docs/_themes/babel/relations.html
|
||||
docs/_themes/babel/theme.conf
|
||||
docs/_themes/babel/static/babel.css_t
|
||||
docs/_themes/babel/static/small_babel.css
|
||||
docs/api/core.rst
|
||||
docs/api/dates.rst
|
||||
docs/api/index.rst
|
||||
docs/api/languages.rst
|
||||
docs/api/lists.rst
|
||||
docs/api/numbers.rst
|
||||
docs/api/plural.rst
|
||||
docs/api/support.rst
|
||||
docs/api/units.rst
|
||||
docs/api/messages/catalog.rst
|
||||
docs/api/messages/extract.rst
|
||||
docs/api/messages/index.rst
|
||||
docs/api/messages/mofile.rst
|
||||
docs/api/messages/pofile.rst
|
||||
scripts/download_import_cldr.py
|
||||
scripts/dump_data.py
|
||||
scripts/dump_global.py
|
||||
scripts/generate_authors.py
|
||||
scripts/import_cldr.py
|
||||
scripts/make-release.py
|
||||
tests/__init__.py
|
||||
tests/conftest.py
|
||||
tests/test_core.py
|
||||
tests/test_date_intervals.py
|
||||
tests/test_dates.py
|
||||
tests/test_day_periods.py
|
||||
tests/test_languages.py
|
||||
tests/test_lists.py
|
||||
tests/test_localedata.py
|
||||
tests/test_numbers.py
|
||||
tests/test_plural.py
|
||||
tests/test_smoke.py
|
||||
tests/test_support.py
|
||||
tests/test_util.py
|
||||
tests/messages/__init__.py
|
||||
tests/messages/test_catalog.py
|
||||
tests/messages/test_checkers.py
|
||||
tests/messages/test_extract.py
|
||||
tests/messages/test_frontend.py
|
||||
tests/messages/test_js_extract.py
|
||||
tests/messages/test_jslexer.py
|
||||
tests/messages/test_mofile.py
|
||||
tests/messages/test_normalized_string.py
|
||||
tests/messages/test_plurals.py
|
||||
tests/messages/test_pofile.py
|
||||
tests/messages/data/mapping.cfg
|
||||
tests/messages/data/setup.cfg
|
||||
tests/messages/data/setup.py
|
||||
tests/messages/data/project/__init__.py
|
||||
tests/messages/data/project/file1.py
|
||||
tests/messages/data/project/file2.py
|
||||
tests/messages/data/project/i18n/messages.pot
|
||||
tests/messages/data/project/i18n/messages_non_fuzzy.pot
|
||||
tests/messages/data/project/i18n/de/LC_MESSAGES/messages.mo
|
||||
tests/messages/data/project/i18n/de/LC_MESSAGES/messages.po
|
||||
tests/messages/data/project/i18n/de_DE/LC_MESSAGES/bar.po
|
||||
tests/messages/data/project/i18n/de_DE/LC_MESSAGES/foo.po
|
||||
tests/messages/data/project/i18n/de_DE/LC_MESSAGES/messages.po
|
||||
tests/messages/data/project/i18n/fi_BUGGY/LC_MESSAGES/messages.po
|
||||
tests/messages/data/project/i18n/ru_RU/LC_MESSAGES/messages.po
|
||||
tests/messages/data/project/ignored/a_test_file.txt
|
||||
tests/messages/data/project/ignored/an_example.txt
|
||||
tests/messages/data/project/ignored/this_wont_normally_be_here.py
|
||||
@ -0,0 +1 @@
|
||||
|
||||
@ -0,0 +1,22 @@
|
||||
|
||||
[console_scripts]
|
||||
pybabel = babel.messages.frontend:main
|
||||
|
||||
[distutils.commands]
|
||||
compile_catalog = babel.messages.frontend:compile_catalog
|
||||
extract_messages = babel.messages.frontend:extract_messages
|
||||
init_catalog = babel.messages.frontend:init_catalog
|
||||
update_catalog = babel.messages.frontend:update_catalog
|
||||
|
||||
[distutils.setup_keywords]
|
||||
message_extractors = babel.messages.frontend:check_message_extractors
|
||||
|
||||
[babel.checkers]
|
||||
num_plurals = babel.messages.checkers:num_plurals
|
||||
python_format = babel.messages.checkers:python_format
|
||||
|
||||
[babel.extractors]
|
||||
ignore = babel.messages.extract:extract_nothing
|
||||
python = babel.messages.extract:extract_python
|
||||
javascript = babel.messages.extract:extract_javascript
|
||||
|
||||
@ -0,0 +1 @@
|
||||
|
||||
@ -0,0 +1 @@
|
||||
pytz>=2015.7
|
||||
@ -0,0 +1 @@
|
||||
babel
|
||||
@ -0,0 +1,125 @@
|
||||
Metadata-Version: 2.1
|
||||
Name: CherryPy
|
||||
Version: 12.0.1
|
||||
Summary: Object-Oriented HTTP framework
|
||||
Home-page: http://www.cherrypy.org
|
||||
Author: CherryPy Team
|
||||
Author-email: team@cherrypy.org
|
||||
License: BSD
|
||||
Platform: UNKNOWN
|
||||
Classifier: Development Status :: 5 - Production/Stable
|
||||
Classifier: Environment :: Web Environment
|
||||
Classifier: Intended Audience :: Developers
|
||||
Classifier: License :: Freely Distributable
|
||||
Classifier: Operating System :: OS Independent
|
||||
Classifier: Framework :: CherryPy
|
||||
Classifier: License :: OSI Approved :: BSD License
|
||||
Classifier: Programming Language :: Python
|
||||
Classifier: Programming Language :: Python :: 2
|
||||
Classifier: Programming Language :: Python :: 2.7
|
||||
Classifier: Programming Language :: Python :: 3
|
||||
Classifier: Programming Language :: Python :: 3.3
|
||||
Classifier: Programming Language :: Python :: 3.4
|
||||
Classifier: Programming Language :: Python :: 3.5
|
||||
Classifier: Programming Language :: Python :: 3.6
|
||||
Classifier: Programming Language :: Python :: Implementation
|
||||
Classifier: Programming Language :: Python :: Implementation :: CPython
|
||||
Classifier: Programming Language :: Python :: Implementation :: Jython
|
||||
Classifier: Programming Language :: Python :: Implementation :: PyPy
|
||||
Classifier: Topic :: Internet :: WWW/HTTP
|
||||
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
|
||||
Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
|
||||
Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
|
||||
Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
|
||||
Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server
|
||||
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
|
||||
Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*
|
||||
Provides-Extra: docs
|
||||
Provides-Extra: json
|
||||
Provides-Extra: routes_dispatcher
|
||||
Provides-Extra: ssl
|
||||
Provides-Extra: testing
|
||||
Provides-Extra: memcached_session
|
||||
Provides-Extra: xcgi
|
||||
License-File: LICENSE.md
|
||||
|
||||
.. image:: https://img.shields.io/pypi/v/cherrypy.svg
|
||||
:target: https://pypi.org/project/cherrypy
|
||||
|
||||
.. image:: https://readthedocs.org/projects/cherrypy/badge/?version=latest
|
||||
:target: http://docs.cherrypy.org/en/latest/?badge=latest
|
||||
|
||||
.. image:: https://img.shields.io/travis/cherrypy/cherrypy/master.svg?label=Linux%20build%20%40%20Travis%20CI
|
||||
:target: http://travis-ci.org/cherrypy/cherrypy
|
||||
|
||||
.. image:: https://img.shields.io/appveyor/ci/CherryPy/cherrypy/master.svg?label=Windows%20build%20%40%20Appveyor
|
||||
:target: https://ci.appveyor.com/project/CherryPy/cherrypy/branch/master
|
||||
|
||||
.. image:: https://img.shields.io/pypi/pyversions/cherrypy.svg
|
||||
|
||||
.. image:: http://badges.github.io/stability-badges/dist/stable.svg
|
||||
:target: http://github.com/badges/stability-badges
|
||||
:alt: stable
|
||||
|
||||
.. image:: https://api.codacy.com/project/badge/Grade/48b11060b5d249dc86e52dac2be2c715
|
||||
:target: https://www.codacy.com/app/webknjaz/cherrypy-upstream?utm_source=github.com&utm_medium=referral&utm_content=cherrypy/cherrypy&utm_campaign=Badge_Grade
|
||||
|
||||
.. image:: https://codecov.io/gh/cherrypy/cherrypy/branch/master/graph/badge.svg
|
||||
:target: https://codecov.io/gh/cherrypy/cherrypy
|
||||
:alt: codecov
|
||||
|
||||
Welcome to the GitHub repository of `CherryPy <http://cherrypy.org/>`_!
|
||||
|
||||
CherryPy is a pythonic, object-oriented HTTP framework.
|
||||
|
||||
1. It allows building web applications in much the same way one would
|
||||
build any other object-oriented program.
|
||||
2. This design results in less and more readable code being developed faster.
|
||||
It's all just properties and methods.
|
||||
3. It is now more than ten years old and has proven fast and very
|
||||
stable.
|
||||
4. It is being used in production by many sites, from the simplest to
|
||||
the most demanding.
|
||||
5. And perhaps most importantly, it is fun to work with :-)
|
||||
|
||||
Here's how easy it is to write "Hello World" in CherryPy:
|
||||
|
||||
.. code:: python
|
||||
|
||||
import cherrypy
|
||||
|
||||
class HelloWorld(object):
|
||||
@cherrypy.expose
|
||||
def index(self):
|
||||
return "Hello World!"
|
||||
|
||||
cherrypy.quickstart(HelloWorld())
|
||||
|
||||
And it continues to work that intuitively when systems grow, allowing
|
||||
for the Python object model to be dynamically presented as a web site
|
||||
and/or API.
|
||||
|
||||
While CherryPy is one of the easiest and most intuitive frameworks out
|
||||
there, the prerequisite for understanding the `CherryPy
|
||||
documentation <http://docs.cherrypy.org/en/latest/>`_ is that you have
|
||||
a general understanding of Python and web development.
|
||||
Additionally:
|
||||
|
||||
- Tutorials are included in the repository:
|
||||
https://github.com/cherrypy/cherrypy/tree/master/cherrypy/tutorial
|
||||
- A general wiki at:
|
||||
https://github.com/cherrypy/cherrypy/wiki
|
||||
|
||||
If the docs are insufficient to address your needs, the CherryPy
|
||||
community has several `avenues for support
|
||||
<http://docs.cherrypy.org/en/latest/support.html>`_.
|
||||
|
||||
Contributing
|
||||
------------
|
||||
|
||||
Please follow the `contribution guidelines
|
||||
<http://docs.cherrypy.org/en/latest/contribute.html>`_.
|
||||
And by all means, absorb the `Zen of
|
||||
CherryPy <https://github.com/cherrypy/cherrypy/wiki/The-Zen-of-CherryPy>`_.
|
||||
|
||||
|
||||
@ -0,0 +1,185 @@
|
||||
.codecov.yml
|
||||
.gitignore
|
||||
.mention-bot
|
||||
.pre-commit-config-pep257.yaml
|
||||
.pre-commit-config.yaml
|
||||
.travis.yml
|
||||
CHANGES.rst
|
||||
LICENSE.md
|
||||
README.rst
|
||||
appveyor.yml
|
||||
pytest.ini
|
||||
setup.cfg
|
||||
setup.py
|
||||
tox.ini
|
||||
.circleci/config.yml
|
||||
.github/CONTRIBUTING.rst
|
||||
.github/ISSUE_TEMPLATE.md
|
||||
.github/PULL_REQUEST_TEMPLATE.md
|
||||
CherryPy.egg-info/PKG-INFO
|
||||
CherryPy.egg-info/SOURCES.txt
|
||||
CherryPy.egg-info/dependency_links.txt
|
||||
CherryPy.egg-info/entry_points.txt
|
||||
CherryPy.egg-info/requires.txt
|
||||
CherryPy.egg-info/top_level.txt
|
||||
cherrypy/__init__.py
|
||||
cherrypy/__main__.py
|
||||
cherrypy/_cpchecker.py
|
||||
cherrypy/_cpcompat.py
|
||||
cherrypy/_cpconfig.py
|
||||
cherrypy/_cpdispatch.py
|
||||
cherrypy/_cperror.py
|
||||
cherrypy/_cplogging.py
|
||||
cherrypy/_cpmodpy.py
|
||||
cherrypy/_cpnative_server.py
|
||||
cherrypy/_cpreqbody.py
|
||||
cherrypy/_cprequest.py
|
||||
cherrypy/_cpserver.py
|
||||
cherrypy/_cptools.py
|
||||
cherrypy/_cptree.py
|
||||
cherrypy/_cpwsgi.py
|
||||
cherrypy/_cpwsgi_server.py
|
||||
cherrypy/_helper.py
|
||||
cherrypy/daemon.py
|
||||
cherrypy/favicon.ico
|
||||
cherrypy/lib/__init__.py
|
||||
cherrypy/lib/auth.py
|
||||
cherrypy/lib/auth_basic.py
|
||||
cherrypy/lib/auth_digest.py
|
||||
cherrypy/lib/caching.py
|
||||
cherrypy/lib/covercp.py
|
||||
cherrypy/lib/cpstats.py
|
||||
cherrypy/lib/cptools.py
|
||||
cherrypy/lib/encoding.py
|
||||
cherrypy/lib/gctools.py
|
||||
cherrypy/lib/httpauth.py
|
||||
cherrypy/lib/httputil.py
|
||||
cherrypy/lib/jsontools.py
|
||||
cherrypy/lib/lockfile.py
|
||||
cherrypy/lib/locking.py
|
||||
cherrypy/lib/profiler.py
|
||||
cherrypy/lib/reprconf.py
|
||||
cherrypy/lib/sessions.py
|
||||
cherrypy/lib/static.py
|
||||
cherrypy/lib/xmlrpcutil.py
|
||||
cherrypy/process/__init__.py
|
||||
cherrypy/process/plugins.py
|
||||
cherrypy/process/servers.py
|
||||
cherrypy/process/win32.py
|
||||
cherrypy/process/wspbus.py
|
||||
cherrypy/scaffold/__init__.py
|
||||
cherrypy/scaffold/apache-fcgi.conf
|
||||
cherrypy/scaffold/example.conf
|
||||
cherrypy/scaffold/site.conf
|
||||
cherrypy/scaffold/static/made_with_cherrypy_small.png
|
||||
cherrypy/test/__init__.py
|
||||
cherrypy/test/_test_decorators.py
|
||||
cherrypy/test/_test_states_demo.py
|
||||
cherrypy/test/benchmark.py
|
||||
cherrypy/test/checkerdemo.py
|
||||
cherrypy/test/fastcgi.conf
|
||||
cherrypy/test/fcgi.conf
|
||||
cherrypy/test/helper.py
|
||||
cherrypy/test/logtest.py
|
||||
cherrypy/test/modfastcgi.py
|
||||
cherrypy/test/modfcgid.py
|
||||
cherrypy/test/modpy.py
|
||||
cherrypy/test/modwsgi.py
|
||||
cherrypy/test/sessiondemo.py
|
||||
cherrypy/test/style.css
|
||||
cherrypy/test/test.pem
|
||||
cherrypy/test/test_auth_basic.py
|
||||
cherrypy/test/test_auth_digest.py
|
||||
cherrypy/test/test_bus.py
|
||||
cherrypy/test/test_caching.py
|
||||
cherrypy/test/test_compat.py
|
||||
cherrypy/test/test_config.py
|
||||
cherrypy/test/test_config_server.py
|
||||
cherrypy/test/test_conn.py
|
||||
cherrypy/test/test_core.py
|
||||
cherrypy/test/test_dynamicobjectmapping.py
|
||||
cherrypy/test/test_encoding.py
|
||||
cherrypy/test/test_etags.py
|
||||
cherrypy/test/test_http.py
|
||||
cherrypy/test/test_httpauth.py
|
||||
cherrypy/test/test_httputil.py
|
||||
cherrypy/test/test_iterator.py
|
||||
cherrypy/test/test_json.py
|
||||
cherrypy/test/test_logging.py
|
||||
cherrypy/test/test_mime.py
|
||||
cherrypy/test/test_misc_tools.py
|
||||
cherrypy/test/test_objectmapping.py
|
||||
cherrypy/test/test_params.py
|
||||
cherrypy/test/test_proxy.py
|
||||
cherrypy/test/test_refleaks.py
|
||||
cherrypy/test/test_request_obj.py
|
||||
cherrypy/test/test_routes.py
|
||||
cherrypy/test/test_session.py
|
||||
cherrypy/test/test_sessionauthenticate.py
|
||||
cherrypy/test/test_states.py
|
||||
cherrypy/test/test_static.py
|
||||
cherrypy/test/test_tools.py
|
||||
cherrypy/test/test_tutorials.py
|
||||
cherrypy/test/test_virtualhost.py
|
||||
cherrypy/test/test_wsgi_ns.py
|
||||
cherrypy/test/test_wsgi_unix_socket.py
|
||||
cherrypy/test/test_wsgi_vhost.py
|
||||
cherrypy/test/test_wsgiapps.py
|
||||
cherrypy/test/test_xmlrpc.py
|
||||
cherrypy/test/webtest.py
|
||||
cherrypy/test/static/404.html
|
||||
cherrypy/test/static/dirback.jpg
|
||||
cherrypy/test/static/index.html
|
||||
cherrypy/tutorial/README.rst
|
||||
cherrypy/tutorial/__init__.py
|
||||
cherrypy/tutorial/custom_error.html
|
||||
cherrypy/tutorial/pdf_file.pdf
|
||||
cherrypy/tutorial/tut01_helloworld.py
|
||||
cherrypy/tutorial/tut02_expose_methods.py
|
||||
cherrypy/tutorial/tut03_get_and_post.py
|
||||
cherrypy/tutorial/tut04_complex_site.py
|
||||
cherrypy/tutorial/tut05_derived_objects.py
|
||||
cherrypy/tutorial/tut06_default_method.py
|
||||
cherrypy/tutorial/tut07_sessions.py
|
||||
cherrypy/tutorial/tut08_generators_and_yield.py
|
||||
cherrypy/tutorial/tut09_files.py
|
||||
cherrypy/tutorial/tut10_http_errors.py
|
||||
cherrypy/tutorial/tutorial.conf
|
||||
docs/.gitignore
|
||||
docs/advanced.rst
|
||||
docs/basics.rst
|
||||
docs/conf.py
|
||||
docs/config.rst
|
||||
docs/contribute.rst
|
||||
docs/deploy.rst
|
||||
docs/development.rst
|
||||
docs/extend.rst
|
||||
docs/glossary.rst
|
||||
docs/history.rst
|
||||
docs/index.rst
|
||||
docs/install.rst
|
||||
docs/intro.rst
|
||||
docs/requirements.txt
|
||||
docs/support.rst
|
||||
docs/tutorials.rst
|
||||
docs/_static/bgsides.png
|
||||
docs/_static/cpdocmain.css
|
||||
docs/_static/images/cherrypy_logo_big.png
|
||||
docs/_static/images/cpreturn.gif
|
||||
docs/_static/images/cpyield.gif
|
||||
docs/_static/images/sushibelt.JPG
|
||||
docs/_templates/python_2_eol.html
|
||||
docs/pkg/cherrypy.lib.rst
|
||||
docs/pkg/cherrypy.process.rst
|
||||
docs/pkg/cherrypy.rst
|
||||
docs/pkg/cherrypy.scaffold.rst
|
||||
docs/pkg/cherrypy.test.rst
|
||||
docs/pkg/cherrypy.tutorial.rst
|
||||
docs/pkg/modules.rst
|
||||
man/cherryd.1
|
||||
tests/dist-check.py
|
||||
visuals/cherrypy_logo_big.png
|
||||
visuals/cherrypy_logo_small.jpg
|
||||
visuals/favicon.ico
|
||||
visuals/made_with_cherrypy_big.png
|
||||
visuals/made_with_cherrypy_small.png
|
||||
@ -0,0 +1 @@
|
||||
|
||||
@ -0,0 +1,3 @@
|
||||
[console_scripts]
|
||||
cherryd = cherrypy.__main__:run
|
||||
|
||||
@ -0,0 +1,39 @@
|
||||
six>=1.11.0
|
||||
cheroot>=5.9.1
|
||||
portend>=2.1.1
|
||||
jaraco.classes
|
||||
|
||||
[:sys_platform == "win32"]
|
||||
pypiwin32
|
||||
|
||||
[docs]
|
||||
sphinx
|
||||
docutils
|
||||
alabaster
|
||||
rst.linker>=1.9
|
||||
jaraco.packaging>=3.2
|
||||
|
||||
[json]
|
||||
simplejson
|
||||
|
||||
[memcached_session]
|
||||
python-memcached>=1.58
|
||||
|
||||
[routes_dispatcher]
|
||||
routes>=2.3.1
|
||||
|
||||
[ssl]
|
||||
pyOpenSSL
|
||||
|
||||
[testing]
|
||||
coverage
|
||||
codecov
|
||||
objgraph
|
||||
pytest>=2.8
|
||||
pytest-cov
|
||||
pytest-sugar
|
||||
backports.unittest_mock
|
||||
path.py
|
||||
|
||||
[xcgi]
|
||||
flup
|
||||
@ -0,0 +1 @@
|
||||
cherrypy
|
||||
@ -0,0 +1,250 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/AES.py : AES
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""
|
||||
Module's constants for the modes of operation supported with AES:
|
||||
|
||||
:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
|
||||
:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
|
||||
:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
|
||||
:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
|
||||
:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
|
||||
:var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
|
||||
:var MODE_CCM: :ref:`Counter with CBC-MAC (CCM) Mode <ccm_mode>`
|
||||
:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
|
||||
:var MODE_GCM: :ref:`Galois Counter Mode (GCM) <gcm_mode>`
|
||||
:var MODE_SIV: :ref:`Syntethic Initialization Vector (SIV) <siv_mode>`
|
||||
:var MODE_OCB: :ref:`Offset Code Book (OCB) <ocb_mode>`
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from Cryptodome.Cipher import _create_cipher
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, SmartPointer,
|
||||
c_size_t, c_uint8_ptr)
|
||||
|
||||
from Cryptodome.Util import _cpu_features
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
|
||||
_cproto = """
|
||||
int AES_start_operation(const uint8_t key[],
|
||||
size_t key_len,
|
||||
void **pResult);
|
||||
int AES_encrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int AES_decrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int AES_stop_operation(void *state);
|
||||
"""
|
||||
|
||||
|
||||
# Load portable AES
|
||||
_raw_aes_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_aes",
|
||||
_cproto)
|
||||
|
||||
# Try to load AES with AES NI instructions
|
||||
try:
|
||||
_raw_aesni_lib = None
|
||||
if _cpu_features.have_aes_ni():
|
||||
_raw_aesni_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_aesni",
|
||||
_cproto.replace("AES",
|
||||
"AESNI"))
|
||||
# _raw_aesni may not have been compiled in
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
def _create_base_cipher(dict_parameters):
|
||||
"""This method instantiates and returns a handle to a low-level
|
||||
base cipher. It will absorb named parameters in the process."""
|
||||
|
||||
use_aesni = dict_parameters.pop("use_aesni", True)
|
||||
|
||||
try:
|
||||
key = dict_parameters.pop("key")
|
||||
except KeyError:
|
||||
raise TypeError("Missing 'key' parameter")
|
||||
|
||||
if len(key) not in key_size:
|
||||
raise ValueError("Incorrect AES key length (%d bytes)" % len(key))
|
||||
|
||||
if use_aesni and _raw_aesni_lib:
|
||||
start_operation = _raw_aesni_lib.AESNI_start_operation
|
||||
stop_operation = _raw_aesni_lib.AESNI_stop_operation
|
||||
else:
|
||||
start_operation = _raw_aes_lib.AES_start_operation
|
||||
stop_operation = _raw_aes_lib.AES_stop_operation
|
||||
|
||||
cipher = VoidPointer()
|
||||
result = start_operation(c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
cipher.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the AES cipher"
|
||||
% result)
|
||||
return SmartPointer(cipher.get(), stop_operation)
|
||||
|
||||
|
||||
def _derive_Poly1305_key_pair(key, nonce):
|
||||
"""Derive a tuple (r, s, nonce) for a Poly1305 MAC.
|
||||
|
||||
If nonce is ``None``, a new 16-byte nonce is generated.
|
||||
"""
|
||||
|
||||
if len(key) != 32:
|
||||
raise ValueError("Poly1305 with AES requires a 32-byte key")
|
||||
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(16)
|
||||
elif len(nonce) != 16:
|
||||
raise ValueError("Poly1305 with AES requires a 16-byte nonce")
|
||||
|
||||
s = new(key[:16], MODE_ECB).encrypt(nonce)
|
||||
return key[16:], s, nonce
|
||||
|
||||
|
||||
def new(key, mode, *args, **kwargs):
|
||||
"""Create a new AES cipher.
|
||||
|
||||
:param key:
|
||||
The secret key to use in the symmetric cipher.
|
||||
|
||||
It must be 16, 24 or 32 bytes long (respectively for *AES-128*,
|
||||
*AES-192* or *AES-256*).
|
||||
|
||||
For ``MODE_SIV`` only, it doubles to 32, 48, or 64 bytes.
|
||||
:type key: bytes/bytearray/memoryview
|
||||
|
||||
:param mode:
|
||||
The chaining mode to use for encryption or decryption.
|
||||
If in doubt, use ``MODE_EAX``.
|
||||
:type mode: One of the supported ``MODE_*`` constants
|
||||
|
||||
:Keyword Arguments:
|
||||
* **iv** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
|
||||
and ``MODE_OPENPGP`` modes).
|
||||
|
||||
The initialization vector to use for encryption or decryption.
|
||||
|
||||
For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 16 bytes long.
|
||||
|
||||
For ``MODE_OPENPGP`` mode only,
|
||||
it must be 16 bytes long for encryption
|
||||
and 18 bytes for decryption (in the latter case, it is
|
||||
actually the *encrypted* IV which was prefixed to the ciphertext).
|
||||
|
||||
If not provided, a random byte string is generated (you must then
|
||||
read its value with the :attr:`iv` attribute).
|
||||
|
||||
* **nonce** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_CCM``, ``MODE_EAX``, ``MODE_GCM``,
|
||||
``MODE_SIV``, ``MODE_OCB``, and ``MODE_CTR``).
|
||||
|
||||
A value that must never be reused for any other encryption done
|
||||
with this key (except possibly for ``MODE_SIV``, see below).
|
||||
|
||||
For ``MODE_EAX``, ``MODE_GCM`` and ``MODE_SIV`` there are no
|
||||
restrictions on its length (recommended: **16** bytes).
|
||||
|
||||
For ``MODE_CCM``, its length must be in the range **[7..13]**.
|
||||
Bear in mind that with CCM there is a trade-off between nonce
|
||||
length and maximum message size. Recommendation: **11** bytes.
|
||||
|
||||
For ``MODE_OCB``, its length must be in the range **[1..15]**
|
||||
(recommended: **15**).
|
||||
|
||||
For ``MODE_CTR``, its length must be in the range **[0..15]**
|
||||
(recommended: **8**).
|
||||
|
||||
For ``MODE_SIV``, the nonce is optional, if it is not specified,
|
||||
then no nonce is being used, which renders the encryption
|
||||
deterministic.
|
||||
|
||||
If not provided, for modes other than ``MODE_SIV```, a random
|
||||
byte string of the recommended length is used (you must then
|
||||
read its value with the :attr:`nonce` attribute).
|
||||
|
||||
* **segment_size** (*integer*) --
|
||||
(Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
|
||||
are segmented in. It must be a multiple of 8.
|
||||
If not specified, it will be assumed to be 8.
|
||||
|
||||
* **mac_len** : (*integer*) --
|
||||
(Only ``MODE_EAX``, ``MODE_GCM``, ``MODE_OCB``, ``MODE_CCM``)
|
||||
Length of the authentication tag, in bytes.
|
||||
|
||||
It must be even and in the range **[4..16]**.
|
||||
The recommended value (and the default, if not specified) is **16**.
|
||||
|
||||
* **msg_len** : (*integer*) --
|
||||
(Only ``MODE_CCM``). Length of the message to (de)cipher.
|
||||
If not specified, ``encrypt`` must be called with the entire message.
|
||||
Similarly, ``decrypt`` can only be called once.
|
||||
|
||||
* **assoc_len** : (*integer*) --
|
||||
(Only ``MODE_CCM``). Length of the associated data.
|
||||
If not specified, all associated data is buffered internally,
|
||||
which may represent a problem for very large messages.
|
||||
|
||||
* **initial_value** : (*integer* or *bytes/bytearray/memoryview*) --
|
||||
(Only ``MODE_CTR``).
|
||||
The initial value for the counter. If not present, the cipher will
|
||||
start counting from 0. The value is incremented by one for each block.
|
||||
The counter number is encoded in big endian mode.
|
||||
|
||||
* **counter** : (*object*) --
|
||||
Instance of ``Cryptodome.Util.Counter``, which allows full customization
|
||||
of the counter block. This parameter is incompatible to both ``nonce``
|
||||
and ``initial_value``.
|
||||
|
||||
* **use_aesni** : (*boolean*) --
|
||||
Use Intel AES-NI hardware extensions (default: use if available).
|
||||
|
||||
:Return: an AES object, of the applicable mode.
|
||||
"""
|
||||
|
||||
kwargs["add_aes_modes"] = True
|
||||
return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
|
||||
|
||||
|
||||
MODE_ECB = 1
|
||||
MODE_CBC = 2
|
||||
MODE_CFB = 3
|
||||
MODE_OFB = 5
|
||||
MODE_CTR = 6
|
||||
MODE_OPENPGP = 7
|
||||
MODE_CCM = 8
|
||||
MODE_EAX = 9
|
||||
MODE_SIV = 10
|
||||
MODE_GCM = 11
|
||||
MODE_OCB = 12
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 16
|
||||
# Size of a key (in bytes)
|
||||
key_size = (16, 24, 32)
|
||||
Binary file not shown.
@ -0,0 +1,47 @@
|
||||
from typing import Union, Tuple, Optional, Dict
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import EcbMode
|
||||
from Cryptodome.Cipher._mode_cbc import CbcMode
|
||||
from Cryptodome.Cipher._mode_cfb import CfbMode
|
||||
from Cryptodome.Cipher._mode_ofb import OfbMode
|
||||
from Cryptodome.Cipher._mode_ctr import CtrMode
|
||||
from Cryptodome.Cipher._mode_openpgp import OpenPgpMode
|
||||
from Cryptodome.Cipher._mode_ccm import CcmMode
|
||||
from Cryptodome.Cipher._mode_eax import EaxMode
|
||||
from Cryptodome.Cipher._mode_gcm import GcmMode
|
||||
from Cryptodome.Cipher._mode_siv import SivMode
|
||||
from Cryptodome.Cipher._mode_ocb import OcbMode
|
||||
|
||||
AESMode = int
|
||||
|
||||
MODE_ECB: AESMode
|
||||
MODE_CBC: AESMode
|
||||
MODE_CFB: AESMode
|
||||
MODE_OFB: AESMode
|
||||
MODE_CTR: AESMode
|
||||
MODE_OPENPGP: AESMode
|
||||
MODE_CCM: AESMode
|
||||
MODE_EAX: AESMode
|
||||
MODE_GCM: AESMode
|
||||
MODE_SIV: AESMode
|
||||
MODE_OCB: AESMode
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def new(key: Buffer,
|
||||
mode: AESMode,
|
||||
iv : Buffer = ...,
|
||||
IV : Buffer = ...,
|
||||
nonce : Buffer = ...,
|
||||
segment_size : int = ...,
|
||||
mac_len : int = ...,
|
||||
assoc_len : int = ...,
|
||||
initial_value : Union[int, Buffer] = ...,
|
||||
counter : Dict = ...,
|
||||
use_aesni : bool = ...) -> \
|
||||
Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode,
|
||||
OpenPgpMode, CcmMode, EaxMode, GcmMode,
|
||||
SivMode, OcbMode]: ...
|
||||
|
||||
block_size: int
|
||||
key_size: Tuple[int, int, int]
|
||||
@ -0,0 +1,175 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/ARC2.py : ARC2.py
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""
|
||||
Module's constants for the modes of operation supported with ARC2:
|
||||
|
||||
:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
|
||||
:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
|
||||
:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
|
||||
:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
|
||||
:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
|
||||
:var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
|
||||
:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from Cryptodome.Cipher import _create_cipher
|
||||
from Cryptodome.Util.py3compat import byte_string
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, SmartPointer,
|
||||
c_size_t, c_uint8_ptr)
|
||||
|
||||
_raw_arc2_lib = load_pycryptodome_raw_lib(
|
||||
"Cryptodome.Cipher._raw_arc2",
|
||||
"""
|
||||
int ARC2_start_operation(const uint8_t key[],
|
||||
size_t key_len,
|
||||
size_t effective_key_len,
|
||||
void **pResult);
|
||||
int ARC2_encrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int ARC2_decrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int ARC2_stop_operation(void *state);
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
def _create_base_cipher(dict_parameters):
|
||||
"""This method instantiates and returns a handle to a low-level
|
||||
base cipher. It will absorb named parameters in the process."""
|
||||
|
||||
try:
|
||||
key = dict_parameters.pop("key")
|
||||
except KeyError:
|
||||
raise TypeError("Missing 'key' parameter")
|
||||
|
||||
effective_keylen = dict_parameters.pop("effective_keylen", 1024)
|
||||
|
||||
if len(key) not in key_size:
|
||||
raise ValueError("Incorrect ARC2 key length (%d bytes)" % len(key))
|
||||
|
||||
if not (40 <= effective_keylen <= 1024):
|
||||
raise ValueError("'effective_key_len' must be at least 40 and no larger than 1024 "
|
||||
"(not %d)" % effective_keylen)
|
||||
|
||||
start_operation = _raw_arc2_lib.ARC2_start_operation
|
||||
stop_operation = _raw_arc2_lib.ARC2_stop_operation
|
||||
|
||||
cipher = VoidPointer()
|
||||
result = start_operation(c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
c_size_t(effective_keylen),
|
||||
cipher.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the ARC2 cipher"
|
||||
% result)
|
||||
|
||||
return SmartPointer(cipher.get(), stop_operation)
|
||||
|
||||
|
||||
def new(key, mode, *args, **kwargs):
|
||||
"""Create a new RC2 cipher.
|
||||
|
||||
:param key:
|
||||
The secret key to use in the symmetric cipher.
|
||||
Its length can vary from 5 to 128 bytes; the actual search space
|
||||
(and the cipher strength) can be reduced with the ``effective_keylen`` parameter.
|
||||
:type key: bytes, bytearray, memoryview
|
||||
|
||||
:param mode:
|
||||
The chaining mode to use for encryption or decryption.
|
||||
:type mode: One of the supported ``MODE_*`` constants
|
||||
|
||||
:Keyword Arguments:
|
||||
* **iv** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
|
||||
and ``MODE_OPENPGP`` modes).
|
||||
|
||||
The initialization vector to use for encryption or decryption.
|
||||
|
||||
For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
|
||||
|
||||
For ``MODE_OPENPGP`` mode only,
|
||||
it must be 8 bytes long for encryption
|
||||
and 10 bytes for decryption (in the latter case, it is
|
||||
actually the *encrypted* IV which was prefixed to the ciphertext).
|
||||
|
||||
If not provided, a random byte string is generated (you must then
|
||||
read its value with the :attr:`iv` attribute).
|
||||
|
||||
* **nonce** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
|
||||
|
||||
A value that must never be reused for any other encryption done
|
||||
with this key.
|
||||
|
||||
For ``MODE_EAX`` there are no
|
||||
restrictions on its length (recommended: **16** bytes).
|
||||
|
||||
For ``MODE_CTR``, its length must be in the range **[0..7]**.
|
||||
|
||||
If not provided for ``MODE_EAX``, a random byte string is generated (you
|
||||
can read it back via the ``nonce`` attribute).
|
||||
|
||||
* **effective_keylen** (*integer*) --
|
||||
Optional. Maximum strength in bits of the actual key used by the ARC2 algorithm.
|
||||
If the supplied ``key`` parameter is longer (in bits) of the value specified
|
||||
here, it will be weakened to match it.
|
||||
If not specified, no limitation is applied.
|
||||
|
||||
* **segment_size** (*integer*) --
|
||||
(Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
|
||||
are segmented in. It must be a multiple of 8.
|
||||
If not specified, it will be assumed to be 8.
|
||||
|
||||
* **mac_len** : (*integer*) --
|
||||
(Only ``MODE_EAX``)
|
||||
Length of the authentication tag, in bytes.
|
||||
It must be no longer than 8 (default).
|
||||
|
||||
* **initial_value** : (*integer*) --
|
||||
(Only ``MODE_CTR``). The initial value for the counter within
|
||||
the counter block. By default it is **0**.
|
||||
|
||||
:Return: an ARC2 object, of the applicable mode.
|
||||
"""
|
||||
|
||||
return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
|
||||
|
||||
MODE_ECB = 1
|
||||
MODE_CBC = 2
|
||||
MODE_CFB = 3
|
||||
MODE_OFB = 5
|
||||
MODE_CTR = 6
|
||||
MODE_OPENPGP = 7
|
||||
MODE_EAX = 9
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 8
|
||||
# Size of a key (in bytes)
|
||||
key_size = range(5, 128 + 1)
|
||||
Binary file not shown.
@ -0,0 +1,35 @@
|
||||
from typing import Union, Dict, Iterable
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import EcbMode
|
||||
from Cryptodome.Cipher._mode_cbc import CbcMode
|
||||
from Cryptodome.Cipher._mode_cfb import CfbMode
|
||||
from Cryptodome.Cipher._mode_ofb import OfbMode
|
||||
from Cryptodome.Cipher._mode_ctr import CtrMode
|
||||
from Cryptodome.Cipher._mode_openpgp import OpenPgpMode
|
||||
from Cryptodome.Cipher._mode_eax import EaxMode
|
||||
|
||||
ARC2Mode = int
|
||||
|
||||
MODE_ECB: ARC2Mode
|
||||
MODE_CBC: ARC2Mode
|
||||
MODE_CFB: ARC2Mode
|
||||
MODE_OFB: ARC2Mode
|
||||
MODE_CTR: ARC2Mode
|
||||
MODE_OPENPGP: ARC2Mode
|
||||
MODE_EAX: ARC2Mode
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def new(key: Buffer,
|
||||
mode: ARC2Mode,
|
||||
iv : Buffer = ...,
|
||||
IV : Buffer = ...,
|
||||
nonce : Buffer = ...,
|
||||
segment_size : int = ...,
|
||||
mac_len : int = ...,
|
||||
initial_value : Union[int, Buffer] = ...,
|
||||
counter : Dict = ...) -> \
|
||||
Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
|
||||
|
||||
block_size: int
|
||||
key_size: Iterable[int]
|
||||
@ -0,0 +1,137 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/ARC4.py : ARC4
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
from Cryptodome.Util.py3compat import b
|
||||
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
|
||||
create_string_buffer, get_raw_buffer,
|
||||
SmartPointer, c_size_t, c_uint8_ptr)
|
||||
|
||||
|
||||
_raw_arc4_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._ARC4", """
|
||||
int ARC4_stream_encrypt(void *rc4State, const uint8_t in[],
|
||||
uint8_t out[], size_t len);
|
||||
int ARC4_stream_init(uint8_t *key, size_t keylen,
|
||||
void **pRc4State);
|
||||
int ARC4_stream_destroy(void *rc4State);
|
||||
""")
|
||||
|
||||
|
||||
class ARC4Cipher:
|
||||
"""ARC4 cipher object. Do not create it directly. Use
|
||||
:func:`Cryptodome.Cipher.ARC4.new` instead.
|
||||
"""
|
||||
|
||||
def __init__(self, key, *args, **kwargs):
|
||||
"""Initialize an ARC4 cipher object
|
||||
|
||||
See also `new()` at the module level."""
|
||||
|
||||
if len(args) > 0:
|
||||
ndrop = args[0]
|
||||
args = args[1:]
|
||||
else:
|
||||
ndrop = kwargs.pop('drop', 0)
|
||||
|
||||
if len(key) not in key_size:
|
||||
raise ValueError("Incorrect ARC4 key length (%d bytes)" %
|
||||
len(key))
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = _raw_arc4_lib.ARC4_stream_init(c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
self._state.address_of())
|
||||
if result != 0:
|
||||
raise ValueError("Error %d while creating the ARC4 cipher"
|
||||
% result)
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
_raw_arc4_lib.ARC4_stream_destroy)
|
||||
|
||||
if ndrop > 0:
|
||||
# This is OK even if the cipher is used for decryption,
|
||||
# since encrypt and decrypt are actually the same thing
|
||||
# with ARC4.
|
||||
self.encrypt(b'\x00' * ndrop)
|
||||
|
||||
self.block_size = 1
|
||||
self.key_size = len(key)
|
||||
|
||||
def encrypt(self, plaintext):
|
||||
"""Encrypt a piece of data.
|
||||
|
||||
:param plaintext: The data to encrypt, of any size.
|
||||
:type plaintext: bytes, bytearray, memoryview
|
||||
:returns: the encrypted byte string, of equal length as the
|
||||
plaintext.
|
||||
"""
|
||||
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
result = _raw_arc4_lib.ARC4_stream_encrypt(self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
ciphertext,
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
raise ValueError("Error %d while encrypting with RC4" % result)
|
||||
return get_raw_buffer(ciphertext)
|
||||
|
||||
def decrypt(self, ciphertext):
|
||||
"""Decrypt a piece of data.
|
||||
|
||||
:param ciphertext: The data to decrypt, of any size.
|
||||
:type ciphertext: bytes, bytearray, memoryview
|
||||
:returns: the decrypted byte string, of equal length as the
|
||||
ciphertext.
|
||||
"""
|
||||
|
||||
try:
|
||||
return self.encrypt(ciphertext)
|
||||
except ValueError as e:
|
||||
raise ValueError(str(e).replace("enc", "dec"))
|
||||
|
||||
|
||||
def new(key, *args, **kwargs):
|
||||
"""Create a new ARC4 cipher.
|
||||
|
||||
:param key:
|
||||
The secret key to use in the symmetric cipher.
|
||||
Its length must be in the range ``[5..256]``.
|
||||
The recommended length is 16 bytes.
|
||||
:type key: bytes, bytearray, memoryview
|
||||
|
||||
:Keyword Arguments:
|
||||
* *drop* (``integer``) --
|
||||
The amount of bytes to discard from the initial part of the keystream.
|
||||
In fact, such part has been found to be distinguishable from random
|
||||
data (while it shouldn't) and also correlated to key.
|
||||
|
||||
The recommended value is 3072_ bytes. The default value is 0.
|
||||
|
||||
:Return: an `ARC4Cipher` object
|
||||
|
||||
.. _3072: http://eprint.iacr.org/2002/067.pdf
|
||||
"""
|
||||
return ARC4Cipher(key, *args, **kwargs)
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 1
|
||||
# Size of a key (in bytes)
|
||||
key_size = range(5, 256+1)
|
||||
Binary file not shown.
@ -0,0 +1,16 @@
|
||||
from typing import Any, Union, Iterable
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
class ARC4Cipher:
|
||||
block_size: int
|
||||
key_size: int
|
||||
|
||||
def __init__(self, key: Buffer, *args: Any, **kwargs: Any) -> None: ...
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
def decrypt(self, ciphertext: Buffer) -> bytes: ...
|
||||
|
||||
def new(key: Buffer, drop : int = ...) -> ARC4Cipher: ...
|
||||
|
||||
block_size: int
|
||||
key_size: Iterable[int]
|
||||
@ -0,0 +1,159 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/Blowfish.py : Blowfish
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""
|
||||
Module's constants for the modes of operation supported with Blowfish:
|
||||
|
||||
:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
|
||||
:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
|
||||
:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
|
||||
:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
|
||||
:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
|
||||
:var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
|
||||
:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from Cryptodome.Cipher import _create_cipher
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, SmartPointer, c_size_t,
|
||||
c_uint8_ptr)
|
||||
|
||||
_raw_blowfish_lib = load_pycryptodome_raw_lib(
|
||||
"Cryptodome.Cipher._raw_blowfish",
|
||||
"""
|
||||
int Blowfish_start_operation(const uint8_t key[],
|
||||
size_t key_len,
|
||||
void **pResult);
|
||||
int Blowfish_encrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int Blowfish_decrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int Blowfish_stop_operation(void *state);
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
def _create_base_cipher(dict_parameters):
|
||||
"""This method instantiates and returns a smart pointer to
|
||||
a low-level base cipher. It will absorb named parameters in
|
||||
the process."""
|
||||
|
||||
try:
|
||||
key = dict_parameters.pop("key")
|
||||
except KeyError:
|
||||
raise TypeError("Missing 'key' parameter")
|
||||
|
||||
if len(key) not in key_size:
|
||||
raise ValueError("Incorrect Blowfish key length (%d bytes)" % len(key))
|
||||
|
||||
start_operation = _raw_blowfish_lib.Blowfish_start_operation
|
||||
stop_operation = _raw_blowfish_lib.Blowfish_stop_operation
|
||||
|
||||
void_p = VoidPointer()
|
||||
result = start_operation(c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
void_p.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the Blowfish cipher"
|
||||
% result)
|
||||
return SmartPointer(void_p.get(), stop_operation)
|
||||
|
||||
|
||||
def new(key, mode, *args, **kwargs):
|
||||
"""Create a new Blowfish cipher
|
||||
|
||||
:param key:
|
||||
The secret key to use in the symmetric cipher.
|
||||
Its length can vary from 5 to 56 bytes.
|
||||
:type key: bytes, bytearray, memoryview
|
||||
|
||||
:param mode:
|
||||
The chaining mode to use for encryption or decryption.
|
||||
:type mode: One of the supported ``MODE_*`` constants
|
||||
|
||||
:Keyword Arguments:
|
||||
* **iv** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
|
||||
and ``MODE_OPENPGP`` modes).
|
||||
|
||||
The initialization vector to use for encryption or decryption.
|
||||
|
||||
For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
|
||||
|
||||
For ``MODE_OPENPGP`` mode only,
|
||||
it must be 8 bytes long for encryption
|
||||
and 10 bytes for decryption (in the latter case, it is
|
||||
actually the *encrypted* IV which was prefixed to the ciphertext).
|
||||
|
||||
If not provided, a random byte string is generated (you must then
|
||||
read its value with the :attr:`iv` attribute).
|
||||
|
||||
* **nonce** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
|
||||
|
||||
A value that must never be reused for any other encryption done
|
||||
with this key.
|
||||
|
||||
For ``MODE_EAX`` there are no
|
||||
restrictions on its length (recommended: **16** bytes).
|
||||
|
||||
For ``MODE_CTR``, its length must be in the range **[0..7]**.
|
||||
|
||||
If not provided for ``MODE_EAX``, a random byte string is generated (you
|
||||
can read it back via the ``nonce`` attribute).
|
||||
|
||||
* **segment_size** (*integer*) --
|
||||
(Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
|
||||
are segmented in. It must be a multiple of 8.
|
||||
If not specified, it will be assumed to be 8.
|
||||
|
||||
* **mac_len** : (*integer*) --
|
||||
(Only ``MODE_EAX``)
|
||||
Length of the authentication tag, in bytes.
|
||||
It must be no longer than 8 (default).
|
||||
|
||||
* **initial_value** : (*integer*) --
|
||||
(Only ``MODE_CTR``). The initial value for the counter within
|
||||
the counter block. By default it is **0**.
|
||||
|
||||
:Return: a Blowfish object, of the applicable mode.
|
||||
"""
|
||||
|
||||
return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
|
||||
|
||||
MODE_ECB = 1
|
||||
MODE_CBC = 2
|
||||
MODE_CFB = 3
|
||||
MODE_OFB = 5
|
||||
MODE_CTR = 6
|
||||
MODE_OPENPGP = 7
|
||||
MODE_EAX = 9
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 8
|
||||
# Size of a key (in bytes)
|
||||
key_size = range(4, 56 + 1)
|
||||
Binary file not shown.
@ -0,0 +1,35 @@
|
||||
from typing import Union, Dict, Iterable
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import EcbMode
|
||||
from Cryptodome.Cipher._mode_cbc import CbcMode
|
||||
from Cryptodome.Cipher._mode_cfb import CfbMode
|
||||
from Cryptodome.Cipher._mode_ofb import OfbMode
|
||||
from Cryptodome.Cipher._mode_ctr import CtrMode
|
||||
from Cryptodome.Cipher._mode_openpgp import OpenPgpMode
|
||||
from Cryptodome.Cipher._mode_eax import EaxMode
|
||||
|
||||
BlowfishMode = int
|
||||
|
||||
MODE_ECB: BlowfishMode
|
||||
MODE_CBC: BlowfishMode
|
||||
MODE_CFB: BlowfishMode
|
||||
MODE_OFB: BlowfishMode
|
||||
MODE_CTR: BlowfishMode
|
||||
MODE_OPENPGP: BlowfishMode
|
||||
MODE_EAX: BlowfishMode
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def new(key: Buffer,
|
||||
mode: BlowfishMode,
|
||||
iv : Buffer = ...,
|
||||
IV : Buffer = ...,
|
||||
nonce : Buffer = ...,
|
||||
segment_size : int = ...,
|
||||
mac_len : int = ...,
|
||||
initial_value : Union[int, Buffer] = ...,
|
||||
counter : Dict = ...) -> \
|
||||
Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
|
||||
|
||||
block_size: int
|
||||
key_size: Iterable[int]
|
||||
@ -0,0 +1,159 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/CAST.py : CAST
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""
|
||||
Module's constants for the modes of operation supported with CAST:
|
||||
|
||||
:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
|
||||
:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
|
||||
:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
|
||||
:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
|
||||
:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
|
||||
:var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
|
||||
:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from Cryptodome.Cipher import _create_cipher
|
||||
from Cryptodome.Util.py3compat import byte_string
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, SmartPointer,
|
||||
c_size_t, c_uint8_ptr)
|
||||
|
||||
_raw_cast_lib = load_pycryptodome_raw_lib(
|
||||
"Cryptodome.Cipher._raw_cast",
|
||||
"""
|
||||
int CAST_start_operation(const uint8_t key[],
|
||||
size_t key_len,
|
||||
void **pResult);
|
||||
int CAST_encrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CAST_decrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CAST_stop_operation(void *state);
|
||||
""")
|
||||
|
||||
|
||||
def _create_base_cipher(dict_parameters):
|
||||
"""This method instantiates and returns a handle to a low-level
|
||||
base cipher. It will absorb named parameters in the process."""
|
||||
|
||||
try:
|
||||
key = dict_parameters.pop("key")
|
||||
except KeyError:
|
||||
raise TypeError("Missing 'key' parameter")
|
||||
|
||||
if len(key) not in key_size:
|
||||
raise ValueError("Incorrect CAST key length (%d bytes)" % len(key))
|
||||
|
||||
start_operation = _raw_cast_lib.CAST_start_operation
|
||||
stop_operation = _raw_cast_lib.CAST_stop_operation
|
||||
|
||||
cipher = VoidPointer()
|
||||
result = start_operation(c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
cipher.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the CAST cipher"
|
||||
% result)
|
||||
|
||||
return SmartPointer(cipher.get(), stop_operation)
|
||||
|
||||
|
||||
def new(key, mode, *args, **kwargs):
|
||||
"""Create a new CAST cipher
|
||||
|
||||
:param key:
|
||||
The secret key to use in the symmetric cipher.
|
||||
Its length can vary from 5 to 16 bytes.
|
||||
:type key: bytes, bytearray, memoryview
|
||||
|
||||
:param mode:
|
||||
The chaining mode to use for encryption or decryption.
|
||||
:type mode: One of the supported ``MODE_*`` constants
|
||||
|
||||
:Keyword Arguments:
|
||||
* **iv** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
|
||||
and ``MODE_OPENPGP`` modes).
|
||||
|
||||
The initialization vector to use for encryption or decryption.
|
||||
|
||||
For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
|
||||
|
||||
For ``MODE_OPENPGP`` mode only,
|
||||
it must be 8 bytes long for encryption
|
||||
and 10 bytes for decryption (in the latter case, it is
|
||||
actually the *encrypted* IV which was prefixed to the ciphertext).
|
||||
|
||||
If not provided, a random byte string is generated (you must then
|
||||
read its value with the :attr:`iv` attribute).
|
||||
|
||||
* **nonce** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
|
||||
|
||||
A value that must never be reused for any other encryption done
|
||||
with this key.
|
||||
|
||||
For ``MODE_EAX`` there are no
|
||||
restrictions on its length (recommended: **16** bytes).
|
||||
|
||||
For ``MODE_CTR``, its length must be in the range **[0..7]**.
|
||||
|
||||
If not provided for ``MODE_EAX``, a random byte string is generated (you
|
||||
can read it back via the ``nonce`` attribute).
|
||||
|
||||
* **segment_size** (*integer*) --
|
||||
(Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
|
||||
are segmented in. It must be a multiple of 8.
|
||||
If not specified, it will be assumed to be 8.
|
||||
|
||||
* **mac_len** : (*integer*) --
|
||||
(Only ``MODE_EAX``)
|
||||
Length of the authentication tag, in bytes.
|
||||
It must be no longer than 8 (default).
|
||||
|
||||
* **initial_value** : (*integer*) --
|
||||
(Only ``MODE_CTR``). The initial value for the counter within
|
||||
the counter block. By default it is **0**.
|
||||
|
||||
:Return: a CAST object, of the applicable mode.
|
||||
"""
|
||||
|
||||
return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
|
||||
|
||||
MODE_ECB = 1
|
||||
MODE_CBC = 2
|
||||
MODE_CFB = 3
|
||||
MODE_OFB = 5
|
||||
MODE_CTR = 6
|
||||
MODE_OPENPGP = 7
|
||||
MODE_EAX = 9
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 8
|
||||
# Size of a key (in bytes)
|
||||
key_size = range(5, 16 + 1)
|
||||
Binary file not shown.
@ -0,0 +1,35 @@
|
||||
from typing import Union, Dict, Iterable
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import EcbMode
|
||||
from Cryptodome.Cipher._mode_cbc import CbcMode
|
||||
from Cryptodome.Cipher._mode_cfb import CfbMode
|
||||
from Cryptodome.Cipher._mode_ofb import OfbMode
|
||||
from Cryptodome.Cipher._mode_ctr import CtrMode
|
||||
from Cryptodome.Cipher._mode_openpgp import OpenPgpMode
|
||||
from Cryptodome.Cipher._mode_eax import EaxMode
|
||||
|
||||
CASTMode = int
|
||||
|
||||
MODE_ECB: CASTMode
|
||||
MODE_CBC: CASTMode
|
||||
MODE_CFB: CASTMode
|
||||
MODE_OFB: CASTMode
|
||||
MODE_CTR: CASTMode
|
||||
MODE_OPENPGP: CASTMode
|
||||
MODE_EAX: CASTMode
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def new(key: Buffer,
|
||||
mode: CASTMode,
|
||||
iv : Buffer = ...,
|
||||
IV : Buffer = ...,
|
||||
nonce : Buffer = ...,
|
||||
segment_size : int = ...,
|
||||
mac_len : int = ...,
|
||||
initial_value : Union[int, Buffer] = ...,
|
||||
counter : Dict = ...) -> \
|
||||
Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
|
||||
|
||||
block_size: int
|
||||
key_size : Iterable[int]
|
||||
@ -0,0 +1,287 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
from Cryptodome.Util.py3compat import _copy_bytes
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
create_string_buffer,
|
||||
get_raw_buffer, VoidPointer,
|
||||
SmartPointer, c_size_t,
|
||||
c_uint8_ptr, c_ulong,
|
||||
is_writeable_buffer)
|
||||
|
||||
_raw_chacha20_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._chacha20",
|
||||
"""
|
||||
int chacha20_init(void **pState,
|
||||
const uint8_t *key,
|
||||
size_t keySize,
|
||||
const uint8_t *nonce,
|
||||
size_t nonceSize);
|
||||
|
||||
int chacha20_destroy(void *state);
|
||||
|
||||
int chacha20_encrypt(void *state,
|
||||
const uint8_t in[],
|
||||
uint8_t out[],
|
||||
size_t len);
|
||||
|
||||
int chacha20_seek(void *state,
|
||||
unsigned long block_high,
|
||||
unsigned long block_low,
|
||||
unsigned offset);
|
||||
int hchacha20( const uint8_t key[32],
|
||||
const uint8_t nonce16[16],
|
||||
uint8_t subkey[32]);
|
||||
""")
|
||||
|
||||
|
||||
def _HChaCha20(key, nonce):
|
||||
|
||||
assert(len(key) == 32)
|
||||
assert(len(nonce) == 16)
|
||||
|
||||
subkey = bytearray(32)
|
||||
result = _raw_chacha20_lib.hchacha20(
|
||||
c_uint8_ptr(key),
|
||||
c_uint8_ptr(nonce),
|
||||
c_uint8_ptr(subkey))
|
||||
if result:
|
||||
raise ValueError("Error %d when deriving subkey with HChaCha20" % result)
|
||||
|
||||
return subkey
|
||||
|
||||
|
||||
class ChaCha20Cipher(object):
|
||||
"""ChaCha20 (or XChaCha20) cipher object.
|
||||
Do not create it directly. Use :py:func:`new` instead.
|
||||
|
||||
:var nonce: The nonce with length 8, 12 or 24 bytes
|
||||
:vartype nonce: bytes
|
||||
"""
|
||||
|
||||
block_size = 1
|
||||
|
||||
def __init__(self, key, nonce):
|
||||
"""Initialize a ChaCha20/XChaCha20 cipher object
|
||||
|
||||
See also `new()` at the module level."""
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
|
||||
# XChaCha20 requires a key derivation with HChaCha20
|
||||
# See 2.3 in https://tools.ietf.org/html/draft-arciszewski-xchacha-03
|
||||
if len(nonce) == 24:
|
||||
key = _HChaCha20(key, nonce[:16])
|
||||
nonce = b'\x00' * 4 + nonce[16:]
|
||||
self._name = "XChaCha20"
|
||||
else:
|
||||
self._name = "ChaCha20"
|
||||
nonce = self.nonce
|
||||
|
||||
self._next = ( self.encrypt, self.decrypt )
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = _raw_chacha20_lib.chacha20_init(
|
||||
self._state.address_of(),
|
||||
c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
nonce,
|
||||
c_size_t(len(nonce)))
|
||||
if result:
|
||||
raise ValueError("Error %d instantiating a %s cipher" % (result,
|
||||
self._name))
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
_raw_chacha20_lib.chacha20_destroy)
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt a piece of data.
|
||||
|
||||
Args:
|
||||
plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
|
||||
Keyword Args:
|
||||
output(bytes/bytearray/memoryview): The location where the ciphertext
|
||||
is written to. If ``None``, the ciphertext is returned.
|
||||
Returns:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("Cipher object can only be used for decryption")
|
||||
self._next = ( self.encrypt, )
|
||||
return self._encrypt(plaintext, output)
|
||||
|
||||
def _encrypt(self, plaintext, output):
|
||||
"""Encrypt without FSM checks"""
|
||||
|
||||
if output is None:
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
else:
|
||||
ciphertext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(plaintext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = _raw_chacha20_lib.chacha20_encrypt(
|
||||
self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
raise ValueError("Error %d while encrypting with %s" % (result, self._name))
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(ciphertext)
|
||||
else:
|
||||
return None
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt a piece of data.
|
||||
|
||||
Args:
|
||||
ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
|
||||
Keyword Args:
|
||||
output(bytes/bytearray/memoryview): The location where the plaintext
|
||||
is written to. If ``None``, the plaintext is returned.
|
||||
Returns:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("Cipher object can only be used for encryption")
|
||||
self._next = ( self.decrypt, )
|
||||
|
||||
try:
|
||||
return self._encrypt(ciphertext, output)
|
||||
except ValueError as e:
|
||||
raise ValueError(str(e).replace("enc", "dec"))
|
||||
|
||||
def seek(self, position):
|
||||
"""Seek to a certain position in the key stream.
|
||||
|
||||
Args:
|
||||
position (integer):
|
||||
The absolute position within the key stream, in bytes.
|
||||
"""
|
||||
|
||||
position, offset = divmod(position, 64)
|
||||
block_low = position & 0xFFFFFFFF
|
||||
block_high = position >> 32
|
||||
|
||||
result = _raw_chacha20_lib.chacha20_seek(
|
||||
self._state.get(),
|
||||
c_ulong(block_high),
|
||||
c_ulong(block_low),
|
||||
offset
|
||||
)
|
||||
if result:
|
||||
raise ValueError("Error %d while seeking with %s" % (result, self._name))
|
||||
|
||||
|
||||
def _derive_Poly1305_key_pair(key, nonce):
|
||||
"""Derive a tuple (r, s, nonce) for a Poly1305 MAC.
|
||||
|
||||
If nonce is ``None``, a new 12-byte nonce is generated.
|
||||
"""
|
||||
|
||||
if len(key) != 32:
|
||||
raise ValueError("Poly1305 with ChaCha20 requires a 32-byte key")
|
||||
|
||||
if nonce is None:
|
||||
padded_nonce = nonce = get_random_bytes(12)
|
||||
elif len(nonce) == 8:
|
||||
# See RFC7538, 2.6: [...] ChaCha20 as specified here requires a 96-bit
|
||||
# nonce. So if the provided nonce is only 64-bit, then the first 32
|
||||
# bits of the nonce will be set to a constant number.
|
||||
# This will usually be zero, but for protocols with multiple senders it may be
|
||||
# different for each sender, but should be the same for all
|
||||
# invocations of the function with the same key by a particular
|
||||
# sender.
|
||||
padded_nonce = b'\x00\x00\x00\x00' + nonce
|
||||
elif len(nonce) == 12:
|
||||
padded_nonce = nonce
|
||||
else:
|
||||
raise ValueError("Poly1305 with ChaCha20 requires an 8- or 12-byte nonce")
|
||||
|
||||
rs = new(key=key, nonce=padded_nonce).encrypt(b'\x00' * 32)
|
||||
return rs[:16], rs[16:], nonce
|
||||
|
||||
|
||||
def new(**kwargs):
|
||||
"""Create a new ChaCha20 or XChaCha20 cipher
|
||||
|
||||
Keyword Args:
|
||||
key (bytes/bytearray/memoryview): The secret key to use.
|
||||
It must be 32 bytes long.
|
||||
nonce (bytes/bytearray/memoryview): A mandatory value that
|
||||
must never be reused for any other encryption
|
||||
done with this key.
|
||||
|
||||
For ChaCha20, it must be 8 or 12 bytes long.
|
||||
|
||||
For XChaCha20, it must be 24 bytes long.
|
||||
|
||||
If not provided, 8 bytes will be randomly generated
|
||||
(you can find them back in the ``nonce`` attribute).
|
||||
|
||||
:Return: a :class:`Cryptodome.Cipher.ChaCha20.ChaCha20Cipher` object
|
||||
"""
|
||||
|
||||
try:
|
||||
key = kwargs.pop("key")
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing parameter %s" % e)
|
||||
|
||||
nonce = kwargs.pop("nonce", None)
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(8)
|
||||
|
||||
if len(key) != 32:
|
||||
raise ValueError("ChaCha20/XChaCha20 key must be 32 bytes long")
|
||||
|
||||
if len(nonce) not in (8, 12, 24):
|
||||
raise ValueError("Nonce must be 8/12 bytes(ChaCha20) or 24 bytes (XChaCha20)")
|
||||
|
||||
if kwargs:
|
||||
raise TypeError("Unknown parameters: " + str(kwargs))
|
||||
|
||||
return ChaCha20Cipher(key, nonce)
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 1
|
||||
|
||||
# Size of a key (in bytes)
|
||||
key_size = 32
|
||||
Binary file not shown.
@ -0,0 +1,25 @@
|
||||
from typing import Union, overload
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def _HChaCha20(key: Buffer, nonce: Buffer) -> bytearray: ...
|
||||
|
||||
class ChaCha20Cipher:
|
||||
block_size: int
|
||||
nonce: bytes
|
||||
|
||||
def __init__(self, key: Buffer, nonce: Buffer) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
def seek(self, position: int) -> None: ...
|
||||
|
||||
def new(key: Buffer, nonce: Buffer = ...) -> ChaCha20Cipher: ...
|
||||
|
||||
block_size: int
|
||||
key_size: int
|
||||
@ -0,0 +1,336 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2018, Helder Eijs <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
from binascii import unhexlify
|
||||
|
||||
from Cryptodome.Cipher import ChaCha20
|
||||
from Cryptodome.Cipher.ChaCha20 import _HChaCha20
|
||||
from Cryptodome.Hash import Poly1305, BLAKE2s
|
||||
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
from Cryptodome.Util.number import long_to_bytes
|
||||
from Cryptodome.Util.py3compat import _copy_bytes, bord
|
||||
from Cryptodome.Util._raw_api import is_buffer
|
||||
|
||||
|
||||
def _enum(**enums):
|
||||
return type('Enum', (), enums)
|
||||
|
||||
|
||||
_CipherStatus = _enum(PROCESSING_AUTH_DATA=1,
|
||||
PROCESSING_CIPHERTEXT=2,
|
||||
PROCESSING_DONE=3)
|
||||
|
||||
|
||||
class ChaCha20Poly1305Cipher(object):
|
||||
"""ChaCha20-Poly1305 and XChaCha20-Poly1305 cipher object.
|
||||
Do not create it directly. Use :py:func:`new` instead.
|
||||
|
||||
:var nonce: The nonce with length 8, 12 or 24 bytes
|
||||
:vartype nonce: byte string
|
||||
"""
|
||||
|
||||
def __init__(self, key, nonce):
|
||||
"""Initialize a ChaCha20-Poly1305 AEAD cipher object
|
||||
|
||||
See also `new()` at the module level."""
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
|
||||
self._next = (self.update, self.encrypt, self.decrypt, self.digest,
|
||||
self.verify)
|
||||
|
||||
self._authenticator = Poly1305.new(key=key, nonce=nonce, cipher=ChaCha20)
|
||||
|
||||
self._cipher = ChaCha20.new(key=key, nonce=nonce)
|
||||
self._cipher.seek(64) # Block counter starts at 1
|
||||
|
||||
self._len_aad = 0
|
||||
self._len_ct = 0
|
||||
self._mac_tag = None
|
||||
self._status = _CipherStatus.PROCESSING_AUTH_DATA
|
||||
|
||||
def update(self, data):
|
||||
"""Protect the associated data.
|
||||
|
||||
Associated data (also known as *additional authenticated data* - AAD)
|
||||
is the piece of the message that must stay in the clear, while
|
||||
still allowing the receiver to verify its integrity.
|
||||
An example is packet headers.
|
||||
|
||||
The associated data (possibly split into multiple segments) is
|
||||
fed into :meth:`update` before any call to :meth:`decrypt` or :meth:`encrypt`.
|
||||
If there is no associated data, :meth:`update` is not called.
|
||||
|
||||
:param bytes/bytearray/memoryview assoc_data:
|
||||
A piece of associated data. There are no restrictions on its size.
|
||||
"""
|
||||
|
||||
if self.update not in self._next:
|
||||
raise TypeError("update() method cannot be called")
|
||||
|
||||
self._len_aad += len(data)
|
||||
self._authenticator.update(data)
|
||||
|
||||
def _pad_aad(self):
|
||||
|
||||
assert(self._status == _CipherStatus.PROCESSING_AUTH_DATA)
|
||||
if self._len_aad & 0x0F:
|
||||
self._authenticator.update(b'\x00' * (16 - (self._len_aad & 0x0F)))
|
||||
self._status = _CipherStatus.PROCESSING_CIPHERTEXT
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt a piece of data.
|
||||
|
||||
Args:
|
||||
plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
|
||||
Keyword Args:
|
||||
output(bytes/bytearray/memoryview): The location where the ciphertext
|
||||
is written to. If ``None``, the ciphertext is returned.
|
||||
Returns:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() method cannot be called")
|
||||
|
||||
if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
|
||||
self._pad_aad()
|
||||
|
||||
self._next = (self.encrypt, self.digest)
|
||||
|
||||
result = self._cipher.encrypt(plaintext, output=output)
|
||||
self._len_ct += len(plaintext)
|
||||
if output is None:
|
||||
self._authenticator.update(result)
|
||||
else:
|
||||
self._authenticator.update(output)
|
||||
return result
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt a piece of data.
|
||||
|
||||
Args:
|
||||
ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
|
||||
Keyword Args:
|
||||
output(bytes/bytearray/memoryview): The location where the plaintext
|
||||
is written to. If ``None``, the plaintext is returned.
|
||||
Returns:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() method cannot be called")
|
||||
|
||||
if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
|
||||
self._pad_aad()
|
||||
|
||||
self._next = (self.decrypt, self.verify)
|
||||
|
||||
self._len_ct += len(ciphertext)
|
||||
self._authenticator.update(ciphertext)
|
||||
return self._cipher.decrypt(ciphertext, output=output)
|
||||
|
||||
def _compute_mac(self):
|
||||
"""Finalize the cipher (if not done already) and return the MAC."""
|
||||
|
||||
if self._mac_tag:
|
||||
assert(self._status == _CipherStatus.PROCESSING_DONE)
|
||||
return self._mac_tag
|
||||
|
||||
assert(self._status != _CipherStatus.PROCESSING_DONE)
|
||||
|
||||
if self._status == _CipherStatus.PROCESSING_AUTH_DATA:
|
||||
self._pad_aad()
|
||||
|
||||
if self._len_ct & 0x0F:
|
||||
self._authenticator.update(b'\x00' * (16 - (self._len_ct & 0x0F)))
|
||||
|
||||
self._status = _CipherStatus.PROCESSING_DONE
|
||||
|
||||
self._authenticator.update(long_to_bytes(self._len_aad, 8)[::-1])
|
||||
self._authenticator.update(long_to_bytes(self._len_ct, 8)[::-1])
|
||||
self._mac_tag = self._authenticator.digest()
|
||||
return self._mac_tag
|
||||
|
||||
def digest(self):
|
||||
"""Compute the *binary* authentication tag (MAC).
|
||||
|
||||
:Return: the MAC tag, as 16 ``bytes``.
|
||||
"""
|
||||
|
||||
if self.digest not in self._next:
|
||||
raise TypeError("digest() method cannot be called")
|
||||
self._next = (self.digest,)
|
||||
|
||||
return self._compute_mac()
|
||||
|
||||
def hexdigest(self):
|
||||
"""Compute the *printable* authentication tag (MAC).
|
||||
|
||||
This method is like :meth:`digest`.
|
||||
|
||||
:Return: the MAC tag, as a hexadecimal string.
|
||||
"""
|
||||
return "".join(["%02x" % bord(x) for x in self.digest()])
|
||||
|
||||
def verify(self, received_mac_tag):
|
||||
"""Validate the *binary* authentication tag (MAC).
|
||||
|
||||
The receiver invokes this method at the very end, to
|
||||
check if the associated data (if any) and the decrypted
|
||||
messages are valid.
|
||||
|
||||
:param bytes/bytearray/memoryview received_mac_tag:
|
||||
This is the 16-byte *binary* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
if self.verify not in self._next:
|
||||
raise TypeError("verify() cannot be called"
|
||||
" when encrypting a message")
|
||||
self._next = (self.verify,)
|
||||
|
||||
secret = get_random_bytes(16)
|
||||
|
||||
self._compute_mac()
|
||||
|
||||
mac1 = BLAKE2s.new(digest_bits=160, key=secret,
|
||||
data=self._mac_tag)
|
||||
mac2 = BLAKE2s.new(digest_bits=160, key=secret,
|
||||
data=received_mac_tag)
|
||||
|
||||
if mac1.digest() != mac2.digest():
|
||||
raise ValueError("MAC check failed")
|
||||
|
||||
def hexverify(self, hex_mac_tag):
|
||||
"""Validate the *printable* authentication tag (MAC).
|
||||
|
||||
This method is like :meth:`verify`.
|
||||
|
||||
:param string hex_mac_tag:
|
||||
This is the *printable* MAC.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
self.verify(unhexlify(hex_mac_tag))
|
||||
|
||||
def encrypt_and_digest(self, plaintext):
|
||||
"""Perform :meth:`encrypt` and :meth:`digest` in one step.
|
||||
|
||||
:param plaintext: The data to encrypt, of any size.
|
||||
:type plaintext: bytes/bytearray/memoryview
|
||||
:return: a tuple with two ``bytes`` objects:
|
||||
|
||||
- the ciphertext, of equal length as the plaintext
|
||||
- the 16-byte MAC tag
|
||||
"""
|
||||
|
||||
return self.encrypt(plaintext), self.digest()
|
||||
|
||||
def decrypt_and_verify(self, ciphertext, received_mac_tag):
|
||||
"""Perform :meth:`decrypt` and :meth:`verify` in one step.
|
||||
|
||||
:param ciphertext: The piece of data to decrypt.
|
||||
:type ciphertext: bytes/bytearray/memoryview
|
||||
:param bytes received_mac_tag:
|
||||
This is the 16-byte *binary* MAC, as received from the sender.
|
||||
:return: the decrypted data (as ``bytes``)
|
||||
:raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
plaintext = self.decrypt(ciphertext)
|
||||
self.verify(received_mac_tag)
|
||||
return plaintext
|
||||
|
||||
|
||||
def new(**kwargs):
|
||||
"""Create a new ChaCha20-Poly1305 or XChaCha20-Poly1305 AEAD cipher.
|
||||
|
||||
:keyword key: The secret key to use. It must be 32 bytes long.
|
||||
:type key: byte string
|
||||
|
||||
:keyword nonce:
|
||||
A value that must never be reused for any other encryption
|
||||
done with this key.
|
||||
|
||||
For ChaCha20-Poly1305, it must be 8 or 12 bytes long.
|
||||
|
||||
For XChaCha20-Poly1305, it must be 24 bytes long.
|
||||
|
||||
If not provided, 12 ``bytes`` will be generated randomly
|
||||
(you can find them back in the ``nonce`` attribute).
|
||||
:type nonce: bytes, bytearray, memoryview
|
||||
|
||||
:Return: a :class:`Cryptodome.Cipher.ChaCha20.ChaCha20Poly1305Cipher` object
|
||||
"""
|
||||
|
||||
try:
|
||||
key = kwargs.pop("key")
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing parameter %s" % e)
|
||||
|
||||
self._len_ct += len(plaintext)
|
||||
|
||||
if len(key) != 32:
|
||||
raise ValueError("Key must be 32 bytes long")
|
||||
|
||||
nonce = kwargs.pop("nonce", None)
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(12)
|
||||
|
||||
if len(nonce) in (8, 12):
|
||||
pass
|
||||
elif len(nonce) == 24:
|
||||
key = _HChaCha20(key, nonce[:16])
|
||||
nonce = b'\x00\x00\x00\x00' + nonce[16:]
|
||||
else:
|
||||
raise ValueError("Nonce must be 8, 12 or 24 bytes long")
|
||||
|
||||
if not is_buffer(nonce):
|
||||
raise TypeError("nonce must be bytes, bytearray or memoryview")
|
||||
|
||||
if kwargs:
|
||||
raise TypeError("Unknown parameters: " + str(kwargs))
|
||||
|
||||
return ChaCha20Poly1305Cipher(key, nonce)
|
||||
|
||||
|
||||
# Size of a key (in bytes)
|
||||
key_size = 32
|
||||
Binary file not shown.
@ -0,0 +1,28 @@
|
||||
from typing import Union, Tuple, overload
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
class ChaCha20Poly1305Cipher:
|
||||
nonce: bytes
|
||||
|
||||
def __init__(self, key: Buffer, nonce: Buffer) -> None: ...
|
||||
def update(self, data: Buffer) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
def digest(self) -> bytes: ...
|
||||
def hexdigest(self) -> str: ...
|
||||
def verify(self, received_mac_tag: Buffer) -> None: ...
|
||||
def hexverify(self, received_mac_tag: str) -> None: ...
|
||||
def encrypt_and_digest(self, plaintext: Buffer) -> Tuple[bytes, bytes]: ...
|
||||
def decrypt_and_verify(self, ciphertext: Buffer, received_mac_tag: Buffer) -> bytes: ...
|
||||
|
||||
def new(key: Buffer, nonce: Buffer = ...) -> ChaCha20Poly1305Cipher: ...
|
||||
|
||||
block_size: int
|
||||
key_size: int
|
||||
@ -0,0 +1,158 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/DES.py : DES
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""
|
||||
Module's constants for the modes of operation supported with Single DES:
|
||||
|
||||
:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
|
||||
:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
|
||||
:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
|
||||
:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
|
||||
:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
|
||||
:var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
|
||||
:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from Cryptodome.Cipher import _create_cipher
|
||||
from Cryptodome.Util.py3compat import byte_string
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, SmartPointer,
|
||||
c_size_t, c_uint8_ptr)
|
||||
|
||||
_raw_des_lib = load_pycryptodome_raw_lib(
|
||||
"Cryptodome.Cipher._raw_des",
|
||||
"""
|
||||
int DES_start_operation(const uint8_t key[],
|
||||
size_t key_len,
|
||||
void **pResult);
|
||||
int DES_encrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int DES_decrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int DES_stop_operation(void *state);
|
||||
""")
|
||||
|
||||
|
||||
def _create_base_cipher(dict_parameters):
|
||||
"""This method instantiates and returns a handle to a low-level
|
||||
base cipher. It will absorb named parameters in the process."""
|
||||
|
||||
try:
|
||||
key = dict_parameters.pop("key")
|
||||
except KeyError:
|
||||
raise TypeError("Missing 'key' parameter")
|
||||
|
||||
if len(key) != key_size:
|
||||
raise ValueError("Incorrect DES key length (%d bytes)" % len(key))
|
||||
|
||||
start_operation = _raw_des_lib.DES_start_operation
|
||||
stop_operation = _raw_des_lib.DES_stop_operation
|
||||
|
||||
cipher = VoidPointer()
|
||||
result = start_operation(c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
cipher.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the DES cipher"
|
||||
% result)
|
||||
return SmartPointer(cipher.get(), stop_operation)
|
||||
|
||||
|
||||
def new(key, mode, *args, **kwargs):
|
||||
"""Create a new DES cipher.
|
||||
|
||||
:param key:
|
||||
The secret key to use in the symmetric cipher.
|
||||
It must be 8 byte long. The parity bits will be ignored.
|
||||
:type key: bytes/bytearray/memoryview
|
||||
|
||||
:param mode:
|
||||
The chaining mode to use for encryption or decryption.
|
||||
:type mode: One of the supported ``MODE_*`` constants
|
||||
|
||||
:Keyword Arguments:
|
||||
* **iv** (*byte string*) --
|
||||
(Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
|
||||
and ``MODE_OPENPGP`` modes).
|
||||
|
||||
The initialization vector to use for encryption or decryption.
|
||||
|
||||
For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
|
||||
|
||||
For ``MODE_OPENPGP`` mode only,
|
||||
it must be 8 bytes long for encryption
|
||||
and 10 bytes for decryption (in the latter case, it is
|
||||
actually the *encrypted* IV which was prefixed to the ciphertext).
|
||||
|
||||
If not provided, a random byte string is generated (you must then
|
||||
read its value with the :attr:`iv` attribute).
|
||||
|
||||
* **nonce** (*byte string*) --
|
||||
(Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
|
||||
|
||||
A value that must never be reused for any other encryption done
|
||||
with this key.
|
||||
|
||||
For ``MODE_EAX`` there are no
|
||||
restrictions on its length (recommended: **16** bytes).
|
||||
|
||||
For ``MODE_CTR``, its length must be in the range **[0..7]**.
|
||||
|
||||
If not provided for ``MODE_EAX``, a random byte string is generated (you
|
||||
can read it back via the ``nonce`` attribute).
|
||||
|
||||
* **segment_size** (*integer*) --
|
||||
(Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
|
||||
are segmented in. It must be a multiple of 8.
|
||||
If not specified, it will be assumed to be 8.
|
||||
|
||||
* **mac_len** : (*integer*) --
|
||||
(Only ``MODE_EAX``)
|
||||
Length of the authentication tag, in bytes.
|
||||
It must be no longer than 8 (default).
|
||||
|
||||
* **initial_value** : (*integer*) --
|
||||
(Only ``MODE_CTR``). The initial value for the counter within
|
||||
the counter block. By default it is **0**.
|
||||
|
||||
:Return: a DES object, of the applicable mode.
|
||||
"""
|
||||
|
||||
return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
|
||||
|
||||
MODE_ECB = 1
|
||||
MODE_CBC = 2
|
||||
MODE_CFB = 3
|
||||
MODE_OFB = 5
|
||||
MODE_CTR = 6
|
||||
MODE_OPENPGP = 7
|
||||
MODE_EAX = 9
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 8
|
||||
# Size of a key (in bytes)
|
||||
key_size = 8
|
||||
Binary file not shown.
@ -0,0 +1,35 @@
|
||||
from typing import Union, Dict, Iterable
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import EcbMode
|
||||
from Cryptodome.Cipher._mode_cbc import CbcMode
|
||||
from Cryptodome.Cipher._mode_cfb import CfbMode
|
||||
from Cryptodome.Cipher._mode_ofb import OfbMode
|
||||
from Cryptodome.Cipher._mode_ctr import CtrMode
|
||||
from Cryptodome.Cipher._mode_openpgp import OpenPgpMode
|
||||
from Cryptodome.Cipher._mode_eax import EaxMode
|
||||
|
||||
DESMode = int
|
||||
|
||||
MODE_ECB: DESMode
|
||||
MODE_CBC: DESMode
|
||||
MODE_CFB: DESMode
|
||||
MODE_OFB: DESMode
|
||||
MODE_CTR: DESMode
|
||||
MODE_OPENPGP: DESMode
|
||||
MODE_EAX: DESMode
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def new(key: Buffer,
|
||||
mode: DESMode,
|
||||
iv : Buffer = ...,
|
||||
IV : Buffer = ...,
|
||||
nonce : Buffer = ...,
|
||||
segment_size : int = ...,
|
||||
mac_len : int = ...,
|
||||
initial_value : Union[int, Buffer] = ...,
|
||||
counter : Dict = ...) -> \
|
||||
Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
|
||||
|
||||
block_size: int
|
||||
key_size: int
|
||||
@ -0,0 +1,187 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/DES3.py : DES3
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""
|
||||
Module's constants for the modes of operation supported with Triple DES:
|
||||
|
||||
:var MODE_ECB: :ref:`Electronic Code Book (ECB) <ecb_mode>`
|
||||
:var MODE_CBC: :ref:`Cipher-Block Chaining (CBC) <cbc_mode>`
|
||||
:var MODE_CFB: :ref:`Cipher FeedBack (CFB) <cfb_mode>`
|
||||
:var MODE_OFB: :ref:`Output FeedBack (OFB) <ofb_mode>`
|
||||
:var MODE_CTR: :ref:`CounTer Mode (CTR) <ctr_mode>`
|
||||
:var MODE_OPENPGP: :ref:`OpenPGP Mode <openpgp_mode>`
|
||||
:var MODE_EAX: :ref:`EAX Mode <eax_mode>`
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from Cryptodome.Cipher import _create_cipher
|
||||
from Cryptodome.Util.py3compat import byte_string, bchr, bord, bstr
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, SmartPointer,
|
||||
c_size_t)
|
||||
|
||||
_raw_des3_lib = load_pycryptodome_raw_lib(
|
||||
"Cryptodome.Cipher._raw_des3",
|
||||
"""
|
||||
int DES3_start_operation(const uint8_t key[],
|
||||
size_t key_len,
|
||||
void **pResult);
|
||||
int DES3_encrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int DES3_decrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int DES3_stop_operation(void *state);
|
||||
""")
|
||||
|
||||
|
||||
def adjust_key_parity(key_in):
|
||||
"""Set the parity bits in a TDES key.
|
||||
|
||||
:param key_in: the TDES key whose bits need to be adjusted
|
||||
:type key_in: byte string
|
||||
|
||||
:returns: a copy of ``key_in``, with the parity bits correctly set
|
||||
:rtype: byte string
|
||||
|
||||
:raises ValueError: if the TDES key is not 16 or 24 bytes long
|
||||
:raises ValueError: if the TDES key degenerates into Single DES
|
||||
"""
|
||||
|
||||
def parity_byte(key_byte):
|
||||
parity = 1
|
||||
for i in range(1, 8):
|
||||
parity ^= (key_byte >> i) & 1
|
||||
return (key_byte & 0xFE) | parity
|
||||
|
||||
if len(key_in) not in key_size:
|
||||
raise ValueError("Not a valid TDES key")
|
||||
|
||||
key_out = b"".join([ bchr(parity_byte(bord(x))) for x in key_in ])
|
||||
|
||||
if key_out[:8] == key_out[8:16] or key_out[-16:-8] == key_out[-8:]:
|
||||
raise ValueError("Triple DES key degenerates to single DES")
|
||||
|
||||
return key_out
|
||||
|
||||
|
||||
def _create_base_cipher(dict_parameters):
|
||||
"""This method instantiates and returns a handle to a low-level base cipher.
|
||||
It will absorb named parameters in the process."""
|
||||
|
||||
try:
|
||||
key_in = dict_parameters.pop("key")
|
||||
except KeyError:
|
||||
raise TypeError("Missing 'key' parameter")
|
||||
|
||||
key = adjust_key_parity(bstr(key_in))
|
||||
|
||||
start_operation = _raw_des3_lib.DES3_start_operation
|
||||
stop_operation = _raw_des3_lib.DES3_stop_operation
|
||||
|
||||
cipher = VoidPointer()
|
||||
result = start_operation(key,
|
||||
c_size_t(len(key)),
|
||||
cipher.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the TDES cipher"
|
||||
% result)
|
||||
return SmartPointer(cipher.get(), stop_operation)
|
||||
|
||||
|
||||
def new(key, mode, *args, **kwargs):
|
||||
"""Create a new Triple DES cipher.
|
||||
|
||||
:param key:
|
||||
The secret key to use in the symmetric cipher.
|
||||
It must be 16 or 24 byte long. The parity bits will be ignored.
|
||||
:type key: bytes/bytearray/memoryview
|
||||
|
||||
:param mode:
|
||||
The chaining mode to use for encryption or decryption.
|
||||
:type mode: One of the supported ``MODE_*`` constants
|
||||
|
||||
:Keyword Arguments:
|
||||
* **iv** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_CBC``, ``MODE_CFB``, ``MODE_OFB``,
|
||||
and ``MODE_OPENPGP`` modes).
|
||||
|
||||
The initialization vector to use for encryption or decryption.
|
||||
|
||||
For ``MODE_CBC``, ``MODE_CFB``, and ``MODE_OFB`` it must be 8 bytes long.
|
||||
|
||||
For ``MODE_OPENPGP`` mode only,
|
||||
it must be 8 bytes long for encryption
|
||||
and 10 bytes for decryption (in the latter case, it is
|
||||
actually the *encrypted* IV which was prefixed to the ciphertext).
|
||||
|
||||
If not provided, a random byte string is generated (you must then
|
||||
read its value with the :attr:`iv` attribute).
|
||||
|
||||
* **nonce** (*bytes*, *bytearray*, *memoryview*) --
|
||||
(Only applicable for ``MODE_EAX`` and ``MODE_CTR``).
|
||||
|
||||
A value that must never be reused for any other encryption done
|
||||
with this key.
|
||||
|
||||
For ``MODE_EAX`` there are no
|
||||
restrictions on its length (recommended: **16** bytes).
|
||||
|
||||
For ``MODE_CTR``, its length must be in the range **[0..7]**.
|
||||
|
||||
If not provided for ``MODE_EAX``, a random byte string is generated (you
|
||||
can read it back via the ``nonce`` attribute).
|
||||
|
||||
* **segment_size** (*integer*) --
|
||||
(Only ``MODE_CFB``).The number of **bits** the plaintext and ciphertext
|
||||
are segmented in. It must be a multiple of 8.
|
||||
If not specified, it will be assumed to be 8.
|
||||
|
||||
* **mac_len** : (*integer*) --
|
||||
(Only ``MODE_EAX``)
|
||||
Length of the authentication tag, in bytes.
|
||||
It must be no longer than 8 (default).
|
||||
|
||||
* **initial_value** : (*integer*) --
|
||||
(Only ``MODE_CTR``). The initial value for the counter within
|
||||
the counter block. By default it is **0**.
|
||||
|
||||
:Return: a Triple DES object, of the applicable mode.
|
||||
"""
|
||||
|
||||
return _create_cipher(sys.modules[__name__], key, mode, *args, **kwargs)
|
||||
|
||||
MODE_ECB = 1
|
||||
MODE_CBC = 2
|
||||
MODE_CFB = 3
|
||||
MODE_OFB = 5
|
||||
MODE_CTR = 6
|
||||
MODE_OPENPGP = 7
|
||||
MODE_EAX = 9
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 8
|
||||
# Size of a key (in bytes)
|
||||
key_size = (16, 24)
|
||||
Binary file not shown.
@ -0,0 +1,37 @@
|
||||
from typing import Union, Dict, Tuple
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import EcbMode
|
||||
from Cryptodome.Cipher._mode_cbc import CbcMode
|
||||
from Cryptodome.Cipher._mode_cfb import CfbMode
|
||||
from Cryptodome.Cipher._mode_ofb import OfbMode
|
||||
from Cryptodome.Cipher._mode_ctr import CtrMode
|
||||
from Cryptodome.Cipher._mode_openpgp import OpenPgpMode
|
||||
from Cryptodome.Cipher._mode_eax import EaxMode
|
||||
|
||||
def adjust_key_parity(key_in: bytes) -> bytes: ...
|
||||
|
||||
DES3Mode = int
|
||||
|
||||
MODE_ECB: DES3Mode
|
||||
MODE_CBC: DES3Mode
|
||||
MODE_CFB: DES3Mode
|
||||
MODE_OFB: DES3Mode
|
||||
MODE_CTR: DES3Mode
|
||||
MODE_OPENPGP: DES3Mode
|
||||
MODE_EAX: DES3Mode
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def new(key: Buffer,
|
||||
mode: DES3Mode,
|
||||
iv : Buffer = ...,
|
||||
IV : Buffer = ...,
|
||||
nonce : Buffer = ...,
|
||||
segment_size : int = ...,
|
||||
mac_len : int = ...,
|
||||
initial_value : Union[int, Buffer] = ...,
|
||||
counter : Dict = ...) -> \
|
||||
Union[EcbMode, CbcMode, CfbMode, OfbMode, CtrMode, OpenPgpMode]: ...
|
||||
|
||||
block_size: int
|
||||
key_size: Tuple[int, int]
|
||||
@ -0,0 +1,239 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/PKCS1_OAEP.py : PKCS#1 OAEP
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
from Cryptodome.Signature.pss import MGF1
|
||||
import Cryptodome.Hash.SHA1
|
||||
|
||||
from Cryptodome.Util.py3compat import bord, _copy_bytes
|
||||
import Cryptodome.Util.number
|
||||
from Cryptodome.Util.number import ceil_div, bytes_to_long, long_to_bytes
|
||||
from Cryptodome.Util.strxor import strxor
|
||||
from Cryptodome import Random
|
||||
|
||||
class PKCS1OAEP_Cipher:
|
||||
"""Cipher object for PKCS#1 v1.5 OAEP.
|
||||
Do not create directly: use :func:`new` instead."""
|
||||
|
||||
def __init__(self, key, hashAlgo, mgfunc, label, randfunc):
|
||||
"""Initialize this PKCS#1 OAEP cipher object.
|
||||
|
||||
:Parameters:
|
||||
key : an RSA key object
|
||||
If a private half is given, both encryption and decryption are possible.
|
||||
If a public half is given, only encryption is possible.
|
||||
hashAlgo : hash object
|
||||
The hash function to use. This can be a module under `Cryptodome.Hash`
|
||||
or an existing hash object created from any of such modules. If not specified,
|
||||
`Cryptodome.Hash.SHA1` is used.
|
||||
mgfunc : callable
|
||||
A mask generation function that accepts two parameters: a string to
|
||||
use as seed, and the lenth of the mask to generate, in bytes.
|
||||
If not specified, the standard MGF1 consistent with ``hashAlgo`` is used (a safe choice).
|
||||
label : bytes/bytearray/memoryview
|
||||
A label to apply to this particular encryption. If not specified,
|
||||
an empty string is used. Specifying a label does not improve
|
||||
security.
|
||||
randfunc : callable
|
||||
A function that returns random bytes.
|
||||
|
||||
:attention: Modify the mask generation function only if you know what you are doing.
|
||||
Sender and receiver must use the same one.
|
||||
"""
|
||||
self._key = key
|
||||
|
||||
if hashAlgo:
|
||||
self._hashObj = hashAlgo
|
||||
else:
|
||||
self._hashObj = Cryptodome.Hash.SHA1
|
||||
|
||||
if mgfunc:
|
||||
self._mgf = mgfunc
|
||||
else:
|
||||
self._mgf = lambda x,y: MGF1(x,y,self._hashObj)
|
||||
|
||||
self._label = _copy_bytes(None, None, label)
|
||||
self._randfunc = randfunc
|
||||
|
||||
def can_encrypt(self):
|
||||
"""Legacy function to check if you can call :meth:`encrypt`.
|
||||
|
||||
.. deprecated:: 3.0"""
|
||||
return self._key.can_encrypt()
|
||||
|
||||
def can_decrypt(self):
|
||||
"""Legacy function to check if you can call :meth:`decrypt`.
|
||||
|
||||
.. deprecated:: 3.0"""
|
||||
return self._key.can_decrypt()
|
||||
|
||||
def encrypt(self, message):
|
||||
"""Encrypt a message with PKCS#1 OAEP.
|
||||
|
||||
:param message:
|
||||
The message to encrypt, also known as plaintext. It can be of
|
||||
variable length, but not longer than the RSA modulus (in bytes)
|
||||
minus 2, minus twice the hash output size.
|
||||
For instance, if you use RSA 2048 and SHA-256, the longest message
|
||||
you can encrypt is 190 byte long.
|
||||
:type message: bytes/bytearray/memoryview
|
||||
|
||||
:returns: The ciphertext, as large as the RSA modulus.
|
||||
:rtype: bytes
|
||||
|
||||
:raises ValueError:
|
||||
if the message is too long.
|
||||
"""
|
||||
|
||||
# See 7.1.1 in RFC3447
|
||||
modBits = Cryptodome.Util.number.size(self._key.n)
|
||||
k = ceil_div(modBits, 8) # Convert from bits to bytes
|
||||
hLen = self._hashObj.digest_size
|
||||
mLen = len(message)
|
||||
|
||||
# Step 1b
|
||||
ps_len = k - mLen - 2 * hLen - 2
|
||||
if ps_len < 0:
|
||||
raise ValueError("Plaintext is too long.")
|
||||
# Step 2a
|
||||
lHash = self._hashObj.new(self._label).digest()
|
||||
# Step 2b
|
||||
ps = b'\x00' * ps_len
|
||||
# Step 2c
|
||||
db = lHash + ps + b'\x01' + _copy_bytes(None, None, message)
|
||||
# Step 2d
|
||||
ros = self._randfunc(hLen)
|
||||
# Step 2e
|
||||
dbMask = self._mgf(ros, k-hLen-1)
|
||||
# Step 2f
|
||||
maskedDB = strxor(db, dbMask)
|
||||
# Step 2g
|
||||
seedMask = self._mgf(maskedDB, hLen)
|
||||
# Step 2h
|
||||
maskedSeed = strxor(ros, seedMask)
|
||||
# Step 2i
|
||||
em = b'\x00' + maskedSeed + maskedDB
|
||||
# Step 3a (OS2IP)
|
||||
em_int = bytes_to_long(em)
|
||||
# Step 3b (RSAEP)
|
||||
m_int = self._key._encrypt(em_int)
|
||||
# Step 3c (I2OSP)
|
||||
c = long_to_bytes(m_int, k)
|
||||
return c
|
||||
|
||||
def decrypt(self, ciphertext):
|
||||
"""Decrypt a message with PKCS#1 OAEP.
|
||||
|
||||
:param ciphertext: The encrypted message.
|
||||
:type ciphertext: bytes/bytearray/memoryview
|
||||
|
||||
:returns: The original message (plaintext).
|
||||
:rtype: bytes
|
||||
|
||||
:raises ValueError:
|
||||
if the ciphertext has the wrong length, or if decryption
|
||||
fails the integrity check (in which case, the decryption
|
||||
key is probably wrong).
|
||||
:raises TypeError:
|
||||
if the RSA key has no private half (i.e. you are trying
|
||||
to decrypt using a public key).
|
||||
"""
|
||||
|
||||
# See 7.1.2 in RFC3447
|
||||
modBits = Cryptodome.Util.number.size(self._key.n)
|
||||
k = ceil_div(modBits,8) # Convert from bits to bytes
|
||||
hLen = self._hashObj.digest_size
|
||||
|
||||
# Step 1b and 1c
|
||||
if len(ciphertext) != k or k<hLen+2:
|
||||
raise ValueError("Ciphertext with incorrect length.")
|
||||
# Step 2a (O2SIP)
|
||||
ct_int = bytes_to_long(ciphertext)
|
||||
# Step 2b (RSADP)
|
||||
m_int = self._key._decrypt(ct_int)
|
||||
# Complete step 2c (I2OSP)
|
||||
em = long_to_bytes(m_int, k)
|
||||
# Step 3a
|
||||
lHash = self._hashObj.new(self._label).digest()
|
||||
# Step 3b
|
||||
y = em[0]
|
||||
# y must be 0, but we MUST NOT check it here in order not to
|
||||
# allow attacks like Manger's (http://dl.acm.org/citation.cfm?id=704143)
|
||||
maskedSeed = em[1:hLen+1]
|
||||
maskedDB = em[hLen+1:]
|
||||
# Step 3c
|
||||
seedMask = self._mgf(maskedDB, hLen)
|
||||
# Step 3d
|
||||
seed = strxor(maskedSeed, seedMask)
|
||||
# Step 3e
|
||||
dbMask = self._mgf(seed, k-hLen-1)
|
||||
# Step 3f
|
||||
db = strxor(maskedDB, dbMask)
|
||||
# Step 3g
|
||||
one_pos = hLen + db[hLen:].find(b'\x01')
|
||||
lHash1 = db[:hLen]
|
||||
invalid = bord(y) | int(one_pos < hLen)
|
||||
hash_compare = strxor(lHash1, lHash)
|
||||
for x in hash_compare:
|
||||
invalid |= bord(x)
|
||||
for x in db[hLen:one_pos]:
|
||||
invalid |= bord(x)
|
||||
if invalid != 0:
|
||||
raise ValueError("Incorrect decryption.")
|
||||
# Step 4
|
||||
return db[one_pos + 1:]
|
||||
|
||||
def new(key, hashAlgo=None, mgfunc=None, label=b'', randfunc=None):
|
||||
"""Return a cipher object :class:`PKCS1OAEP_Cipher` that can be used to perform PKCS#1 OAEP encryption or decryption.
|
||||
|
||||
:param key:
|
||||
The key object to use to encrypt or decrypt the message.
|
||||
Decryption is only possible with a private RSA key.
|
||||
:type key: RSA key object
|
||||
|
||||
:param hashAlgo:
|
||||
The hash function to use. This can be a module under `Cryptodome.Hash`
|
||||
or an existing hash object created from any of such modules.
|
||||
If not specified, `Cryptodome.Hash.SHA1` is used.
|
||||
:type hashAlgo: hash object
|
||||
|
||||
:param mgfunc:
|
||||
A mask generation function that accepts two parameters: a string to
|
||||
use as seed, and the lenth of the mask to generate, in bytes.
|
||||
If not specified, the standard MGF1 consistent with ``hashAlgo`` is used (a safe choice).
|
||||
:type mgfunc: callable
|
||||
|
||||
:param label:
|
||||
A label to apply to this particular encryption. If not specified,
|
||||
an empty string is used. Specifying a label does not improve
|
||||
security.
|
||||
:type label: bytes/bytearray/memoryview
|
||||
|
||||
:param randfunc:
|
||||
A function that returns random bytes.
|
||||
The default is `Random.get_random_bytes`.
|
||||
:type randfunc: callable
|
||||
"""
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = Random.get_random_bytes
|
||||
return PKCS1OAEP_Cipher(key, hashAlgo, mgfunc, label, randfunc)
|
||||
|
||||
Binary file not shown.
@ -0,0 +1,35 @@
|
||||
from typing import Optional, Union, Callable, Any, overload
|
||||
from typing_extensions import Protocol
|
||||
|
||||
from Cryptodome.PublicKey.RSA import RsaKey
|
||||
|
||||
class HashLikeClass(Protocol):
|
||||
digest_size : int
|
||||
def new(self, data: Optional[bytes] = ...) -> Any: ...
|
||||
|
||||
class HashLikeModule(Protocol):
|
||||
digest_size : int
|
||||
@staticmethod
|
||||
def new(data: Optional[bytes] = ...) -> Any: ...
|
||||
|
||||
HashLike = Union[HashLikeClass, HashLikeModule]
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
class PKCS1OAEP_Cipher:
|
||||
def __init__(self,
|
||||
key: RsaKey,
|
||||
hashAlgo: HashLike,
|
||||
mgfunc: Callable[[bytes, int], bytes],
|
||||
label: Buffer,
|
||||
randfunc: Callable[[int], bytes]) -> None: ...
|
||||
def can_encrypt(self) -> bool: ...
|
||||
def can_decrypt(self) -> bool: ...
|
||||
def encrypt(self, message: Buffer) -> bytes: ...
|
||||
def decrypt(self, ciphertext: Buffer) -> bytes: ...
|
||||
|
||||
def new(key: RsaKey,
|
||||
hashAlgo: Optional[HashLike] = ...,
|
||||
mgfunc: Optional[Callable[[bytes, int], bytes]] = ...,
|
||||
label: Optional[Buffer] = ...,
|
||||
randfunc: Optional[Callable[[int], bytes]] = ...) -> PKCS1OAEP_Cipher: ...
|
||||
@ -0,0 +1,217 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/PKCS1-v1_5.py : PKCS#1 v1.5
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
__all__ = ['new', 'PKCS115_Cipher']
|
||||
|
||||
from Cryptodome import Random
|
||||
from Cryptodome.Util.number import bytes_to_long, long_to_bytes
|
||||
from Cryptodome.Util.py3compat import bord, is_bytes, _copy_bytes
|
||||
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, c_size_t,
|
||||
c_uint8_ptr)
|
||||
|
||||
|
||||
_raw_pkcs1_decode = load_pycryptodome_raw_lib("Cryptodome.Cipher._pkcs1_decode",
|
||||
"""
|
||||
int pkcs1_decode(const uint8_t *em, size_t len_em,
|
||||
const uint8_t *sentinel, size_t len_sentinel,
|
||||
size_t expected_pt_len,
|
||||
uint8_t *output);
|
||||
""")
|
||||
|
||||
|
||||
def _pkcs1_decode(em, sentinel, expected_pt_len, output):
|
||||
if len(em) != len(output):
|
||||
raise ValueError("Incorrect output length")
|
||||
|
||||
ret = _raw_pkcs1_decode.pkcs1_decode(c_uint8_ptr(em),
|
||||
c_size_t(len(em)),
|
||||
c_uint8_ptr(sentinel),
|
||||
c_size_t(len(sentinel)),
|
||||
c_size_t(expected_pt_len),
|
||||
c_uint8_ptr(output))
|
||||
return ret
|
||||
|
||||
|
||||
class PKCS115_Cipher:
|
||||
"""This cipher can perform PKCS#1 v1.5 RSA encryption or decryption.
|
||||
Do not instantiate directly. Use :func:`Cryptodome.Cipher.PKCS1_v1_5.new` instead."""
|
||||
|
||||
def __init__(self, key, randfunc):
|
||||
"""Initialize this PKCS#1 v1.5 cipher object.
|
||||
|
||||
:Parameters:
|
||||
key : an RSA key object
|
||||
If a private half is given, both encryption and decryption are possible.
|
||||
If a public half is given, only encryption is possible.
|
||||
randfunc : callable
|
||||
Function that returns random bytes.
|
||||
"""
|
||||
|
||||
self._key = key
|
||||
self._randfunc = randfunc
|
||||
|
||||
def can_encrypt(self):
|
||||
"""Return True if this cipher object can be used for encryption."""
|
||||
return self._key.can_encrypt()
|
||||
|
||||
def can_decrypt(self):
|
||||
"""Return True if this cipher object can be used for decryption."""
|
||||
return self._key.can_decrypt()
|
||||
|
||||
def encrypt(self, message):
|
||||
"""Produce the PKCS#1 v1.5 encryption of a message.
|
||||
|
||||
This function is named ``RSAES-PKCS1-V1_5-ENCRYPT``, and it is specified in
|
||||
`section 7.2.1 of RFC8017
|
||||
<https://tools.ietf.org/html/rfc8017#page-28>`_.
|
||||
|
||||
:param message:
|
||||
The message to encrypt, also known as plaintext. It can be of
|
||||
variable length, but not longer than the RSA modulus (in bytes) minus 11.
|
||||
:type message: bytes/bytearray/memoryview
|
||||
|
||||
:Returns: A byte string, the ciphertext in which the message is encrypted.
|
||||
It is as long as the RSA modulus (in bytes).
|
||||
|
||||
:Raises ValueError:
|
||||
If the RSA key length is not sufficiently long to deal with the given
|
||||
message.
|
||||
"""
|
||||
|
||||
# See 7.2.1 in RFC8017
|
||||
k = self._key.size_in_bytes()
|
||||
mLen = len(message)
|
||||
|
||||
# Step 1
|
||||
if mLen > k - 11:
|
||||
raise ValueError("Plaintext is too long.")
|
||||
# Step 2a
|
||||
ps = []
|
||||
while len(ps) != k - mLen - 3:
|
||||
new_byte = self._randfunc(1)
|
||||
if bord(new_byte[0]) == 0x00:
|
||||
continue
|
||||
ps.append(new_byte)
|
||||
ps = b"".join(ps)
|
||||
assert(len(ps) == k - mLen - 3)
|
||||
# Step 2b
|
||||
em = b'\x00\x02' + ps + b'\x00' + _copy_bytes(None, None, message)
|
||||
# Step 3a (OS2IP)
|
||||
em_int = bytes_to_long(em)
|
||||
# Step 3b (RSAEP)
|
||||
m_int = self._key._encrypt(em_int)
|
||||
# Step 3c (I2OSP)
|
||||
c = long_to_bytes(m_int, k)
|
||||
return c
|
||||
|
||||
def decrypt(self, ciphertext, sentinel, expected_pt_len=0):
|
||||
r"""Decrypt a PKCS#1 v1.5 ciphertext.
|
||||
|
||||
This is the function ``RSAES-PKCS1-V1_5-DECRYPT`` specified in
|
||||
`section 7.2.2 of RFC8017
|
||||
<https://tools.ietf.org/html/rfc8017#page-29>`_.
|
||||
|
||||
Args:
|
||||
ciphertext (bytes/bytearray/memoryview):
|
||||
The ciphertext that contains the message to recover.
|
||||
sentinel (any type):
|
||||
The object to return whenever an error is detected.
|
||||
expected_pt_len (integer):
|
||||
The length the plaintext is known to have, or 0 if unknown.
|
||||
|
||||
Returns (byte string):
|
||||
It is either the original message or the ``sentinel`` (in case of an error).
|
||||
|
||||
.. warning::
|
||||
PKCS#1 v1.5 decryption is intrinsically vulnerable to timing
|
||||
attacks (see `Bleichenbacher's`__ attack).
|
||||
**Use PKCS#1 OAEP instead**.
|
||||
|
||||
This implementation attempts to mitigate the risk
|
||||
with some constant-time constructs.
|
||||
However, they are not sufficient by themselves: the type of protocol you
|
||||
implement and the way you handle errors make a big difference.
|
||||
|
||||
Specifically, you should make it very hard for the (malicious)
|
||||
party that submitted the ciphertext to quickly understand if decryption
|
||||
succeeded or not.
|
||||
|
||||
To this end, it is recommended that your protocol only encrypts
|
||||
plaintexts of fixed length (``expected_pt_len``),
|
||||
that ``sentinel`` is a random byte string of the same length,
|
||||
and that processing continues for as long
|
||||
as possible even if ``sentinel`` is returned (i.e. in case of
|
||||
incorrect decryption).
|
||||
|
||||
.. __: https://dx.doi.org/10.1007/BFb0055716
|
||||
"""
|
||||
|
||||
# See 7.2.2 in RFC8017
|
||||
k = self._key.size_in_bytes()
|
||||
|
||||
# Step 1
|
||||
if len(ciphertext) != k:
|
||||
raise ValueError("Ciphertext with incorrect length (not %d bytes)" % k)
|
||||
|
||||
# Step 2a (O2SIP)
|
||||
ct_int = bytes_to_long(ciphertext)
|
||||
|
||||
# Step 2b (RSADP)
|
||||
m_int = self._key._decrypt(ct_int)
|
||||
|
||||
# Complete step 2c (I2OSP)
|
||||
em = long_to_bytes(m_int, k)
|
||||
|
||||
# Step 3 (not constant time when the sentinel is not a byte string)
|
||||
output = bytes(bytearray(k))
|
||||
if not is_bytes(sentinel) or len(sentinel) > k:
|
||||
size = _pkcs1_decode(em, b'', expected_pt_len, output)
|
||||
if size < 0:
|
||||
return sentinel
|
||||
else:
|
||||
return output[size:]
|
||||
|
||||
# Step 3 (somewhat constant time)
|
||||
size = _pkcs1_decode(em, sentinel, expected_pt_len, output)
|
||||
return output[size:]
|
||||
|
||||
|
||||
def new(key, randfunc=None):
|
||||
"""Create a cipher for performing PKCS#1 v1.5 encryption or decryption.
|
||||
|
||||
:param key:
|
||||
The key to use to encrypt or decrypt the message. This is a `Cryptodome.PublicKey.RSA` object.
|
||||
Decryption is only possible if *key* is a private RSA key.
|
||||
:type key: RSA key object
|
||||
|
||||
:param randfunc:
|
||||
Function that return random bytes.
|
||||
The default is :func:`Cryptodome.Random.get_random_bytes`.
|
||||
:type randfunc: callable
|
||||
|
||||
:returns: A cipher object `PKCS115_Cipher`.
|
||||
"""
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = Random.get_random_bytes
|
||||
return PKCS115_Cipher(key, randfunc)
|
||||
Binary file not shown.
@ -0,0 +1,20 @@
|
||||
from typing import Callable, Union, Any, Optional, TypeVar
|
||||
|
||||
from Cryptodome.PublicKey.RSA import RsaKey
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
T = TypeVar('T')
|
||||
|
||||
class PKCS115_Cipher:
|
||||
def __init__(self,
|
||||
key: RsaKey,
|
||||
randfunc: Callable[[int], bytes]) -> None: ...
|
||||
def can_encrypt(self) -> bool: ...
|
||||
def can_decrypt(self) -> bool: ...
|
||||
def encrypt(self, message: Buffer) -> bytes: ...
|
||||
def decrypt(self, ciphertext: Buffer,
|
||||
sentinel: T,
|
||||
expected_pt_len: Optional[int] = ...) -> Union[bytes, T]: ...
|
||||
|
||||
def new(key: RsaKey,
|
||||
randfunc: Optional[Callable[[int], bytes]] = ...) -> PKCS115_Cipher: ...
|
||||
@ -0,0 +1,167 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/Salsa20.py : Salsa20 stream cipher (http://cr.yp.to/snuffle.html)
|
||||
#
|
||||
# Contributed by Fabrizio Tarizzo <fabrizio@fabriziotarizzo.org>.
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
from Cryptodome.Util.py3compat import _copy_bytes
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
create_string_buffer,
|
||||
get_raw_buffer, VoidPointer,
|
||||
SmartPointer, c_size_t,
|
||||
c_uint8_ptr, is_writeable_buffer)
|
||||
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
_raw_salsa20_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._Salsa20",
|
||||
"""
|
||||
int Salsa20_stream_init(uint8_t *key, size_t keylen,
|
||||
uint8_t *nonce, size_t nonce_len,
|
||||
void **pSalsaState);
|
||||
int Salsa20_stream_destroy(void *salsaState);
|
||||
int Salsa20_stream_encrypt(void *salsaState,
|
||||
const uint8_t in[],
|
||||
uint8_t out[], size_t len);
|
||||
""")
|
||||
|
||||
|
||||
class Salsa20Cipher:
|
||||
"""Salsa20 cipher object. Do not create it directly. Use :py:func:`new`
|
||||
instead.
|
||||
|
||||
:var nonce: The nonce with length 8
|
||||
:vartype nonce: byte string
|
||||
"""
|
||||
|
||||
def __init__(self, key, nonce):
|
||||
"""Initialize a Salsa20 cipher object
|
||||
|
||||
See also `new()` at the module level."""
|
||||
|
||||
if len(key) not in key_size:
|
||||
raise ValueError("Incorrect key length for Salsa20 (%d bytes)" % len(key))
|
||||
|
||||
if len(nonce) != 8:
|
||||
raise ValueError("Incorrect nonce length for Salsa20 (%d bytes)" %
|
||||
len(nonce))
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = _raw_salsa20_lib.Salsa20_stream_init(
|
||||
c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
c_uint8_ptr(nonce),
|
||||
c_size_t(len(nonce)),
|
||||
self._state.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %d instantiating a Salsa20 cipher")
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
_raw_salsa20_lib.Salsa20_stream_destroy)
|
||||
|
||||
self.block_size = 1
|
||||
self.key_size = len(key)
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt a piece of data.
|
||||
|
||||
Args:
|
||||
plaintext(bytes/bytearray/memoryview): The data to encrypt, of any size.
|
||||
Keyword Args:
|
||||
output(bytes/bytearray/memoryview): The location where the ciphertext
|
||||
is written to. If ``None``, the ciphertext is returned.
|
||||
Returns:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if output is None:
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
else:
|
||||
ciphertext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(plaintext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = _raw_salsa20_lib.Salsa20_stream_encrypt(
|
||||
self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
raise ValueError("Error %d while encrypting with Salsa20" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(ciphertext)
|
||||
else:
|
||||
return None
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt a piece of data.
|
||||
|
||||
Args:
|
||||
ciphertext(bytes/bytearray/memoryview): The data to decrypt, of any size.
|
||||
Keyword Args:
|
||||
output(bytes/bytearray/memoryview): The location where the plaintext
|
||||
is written to. If ``None``, the plaintext is returned.
|
||||
Returns:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
try:
|
||||
return self.encrypt(ciphertext, output=output)
|
||||
except ValueError as e:
|
||||
raise ValueError(str(e).replace("enc", "dec"))
|
||||
|
||||
|
||||
def new(key, nonce=None):
|
||||
"""Create a new Salsa20 cipher
|
||||
|
||||
:keyword key: The secret key to use. It must be 16 or 32 bytes long.
|
||||
:type key: bytes/bytearray/memoryview
|
||||
|
||||
:keyword nonce:
|
||||
A value that must never be reused for any other encryption
|
||||
done with this key. It must be 8 bytes long.
|
||||
|
||||
If not provided, a random byte string will be generated (you can read
|
||||
it back via the ``nonce`` attribute of the returned object).
|
||||
:type nonce: bytes/bytearray/memoryview
|
||||
|
||||
:Return: a :class:`Cryptodome.Cipher.Salsa20.Salsa20Cipher` object
|
||||
"""
|
||||
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(8)
|
||||
|
||||
return Salsa20Cipher(key, nonce)
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 1
|
||||
|
||||
# Size of a key (in bytes)
|
||||
key_size = (16, 32)
|
||||
|
||||
Binary file not shown.
@ -0,0 +1,27 @@
|
||||
from typing import Union, Tuple, Optional, overload
|
||||
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
class Salsa20Cipher:
|
||||
nonce: bytes
|
||||
block_size: int
|
||||
key_size: int
|
||||
|
||||
def __init__(self,
|
||||
key: Buffer,
|
||||
nonce: Buffer) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
def new(key: Buffer, nonce: Optional[Buffer] = ...) -> Salsa20Cipher: ...
|
||||
|
||||
block_size: int
|
||||
key_size: Tuple[int, int]
|
||||
|
||||
Binary file not shown.
@ -0,0 +1,131 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2019, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
import sys
|
||||
|
||||
from Cryptodome.Cipher import _create_cipher
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, SmartPointer, c_size_t,
|
||||
c_uint8_ptr, c_uint)
|
||||
|
||||
_raw_blowfish_lib = load_pycryptodome_raw_lib(
|
||||
"Cryptodome.Cipher._raw_eksblowfish",
|
||||
"""
|
||||
int EKSBlowfish_start_operation(const uint8_t key[],
|
||||
size_t key_len,
|
||||
const uint8_t salt[16],
|
||||
size_t salt_len,
|
||||
unsigned cost,
|
||||
unsigned invert,
|
||||
void **pResult);
|
||||
int EKSBlowfish_encrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int EKSBlowfish_decrypt(const void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int EKSBlowfish_stop_operation(void *state);
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
def _create_base_cipher(dict_parameters):
|
||||
"""This method instantiates and returns a smart pointer to
|
||||
a low-level base cipher. It will absorb named parameters in
|
||||
the process."""
|
||||
|
||||
try:
|
||||
key = dict_parameters.pop("key")
|
||||
salt = dict_parameters.pop("salt")
|
||||
cost = dict_parameters.pop("cost")
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing EKSBlowfish parameter: " + str(e))
|
||||
invert = dict_parameters.pop("invert", True)
|
||||
|
||||
if len(key) not in key_size:
|
||||
raise ValueError("Incorrect EKSBlowfish key length (%d bytes)" % len(key))
|
||||
|
||||
start_operation = _raw_blowfish_lib.EKSBlowfish_start_operation
|
||||
stop_operation = _raw_blowfish_lib.EKSBlowfish_stop_operation
|
||||
|
||||
void_p = VoidPointer()
|
||||
result = start_operation(c_uint8_ptr(key),
|
||||
c_size_t(len(key)),
|
||||
c_uint8_ptr(salt),
|
||||
c_size_t(len(salt)),
|
||||
c_uint(cost),
|
||||
c_uint(int(invert)),
|
||||
void_p.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the EKSBlowfish cipher"
|
||||
% result)
|
||||
return SmartPointer(void_p.get(), stop_operation)
|
||||
|
||||
|
||||
def new(key, mode, salt, cost, invert):
|
||||
"""Create a new EKSBlowfish cipher
|
||||
|
||||
Args:
|
||||
|
||||
key (bytes, bytearray, memoryview):
|
||||
The secret key to use in the symmetric cipher.
|
||||
Its length can vary from 0 to 72 bytes.
|
||||
|
||||
mode (one of the supported ``MODE_*`` constants):
|
||||
The chaining mode to use for encryption or decryption.
|
||||
|
||||
salt (bytes, bytearray, memoryview):
|
||||
The salt that bcrypt uses to thwart rainbow table attacks
|
||||
|
||||
cost (integer):
|
||||
The complexity factor in bcrypt
|
||||
|
||||
invert (bool):
|
||||
If ``False``, in the inner loop use ``ExpandKey`` first over the salt
|
||||
and then over the key, as defined in
|
||||
the `original bcrypt specification <https://www.usenix.org/legacy/events/usenix99/provos/provos_html/node4.html>`_.
|
||||
If ``True``, reverse the order, as in the first implementation of
|
||||
`bcrypt` in OpenBSD.
|
||||
|
||||
:Return: an EKSBlowfish object
|
||||
"""
|
||||
|
||||
kwargs = { 'salt':salt, 'cost':cost, 'invert':invert }
|
||||
return _create_cipher(sys.modules[__name__], key, mode, **kwargs)
|
||||
|
||||
|
||||
MODE_ECB = 1
|
||||
|
||||
# Size of a data block (in bytes)
|
||||
block_size = 8
|
||||
# Size of a key (in bytes)
|
||||
key_size = range(0, 72 + 1)
|
||||
Binary file not shown.
@ -0,0 +1,15 @@
|
||||
from typing import Union, Iterable
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import EcbMode
|
||||
|
||||
MODE_ECB: int
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
def new(key: Buffer,
|
||||
mode: int,
|
||||
salt: Buffer,
|
||||
cost: int) -> EcbMode: ...
|
||||
|
||||
block_size: int
|
||||
key_size: Iterable[int]
|
||||
Binary file not shown.
@ -0,0 +1,79 @@
|
||||
#
|
||||
# A block cipher is instantiated as a combination of:
|
||||
# 1. A base cipher (such as AES)
|
||||
# 2. A mode of operation (such as CBC)
|
||||
#
|
||||
# Both items are implemented as C modules.
|
||||
#
|
||||
# The API of #1 is (replace "AES" with the name of the actual cipher):
|
||||
# - AES_start_operaion(key) --> base_cipher_state
|
||||
# - AES_encrypt(base_cipher_state, in, out, length)
|
||||
# - AES_decrypt(base_cipher_state, in, out, length)
|
||||
# - AES_stop_operation(base_cipher_state)
|
||||
#
|
||||
# Where base_cipher_state is AES_State, a struct with BlockBase (set of
|
||||
# pointers to encrypt/decrypt/stop) followed by cipher-specific data.
|
||||
#
|
||||
# The API of #2 is (replace "CBC" with the name of the actual mode):
|
||||
# - CBC_start_operation(base_cipher_state) --> mode_state
|
||||
# - CBC_encrypt(mode_state, in, out, length)
|
||||
# - CBC_decrypt(mode_state, in, out, length)
|
||||
# - CBC_stop_operation(mode_state)
|
||||
#
|
||||
# where mode_state is a a pointer to base_cipher_state plus mode-specific data.
|
||||
|
||||
import os
|
||||
|
||||
from Cryptodome.Cipher._mode_ecb import _create_ecb_cipher
|
||||
from Cryptodome.Cipher._mode_cbc import _create_cbc_cipher
|
||||
from Cryptodome.Cipher._mode_cfb import _create_cfb_cipher
|
||||
from Cryptodome.Cipher._mode_ofb import _create_ofb_cipher
|
||||
from Cryptodome.Cipher._mode_ctr import _create_ctr_cipher
|
||||
from Cryptodome.Cipher._mode_openpgp import _create_openpgp_cipher
|
||||
from Cryptodome.Cipher._mode_ccm import _create_ccm_cipher
|
||||
from Cryptodome.Cipher._mode_eax import _create_eax_cipher
|
||||
from Cryptodome.Cipher._mode_siv import _create_siv_cipher
|
||||
from Cryptodome.Cipher._mode_gcm import _create_gcm_cipher
|
||||
from Cryptodome.Cipher._mode_ocb import _create_ocb_cipher
|
||||
|
||||
_modes = { 1:_create_ecb_cipher,
|
||||
2:_create_cbc_cipher,
|
||||
3:_create_cfb_cipher,
|
||||
5:_create_ofb_cipher,
|
||||
6:_create_ctr_cipher,
|
||||
7:_create_openpgp_cipher,
|
||||
9:_create_eax_cipher
|
||||
}
|
||||
|
||||
_extra_modes = { 8:_create_ccm_cipher,
|
||||
10:_create_siv_cipher,
|
||||
11:_create_gcm_cipher,
|
||||
12:_create_ocb_cipher
|
||||
}
|
||||
|
||||
def _create_cipher(factory, key, mode, *args, **kwargs):
|
||||
|
||||
kwargs["key"] = key
|
||||
|
||||
modes = dict(_modes)
|
||||
if kwargs.pop("add_aes_modes", False):
|
||||
modes.update(_extra_modes)
|
||||
if not mode in modes:
|
||||
raise ValueError("Mode not supported")
|
||||
|
||||
if args:
|
||||
if mode in (8, 9, 10, 11, 12):
|
||||
if len(args) > 1:
|
||||
raise TypeError("Too many arguments for this mode")
|
||||
kwargs["nonce"] = args[0]
|
||||
elif mode in (2, 3, 5, 7):
|
||||
if len(args) > 1:
|
||||
raise TypeError("Too many arguments for this mode")
|
||||
kwargs["IV"] = args[0]
|
||||
elif mode == 6:
|
||||
if len(args) > 0:
|
||||
raise TypeError("Too many arguments for this mode")
|
||||
elif mode == 1:
|
||||
raise TypeError("IV is not meaningful for the ECB mode")
|
||||
|
||||
return modes[mode](factory, **kwargs)
|
||||
Binary file not shown.
Binary file not shown.
@ -0,0 +1,293 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Ciphertext Block Chaining (CBC) mode.
|
||||
"""
|
||||
|
||||
__all__ = ['CbcMode']
|
||||
|
||||
from Cryptodome.Util.py3compat import _copy_bytes
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
|
||||
create_string_buffer, get_raw_buffer,
|
||||
SmartPointer, c_size_t, c_uint8_ptr,
|
||||
is_writeable_buffer)
|
||||
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
raw_cbc_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_cbc", """
|
||||
int CBC_start_operation(void *cipher,
|
||||
const uint8_t iv[],
|
||||
size_t iv_len,
|
||||
void **pResult);
|
||||
int CBC_encrypt(void *cbcState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CBC_decrypt(void *cbcState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CBC_stop_operation(void *state);
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
class CbcMode(object):
|
||||
"""*Cipher-Block Chaining (CBC)*.
|
||||
|
||||
Each of the ciphertext blocks depends on the current
|
||||
and all previous plaintext blocks.
|
||||
|
||||
An Initialization Vector (*IV*) is required.
|
||||
|
||||
See `NIST SP800-38A`_ , Section 6.2 .
|
||||
|
||||
.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, block_cipher, iv):
|
||||
"""Create a new block cipher, configured in CBC mode.
|
||||
|
||||
:Parameters:
|
||||
block_cipher : C pointer
|
||||
A smart pointer to the low-level block cipher instance.
|
||||
|
||||
iv : bytes/bytearray/memoryview
|
||||
The initialization vector to use for encryption or decryption.
|
||||
It is as long as the cipher block.
|
||||
|
||||
**The IV must be unpredictable**. Ideally it is picked randomly.
|
||||
|
||||
Reusing the *IV* for encryptions performed with the same key
|
||||
compromises confidentiality.
|
||||
"""
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = raw_cbc_lib.CBC_start_operation(block_cipher.get(),
|
||||
c_uint8_ptr(iv),
|
||||
c_size_t(len(iv)),
|
||||
self._state.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %d while instantiating the CBC mode"
|
||||
% result)
|
||||
|
||||
# Ensure that object disposal of this Python object will (eventually)
|
||||
# free the memory allocated by the raw library for the cipher mode
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
raw_cbc_lib.CBC_stop_operation)
|
||||
|
||||
# Memory allocated for the underlying block cipher is now owed
|
||||
# by the cipher mode
|
||||
block_cipher.release()
|
||||
|
||||
self.block_size = len(iv)
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self.iv = _copy_bytes(None, None, iv)
|
||||
"""The Initialization Vector originally used to create the object.
|
||||
The value does not change."""
|
||||
|
||||
self.IV = self.iv
|
||||
"""Alias for `iv`"""
|
||||
|
||||
self._next = [ self.encrypt, self.decrypt ]
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
That also means that you cannot reuse an object for encrypting
|
||||
or decrypting other data with the same key.
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
Its lenght must be multiple of the cipher block size.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() cannot be called after decrypt()")
|
||||
self._next = [ self.encrypt ]
|
||||
|
||||
if output is None:
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
else:
|
||||
ciphertext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(plaintext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_cbc_lib.CBC_encrypt(self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
if result == 3:
|
||||
raise ValueError("Data must be padded to %d byte boundary in CBC mode" % self.block_size)
|
||||
raise ValueError("Error %d while encrypting in CBC mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(ciphertext)
|
||||
else:
|
||||
return None
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
Its length must be multiple of the cipher block size.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() cannot be called after encrypt()")
|
||||
self._next = [ self.decrypt ]
|
||||
|
||||
if output is None:
|
||||
plaintext = create_string_buffer(len(ciphertext))
|
||||
else:
|
||||
plaintext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(ciphertext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_cbc_lib.CBC_decrypt(self._state.get(),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_size_t(len(ciphertext)))
|
||||
if result:
|
||||
if result == 3:
|
||||
raise ValueError("Data must be padded to %d byte boundary in CBC mode" % self.block_size)
|
||||
raise ValueError("Error %d while decrypting in CBC mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(plaintext)
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def _create_cbc_cipher(factory, **kwargs):
|
||||
"""Instantiate a cipher object that performs CBC encryption/decryption.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
The underlying block cipher, a module from ``Cryptodome.Cipher``.
|
||||
|
||||
:Keywords:
|
||||
iv : bytes/bytearray/memoryview
|
||||
The IV to use for CBC.
|
||||
|
||||
IV : bytes/bytearray/memoryview
|
||||
Alias for ``iv``.
|
||||
|
||||
Any other keyword will be passed to the underlying block cipher.
|
||||
See the relevant documentation for details (at least ``key`` will need
|
||||
to be present).
|
||||
"""
|
||||
|
||||
cipher_state = factory._create_base_cipher(kwargs)
|
||||
iv = kwargs.pop("IV", None)
|
||||
IV = kwargs.pop("iv", None)
|
||||
|
||||
if (None, None) == (iv, IV):
|
||||
iv = get_random_bytes(factory.block_size)
|
||||
if iv is not None:
|
||||
if IV is not None:
|
||||
raise TypeError("You must either use 'iv' or 'IV', not both")
|
||||
else:
|
||||
iv = IV
|
||||
|
||||
if len(iv) != factory.block_size:
|
||||
raise ValueError("Incorrect IV length (it must be %d bytes long)" %
|
||||
factory.block_size)
|
||||
|
||||
if kwargs:
|
||||
raise TypeError("Unknown parameters for CBC: %s" % str(kwargs))
|
||||
|
||||
return CbcMode(cipher_state, iv)
|
||||
Binary file not shown.
@ -0,0 +1,25 @@
|
||||
from typing import Union, overload
|
||||
|
||||
from Cryptodome.Util._raw_api import SmartPointer
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = ['CbcMode']
|
||||
|
||||
class CbcMode(object):
|
||||
block_size: int
|
||||
iv: Buffer
|
||||
IV: Buffer
|
||||
|
||||
def __init__(self,
|
||||
block_cipher: SmartPointer,
|
||||
iv: Buffer) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
@ -0,0 +1,650 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Counter with CBC-MAC (CCM) mode.
|
||||
"""
|
||||
|
||||
__all__ = ['CcmMode']
|
||||
|
||||
import struct
|
||||
from binascii import unhexlify
|
||||
|
||||
from Cryptodome.Util.py3compat import (byte_string, bord,
|
||||
_copy_bytes)
|
||||
from Cryptodome.Util._raw_api import is_writeable_buffer
|
||||
|
||||
from Cryptodome.Util.strxor import strxor
|
||||
from Cryptodome.Util.number import long_to_bytes
|
||||
|
||||
from Cryptodome.Hash import BLAKE2s
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
|
||||
def enum(**enums):
|
||||
return type('Enum', (), enums)
|
||||
|
||||
MacStatus = enum(NOT_STARTED=0, PROCESSING_AUTH_DATA=1, PROCESSING_PLAINTEXT=2)
|
||||
|
||||
|
||||
class CcmMode(object):
|
||||
"""Counter with CBC-MAC (CCM).
|
||||
|
||||
This is an Authenticated Encryption with Associated Data (`AEAD`_) mode.
|
||||
It provides both confidentiality and authenticity.
|
||||
|
||||
The header of the message may be left in the clear, if needed, and it will
|
||||
still be subject to authentication. The decryption step tells the receiver
|
||||
if the message comes from a source that really knowns the secret key.
|
||||
Additionally, decryption detects if any part of the message - including the
|
||||
header - has been modified or corrupted.
|
||||
|
||||
This mode requires a nonce. The nonce shall never repeat for two
|
||||
different messages encrypted with the same key, but it does not need
|
||||
to be random.
|
||||
Note that there is a trade-off between the size of the nonce and the
|
||||
maximum size of a single message you can encrypt.
|
||||
|
||||
It is important to use a large nonce if the key is reused across several
|
||||
messages and the nonce is chosen randomly.
|
||||
|
||||
It is acceptable to us a short nonce if the key is only used a few times or
|
||||
if the nonce is taken from a counter.
|
||||
|
||||
The following table shows the trade-off when the nonce is chosen at
|
||||
random. The column on the left shows how many messages it takes
|
||||
for the keystream to repeat **on average**. In practice, you will want to
|
||||
stop using the key way before that.
|
||||
|
||||
+--------------------+---------------+-------------------+
|
||||
| Avg. # of messages | nonce | Max. message |
|
||||
| before keystream | size | size |
|
||||
| repeats | (bytes) | (bytes) |
|
||||
+====================+===============+===================+
|
||||
| 2^52 | 13 | 64K |
|
||||
+--------------------+---------------+-------------------+
|
||||
| 2^48 | 12 | 16M |
|
||||
+--------------------+---------------+-------------------+
|
||||
| 2^44 | 11 | 4G |
|
||||
+--------------------+---------------+-------------------+
|
||||
| 2^40 | 10 | 1T |
|
||||
+--------------------+---------------+-------------------+
|
||||
| 2^36 | 9 | 64P |
|
||||
+--------------------+---------------+-------------------+
|
||||
| 2^32 | 8 | 16E |
|
||||
+--------------------+---------------+-------------------+
|
||||
|
||||
This mode is only available for ciphers that operate on 128 bits blocks
|
||||
(e.g. AES but not TDES).
|
||||
|
||||
See `NIST SP800-38C`_ or RFC3610_.
|
||||
|
||||
.. _`NIST SP800-38C`: http://csrc.nist.gov/publications/nistpubs/800-38C/SP800-38C.pdf
|
||||
.. _RFC3610: https://tools.ietf.org/html/rfc3610
|
||||
.. _AEAD: http://blog.cryptographyengineering.com/2012/05/how-to-choose-authenticated-encryption.html
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, factory, key, nonce, mac_len, msg_len, assoc_len,
|
||||
cipher_params):
|
||||
|
||||
self.block_size = factory.block_size
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
"""The nonce used for this cipher instance"""
|
||||
|
||||
self._factory = factory
|
||||
self._key = _copy_bytes(None, None, key)
|
||||
self._mac_len = mac_len
|
||||
self._msg_len = msg_len
|
||||
self._assoc_len = assoc_len
|
||||
self._cipher_params = cipher_params
|
||||
|
||||
self._mac_tag = None # Cache for MAC tag
|
||||
|
||||
if self.block_size != 16:
|
||||
raise ValueError("CCM mode is only available for ciphers"
|
||||
" that operate on 128 bits blocks")
|
||||
|
||||
# MAC tag length (Tlen)
|
||||
if mac_len not in (4, 6, 8, 10, 12, 14, 16):
|
||||
raise ValueError("Parameter 'mac_len' must be even"
|
||||
" and in the range 4..16 (not %d)" % mac_len)
|
||||
|
||||
# Nonce value
|
||||
if not (nonce and 7 <= len(nonce) <= 13):
|
||||
raise ValueError("Length of parameter 'nonce' must be"
|
||||
" in the range 7..13 bytes")
|
||||
|
||||
# Create MAC object (the tag will be the last block
|
||||
# bytes worth of ciphertext)
|
||||
self._mac = self._factory.new(key,
|
||||
factory.MODE_CBC,
|
||||
iv=b'\x00' * 16,
|
||||
**cipher_params)
|
||||
self._mac_status = MacStatus.NOT_STARTED
|
||||
self._t = None
|
||||
|
||||
# Allowed transitions after initialization
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
# Cumulative lengths
|
||||
self._cumul_assoc_len = 0
|
||||
self._cumul_msg_len = 0
|
||||
|
||||
# Cache for unaligned associated data/plaintext.
|
||||
# This is a list with byte strings, but when the MAC starts,
|
||||
# it will become a binary string no longer than the block size.
|
||||
self._cache = []
|
||||
|
||||
# Start CTR cipher, by formatting the counter (A.3)
|
||||
q = 15 - len(nonce) # length of Q, the encoded message length
|
||||
self._cipher = self._factory.new(key,
|
||||
self._factory.MODE_CTR,
|
||||
nonce=struct.pack("B", q - 1) + self.nonce,
|
||||
**cipher_params)
|
||||
|
||||
# S_0, step 6 in 6.1 for j=0
|
||||
self._s_0 = self._cipher.encrypt(b'\x00' * 16)
|
||||
|
||||
# Try to start the MAC
|
||||
if None not in (assoc_len, msg_len):
|
||||
self._start_mac()
|
||||
|
||||
def _start_mac(self):
|
||||
|
||||
assert(self._mac_status == MacStatus.NOT_STARTED)
|
||||
assert(None not in (self._assoc_len, self._msg_len))
|
||||
assert(isinstance(self._cache, list))
|
||||
|
||||
# Formatting control information and nonce (A.2.1)
|
||||
q = 15 - len(self.nonce) # length of Q, the encoded message length
|
||||
flags = (64 * (self._assoc_len > 0) + 8 * ((self._mac_len - 2) // 2) +
|
||||
(q - 1))
|
||||
b_0 = struct.pack("B", flags) + self.nonce + long_to_bytes(self._msg_len, q)
|
||||
|
||||
# Formatting associated data (A.2.2)
|
||||
# Encoded 'a' is concatenated with the associated data 'A'
|
||||
assoc_len_encoded = b''
|
||||
if self._assoc_len > 0:
|
||||
if self._assoc_len < (2 ** 16 - 2 ** 8):
|
||||
enc_size = 2
|
||||
elif self._assoc_len < (2 ** 32):
|
||||
assoc_len_encoded = b'\xFF\xFE'
|
||||
enc_size = 4
|
||||
else:
|
||||
assoc_len_encoded = b'\xFF\xFF'
|
||||
enc_size = 8
|
||||
assoc_len_encoded += long_to_bytes(self._assoc_len, enc_size)
|
||||
|
||||
# b_0 and assoc_len_encoded must be processed first
|
||||
self._cache.insert(0, b_0)
|
||||
self._cache.insert(1, assoc_len_encoded)
|
||||
|
||||
# Process all the data cached so far
|
||||
first_data_to_mac = b"".join(self._cache)
|
||||
self._cache = b""
|
||||
self._mac_status = MacStatus.PROCESSING_AUTH_DATA
|
||||
self._update(first_data_to_mac)
|
||||
|
||||
def _pad_cache_and_update(self):
|
||||
|
||||
assert(self._mac_status != MacStatus.NOT_STARTED)
|
||||
assert(len(self._cache) < self.block_size)
|
||||
|
||||
# Associated data is concatenated with the least number
|
||||
# of zero bytes (possibly none) to reach alignment to
|
||||
# the 16 byte boundary (A.2.3)
|
||||
len_cache = len(self._cache)
|
||||
if len_cache > 0:
|
||||
self._update(b'\x00' * (self.block_size - len_cache))
|
||||
|
||||
def update(self, assoc_data):
|
||||
"""Protect associated data
|
||||
|
||||
If there is any associated data, the caller has to invoke
|
||||
this function one or more times, before using
|
||||
``decrypt`` or ``encrypt``.
|
||||
|
||||
By *associated data* it is meant any data (e.g. packet headers) that
|
||||
will not be encrypted and will be transmitted in the clear.
|
||||
However, the receiver is still able to detect any modification to it.
|
||||
In CCM, the *associated data* is also called
|
||||
*additional authenticated data* (AAD).
|
||||
|
||||
If there is no associated data, this method must not be called.
|
||||
|
||||
The caller may split associated data in segments of any size, and
|
||||
invoke this method multiple times, each time with the next segment.
|
||||
|
||||
:Parameters:
|
||||
assoc_data : bytes/bytearray/memoryview
|
||||
A piece of associated data. There are no restrictions on its size.
|
||||
"""
|
||||
|
||||
if self.update not in self._next:
|
||||
raise TypeError("update() can only be called"
|
||||
" immediately after initialization")
|
||||
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
self._cumul_assoc_len += len(assoc_data)
|
||||
if self._assoc_len is not None and \
|
||||
self._cumul_assoc_len > self._assoc_len:
|
||||
raise ValueError("Associated data is too long")
|
||||
|
||||
self._update(assoc_data)
|
||||
return self
|
||||
|
||||
def _update(self, assoc_data_pt=b""):
|
||||
"""Update the MAC with associated data or plaintext
|
||||
(without FSM checks)"""
|
||||
|
||||
# If MAC has not started yet, we just park the data into a list.
|
||||
# If the data is mutable, we create a copy and store that instead.
|
||||
if self._mac_status == MacStatus.NOT_STARTED:
|
||||
if is_writeable_buffer(assoc_data_pt):
|
||||
assoc_data_pt = _copy_bytes(None, None, assoc_data_pt)
|
||||
self._cache.append(assoc_data_pt)
|
||||
return
|
||||
|
||||
assert(len(self._cache) < self.block_size)
|
||||
|
||||
if len(self._cache) > 0:
|
||||
filler = min(self.block_size - len(self._cache),
|
||||
len(assoc_data_pt))
|
||||
self._cache += _copy_bytes(None, filler, assoc_data_pt)
|
||||
assoc_data_pt = _copy_bytes(filler, None, assoc_data_pt)
|
||||
|
||||
if len(self._cache) < self.block_size:
|
||||
return
|
||||
|
||||
# The cache is exactly one block
|
||||
self._t = self._mac.encrypt(self._cache)
|
||||
self._cache = b""
|
||||
|
||||
update_len = len(assoc_data_pt) // self.block_size * self.block_size
|
||||
self._cache = _copy_bytes(update_len, None, assoc_data_pt)
|
||||
if update_len > 0:
|
||||
self._t = self._mac.encrypt(assoc_data_pt[:update_len])[-16:]
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
This method can be called only **once** if ``msg_len`` was
|
||||
not passed at initialization.
|
||||
|
||||
If ``msg_len`` was given, the data to encrypt can be broken
|
||||
up in two or more pieces and `encrypt` can be called
|
||||
multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() can only be called after"
|
||||
" initialization or an update()")
|
||||
self._next = [self.encrypt, self.digest]
|
||||
|
||||
# No more associated data allowed from now
|
||||
if self._assoc_len is None:
|
||||
assert(isinstance(self._cache, list))
|
||||
self._assoc_len = sum([len(x) for x in self._cache])
|
||||
if self._msg_len is not None:
|
||||
self._start_mac()
|
||||
else:
|
||||
if self._cumul_assoc_len < self._assoc_len:
|
||||
raise ValueError("Associated data is too short")
|
||||
|
||||
# Only once piece of plaintext accepted if message length was
|
||||
# not declared in advance
|
||||
if self._msg_len is None:
|
||||
self._msg_len = len(plaintext)
|
||||
self._start_mac()
|
||||
self._next = [self.digest]
|
||||
|
||||
self._cumul_msg_len += len(plaintext)
|
||||
if self._cumul_msg_len > self._msg_len:
|
||||
raise ValueError("Message is too long")
|
||||
|
||||
if self._mac_status == MacStatus.PROCESSING_AUTH_DATA:
|
||||
# Associated data is concatenated with the least number
|
||||
# of zero bytes (possibly none) to reach alignment to
|
||||
# the 16 byte boundary (A.2.3)
|
||||
self._pad_cache_and_update()
|
||||
self._mac_status = MacStatus.PROCESSING_PLAINTEXT
|
||||
|
||||
self._update(plaintext)
|
||||
return self._cipher.encrypt(plaintext, output=output)
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
This method can be called only **once** if ``msg_len`` was
|
||||
not passed at initialization.
|
||||
|
||||
If ``msg_len`` was given, the data to decrypt can be
|
||||
broken up in two or more pieces and `decrypt` can be
|
||||
called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() can only be called"
|
||||
" after initialization or an update()")
|
||||
self._next = [self.decrypt, self.verify]
|
||||
|
||||
# No more associated data allowed from now
|
||||
if self._assoc_len is None:
|
||||
assert(isinstance(self._cache, list))
|
||||
self._assoc_len = sum([len(x) for x in self._cache])
|
||||
if self._msg_len is not None:
|
||||
self._start_mac()
|
||||
else:
|
||||
if self._cumul_assoc_len < self._assoc_len:
|
||||
raise ValueError("Associated data is too short")
|
||||
|
||||
# Only once piece of ciphertext accepted if message length was
|
||||
# not declared in advance
|
||||
if self._msg_len is None:
|
||||
self._msg_len = len(ciphertext)
|
||||
self._start_mac()
|
||||
self._next = [self.verify]
|
||||
|
||||
self._cumul_msg_len += len(ciphertext)
|
||||
if self._cumul_msg_len > self._msg_len:
|
||||
raise ValueError("Message is too long")
|
||||
|
||||
if self._mac_status == MacStatus.PROCESSING_AUTH_DATA:
|
||||
# Associated data is concatenated with the least number
|
||||
# of zero bytes (possibly none) to reach alignment to
|
||||
# the 16 byte boundary (A.2.3)
|
||||
self._pad_cache_and_update()
|
||||
self._mac_status = MacStatus.PROCESSING_PLAINTEXT
|
||||
|
||||
# Encrypt is equivalent to decrypt with the CTR mode
|
||||
plaintext = self._cipher.encrypt(ciphertext, output=output)
|
||||
if output is None:
|
||||
self._update(plaintext)
|
||||
else:
|
||||
self._update(output)
|
||||
return plaintext
|
||||
|
||||
def digest(self):
|
||||
"""Compute the *binary* MAC tag.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method returns the MAC that shall be sent to the receiver,
|
||||
together with the ciphertext.
|
||||
|
||||
:Return: the MAC, as a byte string.
|
||||
"""
|
||||
|
||||
if self.digest not in self._next:
|
||||
raise TypeError("digest() cannot be called when decrypting"
|
||||
" or validating a message")
|
||||
self._next = [self.digest]
|
||||
return self._digest()
|
||||
|
||||
def _digest(self):
|
||||
if self._mac_tag:
|
||||
return self._mac_tag
|
||||
|
||||
if self._assoc_len is None:
|
||||
assert(isinstance(self._cache, list))
|
||||
self._assoc_len = sum([len(x) for x in self._cache])
|
||||
if self._msg_len is not None:
|
||||
self._start_mac()
|
||||
else:
|
||||
if self._cumul_assoc_len < self._assoc_len:
|
||||
raise ValueError("Associated data is too short")
|
||||
|
||||
if self._msg_len is None:
|
||||
self._msg_len = 0
|
||||
self._start_mac()
|
||||
|
||||
if self._cumul_msg_len != self._msg_len:
|
||||
raise ValueError("Message is too short")
|
||||
|
||||
# Both associated data and payload are concatenated with the least
|
||||
# number of zero bytes (possibly none) that align it to the
|
||||
# 16 byte boundary (A.2.2 and A.2.3)
|
||||
self._pad_cache_and_update()
|
||||
|
||||
# Step 8 in 6.1 (T xor MSB_Tlen(S_0))
|
||||
self._mac_tag = strxor(self._t, self._s_0)[:self._mac_len]
|
||||
|
||||
return self._mac_tag
|
||||
|
||||
def hexdigest(self):
|
||||
"""Compute the *printable* MAC tag.
|
||||
|
||||
This method is like `digest`.
|
||||
|
||||
:Return: the MAC, as a hexadecimal string.
|
||||
"""
|
||||
return "".join(["%02x" % bord(x) for x in self.digest()])
|
||||
|
||||
def verify(self, received_mac_tag):
|
||||
"""Validate the *binary* MAC tag.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method checks if the decrypted message is indeed valid
|
||||
(that is, if the key is correct) and it has not been
|
||||
tampered with while in transit.
|
||||
|
||||
:Parameters:
|
||||
received_mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
if self.verify not in self._next:
|
||||
raise TypeError("verify() cannot be called"
|
||||
" when encrypting a message")
|
||||
self._next = [self.verify]
|
||||
|
||||
self._digest()
|
||||
secret = get_random_bytes(16)
|
||||
|
||||
mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=self._mac_tag)
|
||||
mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=received_mac_tag)
|
||||
|
||||
if mac1.digest() != mac2.digest():
|
||||
raise ValueError("MAC check failed")
|
||||
|
||||
def hexverify(self, hex_mac_tag):
|
||||
"""Validate the *printable* MAC tag.
|
||||
|
||||
This method is like `verify`.
|
||||
|
||||
:Parameters:
|
||||
hex_mac_tag : string
|
||||
This is the *printable* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
self.verify(unhexlify(hex_mac_tag))
|
||||
|
||||
def encrypt_and_digest(self, plaintext, output=None):
|
||||
"""Perform encrypt() and digest() in one step.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
a tuple with two items:
|
||||
|
||||
- the ciphertext, as ``bytes``
|
||||
- the MAC tag, as ``bytes``
|
||||
|
||||
The first item becomes ``None`` when the ``output`` parameter
|
||||
specified a location for the result.
|
||||
"""
|
||||
|
||||
return self.encrypt(plaintext, output=output), self.digest()
|
||||
|
||||
def decrypt_and_verify(self, ciphertext, received_mac_tag, output=None):
|
||||
"""Perform decrypt() and verify() in one step.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
received_mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return: the plaintext as ``bytes`` or ``None`` when the ``output``
|
||||
parameter specified a location for the result.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
plaintext = self.decrypt(ciphertext, output=output)
|
||||
self.verify(received_mac_tag)
|
||||
return plaintext
|
||||
|
||||
|
||||
def _create_ccm_cipher(factory, **kwargs):
|
||||
"""Create a new block cipher, configured in CCM mode.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
A symmetric cipher module from `Cryptodome.Cipher` (like
|
||||
`Cryptodome.Cipher.AES`).
|
||||
|
||||
:Keywords:
|
||||
key : bytes/bytearray/memoryview
|
||||
The secret key to use in the symmetric cipher.
|
||||
|
||||
nonce : bytes/bytearray/memoryview
|
||||
A value that must never be reused for any other encryption.
|
||||
|
||||
Its length must be in the range ``[7..13]``.
|
||||
11 or 12 bytes are reasonable values in general. Bear in
|
||||
mind that with CCM there is a trade-off between nonce length and
|
||||
maximum message size.
|
||||
|
||||
If not specified, a 11 byte long random string is used.
|
||||
|
||||
mac_len : integer
|
||||
Length of the MAC, in bytes. It must be even and in
|
||||
the range ``[4..16]``. The default is 16.
|
||||
|
||||
msg_len : integer
|
||||
Length of the message to (de)cipher.
|
||||
If not specified, ``encrypt`` or ``decrypt`` may only be called once.
|
||||
|
||||
assoc_len : integer
|
||||
Length of the associated data.
|
||||
If not specified, all data is internally buffered.
|
||||
"""
|
||||
|
||||
try:
|
||||
key = key = kwargs.pop("key")
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing parameter: " + str(e))
|
||||
|
||||
nonce = kwargs.pop("nonce", None) # N
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(11)
|
||||
mac_len = kwargs.pop("mac_len", factory.block_size)
|
||||
msg_len = kwargs.pop("msg_len", None) # p
|
||||
assoc_len = kwargs.pop("assoc_len", None) # a
|
||||
cipher_params = dict(kwargs)
|
||||
|
||||
return CcmMode(factory, key, nonce, mac_len, msg_len,
|
||||
assoc_len, cipher_params)
|
||||
Binary file not shown.
@ -0,0 +1,47 @@
|
||||
from types import ModuleType
|
||||
from typing import Union, overload, Dict, Tuple, Optional
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = ['CcmMode']
|
||||
|
||||
class CcmMode(object):
|
||||
block_size: int
|
||||
nonce: bytes
|
||||
|
||||
def __init__(self,
|
||||
factory: ModuleType,
|
||||
key: Buffer,
|
||||
nonce: Buffer,
|
||||
mac_len: int,
|
||||
msg_len: int,
|
||||
assoc_len: int,
|
||||
cipher_params: Dict) -> None: ...
|
||||
|
||||
def update(self, assoc_data: Buffer) -> CcmMode: ...
|
||||
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
def digest(self) -> bytes: ...
|
||||
def hexdigest(self) -> str: ...
|
||||
def verify(self, received_mac_tag: Buffer) -> None: ...
|
||||
def hexverify(self, hex_mac_tag: str) -> None: ...
|
||||
|
||||
@overload
|
||||
def encrypt_and_digest(self,
|
||||
plaintext: Buffer) -> Tuple[bytes, bytes]: ...
|
||||
@overload
|
||||
def encrypt_and_digest(self,
|
||||
plaintext: Buffer,
|
||||
output: Buffer) -> Tuple[None, bytes]: ...
|
||||
def decrypt_and_verify(self,
|
||||
ciphertext: Buffer,
|
||||
received_mac_tag: Buffer,
|
||||
output: Optional[Union[bytearray, memoryview]] = ...) -> bytes: ...
|
||||
@ -0,0 +1,293 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/mode_cfb.py : CFB mode
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Counter Feedback (CFB) mode.
|
||||
"""
|
||||
|
||||
__all__ = ['CfbMode']
|
||||
|
||||
from Cryptodome.Util.py3compat import _copy_bytes
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
|
||||
create_string_buffer, get_raw_buffer,
|
||||
SmartPointer, c_size_t, c_uint8_ptr,
|
||||
is_writeable_buffer)
|
||||
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
raw_cfb_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_cfb","""
|
||||
int CFB_start_operation(void *cipher,
|
||||
const uint8_t iv[],
|
||||
size_t iv_len,
|
||||
size_t segment_len, /* In bytes */
|
||||
void **pResult);
|
||||
int CFB_encrypt(void *cfbState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CFB_decrypt(void *cfbState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CFB_stop_operation(void *state);"""
|
||||
)
|
||||
|
||||
|
||||
class CfbMode(object):
|
||||
"""*Cipher FeedBack (CFB)*.
|
||||
|
||||
This mode is similar to CFB, but it transforms
|
||||
the underlying block cipher into a stream cipher.
|
||||
|
||||
Plaintext and ciphertext are processed in *segments*
|
||||
of **s** bits. The mode is therefore sometimes
|
||||
labelled **s**-bit CFB.
|
||||
|
||||
An Initialization Vector (*IV*) is required.
|
||||
|
||||
See `NIST SP800-38A`_ , Section 6.3.
|
||||
|
||||
.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, block_cipher, iv, segment_size):
|
||||
"""Create a new block cipher, configured in CFB mode.
|
||||
|
||||
:Parameters:
|
||||
block_cipher : C pointer
|
||||
A smart pointer to the low-level block cipher instance.
|
||||
|
||||
iv : bytes/bytearray/memoryview
|
||||
The initialization vector to use for encryption or decryption.
|
||||
It is as long as the cipher block.
|
||||
|
||||
**The IV must be unpredictable**. Ideally it is picked randomly.
|
||||
|
||||
Reusing the *IV* for encryptions performed with the same key
|
||||
compromises confidentiality.
|
||||
|
||||
segment_size : integer
|
||||
The number of bytes the plaintext and ciphertext are segmented in.
|
||||
"""
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = raw_cfb_lib.CFB_start_operation(block_cipher.get(),
|
||||
c_uint8_ptr(iv),
|
||||
c_size_t(len(iv)),
|
||||
c_size_t(segment_size),
|
||||
self._state.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %d while instantiating the CFB mode" % result)
|
||||
|
||||
# Ensure that object disposal of this Python object will (eventually)
|
||||
# free the memory allocated by the raw library for the cipher mode
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
raw_cfb_lib.CFB_stop_operation)
|
||||
|
||||
# Memory allocated for the underlying block cipher is now owed
|
||||
# by the cipher mode
|
||||
block_cipher.release()
|
||||
|
||||
self.block_size = len(iv)
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self.iv = _copy_bytes(None, None, iv)
|
||||
"""The Initialization Vector originally used to create the object.
|
||||
The value does not change."""
|
||||
|
||||
self.IV = self.iv
|
||||
"""Alias for `iv`"""
|
||||
|
||||
self._next = [ self.encrypt, self.decrypt ]
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() cannot be called after decrypt()")
|
||||
self._next = [ self.encrypt ]
|
||||
|
||||
if output is None:
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
else:
|
||||
ciphertext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(plaintext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_cfb_lib.CFB_encrypt(self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
raise ValueError("Error %d while encrypting in CFB mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(ciphertext)
|
||||
else:
|
||||
return None
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() cannot be called after encrypt()")
|
||||
self._next = [ self.decrypt ]
|
||||
|
||||
if output is None:
|
||||
plaintext = create_string_buffer(len(ciphertext))
|
||||
else:
|
||||
plaintext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(ciphertext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_cfb_lib.CFB_decrypt(self._state.get(),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_size_t(len(ciphertext)))
|
||||
if result:
|
||||
raise ValueError("Error %d while decrypting in CFB mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(plaintext)
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def _create_cfb_cipher(factory, **kwargs):
|
||||
"""Instantiate a cipher object that performs CFB encryption/decryption.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
The underlying block cipher, a module from ``Cryptodome.Cipher``.
|
||||
|
||||
:Keywords:
|
||||
iv : bytes/bytearray/memoryview
|
||||
The IV to use for CFB.
|
||||
|
||||
IV : bytes/bytearray/memoryview
|
||||
Alias for ``iv``.
|
||||
|
||||
segment_size : integer
|
||||
The number of bit the plaintext and ciphertext are segmented in.
|
||||
If not present, the default is 8.
|
||||
|
||||
Any other keyword will be passed to the underlying block cipher.
|
||||
See the relevant documentation for details (at least ``key`` will need
|
||||
to be present).
|
||||
"""
|
||||
|
||||
cipher_state = factory._create_base_cipher(kwargs)
|
||||
|
||||
iv = kwargs.pop("IV", None)
|
||||
IV = kwargs.pop("iv", None)
|
||||
|
||||
if (None, None) == (iv, IV):
|
||||
iv = get_random_bytes(factory.block_size)
|
||||
if iv is not None:
|
||||
if IV is not None:
|
||||
raise TypeError("You must either use 'iv' or 'IV', not both")
|
||||
else:
|
||||
iv = IV
|
||||
|
||||
if len(iv) != factory.block_size:
|
||||
raise ValueError("Incorrect IV length (it must be %d bytes long)" %
|
||||
factory.block_size)
|
||||
|
||||
segment_size_bytes, rem = divmod(kwargs.pop("segment_size", 8), 8)
|
||||
if segment_size_bytes == 0 or rem != 0:
|
||||
raise ValueError("'segment_size' must be positive and multiple of 8 bits")
|
||||
|
||||
if kwargs:
|
||||
raise TypeError("Unknown parameters for CFB: %s" % str(kwargs))
|
||||
return CfbMode(cipher_state, iv, segment_size_bytes)
|
||||
Binary file not shown.
@ -0,0 +1,26 @@
|
||||
from typing import Union, overload
|
||||
|
||||
from Cryptodome.Util._raw_api import SmartPointer
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = ['CfbMode']
|
||||
|
||||
|
||||
class CfbMode(object):
|
||||
block_size: int
|
||||
iv: Buffer
|
||||
IV: Buffer
|
||||
|
||||
def __init__(self,
|
||||
block_cipher: SmartPointer,
|
||||
iv: Buffer,
|
||||
segment_size: int) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@ -0,0 +1,393 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/mode_ctr.py : CTR mode
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Counter (CTR) mode.
|
||||
"""
|
||||
|
||||
__all__ = ['CtrMode']
|
||||
|
||||
import struct
|
||||
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
|
||||
create_string_buffer, get_raw_buffer,
|
||||
SmartPointer, c_size_t, c_uint8_ptr,
|
||||
is_writeable_buffer)
|
||||
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
from Cryptodome.Util.py3compat import _copy_bytes, is_native_int
|
||||
from Cryptodome.Util.number import long_to_bytes
|
||||
|
||||
raw_ctr_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_ctr", """
|
||||
int CTR_start_operation(void *cipher,
|
||||
uint8_t initialCounterBlock[],
|
||||
size_t initialCounterBlock_len,
|
||||
size_t prefix_len,
|
||||
unsigned counter_len,
|
||||
unsigned littleEndian,
|
||||
void **pResult);
|
||||
int CTR_encrypt(void *ctrState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CTR_decrypt(void *ctrState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int CTR_stop_operation(void *ctrState);"""
|
||||
)
|
||||
|
||||
|
||||
class CtrMode(object):
|
||||
"""*CounTeR (CTR)* mode.
|
||||
|
||||
This mode is very similar to ECB, in that
|
||||
encryption of one block is done independently of all other blocks.
|
||||
|
||||
Unlike ECB, the block *position* contributes to the encryption
|
||||
and no information leaks about symbol frequency.
|
||||
|
||||
Each message block is associated to a *counter* which
|
||||
must be unique across all messages that get encrypted
|
||||
with the same key (not just within the same message).
|
||||
The counter is as big as the block size.
|
||||
|
||||
Counters can be generated in several ways. The most
|
||||
straightword one is to choose an *initial counter block*
|
||||
(which can be made public, similarly to the *IV* for the
|
||||
other modes) and increment its lowest **m** bits by one
|
||||
(modulo *2^m*) for each block. In most cases, **m** is
|
||||
chosen to be half the block size.
|
||||
|
||||
See `NIST SP800-38A`_, Section 6.5 (for the mode) and
|
||||
Appendix B (for how to manage the *initial counter block*).
|
||||
|
||||
.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, block_cipher, initial_counter_block,
|
||||
prefix_len, counter_len, little_endian):
|
||||
"""Create a new block cipher, configured in CTR mode.
|
||||
|
||||
:Parameters:
|
||||
block_cipher : C pointer
|
||||
A smart pointer to the low-level block cipher instance.
|
||||
|
||||
initial_counter_block : bytes/bytearray/memoryview
|
||||
The initial plaintext to use to generate the key stream.
|
||||
|
||||
It is as large as the cipher block, and it embeds
|
||||
the initial value of the counter.
|
||||
|
||||
This value must not be reused.
|
||||
It shall contain a nonce or a random component.
|
||||
Reusing the *initial counter block* for encryptions
|
||||
performed with the same key compromises confidentiality.
|
||||
|
||||
prefix_len : integer
|
||||
The amount of bytes at the beginning of the counter block
|
||||
that never change.
|
||||
|
||||
counter_len : integer
|
||||
The length in bytes of the counter embedded in the counter
|
||||
block.
|
||||
|
||||
little_endian : boolean
|
||||
True if the counter in the counter block is an integer encoded
|
||||
in little endian mode. If False, it is big endian.
|
||||
"""
|
||||
|
||||
if len(initial_counter_block) == prefix_len + counter_len:
|
||||
self.nonce = _copy_bytes(None, prefix_len, initial_counter_block)
|
||||
"""Nonce; not available if there is a fixed suffix"""
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = raw_ctr_lib.CTR_start_operation(block_cipher.get(),
|
||||
c_uint8_ptr(initial_counter_block),
|
||||
c_size_t(len(initial_counter_block)),
|
||||
c_size_t(prefix_len),
|
||||
counter_len,
|
||||
little_endian,
|
||||
self._state.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %X while instantiating the CTR mode"
|
||||
% result)
|
||||
|
||||
# Ensure that object disposal of this Python object will (eventually)
|
||||
# free the memory allocated by the raw library for the cipher mode
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
raw_ctr_lib.CTR_stop_operation)
|
||||
|
||||
# Memory allocated for the underlying block cipher is now owed
|
||||
# by the cipher mode
|
||||
block_cipher.release()
|
||||
|
||||
self.block_size = len(initial_counter_block)
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self._next = [self.encrypt, self.decrypt]
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() cannot be called after decrypt()")
|
||||
self._next = [self.encrypt]
|
||||
|
||||
if output is None:
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
else:
|
||||
ciphertext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(plaintext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_ctr_lib.CTR_encrypt(self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
if result == 0x60002:
|
||||
raise OverflowError("The counter has wrapped around in"
|
||||
" CTR mode")
|
||||
raise ValueError("Error %X while encrypting in CTR mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(ciphertext)
|
||||
else:
|
||||
return None
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() cannot be called after encrypt()")
|
||||
self._next = [self.decrypt]
|
||||
|
||||
if output is None:
|
||||
plaintext = create_string_buffer(len(ciphertext))
|
||||
else:
|
||||
plaintext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(ciphertext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_ctr_lib.CTR_decrypt(self._state.get(),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_size_t(len(ciphertext)))
|
||||
if result:
|
||||
if result == 0x60002:
|
||||
raise OverflowError("The counter has wrapped around in"
|
||||
" CTR mode")
|
||||
raise ValueError("Error %X while decrypting in CTR mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(plaintext)
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def _create_ctr_cipher(factory, **kwargs):
|
||||
"""Instantiate a cipher object that performs CTR encryption/decryption.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
The underlying block cipher, a module from ``Cryptodome.Cipher``.
|
||||
|
||||
:Keywords:
|
||||
nonce : bytes/bytearray/memoryview
|
||||
The fixed part at the beginning of the counter block - the rest is
|
||||
the counter number that gets increased when processing the next block.
|
||||
The nonce must be such that no two messages are encrypted under the
|
||||
same key and the same nonce.
|
||||
|
||||
The nonce must be shorter than the block size (it can have
|
||||
zero length; the counter is then as long as the block).
|
||||
|
||||
If this parameter is not present, a random nonce will be created with
|
||||
length equal to half the block size. No random nonce shorter than
|
||||
64 bits will be created though - you must really think through all
|
||||
security consequences of using such a short block size.
|
||||
|
||||
initial_value : posive integer or bytes/bytearray/memoryview
|
||||
The initial value for the counter. If not present, the cipher will
|
||||
start counting from 0. The value is incremented by one for each block.
|
||||
The counter number is encoded in big endian mode.
|
||||
|
||||
counter : object
|
||||
Instance of ``Cryptodome.Util.Counter``, which allows full customization
|
||||
of the counter block. This parameter is incompatible to both ``nonce``
|
||||
and ``initial_value``.
|
||||
|
||||
Any other keyword will be passed to the underlying block cipher.
|
||||
See the relevant documentation for details (at least ``key`` will need
|
||||
to be present).
|
||||
"""
|
||||
|
||||
cipher_state = factory._create_base_cipher(kwargs)
|
||||
|
||||
counter = kwargs.pop("counter", None)
|
||||
nonce = kwargs.pop("nonce", None)
|
||||
initial_value = kwargs.pop("initial_value", None)
|
||||
if kwargs:
|
||||
raise TypeError("Invalid parameters for CTR mode: %s" % str(kwargs))
|
||||
|
||||
if counter is not None and (nonce, initial_value) != (None, None):
|
||||
raise TypeError("'counter' and 'nonce'/'initial_value'"
|
||||
" are mutually exclusive")
|
||||
|
||||
if counter is None:
|
||||
# Cryptodome.Util.Counter is not used
|
||||
if nonce is None:
|
||||
if factory.block_size < 16:
|
||||
raise TypeError("Impossible to create a safe nonce for short"
|
||||
" block sizes")
|
||||
nonce = get_random_bytes(factory.block_size // 2)
|
||||
else:
|
||||
if len(nonce) >= factory.block_size:
|
||||
raise ValueError("Nonce is too long")
|
||||
|
||||
# What is not nonce is counter
|
||||
counter_len = factory.block_size - len(nonce)
|
||||
|
||||
if initial_value is None:
|
||||
initial_value = 0
|
||||
|
||||
if is_native_int(initial_value):
|
||||
if (1 << (counter_len * 8)) - 1 < initial_value:
|
||||
raise ValueError("Initial counter value is too large")
|
||||
initial_counter_block = nonce + long_to_bytes(initial_value, counter_len)
|
||||
else:
|
||||
if len(initial_value) != counter_len:
|
||||
raise ValueError("Incorrect length for counter byte string (%d bytes, expected %d)" %
|
||||
(len(initial_value), counter_len))
|
||||
initial_counter_block = nonce + initial_value
|
||||
|
||||
return CtrMode(cipher_state,
|
||||
initial_counter_block,
|
||||
len(nonce), # prefix
|
||||
counter_len,
|
||||
False) # little_endian
|
||||
|
||||
# Cryptodome.Util.Counter is used
|
||||
|
||||
# 'counter' used to be a callable object, but now it is
|
||||
# just a dictionary for backward compatibility.
|
||||
_counter = dict(counter)
|
||||
try:
|
||||
counter_len = _counter.pop("counter_len")
|
||||
prefix = _counter.pop("prefix")
|
||||
suffix = _counter.pop("suffix")
|
||||
initial_value = _counter.pop("initial_value")
|
||||
little_endian = _counter.pop("little_endian")
|
||||
except KeyError:
|
||||
raise TypeError("Incorrect counter object"
|
||||
" (use Cryptodome.Util.Counter.new)")
|
||||
|
||||
# Compute initial counter block
|
||||
words = []
|
||||
while initial_value > 0:
|
||||
words.append(struct.pack('B', initial_value & 255))
|
||||
initial_value >>= 8
|
||||
words += [b'\x00'] * max(0, counter_len - len(words))
|
||||
if not little_endian:
|
||||
words.reverse()
|
||||
initial_counter_block = prefix + b"".join(words) + suffix
|
||||
|
||||
if len(initial_counter_block) != factory.block_size:
|
||||
raise ValueError("Size of the counter block (%d bytes) must match"
|
||||
" block size (%d)" % (len(initial_counter_block),
|
||||
factory.block_size))
|
||||
|
||||
return CtrMode(cipher_state, initial_counter_block,
|
||||
len(prefix), counter_len, little_endian)
|
||||
Binary file not shown.
@ -0,0 +1,27 @@
|
||||
from typing import Union, overload
|
||||
|
||||
from Cryptodome.Util._raw_api import SmartPointer
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = ['CtrMode']
|
||||
|
||||
class CtrMode(object):
|
||||
block_size: int
|
||||
nonce: bytes
|
||||
|
||||
def __init__(self,
|
||||
block_cipher: SmartPointer,
|
||||
initial_counter_block: Buffer,
|
||||
prefix_len: int,
|
||||
counter_len: int,
|
||||
little_endian: bool) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
@ -0,0 +1,408 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
EAX mode.
|
||||
"""
|
||||
|
||||
__all__ = ['EaxMode']
|
||||
|
||||
import struct
|
||||
from binascii import unhexlify
|
||||
|
||||
from Cryptodome.Util.py3compat import byte_string, bord, _copy_bytes
|
||||
|
||||
from Cryptodome.Util._raw_api import is_buffer
|
||||
|
||||
from Cryptodome.Util.strxor import strxor
|
||||
from Cryptodome.Util.number import long_to_bytes, bytes_to_long
|
||||
|
||||
from Cryptodome.Hash import CMAC, BLAKE2s
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
|
||||
class EaxMode(object):
|
||||
"""*EAX* mode.
|
||||
|
||||
This is an Authenticated Encryption with Associated Data
|
||||
(`AEAD`_) mode. It provides both confidentiality and authenticity.
|
||||
|
||||
The header of the message may be left in the clear, if needed,
|
||||
and it will still be subject to authentication.
|
||||
|
||||
The decryption step tells the receiver if the message comes
|
||||
from a source that really knowns the secret key.
|
||||
Additionally, decryption detects if any part of the message -
|
||||
including the header - has been modified or corrupted.
|
||||
|
||||
This mode requires a *nonce*.
|
||||
|
||||
This mode is only available for ciphers that operate on 64 or
|
||||
128 bits blocks.
|
||||
|
||||
There are no official standards defining EAX.
|
||||
The implementation is based on `a proposal`__ that
|
||||
was presented to NIST.
|
||||
|
||||
.. _AEAD: http://blog.cryptographyengineering.com/2012/05/how-to-choose-authenticated-encryption.html
|
||||
.. __: http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/eax/eax-spec.pdf
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, factory, key, nonce, mac_len, cipher_params):
|
||||
"""EAX cipher mode"""
|
||||
|
||||
self.block_size = factory.block_size
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
"""The nonce originally used to create the object."""
|
||||
|
||||
self._mac_len = mac_len
|
||||
self._mac_tag = None # Cache for MAC tag
|
||||
|
||||
# Allowed transitions after initialization
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
# MAC tag length
|
||||
if not (4 <= self._mac_len <= self.block_size):
|
||||
raise ValueError("Parameter 'mac_len' must not be larger than %d"
|
||||
% self.block_size)
|
||||
|
||||
# Nonce cannot be empty and must be a byte string
|
||||
if len(self.nonce) == 0:
|
||||
raise ValueError("Nonce cannot be empty in EAX mode")
|
||||
if not is_buffer(nonce):
|
||||
raise TypeError("nonce must be bytes, bytearray or memoryview")
|
||||
|
||||
self._omac = [
|
||||
CMAC.new(key,
|
||||
b'\x00' * (self.block_size - 1) + struct.pack('B', i),
|
||||
ciphermod=factory,
|
||||
cipher_params=cipher_params)
|
||||
for i in range(0, 3)
|
||||
]
|
||||
|
||||
# Compute MAC of nonce
|
||||
self._omac[0].update(self.nonce)
|
||||
self._signer = self._omac[1]
|
||||
|
||||
# MAC of the nonce is also the initial counter for CTR encryption
|
||||
counter_int = bytes_to_long(self._omac[0].digest())
|
||||
self._cipher = factory.new(key,
|
||||
factory.MODE_CTR,
|
||||
initial_value=counter_int,
|
||||
nonce=b"",
|
||||
**cipher_params)
|
||||
|
||||
def update(self, assoc_data):
|
||||
"""Protect associated data
|
||||
|
||||
If there is any associated data, the caller has to invoke
|
||||
this function one or more times, before using
|
||||
``decrypt`` or ``encrypt``.
|
||||
|
||||
By *associated data* it is meant any data (e.g. packet headers) that
|
||||
will not be encrypted and will be transmitted in the clear.
|
||||
However, the receiver is still able to detect any modification to it.
|
||||
|
||||
If there is no associated data, this method must not be called.
|
||||
|
||||
The caller may split associated data in segments of any size, and
|
||||
invoke this method multiple times, each time with the next segment.
|
||||
|
||||
:Parameters:
|
||||
assoc_data : bytes/bytearray/memoryview
|
||||
A piece of associated data. There are no restrictions on its size.
|
||||
"""
|
||||
|
||||
if self.update not in self._next:
|
||||
raise TypeError("update() can only be called"
|
||||
" immediately after initialization")
|
||||
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
self._signer.update(assoc_data)
|
||||
return self
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() can only be called after"
|
||||
" initialization or an update()")
|
||||
self._next = [self.encrypt, self.digest]
|
||||
ct = self._cipher.encrypt(plaintext, output=output)
|
||||
if output is None:
|
||||
self._omac[2].update(ct)
|
||||
else:
|
||||
self._omac[2].update(output)
|
||||
return ct
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() can only be called"
|
||||
" after initialization or an update()")
|
||||
self._next = [self.decrypt, self.verify]
|
||||
self._omac[2].update(ciphertext)
|
||||
return self._cipher.decrypt(ciphertext, output=output)
|
||||
|
||||
def digest(self):
|
||||
"""Compute the *binary* MAC tag.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method returns the MAC that shall be sent to the receiver,
|
||||
together with the ciphertext.
|
||||
|
||||
:Return: the MAC, as a byte string.
|
||||
"""
|
||||
|
||||
if self.digest not in self._next:
|
||||
raise TypeError("digest() cannot be called when decrypting"
|
||||
" or validating a message")
|
||||
self._next = [self.digest]
|
||||
|
||||
if not self._mac_tag:
|
||||
tag = b'\x00' * self.block_size
|
||||
for i in range(3):
|
||||
tag = strxor(tag, self._omac[i].digest())
|
||||
self._mac_tag = tag[:self._mac_len]
|
||||
|
||||
return self._mac_tag
|
||||
|
||||
def hexdigest(self):
|
||||
"""Compute the *printable* MAC tag.
|
||||
|
||||
This method is like `digest`.
|
||||
|
||||
:Return: the MAC, as a hexadecimal string.
|
||||
"""
|
||||
return "".join(["%02x" % bord(x) for x in self.digest()])
|
||||
|
||||
def verify(self, received_mac_tag):
|
||||
"""Validate the *binary* MAC tag.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method checks if the decrypted message is indeed valid
|
||||
(that is, if the key is correct) and it has not been
|
||||
tampered with while in transit.
|
||||
|
||||
:Parameters:
|
||||
received_mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Raises MacMismatchError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
if self.verify not in self._next:
|
||||
raise TypeError("verify() cannot be called"
|
||||
" when encrypting a message")
|
||||
self._next = [self.verify]
|
||||
|
||||
if not self._mac_tag:
|
||||
tag = b'\x00' * self.block_size
|
||||
for i in range(3):
|
||||
tag = strxor(tag, self._omac[i].digest())
|
||||
self._mac_tag = tag[:self._mac_len]
|
||||
|
||||
secret = get_random_bytes(16)
|
||||
|
||||
mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=self._mac_tag)
|
||||
mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=received_mac_tag)
|
||||
|
||||
if mac1.digest() != mac2.digest():
|
||||
raise ValueError("MAC check failed")
|
||||
|
||||
def hexverify(self, hex_mac_tag):
|
||||
"""Validate the *printable* MAC tag.
|
||||
|
||||
This method is like `verify`.
|
||||
|
||||
:Parameters:
|
||||
hex_mac_tag : string
|
||||
This is the *printable* MAC, as received from the sender.
|
||||
:Raises MacMismatchError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
self.verify(unhexlify(hex_mac_tag))
|
||||
|
||||
def encrypt_and_digest(self, plaintext, output=None):
|
||||
"""Perform encrypt() and digest() in one step.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
a tuple with two items:
|
||||
|
||||
- the ciphertext, as ``bytes``
|
||||
- the MAC tag, as ``bytes``
|
||||
|
||||
The first item becomes ``None`` when the ``output`` parameter
|
||||
specified a location for the result.
|
||||
"""
|
||||
|
||||
return self.encrypt(plaintext, output=output), self.digest()
|
||||
|
||||
def decrypt_and_verify(self, ciphertext, received_mac_tag, output=None):
|
||||
"""Perform decrypt() and verify() in one step.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
received_mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return: the plaintext as ``bytes`` or ``None`` when the ``output``
|
||||
parameter specified a location for the result.
|
||||
:Raises MacMismatchError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
pt = self.decrypt(ciphertext, output=output)
|
||||
self.verify(received_mac_tag)
|
||||
return pt
|
||||
|
||||
|
||||
def _create_eax_cipher(factory, **kwargs):
|
||||
"""Create a new block cipher, configured in EAX mode.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
A symmetric cipher module from `Cryptodome.Cipher` (like
|
||||
`Cryptodome.Cipher.AES`).
|
||||
|
||||
:Keywords:
|
||||
key : bytes/bytearray/memoryview
|
||||
The secret key to use in the symmetric cipher.
|
||||
|
||||
nonce : bytes/bytearray/memoryview
|
||||
A value that must never be reused for any other encryption.
|
||||
There are no restrictions on its length, but it is recommended to use
|
||||
at least 16 bytes.
|
||||
|
||||
The nonce shall never repeat for two different messages encrypted with
|
||||
the same key, but it does not need to be random.
|
||||
|
||||
If not specified, a 16 byte long random string is used.
|
||||
|
||||
mac_len : integer
|
||||
Length of the MAC, in bytes. It must be no larger than the cipher
|
||||
block bytes (which is the default).
|
||||
"""
|
||||
|
||||
try:
|
||||
key = kwargs.pop("key")
|
||||
nonce = kwargs.pop("nonce", None)
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(16)
|
||||
mac_len = kwargs.pop("mac_len", factory.block_size)
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing parameter: " + str(e))
|
||||
|
||||
return EaxMode(factory, key, nonce, mac_len, kwargs)
|
||||
Binary file not shown.
@ -0,0 +1,45 @@
|
||||
from types import ModuleType
|
||||
from typing import Any, Union, Tuple, Dict, overload, Optional
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = ['EaxMode']
|
||||
|
||||
class EaxMode(object):
|
||||
block_size: int
|
||||
nonce: bytes
|
||||
|
||||
def __init__(self,
|
||||
factory: ModuleType,
|
||||
key: Buffer,
|
||||
nonce: Buffer,
|
||||
mac_len: int,
|
||||
cipher_params: Dict) -> None: ...
|
||||
|
||||
def update(self, assoc_data: Buffer) -> EaxMode: ...
|
||||
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
def digest(self) -> bytes: ...
|
||||
def hexdigest(self) -> str: ...
|
||||
def verify(self, received_mac_tag: Buffer) -> None: ...
|
||||
def hexverify(self, hex_mac_tag: str) -> None: ...
|
||||
|
||||
@overload
|
||||
def encrypt_and_digest(self,
|
||||
plaintext: Buffer) -> Tuple[bytes, bytes]: ...
|
||||
@overload
|
||||
def encrypt_and_digest(self,
|
||||
plaintext: Buffer,
|
||||
output: Buffer) -> Tuple[None, bytes]: ...
|
||||
def decrypt_and_verify(self,
|
||||
ciphertext: Buffer,
|
||||
received_mac_tag: Buffer,
|
||||
output: Optional[Union[bytearray, memoryview]] = ...) -> bytes: ...
|
||||
@ -0,0 +1,220 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/mode_ecb.py : ECB mode
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Electronic Code Book (ECB) mode.
|
||||
"""
|
||||
|
||||
__all__ = [ 'EcbMode' ]
|
||||
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib,
|
||||
VoidPointer, create_string_buffer,
|
||||
get_raw_buffer, SmartPointer,
|
||||
c_size_t, c_uint8_ptr,
|
||||
is_writeable_buffer)
|
||||
|
||||
raw_ecb_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_ecb", """
|
||||
int ECB_start_operation(void *cipher,
|
||||
void **pResult);
|
||||
int ECB_encrypt(void *ecbState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int ECB_decrypt(void *ecbState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int ECB_stop_operation(void *state);
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
class EcbMode(object):
|
||||
"""*Electronic Code Book (ECB)*.
|
||||
|
||||
This is the simplest encryption mode. Each of the plaintext blocks
|
||||
is directly encrypted into a ciphertext block, independently of
|
||||
any other block.
|
||||
|
||||
This mode is dangerous because it exposes frequency of symbols
|
||||
in your plaintext. Other modes (e.g. *CBC*) should be used instead.
|
||||
|
||||
See `NIST SP800-38A`_ , Section 6.1.
|
||||
|
||||
.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, block_cipher):
|
||||
"""Create a new block cipher, configured in ECB mode.
|
||||
|
||||
:Parameters:
|
||||
block_cipher : C pointer
|
||||
A smart pointer to the low-level block cipher instance.
|
||||
"""
|
||||
self.block_size = block_cipher.block_size
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = raw_ecb_lib.ECB_start_operation(block_cipher.get(),
|
||||
self._state.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %d while instantiating the ECB mode"
|
||||
% result)
|
||||
|
||||
# Ensure that object disposal of this Python object will (eventually)
|
||||
# free the memory allocated by the raw library for the cipher
|
||||
# mode
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
raw_ecb_lib.ECB_stop_operation)
|
||||
|
||||
# Memory allocated for the underlying block cipher is now owned
|
||||
# by the cipher mode
|
||||
block_cipher.release()
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key set at initialization.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
The length must be multiple of the cipher block length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if output is None:
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
else:
|
||||
ciphertext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(plaintext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_ecb_lib.ECB_encrypt(self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
if result == 3:
|
||||
raise ValueError("Data must be aligned to block boundary in ECB mode")
|
||||
raise ValueError("Error %d while encrypting in ECB mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(ciphertext)
|
||||
else:
|
||||
return None
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key set at initialization.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
The length must be multiple of the cipher block length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if output is None:
|
||||
plaintext = create_string_buffer(len(ciphertext))
|
||||
else:
|
||||
plaintext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(ciphertext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_ecb_lib.ECB_decrypt(self._state.get(),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_size_t(len(ciphertext)))
|
||||
if result:
|
||||
if result == 3:
|
||||
raise ValueError("Data must be aligned to block boundary in ECB mode")
|
||||
raise ValueError("Error %d while decrypting in ECB mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(plaintext)
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def _create_ecb_cipher(factory, **kwargs):
|
||||
"""Instantiate a cipher object that performs ECB encryption/decryption.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
The underlying block cipher, a module from ``Cryptodome.Cipher``.
|
||||
|
||||
All keywords are passed to the underlying block cipher.
|
||||
See the relevant documentation for details (at least ``key`` will need
|
||||
to be present"""
|
||||
|
||||
cipher_state = factory._create_base_cipher(kwargs)
|
||||
cipher_state.block_size = factory.block_size
|
||||
if kwargs:
|
||||
raise TypeError("Unknown parameters for ECB: %s" % str(kwargs))
|
||||
return EcbMode(cipher_state)
|
||||
Binary file not shown.
@ -0,0 +1,19 @@
|
||||
from typing import Union, overload
|
||||
|
||||
from Cryptodome.Util._raw_api import SmartPointer
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = [ 'EcbMode' ]
|
||||
|
||||
class EcbMode(object):
|
||||
def __init__(self, block_cipher: SmartPointer) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
@ -0,0 +1,620 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Galois/Counter Mode (GCM).
|
||||
"""
|
||||
|
||||
__all__ = ['GcmMode']
|
||||
|
||||
from binascii import unhexlify
|
||||
|
||||
from Cryptodome.Util.py3compat import bord, _copy_bytes
|
||||
|
||||
from Cryptodome.Util._raw_api import is_buffer
|
||||
|
||||
from Cryptodome.Util.number import long_to_bytes, bytes_to_long
|
||||
from Cryptodome.Hash import BLAKE2s
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
|
||||
create_string_buffer, get_raw_buffer,
|
||||
SmartPointer, c_size_t, c_uint8_ptr)
|
||||
|
||||
from Cryptodome.Util import _cpu_features
|
||||
|
||||
|
||||
# C API by module implementing GHASH
|
||||
_ghash_api_template = """
|
||||
int ghash_%imp%(uint8_t y_out[16],
|
||||
const uint8_t block_data[],
|
||||
size_t len,
|
||||
const uint8_t y_in[16],
|
||||
const void *exp_key);
|
||||
int ghash_expand_%imp%(const uint8_t h[16],
|
||||
void **ghash_tables);
|
||||
int ghash_destroy_%imp%(void *ghash_tables);
|
||||
"""
|
||||
|
||||
def _build_impl(lib, postfix):
|
||||
from collections import namedtuple
|
||||
|
||||
funcs = ( "ghash", "ghash_expand", "ghash_destroy" )
|
||||
GHASH_Imp = namedtuple('_GHash_Imp', funcs)
|
||||
try:
|
||||
imp_funcs = [ getattr(lib, x + "_" + postfix) for x in funcs ]
|
||||
except AttributeError: # Make sphinx stop complaining with its mocklib
|
||||
imp_funcs = [ None ] * 3
|
||||
params = dict(zip(funcs, imp_funcs))
|
||||
return GHASH_Imp(**params)
|
||||
|
||||
|
||||
def _get_ghash_portable():
|
||||
api = _ghash_api_template.replace("%imp%", "portable")
|
||||
lib = load_pycryptodome_raw_lib("Cryptodome.Hash._ghash_portable", api)
|
||||
result = _build_impl(lib, "portable")
|
||||
return result
|
||||
_ghash_portable = _get_ghash_portable()
|
||||
|
||||
|
||||
def _get_ghash_clmul():
|
||||
"""Return None if CLMUL implementation is not available"""
|
||||
|
||||
if not _cpu_features.have_clmul():
|
||||
return None
|
||||
try:
|
||||
api = _ghash_api_template.replace("%imp%", "clmul")
|
||||
lib = load_pycryptodome_raw_lib("Cryptodome.Hash._ghash_clmul", api)
|
||||
result = _build_impl(lib, "clmul")
|
||||
except OSError:
|
||||
result = None
|
||||
return result
|
||||
_ghash_clmul = _get_ghash_clmul()
|
||||
|
||||
|
||||
class _GHASH(object):
|
||||
"""GHASH function defined in NIST SP 800-38D, Algorithm 2.
|
||||
|
||||
If X_1, X_2, .. X_m are the blocks of input data, the function
|
||||
computes:
|
||||
|
||||
X_1*H^{m} + X_2*H^{m-1} + ... + X_m*H
|
||||
|
||||
in the Galois field GF(2^256) using the reducing polynomial
|
||||
(x^128 + x^7 + x^2 + x + 1).
|
||||
"""
|
||||
|
||||
def __init__(self, subkey, ghash_c):
|
||||
assert len(subkey) == 16
|
||||
|
||||
self.ghash_c = ghash_c
|
||||
|
||||
self._exp_key = VoidPointer()
|
||||
result = ghash_c.ghash_expand(c_uint8_ptr(subkey),
|
||||
self._exp_key.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %d while expanding the GHASH key" % result)
|
||||
|
||||
self._exp_key = SmartPointer(self._exp_key.get(),
|
||||
ghash_c.ghash_destroy)
|
||||
|
||||
# create_string_buffer always returns a string of zeroes
|
||||
self._last_y = create_string_buffer(16)
|
||||
|
||||
def update(self, block_data):
|
||||
assert len(block_data) % 16 == 0
|
||||
|
||||
result = self.ghash_c.ghash(self._last_y,
|
||||
c_uint8_ptr(block_data),
|
||||
c_size_t(len(block_data)),
|
||||
self._last_y,
|
||||
self._exp_key.get())
|
||||
if result:
|
||||
raise ValueError("Error %d while updating GHASH" % result)
|
||||
|
||||
return self
|
||||
|
||||
def digest(self):
|
||||
return get_raw_buffer(self._last_y)
|
||||
|
||||
|
||||
def enum(**enums):
|
||||
return type('Enum', (), enums)
|
||||
|
||||
|
||||
MacStatus = enum(PROCESSING_AUTH_DATA=1, PROCESSING_CIPHERTEXT=2)
|
||||
|
||||
|
||||
class GcmMode(object):
|
||||
"""Galois Counter Mode (GCM).
|
||||
|
||||
This is an Authenticated Encryption with Associated Data (`AEAD`_) mode.
|
||||
It provides both confidentiality and authenticity.
|
||||
|
||||
The header of the message may be left in the clear, if needed, and it will
|
||||
still be subject to authentication. The decryption step tells the receiver
|
||||
if the message comes from a source that really knowns the secret key.
|
||||
Additionally, decryption detects if any part of the message - including the
|
||||
header - has been modified or corrupted.
|
||||
|
||||
This mode requires a *nonce*.
|
||||
|
||||
This mode is only available for ciphers that operate on 128 bits blocks
|
||||
(e.g. AES but not TDES).
|
||||
|
||||
See `NIST SP800-38D`_.
|
||||
|
||||
.. _`NIST SP800-38D`: http://csrc.nist.gov/publications/nistpubs/800-38D/SP-800-38D.pdf
|
||||
.. _AEAD: http://blog.cryptographyengineering.com/2012/05/how-to-choose-authenticated-encryption.html
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, factory, key, nonce, mac_len, cipher_params, ghash_c):
|
||||
|
||||
self.block_size = factory.block_size
|
||||
if self.block_size != 16:
|
||||
raise ValueError("GCM mode is only available for ciphers"
|
||||
" that operate on 128 bits blocks")
|
||||
|
||||
if len(nonce) == 0:
|
||||
raise ValueError("Nonce cannot be empty")
|
||||
|
||||
if not is_buffer(nonce):
|
||||
raise TypeError("Nonce must be bytes, bytearray or memoryview")
|
||||
|
||||
# See NIST SP 800 38D, 5.2.1.1
|
||||
if len(nonce) > 2**64 - 1:
|
||||
raise ValueError("Nonce exceeds maximum length")
|
||||
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
"""Nonce"""
|
||||
|
||||
self._factory = factory
|
||||
self._key = _copy_bytes(None, None, key)
|
||||
self._tag = None # Cache for MAC tag
|
||||
|
||||
self._mac_len = mac_len
|
||||
if not (4 <= mac_len <= 16):
|
||||
raise ValueError("Parameter 'mac_len' must be in the range 4..16")
|
||||
|
||||
# Allowed transitions after initialization
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
self._no_more_assoc_data = False
|
||||
|
||||
# Length of associated data
|
||||
self._auth_len = 0
|
||||
|
||||
# Length of the ciphertext or plaintext
|
||||
self._msg_len = 0
|
||||
|
||||
# Step 1 in SP800-38D, Algorithm 4 (encryption) - Compute H
|
||||
# See also Algorithm 5 (decryption)
|
||||
hash_subkey = factory.new(key,
|
||||
self._factory.MODE_ECB,
|
||||
**cipher_params
|
||||
).encrypt(b'\x00' * 16)
|
||||
|
||||
# Step 2 - Compute J0
|
||||
if len(self.nonce) == 12:
|
||||
j0 = self.nonce + b"\x00\x00\x00\x01"
|
||||
else:
|
||||
fill = (16 - (len(nonce) % 16)) % 16 + 8
|
||||
ghash_in = (self.nonce +
|
||||
b'\x00' * fill +
|
||||
long_to_bytes(8 * len(nonce), 8))
|
||||
j0 = _GHASH(hash_subkey, ghash_c).update(ghash_in).digest()
|
||||
|
||||
# Step 3 - Prepare GCTR cipher for encryption/decryption
|
||||
nonce_ctr = j0[:12]
|
||||
iv_ctr = (bytes_to_long(j0) + 1) & 0xFFFFFFFF
|
||||
self._cipher = factory.new(key,
|
||||
self._factory.MODE_CTR,
|
||||
initial_value=iv_ctr,
|
||||
nonce=nonce_ctr,
|
||||
**cipher_params)
|
||||
|
||||
# Step 5 - Bootstrat GHASH
|
||||
self._signer = _GHASH(hash_subkey, ghash_c)
|
||||
|
||||
# Step 6 - Prepare GCTR cipher for GMAC
|
||||
self._tag_cipher = factory.new(key,
|
||||
self._factory.MODE_CTR,
|
||||
initial_value=j0,
|
||||
nonce=b"",
|
||||
**cipher_params)
|
||||
|
||||
# Cache for data to authenticate
|
||||
self._cache = b""
|
||||
|
||||
self._status = MacStatus.PROCESSING_AUTH_DATA
|
||||
|
||||
def update(self, assoc_data):
|
||||
"""Protect associated data
|
||||
|
||||
If there is any associated data, the caller has to invoke
|
||||
this function one or more times, before using
|
||||
``decrypt`` or ``encrypt``.
|
||||
|
||||
By *associated data* it is meant any data (e.g. packet headers) that
|
||||
will not be encrypted and will be transmitted in the clear.
|
||||
However, the receiver is still able to detect any modification to it.
|
||||
In GCM, the *associated data* is also called
|
||||
*additional authenticated data* (AAD).
|
||||
|
||||
If there is no associated data, this method must not be called.
|
||||
|
||||
The caller may split associated data in segments of any size, and
|
||||
invoke this method multiple times, each time with the next segment.
|
||||
|
||||
:Parameters:
|
||||
assoc_data : bytes/bytearray/memoryview
|
||||
A piece of associated data. There are no restrictions on its size.
|
||||
"""
|
||||
|
||||
if self.update not in self._next:
|
||||
raise TypeError("update() can only be called"
|
||||
" immediately after initialization")
|
||||
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
self._update(assoc_data)
|
||||
self._auth_len += len(assoc_data)
|
||||
|
||||
# See NIST SP 800 38D, 5.2.1.1
|
||||
if self._auth_len > 2**64 - 1:
|
||||
raise ValueError("Additional Authenticated Data exceeds maximum length")
|
||||
|
||||
return self
|
||||
|
||||
def _update(self, data):
|
||||
assert(len(self._cache) < 16)
|
||||
|
||||
if len(self._cache) > 0:
|
||||
filler = min(16 - len(self._cache), len(data))
|
||||
self._cache += _copy_bytes(None, filler, data)
|
||||
data = data[filler:]
|
||||
|
||||
if len(self._cache) < 16:
|
||||
return
|
||||
|
||||
# The cache is exactly one block
|
||||
self._signer.update(self._cache)
|
||||
self._cache = b""
|
||||
|
||||
update_len = len(data) // 16 * 16
|
||||
self._cache = _copy_bytes(update_len, None, data)
|
||||
if update_len > 0:
|
||||
self._signer.update(data[:update_len])
|
||||
|
||||
def _pad_cache_and_update(self):
|
||||
assert(len(self._cache) < 16)
|
||||
|
||||
# The authenticated data A is concatenated to the minimum
|
||||
# number of zero bytes (possibly none) such that the
|
||||
# - ciphertext C is aligned to the 16 byte boundary.
|
||||
# See step 5 in section 7.1
|
||||
# - ciphertext C is aligned to the 16 byte boundary.
|
||||
# See step 6 in section 7.2
|
||||
len_cache = len(self._cache)
|
||||
if len_cache > 0:
|
||||
self._update(b'\x00' * (16 - len_cache))
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() can only be called after"
|
||||
" initialization or an update()")
|
||||
self._next = [self.encrypt, self.digest]
|
||||
|
||||
ciphertext = self._cipher.encrypt(plaintext, output=output)
|
||||
|
||||
if self._status == MacStatus.PROCESSING_AUTH_DATA:
|
||||
self._pad_cache_and_update()
|
||||
self._status = MacStatus.PROCESSING_CIPHERTEXT
|
||||
|
||||
self._update(ciphertext if output is None else output)
|
||||
self._msg_len += len(plaintext)
|
||||
|
||||
# See NIST SP 800 38D, 5.2.1.1
|
||||
if self._msg_len > 2**39 - 256:
|
||||
raise ValueError("Plaintext exceeds maximum length")
|
||||
|
||||
return ciphertext
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() can only be called"
|
||||
" after initialization or an update()")
|
||||
self._next = [self.decrypt, self.verify]
|
||||
|
||||
if self._status == MacStatus.PROCESSING_AUTH_DATA:
|
||||
self._pad_cache_and_update()
|
||||
self._status = MacStatus.PROCESSING_CIPHERTEXT
|
||||
|
||||
self._update(ciphertext)
|
||||
self._msg_len += len(ciphertext)
|
||||
|
||||
return self._cipher.decrypt(ciphertext, output=output)
|
||||
|
||||
def digest(self):
|
||||
"""Compute the *binary* MAC tag in an AEAD mode.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method returns the MAC that shall be sent to the receiver,
|
||||
together with the ciphertext.
|
||||
|
||||
:Return: the MAC, as a byte string.
|
||||
"""
|
||||
|
||||
if self.digest not in self._next:
|
||||
raise TypeError("digest() cannot be called when decrypting"
|
||||
" or validating a message")
|
||||
self._next = [self.digest]
|
||||
|
||||
return self._compute_mac()
|
||||
|
||||
def _compute_mac(self):
|
||||
"""Compute MAC without any FSM checks."""
|
||||
|
||||
if self._tag:
|
||||
return self._tag
|
||||
|
||||
# Step 5 in NIST SP 800-38D, Algorithm 4 - Compute S
|
||||
self._pad_cache_and_update()
|
||||
self._update(long_to_bytes(8 * self._auth_len, 8))
|
||||
self._update(long_to_bytes(8 * self._msg_len, 8))
|
||||
s_tag = self._signer.digest()
|
||||
|
||||
# Step 6 - Compute T
|
||||
self._tag = self._tag_cipher.encrypt(s_tag)[:self._mac_len]
|
||||
|
||||
return self._tag
|
||||
|
||||
def hexdigest(self):
|
||||
"""Compute the *printable* MAC tag.
|
||||
|
||||
This method is like `digest`.
|
||||
|
||||
:Return: the MAC, as a hexadecimal string.
|
||||
"""
|
||||
return "".join(["%02x" % bord(x) for x in self.digest()])
|
||||
|
||||
def verify(self, received_mac_tag):
|
||||
"""Validate the *binary* MAC tag.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method checks if the decrypted message is indeed valid
|
||||
(that is, if the key is correct) and it has not been
|
||||
tampered with while in transit.
|
||||
|
||||
:Parameters:
|
||||
received_mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
if self.verify not in self._next:
|
||||
raise TypeError("verify() cannot be called"
|
||||
" when encrypting a message")
|
||||
self._next = [self.verify]
|
||||
|
||||
secret = get_random_bytes(16)
|
||||
|
||||
mac1 = BLAKE2s.new(digest_bits=160, key=secret,
|
||||
data=self._compute_mac())
|
||||
mac2 = BLAKE2s.new(digest_bits=160, key=secret,
|
||||
data=received_mac_tag)
|
||||
|
||||
if mac1.digest() != mac2.digest():
|
||||
raise ValueError("MAC check failed")
|
||||
|
||||
def hexverify(self, hex_mac_tag):
|
||||
"""Validate the *printable* MAC tag.
|
||||
|
||||
This method is like `verify`.
|
||||
|
||||
:Parameters:
|
||||
hex_mac_tag : string
|
||||
This is the *printable* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
self.verify(unhexlify(hex_mac_tag))
|
||||
|
||||
def encrypt_and_digest(self, plaintext, output=None):
|
||||
"""Perform encrypt() and digest() in one step.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
a tuple with two items:
|
||||
|
||||
- the ciphertext, as ``bytes``
|
||||
- the MAC tag, as ``bytes``
|
||||
|
||||
The first item becomes ``None`` when the ``output`` parameter
|
||||
specified a location for the result.
|
||||
"""
|
||||
|
||||
return self.encrypt(plaintext, output=output), self.digest()
|
||||
|
||||
def decrypt_and_verify(self, ciphertext, received_mac_tag, output=None):
|
||||
"""Perform decrypt() and verify() in one step.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
received_mac_tag : byte string
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return: the plaintext as ``bytes`` or ``None`` when the ``output``
|
||||
parameter specified a location for the result.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
plaintext = self.decrypt(ciphertext, output=output)
|
||||
self.verify(received_mac_tag)
|
||||
return plaintext
|
||||
|
||||
|
||||
def _create_gcm_cipher(factory, **kwargs):
|
||||
"""Create a new block cipher, configured in Galois Counter Mode (GCM).
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
A block cipher module, taken from `Cryptodome.Cipher`.
|
||||
The cipher must have block length of 16 bytes.
|
||||
GCM has been only defined for `Cryptodome.Cipher.AES`.
|
||||
|
||||
:Keywords:
|
||||
key : bytes/bytearray/memoryview
|
||||
The secret key to use in the symmetric cipher.
|
||||
It must be 16 (e.g. *AES-128*), 24 (e.g. *AES-192*)
|
||||
or 32 (e.g. *AES-256*) bytes long.
|
||||
|
||||
nonce : bytes/bytearray/memoryview
|
||||
A value that must never be reused for any other encryption.
|
||||
|
||||
There are no restrictions on its length,
|
||||
but it is recommended to use at least 16 bytes.
|
||||
|
||||
The nonce shall never repeat for two
|
||||
different messages encrypted with the same key,
|
||||
but it does not need to be random.
|
||||
|
||||
If not provided, a 16 byte nonce will be randomly created.
|
||||
|
||||
mac_len : integer
|
||||
Length of the MAC, in bytes.
|
||||
It must be no larger than 16 bytes (which is the default).
|
||||
"""
|
||||
|
||||
try:
|
||||
key = kwargs.pop("key")
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing parameter:" + str(e))
|
||||
|
||||
nonce = kwargs.pop("nonce", None)
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(16)
|
||||
mac_len = kwargs.pop("mac_len", 16)
|
||||
|
||||
# Not documented - only used for testing
|
||||
use_clmul = kwargs.pop("use_clmul", True)
|
||||
if use_clmul and _ghash_clmul:
|
||||
ghash_c = _ghash_clmul
|
||||
else:
|
||||
ghash_c = _ghash_portable
|
||||
|
||||
return GcmMode(factory, key, nonce, mac_len, kwargs, ghash_c)
|
||||
Binary file not shown.
@ -0,0 +1,45 @@
|
||||
from types import ModuleType
|
||||
from typing import Union, Tuple, Dict, overload, Optional
|
||||
|
||||
__all__ = ['GcmMode']
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
class GcmMode(object):
|
||||
block_size: int
|
||||
nonce: Buffer
|
||||
|
||||
def __init__(self,
|
||||
factory: ModuleType,
|
||||
key: Buffer,
|
||||
nonce: Buffer,
|
||||
mac_len: int,
|
||||
cipher_params: Dict) -> None: ...
|
||||
|
||||
def update(self, assoc_data: Buffer) -> GcmMode: ...
|
||||
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
def digest(self) -> bytes: ...
|
||||
def hexdigest(self) -> str: ...
|
||||
def verify(self, received_mac_tag: Buffer) -> None: ...
|
||||
def hexverify(self, hex_mac_tag: str) -> None: ...
|
||||
|
||||
@overload
|
||||
def encrypt_and_digest(self,
|
||||
plaintext: Buffer) -> Tuple[bytes, bytes]: ...
|
||||
@overload
|
||||
def encrypt_and_digest(self,
|
||||
plaintext: Buffer,
|
||||
output: Buffer) -> Tuple[None, bytes]: ...
|
||||
def decrypt_and_verify(self,
|
||||
ciphertext: Buffer,
|
||||
received_mac_tag: Buffer,
|
||||
output: Optional[Union[bytearray, memoryview]] = ...) -> bytes: ...
|
||||
@ -0,0 +1,525 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Offset Codebook (OCB) mode.
|
||||
|
||||
OCB is Authenticated Encryption with Associated Data (AEAD) cipher mode
|
||||
designed by Prof. Phillip Rogaway and specified in `RFC7253`_.
|
||||
|
||||
The algorithm provides both authenticity and privacy, it is very efficient,
|
||||
it uses only one key and it can be used in online mode (so that encryption
|
||||
or decryption can start before the end of the message is available).
|
||||
|
||||
This module implements the third and last variant of OCB (OCB3) and it only
|
||||
works in combination with a 128-bit block symmetric cipher, like AES.
|
||||
|
||||
OCB is patented in US but `free licenses`_ exist for software implementations
|
||||
meant for non-military purposes.
|
||||
|
||||
Example:
|
||||
>>> from Cryptodome.Cipher import AES
|
||||
>>> from Cryptodome.Random import get_random_bytes
|
||||
>>>
|
||||
>>> key = get_random_bytes(32)
|
||||
>>> cipher = AES.new(key, AES.MODE_OCB)
|
||||
>>> plaintext = b"Attack at dawn"
|
||||
>>> ciphertext, mac = cipher.encrypt_and_digest(plaintext)
|
||||
>>> # Deliver cipher.nonce, ciphertext and mac
|
||||
...
|
||||
>>> cipher = AES.new(key, AES.MODE_OCB, nonce=nonce)
|
||||
>>> try:
|
||||
>>> plaintext = cipher.decrypt_and_verify(ciphertext, mac)
|
||||
>>> except ValueError:
|
||||
>>> print "Invalid message"
|
||||
>>> else:
|
||||
>>> print plaintext
|
||||
|
||||
:undocumented: __package__
|
||||
|
||||
.. _RFC7253: http://www.rfc-editor.org/info/rfc7253
|
||||
.. _free licenses: http://web.cs.ucdavis.edu/~rogaway/ocb/license.htm
|
||||
"""
|
||||
|
||||
import struct
|
||||
from binascii import unhexlify
|
||||
|
||||
from Cryptodome.Util.py3compat import bord, _copy_bytes
|
||||
from Cryptodome.Util.number import long_to_bytes, bytes_to_long
|
||||
from Cryptodome.Util.strxor import strxor
|
||||
|
||||
from Cryptodome.Hash import BLAKE2s
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
|
||||
create_string_buffer, get_raw_buffer,
|
||||
SmartPointer, c_size_t, c_uint8_ptr,
|
||||
is_buffer)
|
||||
|
||||
_raw_ocb_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_ocb", """
|
||||
int OCB_start_operation(void *cipher,
|
||||
const uint8_t *offset_0,
|
||||
size_t offset_0_len,
|
||||
void **pState);
|
||||
int OCB_encrypt(void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int OCB_decrypt(void *state,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int OCB_update(void *state,
|
||||
const uint8_t *in,
|
||||
size_t data_len);
|
||||
int OCB_digest(void *state,
|
||||
uint8_t *tag,
|
||||
size_t tag_len);
|
||||
int OCB_stop_operation(void *state);
|
||||
""")
|
||||
|
||||
|
||||
class OcbMode(object):
|
||||
"""Offset Codebook (OCB) mode.
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, factory, nonce, mac_len, cipher_params):
|
||||
|
||||
if factory.block_size != 16:
|
||||
raise ValueError("OCB mode is only available for ciphers"
|
||||
" that operate on 128 bits blocks")
|
||||
|
||||
self.block_size = 16
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
"""Nonce used for this session."""
|
||||
if len(nonce) not in range(1, 16):
|
||||
raise ValueError("Nonce must be at most 15 bytes long")
|
||||
if not is_buffer(nonce):
|
||||
raise TypeError("Nonce must be bytes, bytearray or memoryview")
|
||||
|
||||
self._mac_len = mac_len
|
||||
if not 8 <= mac_len <= 16:
|
||||
raise ValueError("MAC tag must be between 8 and 16 bytes long")
|
||||
|
||||
# Cache for MAC tag
|
||||
self._mac_tag = None
|
||||
|
||||
# Cache for unaligned associated data
|
||||
self._cache_A = b""
|
||||
|
||||
# Cache for unaligned ciphertext/plaintext
|
||||
self._cache_P = b""
|
||||
|
||||
# Allowed transitions after initialization
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
# Compute Offset_0
|
||||
params_without_key = dict(cipher_params)
|
||||
key = params_without_key.pop("key")
|
||||
nonce = (struct.pack('B', self._mac_len << 4 & 0xFF) +
|
||||
b'\x00' * (14 - len(nonce)) +
|
||||
b'\x01' + self.nonce)
|
||||
|
||||
bottom_bits = bord(nonce[15]) & 0x3F # 6 bits, 0..63
|
||||
top_bits = bord(nonce[15]) & 0xC0 # 2 bits
|
||||
|
||||
ktop_cipher = factory.new(key,
|
||||
factory.MODE_ECB,
|
||||
**params_without_key)
|
||||
ktop = ktop_cipher.encrypt(struct.pack('15sB',
|
||||
nonce[:15],
|
||||
top_bits))
|
||||
|
||||
stretch = ktop + strxor(ktop[:8], ktop[1:9]) # 192 bits
|
||||
offset_0 = long_to_bytes(bytes_to_long(stretch) >>
|
||||
(64 - bottom_bits), 24)[8:]
|
||||
|
||||
# Create low-level cipher instance
|
||||
raw_cipher = factory._create_base_cipher(cipher_params)
|
||||
if cipher_params:
|
||||
raise TypeError("Unknown keywords: " + str(cipher_params))
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = _raw_ocb_lib.OCB_start_operation(raw_cipher.get(),
|
||||
offset_0,
|
||||
c_size_t(len(offset_0)),
|
||||
self._state.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %d while instantiating the OCB mode"
|
||||
% result)
|
||||
|
||||
# Ensure that object disposal of this Python object will (eventually)
|
||||
# free the memory allocated by the raw library for the cipher mode
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
_raw_ocb_lib.OCB_stop_operation)
|
||||
|
||||
# Memory allocated for the underlying block cipher is now owed
|
||||
# by the cipher mode
|
||||
raw_cipher.release()
|
||||
|
||||
def _update(self, assoc_data, assoc_data_len):
|
||||
result = _raw_ocb_lib.OCB_update(self._state.get(),
|
||||
c_uint8_ptr(assoc_data),
|
||||
c_size_t(assoc_data_len))
|
||||
if result:
|
||||
raise ValueError("Error %d while computing MAC in OCB mode" % result)
|
||||
|
||||
def update(self, assoc_data):
|
||||
"""Process the associated data.
|
||||
|
||||
If there is any associated data, the caller has to invoke
|
||||
this method one or more times, before using
|
||||
``decrypt`` or ``encrypt``.
|
||||
|
||||
By *associated data* it is meant any data (e.g. packet headers) that
|
||||
will not be encrypted and will be transmitted in the clear.
|
||||
However, the receiver shall still able to detect modifications.
|
||||
|
||||
If there is no associated data, this method must not be called.
|
||||
|
||||
The caller may split associated data in segments of any size, and
|
||||
invoke this method multiple times, each time with the next segment.
|
||||
|
||||
:Parameters:
|
||||
assoc_data : bytes/bytearray/memoryview
|
||||
A piece of associated data.
|
||||
"""
|
||||
|
||||
if self.update not in self._next:
|
||||
raise TypeError("update() can only be called"
|
||||
" immediately after initialization")
|
||||
|
||||
self._next = [self.encrypt, self.decrypt, self.digest,
|
||||
self.verify, self.update]
|
||||
|
||||
if len(self._cache_A) > 0:
|
||||
filler = min(16 - len(self._cache_A), len(assoc_data))
|
||||
self._cache_A += _copy_bytes(None, filler, assoc_data)
|
||||
assoc_data = assoc_data[filler:]
|
||||
|
||||
if len(self._cache_A) < 16:
|
||||
return self
|
||||
|
||||
# Clear the cache, and proceeding with any other aligned data
|
||||
self._cache_A, seg = b"", self._cache_A
|
||||
self.update(seg)
|
||||
|
||||
update_len = len(assoc_data) // 16 * 16
|
||||
self._cache_A = _copy_bytes(update_len, None, assoc_data)
|
||||
self._update(assoc_data, update_len)
|
||||
return self
|
||||
|
||||
def _transcrypt_aligned(self, in_data, in_data_len,
|
||||
trans_func, trans_desc):
|
||||
|
||||
out_data = create_string_buffer(in_data_len)
|
||||
result = trans_func(self._state.get(),
|
||||
in_data,
|
||||
out_data,
|
||||
c_size_t(in_data_len))
|
||||
if result:
|
||||
raise ValueError("Error %d while %sing in OCB mode"
|
||||
% (result, trans_desc))
|
||||
return get_raw_buffer(out_data)
|
||||
|
||||
def _transcrypt(self, in_data, trans_func, trans_desc):
|
||||
# Last piece to encrypt/decrypt
|
||||
if in_data is None:
|
||||
out_data = self._transcrypt_aligned(self._cache_P,
|
||||
len(self._cache_P),
|
||||
trans_func,
|
||||
trans_desc)
|
||||
self._cache_P = b""
|
||||
return out_data
|
||||
|
||||
# Try to fill up the cache, if it already contains something
|
||||
prefix = b""
|
||||
if len(self._cache_P) > 0:
|
||||
filler = min(16 - len(self._cache_P), len(in_data))
|
||||
self._cache_P += _copy_bytes(None, filler, in_data)
|
||||
in_data = in_data[filler:]
|
||||
|
||||
if len(self._cache_P) < 16:
|
||||
# We could not manage to fill the cache, so there is certainly
|
||||
# no output yet.
|
||||
return b""
|
||||
|
||||
# Clear the cache, and proceeding with any other aligned data
|
||||
prefix = self._transcrypt_aligned(self._cache_P,
|
||||
len(self._cache_P),
|
||||
trans_func,
|
||||
trans_desc)
|
||||
self._cache_P = b""
|
||||
|
||||
# Process data in multiples of the block size
|
||||
trans_len = len(in_data) // 16 * 16
|
||||
result = self._transcrypt_aligned(c_uint8_ptr(in_data),
|
||||
trans_len,
|
||||
trans_func,
|
||||
trans_desc)
|
||||
if prefix:
|
||||
result = prefix + result
|
||||
|
||||
# Left-over
|
||||
self._cache_P = _copy_bytes(trans_len, None, in_data)
|
||||
|
||||
return result
|
||||
|
||||
def encrypt(self, plaintext=None):
|
||||
"""Encrypt the next piece of plaintext.
|
||||
|
||||
After the entire plaintext has been passed (but before `digest`),
|
||||
you **must** call this method one last time with no arguments to collect
|
||||
the final piece of ciphertext.
|
||||
|
||||
If possible, use the method `encrypt_and_digest` instead.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The next piece of data to encrypt or ``None`` to signify
|
||||
that encryption has finished and that any remaining ciphertext
|
||||
has to be produced.
|
||||
:Return:
|
||||
the ciphertext, as a byte string.
|
||||
Its length may not match the length of the *plaintext*.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() can only be called after"
|
||||
" initialization or an update()")
|
||||
|
||||
if plaintext is None:
|
||||
self._next = [self.digest]
|
||||
else:
|
||||
self._next = [self.encrypt]
|
||||
return self._transcrypt(plaintext, _raw_ocb_lib.OCB_encrypt, "encrypt")
|
||||
|
||||
def decrypt(self, ciphertext=None):
|
||||
"""Decrypt the next piece of ciphertext.
|
||||
|
||||
After the entire ciphertext has been passed (but before `verify`),
|
||||
you **must** call this method one last time with no arguments to collect
|
||||
the remaining piece of plaintext.
|
||||
|
||||
If possible, use the method `decrypt_and_verify` instead.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The next piece of data to decrypt or ``None`` to signify
|
||||
that decryption has finished and that any remaining plaintext
|
||||
has to be produced.
|
||||
:Return:
|
||||
the plaintext, as a byte string.
|
||||
Its length may not match the length of the *ciphertext*.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() can only be called after"
|
||||
" initialization or an update()")
|
||||
|
||||
if ciphertext is None:
|
||||
self._next = [self.verify]
|
||||
else:
|
||||
self._next = [self.decrypt]
|
||||
return self._transcrypt(ciphertext,
|
||||
_raw_ocb_lib.OCB_decrypt,
|
||||
"decrypt")
|
||||
|
||||
def _compute_mac_tag(self):
|
||||
|
||||
if self._mac_tag is not None:
|
||||
return
|
||||
|
||||
if self._cache_A:
|
||||
self._update(self._cache_A, len(self._cache_A))
|
||||
self._cache_A = b""
|
||||
|
||||
mac_tag = create_string_buffer(16)
|
||||
result = _raw_ocb_lib.OCB_digest(self._state.get(),
|
||||
mac_tag,
|
||||
c_size_t(len(mac_tag))
|
||||
)
|
||||
if result:
|
||||
raise ValueError("Error %d while computing digest in OCB mode"
|
||||
% result)
|
||||
self._mac_tag = get_raw_buffer(mac_tag)[:self._mac_len]
|
||||
|
||||
def digest(self):
|
||||
"""Compute the *binary* MAC tag.
|
||||
|
||||
Call this method after the final `encrypt` (the one with no arguments)
|
||||
to obtain the MAC tag.
|
||||
|
||||
The MAC tag is needed by the receiver to determine authenticity
|
||||
of the message.
|
||||
|
||||
:Return: the MAC, as a byte string.
|
||||
"""
|
||||
|
||||
if self.digest not in self._next:
|
||||
raise TypeError("digest() cannot be called now for this cipher")
|
||||
|
||||
assert(len(self._cache_P) == 0)
|
||||
|
||||
self._next = [self.digest]
|
||||
|
||||
if self._mac_tag is None:
|
||||
self._compute_mac_tag()
|
||||
|
||||
return self._mac_tag
|
||||
|
||||
def hexdigest(self):
|
||||
"""Compute the *printable* MAC tag.
|
||||
|
||||
This method is like `digest`.
|
||||
|
||||
:Return: the MAC, as a hexadecimal string.
|
||||
"""
|
||||
return "".join(["%02x" % bord(x) for x in self.digest()])
|
||||
|
||||
def verify(self, received_mac_tag):
|
||||
"""Validate the *binary* MAC tag.
|
||||
|
||||
Call this method after the final `decrypt` (the one with no arguments)
|
||||
to check if the message is authentic and valid.
|
||||
|
||||
:Parameters:
|
||||
received_mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
if self.verify not in self._next:
|
||||
raise TypeError("verify() cannot be called now for this cipher")
|
||||
|
||||
assert(len(self._cache_P) == 0)
|
||||
|
||||
self._next = [self.verify]
|
||||
|
||||
if self._mac_tag is None:
|
||||
self._compute_mac_tag()
|
||||
|
||||
secret = get_random_bytes(16)
|
||||
mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=self._mac_tag)
|
||||
mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=received_mac_tag)
|
||||
|
||||
if mac1.digest() != mac2.digest():
|
||||
raise ValueError("MAC check failed")
|
||||
|
||||
def hexverify(self, hex_mac_tag):
|
||||
"""Validate the *printable* MAC tag.
|
||||
|
||||
This method is like `verify`.
|
||||
|
||||
:Parameters:
|
||||
hex_mac_tag : string
|
||||
This is the *printable* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
self.verify(unhexlify(hex_mac_tag))
|
||||
|
||||
def encrypt_and_digest(self, plaintext):
|
||||
"""Encrypt the message and create the MAC tag in one step.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The entire message to encrypt.
|
||||
:Return:
|
||||
a tuple with two byte strings:
|
||||
|
||||
- the encrypted data
|
||||
- the MAC
|
||||
"""
|
||||
|
||||
return self.encrypt(plaintext) + self.encrypt(), self.digest()
|
||||
|
||||
def decrypt_and_verify(self, ciphertext, received_mac_tag):
|
||||
"""Decrypted the message and verify its authenticity in one step.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The entire message to decrypt.
|
||||
received_mac_tag : byte string
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
|
||||
:Return: the decrypted data (byte string).
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
plaintext = self.decrypt(ciphertext) + self.decrypt()
|
||||
self.verify(received_mac_tag)
|
||||
return plaintext
|
||||
|
||||
|
||||
def _create_ocb_cipher(factory, **kwargs):
|
||||
"""Create a new block cipher, configured in OCB mode.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
A symmetric cipher module from `Cryptodome.Cipher`
|
||||
(like `Cryptodome.Cipher.AES`).
|
||||
|
||||
:Keywords:
|
||||
nonce : bytes/bytearray/memoryview
|
||||
A value that must never be reused for any other encryption.
|
||||
Its length can vary from 1 to 15 bytes.
|
||||
If not specified, a random 15 bytes long nonce is generated.
|
||||
|
||||
mac_len : integer
|
||||
Length of the MAC, in bytes.
|
||||
It must be in the range ``[8..16]``.
|
||||
The default is 16 (128 bits).
|
||||
|
||||
Any other keyword will be passed to the underlying block cipher.
|
||||
See the relevant documentation for details (at least ``key`` will need
|
||||
to be present).
|
||||
"""
|
||||
|
||||
try:
|
||||
nonce = kwargs.pop("nonce", None)
|
||||
if nonce is None:
|
||||
nonce = get_random_bytes(15)
|
||||
mac_len = kwargs.pop("mac_len", 16)
|
||||
except KeyError as e:
|
||||
raise TypeError("Keyword missing: " + str(e))
|
||||
|
||||
return OcbMode(factory, nonce, mac_len, kwargs)
|
||||
Binary file not shown.
@ -0,0 +1,36 @@
|
||||
from types import ModuleType
|
||||
from typing import Union, Any, Optional, Tuple, Dict, overload
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
class OcbMode(object):
|
||||
block_size: int
|
||||
nonce: Buffer
|
||||
|
||||
def __init__(self,
|
||||
factory: ModuleType,
|
||||
nonce: Buffer,
|
||||
mac_len: int,
|
||||
cipher_params: Dict) -> None: ...
|
||||
|
||||
def update(self, assoc_data: Buffer) -> OcbMode: ...
|
||||
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
def digest(self) -> bytes: ...
|
||||
def hexdigest(self) -> str: ...
|
||||
def verify(self, received_mac_tag: Buffer) -> None: ...
|
||||
def hexverify(self, hex_mac_tag: str) -> None: ...
|
||||
|
||||
def encrypt_and_digest(self,
|
||||
plaintext: Buffer) -> Tuple[bytes, bytes]: ...
|
||||
def decrypt_and_verify(self,
|
||||
ciphertext: Buffer,
|
||||
received_mac_tag: Buffer) -> bytes: ...
|
||||
@ -0,0 +1,282 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Cipher/mode_ofb.py : OFB mode
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Output Feedback (CFB) mode.
|
||||
"""
|
||||
|
||||
__all__ = ['OfbMode']
|
||||
|
||||
from Cryptodome.Util.py3compat import _copy_bytes
|
||||
from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, VoidPointer,
|
||||
create_string_buffer, get_raw_buffer,
|
||||
SmartPointer, c_size_t, c_uint8_ptr,
|
||||
is_writeable_buffer)
|
||||
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
raw_ofb_lib = load_pycryptodome_raw_lib("Cryptodome.Cipher._raw_ofb", """
|
||||
int OFB_start_operation(void *cipher,
|
||||
const uint8_t iv[],
|
||||
size_t iv_len,
|
||||
void **pResult);
|
||||
int OFB_encrypt(void *ofbState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int OFB_decrypt(void *ofbState,
|
||||
const uint8_t *in,
|
||||
uint8_t *out,
|
||||
size_t data_len);
|
||||
int OFB_stop_operation(void *state);
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
class OfbMode(object):
|
||||
"""*Output FeedBack (OFB)*.
|
||||
|
||||
This mode is very similar to CBC, but it
|
||||
transforms the underlying block cipher into a stream cipher.
|
||||
|
||||
The keystream is the iterated block encryption of the
|
||||
previous ciphertext block.
|
||||
|
||||
An Initialization Vector (*IV*) is required.
|
||||
|
||||
See `NIST SP800-38A`_ , Section 6.4.
|
||||
|
||||
.. _`NIST SP800-38A` : http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, block_cipher, iv):
|
||||
"""Create a new block cipher, configured in OFB mode.
|
||||
|
||||
:Parameters:
|
||||
block_cipher : C pointer
|
||||
A smart pointer to the low-level block cipher instance.
|
||||
|
||||
iv : bytes/bytearray/memoryview
|
||||
The initialization vector to use for encryption or decryption.
|
||||
It is as long as the cipher block.
|
||||
|
||||
**The IV must be a nonce, to to be reused for any other
|
||||
message**. It shall be a nonce or a random value.
|
||||
|
||||
Reusing the *IV* for encryptions performed with the same key
|
||||
compromises confidentiality.
|
||||
"""
|
||||
|
||||
self._state = VoidPointer()
|
||||
result = raw_ofb_lib.OFB_start_operation(block_cipher.get(),
|
||||
c_uint8_ptr(iv),
|
||||
c_size_t(len(iv)),
|
||||
self._state.address_of())
|
||||
if result:
|
||||
raise ValueError("Error %d while instantiating the OFB mode"
|
||||
% result)
|
||||
|
||||
# Ensure that object disposal of this Python object will (eventually)
|
||||
# free the memory allocated by the raw library for the cipher mode
|
||||
self._state = SmartPointer(self._state.get(),
|
||||
raw_ofb_lib.OFB_stop_operation)
|
||||
|
||||
# Memory allocated for the underlying block cipher is now owed
|
||||
# by the cipher mode
|
||||
block_cipher.release()
|
||||
|
||||
self.block_size = len(iv)
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self.iv = _copy_bytes(None, None, iv)
|
||||
"""The Initialization Vector originally used to create the object.
|
||||
The value does not change."""
|
||||
|
||||
self.IV = self.iv
|
||||
"""Alias for `iv`"""
|
||||
|
||||
self._next = [ self.encrypt, self.decrypt ]
|
||||
|
||||
def encrypt(self, plaintext, output=None):
|
||||
"""Encrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the ciphertext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() cannot be called after decrypt()")
|
||||
self._next = [ self.encrypt ]
|
||||
|
||||
if output is None:
|
||||
ciphertext = create_string_buffer(len(plaintext))
|
||||
else:
|
||||
ciphertext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(plaintext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_ofb_lib.OFB_encrypt(self._state.get(),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_size_t(len(plaintext)))
|
||||
if result:
|
||||
raise ValueError("Error %d while encrypting in OFB mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(ciphertext)
|
||||
else:
|
||||
return None
|
||||
|
||||
def decrypt(self, ciphertext, output=None):
|
||||
"""Decrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
It can be of any length.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext is written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return:
|
||||
If ``output`` is ``None``, the plaintext is returned as ``bytes``.
|
||||
Otherwise, ``None``.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() cannot be called after encrypt()")
|
||||
self._next = [ self.decrypt ]
|
||||
|
||||
if output is None:
|
||||
plaintext = create_string_buffer(len(ciphertext))
|
||||
else:
|
||||
plaintext = output
|
||||
|
||||
if not is_writeable_buffer(output):
|
||||
raise TypeError("output must be a bytearray or a writeable memoryview")
|
||||
|
||||
if len(ciphertext) != len(output):
|
||||
raise ValueError("output must have the same length as the input"
|
||||
" (%d bytes)" % len(plaintext))
|
||||
|
||||
result = raw_ofb_lib.OFB_decrypt(self._state.get(),
|
||||
c_uint8_ptr(ciphertext),
|
||||
c_uint8_ptr(plaintext),
|
||||
c_size_t(len(ciphertext)))
|
||||
if result:
|
||||
raise ValueError("Error %d while decrypting in OFB mode" % result)
|
||||
|
||||
if output is None:
|
||||
return get_raw_buffer(plaintext)
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def _create_ofb_cipher(factory, **kwargs):
|
||||
"""Instantiate a cipher object that performs OFB encryption/decryption.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
The underlying block cipher, a module from ``Cryptodome.Cipher``.
|
||||
|
||||
:Keywords:
|
||||
iv : bytes/bytearray/memoryview
|
||||
The IV to use for OFB.
|
||||
|
||||
IV : bytes/bytearray/memoryview
|
||||
Alias for ``iv``.
|
||||
|
||||
Any other keyword will be passed to the underlying block cipher.
|
||||
See the relevant documentation for details (at least ``key`` will need
|
||||
to be present).
|
||||
"""
|
||||
|
||||
cipher_state = factory._create_base_cipher(kwargs)
|
||||
iv = kwargs.pop("IV", None)
|
||||
IV = kwargs.pop("iv", None)
|
||||
|
||||
if (None, None) == (iv, IV):
|
||||
iv = get_random_bytes(factory.block_size)
|
||||
if iv is not None:
|
||||
if IV is not None:
|
||||
raise TypeError("You must either use 'iv' or 'IV', not both")
|
||||
else:
|
||||
iv = IV
|
||||
|
||||
if len(iv) != factory.block_size:
|
||||
raise ValueError("Incorrect IV length (it must be %d bytes long)" %
|
||||
factory.block_size)
|
||||
|
||||
if kwargs:
|
||||
raise TypeError("Unknown parameters for OFB: %s" % str(kwargs))
|
||||
|
||||
return OfbMode(cipher_state, iv)
|
||||
Binary file not shown.
@ -0,0 +1,25 @@
|
||||
from typing import Union, overload
|
||||
|
||||
from Cryptodome.Util._raw_api import SmartPointer
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = ['OfbMode']
|
||||
|
||||
class OfbMode(object):
|
||||
block_size: int
|
||||
iv: Buffer
|
||||
IV: Buffer
|
||||
|
||||
def __init__(self,
|
||||
block_cipher: SmartPointer,
|
||||
iv: Buffer) -> None: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def encrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
@overload
|
||||
def decrypt(self, plaintext: Buffer, output: Union[bytearray, memoryview]) -> None: ...
|
||||
|
||||
@ -0,0 +1,206 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
OpenPGP mode.
|
||||
"""
|
||||
|
||||
__all__ = ['OpenPgpMode']
|
||||
|
||||
from Cryptodome.Util.py3compat import _copy_bytes
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
class OpenPgpMode(object):
|
||||
"""OpenPGP mode.
|
||||
|
||||
This mode is a variant of CFB, and it is only used in PGP and
|
||||
OpenPGP_ applications. If in doubt, use another mode.
|
||||
|
||||
An Initialization Vector (*IV*) is required.
|
||||
|
||||
Unlike CFB, the *encrypted* IV (not the IV itself) is
|
||||
transmitted to the receiver.
|
||||
|
||||
The IV is a random data block. For legacy reasons, two of its bytes are
|
||||
duplicated to act as a checksum for the correctness of the key, which is now
|
||||
known to be insecure and is ignored. The encrypted IV is therefore 2 bytes
|
||||
longer than the clean IV.
|
||||
|
||||
.. _OpenPGP: http://tools.ietf.org/html/rfc4880
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, factory, key, iv, cipher_params):
|
||||
|
||||
#: The block size of the underlying cipher, in bytes.
|
||||
self.block_size = factory.block_size
|
||||
|
||||
self._done_first_block = False # True after the first encryption
|
||||
|
||||
# Instantiate a temporary cipher to process the IV
|
||||
IV_cipher = factory.new(
|
||||
key,
|
||||
factory.MODE_CFB,
|
||||
IV=b'\x00' * self.block_size,
|
||||
segment_size=self.block_size * 8,
|
||||
**cipher_params)
|
||||
|
||||
iv = _copy_bytes(None, None, iv)
|
||||
|
||||
# The cipher will be used for...
|
||||
if len(iv) == self.block_size:
|
||||
# ... encryption
|
||||
self._encrypted_IV = IV_cipher.encrypt(iv + iv[-2:])
|
||||
elif len(iv) == self.block_size + 2:
|
||||
# ... decryption
|
||||
self._encrypted_IV = iv
|
||||
# Last two bytes are for a deprecated "quick check" feature that
|
||||
# should not be used. (https://eprint.iacr.org/2005/033)
|
||||
iv = IV_cipher.decrypt(iv)[:-2]
|
||||
else:
|
||||
raise ValueError("Length of IV must be %d or %d bytes"
|
||||
" for MODE_OPENPGP"
|
||||
% (self.block_size, self.block_size + 2))
|
||||
|
||||
self.iv = self.IV = iv
|
||||
|
||||
# Instantiate the cipher for the real PGP data
|
||||
self._cipher = factory.new(
|
||||
key,
|
||||
factory.MODE_CFB,
|
||||
IV=self._encrypted_IV[-self.block_size:],
|
||||
segment_size=self.block_size * 8,
|
||||
**cipher_params)
|
||||
|
||||
def encrypt(self, plaintext):
|
||||
"""Encrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have encrypted a message
|
||||
you cannot encrypt (or decrypt) another message using the same
|
||||
object.
|
||||
|
||||
The data to encrypt can be broken up in two or
|
||||
more pieces and `encrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.encrypt(a) + c.encrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.encrypt(a+b)
|
||||
|
||||
This function does not add any padding to the plaintext.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
|
||||
:Return:
|
||||
the encrypted data, as a byte string.
|
||||
It is as long as *plaintext* with one exception:
|
||||
when encrypting the first message chunk,
|
||||
the encypted IV is prepended to the returned ciphertext.
|
||||
"""
|
||||
|
||||
res = self._cipher.encrypt(plaintext)
|
||||
if not self._done_first_block:
|
||||
res = self._encrypted_IV + res
|
||||
self._done_first_block = True
|
||||
return res
|
||||
|
||||
def decrypt(self, ciphertext):
|
||||
"""Decrypt data with the key and the parameters set at initialization.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
The data to decrypt can be broken up in two or
|
||||
more pieces and `decrypt` can be called multiple times.
|
||||
|
||||
That is, the statement:
|
||||
|
||||
>>> c.decrypt(a) + c.decrypt(b)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
>>> c.decrypt(a+b)
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
|
||||
:Return: the decrypted data (byte string).
|
||||
"""
|
||||
|
||||
return self._cipher.decrypt(ciphertext)
|
||||
|
||||
|
||||
def _create_openpgp_cipher(factory, **kwargs):
|
||||
"""Create a new block cipher, configured in OpenPGP mode.
|
||||
|
||||
:Parameters:
|
||||
factory : module
|
||||
The module.
|
||||
|
||||
:Keywords:
|
||||
key : bytes/bytearray/memoryview
|
||||
The secret key to use in the symmetric cipher.
|
||||
|
||||
IV : bytes/bytearray/memoryview
|
||||
The initialization vector to use for encryption or decryption.
|
||||
|
||||
For encryption, the IV must be as long as the cipher block size.
|
||||
|
||||
For decryption, it must be 2 bytes longer (it is actually the
|
||||
*encrypted* IV which was prefixed to the ciphertext).
|
||||
"""
|
||||
|
||||
iv = kwargs.pop("IV", None)
|
||||
IV = kwargs.pop("iv", None)
|
||||
|
||||
if (None, None) == (iv, IV):
|
||||
iv = get_random_bytes(factory.block_size)
|
||||
if iv is not None:
|
||||
if IV is not None:
|
||||
raise TypeError("You must either use 'iv' or 'IV', not both")
|
||||
else:
|
||||
iv = IV
|
||||
|
||||
try:
|
||||
key = kwargs.pop("key")
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing component: " + str(e))
|
||||
|
||||
return OpenPgpMode(factory, key, iv, kwargs)
|
||||
Binary file not shown.
@ -0,0 +1,20 @@
|
||||
from types import ModuleType
|
||||
from typing import Union, Dict
|
||||
|
||||
Buffer = Union[bytes, bytearray, memoryview]
|
||||
|
||||
__all__ = ['OpenPgpMode']
|
||||
|
||||
class OpenPgpMode(object):
|
||||
block_size: int
|
||||
iv: Union[bytes, bytearray, memoryview]
|
||||
IV: Union[bytes, bytearray, memoryview]
|
||||
|
||||
def __init__(self,
|
||||
factory: ModuleType,
|
||||
key: Buffer,
|
||||
iv: Buffer,
|
||||
cipher_params: Dict) -> None: ...
|
||||
def encrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
def decrypt(self, plaintext: Buffer) -> bytes: ...
|
||||
|
||||
@ -0,0 +1,392 @@
|
||||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Synthetic Initialization Vector (SIV) mode.
|
||||
"""
|
||||
|
||||
__all__ = ['SivMode']
|
||||
|
||||
from binascii import hexlify, unhexlify
|
||||
|
||||
from Cryptodome.Util.py3compat import bord, _copy_bytes
|
||||
|
||||
from Cryptodome.Util._raw_api import is_buffer
|
||||
|
||||
from Cryptodome.Util.number import long_to_bytes, bytes_to_long
|
||||
from Cryptodome.Protocol.KDF import _S2V
|
||||
from Cryptodome.Hash import BLAKE2s
|
||||
from Cryptodome.Random import get_random_bytes
|
||||
|
||||
|
||||
class SivMode(object):
|
||||
"""Synthetic Initialization Vector (SIV).
|
||||
|
||||
This is an Authenticated Encryption with Associated Data (`AEAD`_) mode.
|
||||
It provides both confidentiality and authenticity.
|
||||
|
||||
The header of the message may be left in the clear, if needed, and it will
|
||||
still be subject to authentication. The decryption step tells the receiver
|
||||
if the message comes from a source that really knowns the secret key.
|
||||
Additionally, decryption detects if any part of the message - including the
|
||||
header - has been modified or corrupted.
|
||||
|
||||
Unlike other AEAD modes such as CCM, EAX or GCM, accidental reuse of a
|
||||
nonce is not catastrophic for the confidentiality of the message. The only
|
||||
effect is that an attacker can tell when the same plaintext (and same
|
||||
associated data) is protected with the same key.
|
||||
|
||||
The length of the MAC is fixed to the block size of the underlying cipher.
|
||||
The key size is twice the length of the key of the underlying cipher.
|
||||
|
||||
This mode is only available for AES ciphers.
|
||||
|
||||
+--------------------+---------------+-------------------+
|
||||
| Cipher | SIV MAC size | SIV key length |
|
||||
| | (bytes) | (bytes) |
|
||||
+====================+===============+===================+
|
||||
| AES-128 | 16 | 32 |
|
||||
+--------------------+---------------+-------------------+
|
||||
| AES-192 | 16 | 48 |
|
||||
+--------------------+---------------+-------------------+
|
||||
| AES-256 | 16 | 64 |
|
||||
+--------------------+---------------+-------------------+
|
||||
|
||||
See `RFC5297`_ and the `original paper`__.
|
||||
|
||||
.. _RFC5297: https://tools.ietf.org/html/rfc5297
|
||||
.. _AEAD: http://blog.cryptographyengineering.com/2012/05/how-to-choose-authenticated-encryption.html
|
||||
.. __: http://www.cs.ucdavis.edu/~rogaway/papers/keywrap.pdf
|
||||
|
||||
:undocumented: __init__
|
||||
"""
|
||||
|
||||
def __init__(self, factory, key, nonce, kwargs):
|
||||
|
||||
self.block_size = factory.block_size
|
||||
"""The block size of the underlying cipher, in bytes."""
|
||||
|
||||
self._factory = factory
|
||||
|
||||
self._cipher_params = kwargs
|
||||
|
||||
if len(key) not in (32, 48, 64):
|
||||
raise ValueError("Incorrect key length (%d bytes)" % len(key))
|
||||
|
||||
if nonce is not None:
|
||||
if not is_buffer(nonce):
|
||||
raise TypeError("When provided, the nonce must be bytes, bytearray or memoryview")
|
||||
|
||||
if len(nonce) == 0:
|
||||
raise ValueError("When provided, the nonce must be non-empty")
|
||||
|
||||
self.nonce = _copy_bytes(None, None, nonce)
|
||||
"""Public attribute is only available in case of non-deterministic
|
||||
encryption."""
|
||||
|
||||
subkey_size = len(key) // 2
|
||||
|
||||
self._mac_tag = None # Cache for MAC tag
|
||||
self._kdf = _S2V(key[:subkey_size],
|
||||
ciphermod=factory,
|
||||
cipher_params=self._cipher_params)
|
||||
self._subkey_cipher = key[subkey_size:]
|
||||
|
||||
# Purely for the purpose of verifying that cipher_params are OK
|
||||
factory.new(key[:subkey_size], factory.MODE_ECB, **kwargs)
|
||||
|
||||
# Allowed transitions after initialization
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
def _create_ctr_cipher(self, v):
|
||||
"""Create a new CTR cipher from V in SIV mode"""
|
||||
|
||||
v_int = bytes_to_long(v)
|
||||
q = v_int & 0xFFFFFFFFFFFFFFFF7FFFFFFF7FFFFFFF
|
||||
return self._factory.new(
|
||||
self._subkey_cipher,
|
||||
self._factory.MODE_CTR,
|
||||
initial_value=q,
|
||||
nonce=b"",
|
||||
**self._cipher_params)
|
||||
|
||||
def update(self, component):
|
||||
"""Protect one associated data component
|
||||
|
||||
For SIV, the associated data is a sequence (*vector*) of non-empty
|
||||
byte strings (*components*).
|
||||
|
||||
This method consumes the next component. It must be called
|
||||
once for each of the components that constitue the associated data.
|
||||
|
||||
Note that the components have clear boundaries, so that:
|
||||
|
||||
>>> cipher.update(b"builtin")
|
||||
>>> cipher.update(b"securely")
|
||||
|
||||
is not equivalent to:
|
||||
|
||||
>>> cipher.update(b"built")
|
||||
>>> cipher.update(b"insecurely")
|
||||
|
||||
If there is no associated data, this method must not be called.
|
||||
|
||||
:Parameters:
|
||||
component : bytes/bytearray/memoryview
|
||||
The next associated data component.
|
||||
"""
|
||||
|
||||
if self.update not in self._next:
|
||||
raise TypeError("update() can only be called"
|
||||
" immediately after initialization")
|
||||
|
||||
self._next = [self.update, self.encrypt, self.decrypt,
|
||||
self.digest, self.verify]
|
||||
|
||||
return self._kdf.update(component)
|
||||
|
||||
def encrypt(self, plaintext):
|
||||
"""
|
||||
For SIV, encryption and MAC authentication must take place at the same
|
||||
point. This method shall not be used.
|
||||
|
||||
Use `encrypt_and_digest` instead.
|
||||
"""
|
||||
|
||||
raise TypeError("encrypt() not allowed for SIV mode."
|
||||
" Use encrypt_and_digest() instead.")
|
||||
|
||||
def decrypt(self, ciphertext):
|
||||
"""
|
||||
For SIV, decryption and verification must take place at the same
|
||||
point. This method shall not be used.
|
||||
|
||||
Use `decrypt_and_verify` instead.
|
||||
"""
|
||||
|
||||
raise TypeError("decrypt() not allowed for SIV mode."
|
||||
" Use decrypt_and_verify() instead.")
|
||||
|
||||
def digest(self):
|
||||
"""Compute the *binary* MAC tag.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method returns the MAC that shall be sent to the receiver,
|
||||
together with the ciphertext.
|
||||
|
||||
:Return: the MAC, as a byte string.
|
||||
"""
|
||||
|
||||
if self.digest not in self._next:
|
||||
raise TypeError("digest() cannot be called when decrypting"
|
||||
" or validating a message")
|
||||
self._next = [self.digest]
|
||||
if self._mac_tag is None:
|
||||
self._mac_tag = self._kdf.derive()
|
||||
return self._mac_tag
|
||||
|
||||
def hexdigest(self):
|
||||
"""Compute the *printable* MAC tag.
|
||||
|
||||
This method is like `digest`.
|
||||
|
||||
:Return: the MAC, as a hexadecimal string.
|
||||
"""
|
||||
return "".join(["%02x" % bord(x) for x in self.digest()])
|
||||
|
||||
def verify(self, received_mac_tag):
|
||||
"""Validate the *binary* MAC tag.
|
||||
|
||||
The caller invokes this function at the very end.
|
||||
|
||||
This method checks if the decrypted message is indeed valid
|
||||
(that is, if the key is correct) and it has not been
|
||||
tampered with while in transit.
|
||||
|
||||
:Parameters:
|
||||
received_mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
if self.verify not in self._next:
|
||||
raise TypeError("verify() cannot be called"
|
||||
" when encrypting a message")
|
||||
self._next = [self.verify]
|
||||
|
||||
if self._mac_tag is None:
|
||||
self._mac_tag = self._kdf.derive()
|
||||
|
||||
secret = get_random_bytes(16)
|
||||
|
||||
mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=self._mac_tag)
|
||||
mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=received_mac_tag)
|
||||
|
||||
if mac1.digest() != mac2.digest():
|
||||
raise ValueError("MAC check failed")
|
||||
|
||||
def hexverify(self, hex_mac_tag):
|
||||
"""Validate the *printable* MAC tag.
|
||||
|
||||
This method is like `verify`.
|
||||
|
||||
:Parameters:
|
||||
hex_mac_tag : string
|
||||
This is the *printable* MAC, as received from the sender.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
self.verify(unhexlify(hex_mac_tag))
|
||||
|
||||
def encrypt_and_digest(self, plaintext, output=None):
|
||||
"""Perform encrypt() and digest() in one step.
|
||||
|
||||
:Parameters:
|
||||
plaintext : bytes/bytearray/memoryview
|
||||
The piece of data to encrypt.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the ciphertext must be written to.
|
||||
If ``None``, the ciphertext is returned.
|
||||
:Return:
|
||||
a tuple with two items:
|
||||
|
||||
- the ciphertext, as ``bytes``
|
||||
- the MAC tag, as ``bytes``
|
||||
|
||||
The first item becomes ``None`` when the ``output`` parameter
|
||||
specified a location for the result.
|
||||
"""
|
||||
|
||||
if self.encrypt not in self._next:
|
||||
raise TypeError("encrypt() can only be called after"
|
||||
" initialization or an update()")
|
||||
|
||||
self._next = [ self.digest ]
|
||||
|
||||
# Compute V (MAC)
|
||||
if hasattr(self, 'nonce'):
|
||||
self._kdf.update(self.nonce)
|
||||
self._kdf.update(plaintext)
|
||||
self._mac_tag = self._kdf.derive()
|
||||
|
||||
cipher = self._create_ctr_cipher(self._mac_tag)
|
||||
|
||||
return cipher.encrypt(plaintext, output=output), self._mac_tag
|
||||
|
||||
def decrypt_and_verify(self, ciphertext, mac_tag, output=None):
|
||||
"""Perform decryption and verification in one step.
|
||||
|
||||
A cipher object is stateful: once you have decrypted a message
|
||||
you cannot decrypt (or encrypt) another message with the same
|
||||
object.
|
||||
|
||||
You cannot reuse an object for encrypting
|
||||
or decrypting other data with the same key.
|
||||
|
||||
This function does not remove any padding from the plaintext.
|
||||
|
||||
:Parameters:
|
||||
ciphertext : bytes/bytearray/memoryview
|
||||
The piece of data to decrypt.
|
||||
It can be of any length.
|
||||
mac_tag : bytes/bytearray/memoryview
|
||||
This is the *binary* MAC, as received from the sender.
|
||||
:Keywords:
|
||||
output : bytearray/memoryview
|
||||
The location where the plaintext must be written to.
|
||||
If ``None``, the plaintext is returned.
|
||||
:Return: the plaintext as ``bytes`` or ``None`` when the ``output``
|
||||
parameter specified a location for the result.
|
||||
:Raises ValueError:
|
||||
if the MAC does not match. The message has been tampered with
|
||||
or the key is incorrect.
|
||||
"""
|
||||
|
||||
if self.decrypt not in self._next:
|
||||
raise TypeError("decrypt() can only be called"
|
||||
" after initialization or an update()")
|
||||
self._next = [ self.verify ]
|
||||
|
||||
# Take the MAC and start the cipher for decryption
|
||||
self._cipher = self._create_ctr_cipher(mac_tag)
|
||||
|
||||
plaintext = self._cipher.decrypt(ciphertext, output=output)
|
||||
|
||||
if hasattr(self, 'nonce'):
|
||||
self._kdf.update(self.nonce)
|
||||
self._kdf.update(plaintext if output is None else output)
|
||||
self.verify(mac_tag)
|
||||
|
||||
return plaintext
|
||||
|
||||
|
||||
def _create_siv_cipher(factory, **kwargs):
|
||||
"""Create a new block cipher, configured in
|
||||
Synthetic Initializaton Vector (SIV) mode.
|
||||
|
||||
:Parameters:
|
||||
|
||||
factory : object
|
||||
A symmetric cipher module from `Cryptodome.Cipher`
|
||||
(like `Cryptodome.Cipher.AES`).
|
||||
|
||||
:Keywords:
|
||||
|
||||
key : bytes/bytearray/memoryview
|
||||
The secret key to use in the symmetric cipher.
|
||||
It must be 32, 48 or 64 bytes long.
|
||||
If AES is the chosen cipher, the variants *AES-128*,
|
||||
*AES-192* and or *AES-256* will be used internally.
|
||||
|
||||
nonce : bytes/bytearray/memoryview
|
||||
For deterministic encryption, it is not present.
|
||||
|
||||
Otherwise, it is a value that must never be reused
|
||||
for encrypting message under this key.
|
||||
|
||||
There are no restrictions on its length,
|
||||
but it is recommended to use at least 16 bytes.
|
||||
"""
|
||||
|
||||
try:
|
||||
key = kwargs.pop("key")
|
||||
except KeyError as e:
|
||||
raise TypeError("Missing parameter: " + str(e))
|
||||
|
||||
nonce = kwargs.pop("nonce", None)
|
||||
|
||||
return SivMode(factory, key, nonce, kwargs)
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user