From a0de2e62a0970b5bc325334301e5fa182394fb2f Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Wed, 10 May 2023 03:56:04 +0000 Subject: automatic import of python-pygfc --- python-pygfc.spec | 336 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 336 insertions(+) create mode 100644 python-pygfc.spec (limited to 'python-pygfc.spec') diff --git a/python-pygfc.spec b/python-pygfc.spec new file mode 100644 index 0000000..d1e51a9 --- /dev/null +++ b/python-pygfc.spec @@ -0,0 +1,336 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pygfc +Version: 1.0.5 +Release: 1 +Summary: Implementation of a Generalized-Feistel Cipher for generating random permutations. +License: MIT License +URL: https://github.com/maxmouchet/gfc +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/d5/e2/b63e618912123592fd4075121ceb5c087f56212b9f0872b9ec81c3759093/pygfc-1.0.5.tar.gz +BuildArch: noarch + + +%description +# 🎲 gfc — fast & lazy random permutations + +[![PyPI Status](https://img.shields.io/github/workflow/status/maxmouchet/gfc/PyPI?logo=github&label=pypi)](https://github.com/maxmouchet/gfc/actions/workflows/pypi.yml) +[![Tests Status](https://img.shields.io/github/workflow/status/maxmouchet/gfc/Tests?logo=github&label=tests)](https://github.com/maxmouchet/gfc/actions/workflows/tests.yml) +[![PyPI](https://img.shields.io/pypi/v/pygfc?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/pygfc/) + +gfc is a C implementation of a Generalized-Feistel Cipher [[1, alg. 3]](#1) for generating random permutations. +It uses [Speck](https://en.wikipedia.org/wiki/Speck_%28cipher%29) 64/128 as the random function, and can generate permutations with up to `2^64` elements. +The permutation is computed, and reversed, _on-the-fly_, without any mutable state and by using very little memory. + +## Usage + +### C / C++ + +#### API + +```c +#include +GFC* gfc_init(uint64_t range, uint64_t rounds, uint64_t seed); +void gfc_destroy(GFC* gfc); +uint64_t gfc_decrypt(const GFC* gfc, uint64_t m); +uint64_t gfc_encrypt(const GFC* gfc, uint64_t m); +``` + +#### Example + +```c +// main.c +// gcc -Iinclude/ src/gfc.c main.c -o main +#include +#include + +int main() { + GFC* gfc = gfc_init(65536, 6, 42); + + for (uint64_t i = 0; i < 65536; i++) { + uint64_t enc = gfc_encrypt(gfc, i); + uint64_t dec = gfc_decrypt(gfc, enc); + assert(enc != i); + assert(dec == i); + } + + gfc_destroy(gfc); + return 0; +} +``` + +#### CMake Integration + +```cmake +cmake_minimum_required(VERSION 3.12) +project(example) +add_subdirectory(gfc) +add_executable(main main.c) +target_link_libraries(main PRIVATE gfc) +``` + +```bash +git submodule add https://github.com/maxmouchet/gfc.git +mkdir build && cd build +cmake .. && cmake --build . +./main +``` + +### Python + +``` +pip install pygfc +``` + +```python +from pygfc import Permutation +# Permutation(range, rounds, seed) +perm = Permutation(2 ** 16, 8, 42) +assert set(perm) == set(range(2 ** 16)) +assert all(perm.inv(perm[i]) == i for i in range(2 ** 16)) +``` + +## Dependencies + +The Speck implementation is from [madmo/speck](https://github.com/madmo/speck) and is licensed under the ISC license (MIT-compatible). + +## References + +[1] Black, John, and Phillip Rogaway. "Ciphers with arbitrary finite domains." _Cryptographers’ track at the RSA conference_. Springer, Berlin, Heidelberg, 2002. +https://web.cs.ucdavis.edu/~rogaway/papers/subset.pdf + + + + +%package -n python3-pygfc +Summary: Implementation of a Generalized-Feistel Cipher for generating random permutations. +Provides: python-pygfc +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-pygfc +# 🎲 gfc — fast & lazy random permutations + +[![PyPI Status](https://img.shields.io/github/workflow/status/maxmouchet/gfc/PyPI?logo=github&label=pypi)](https://github.com/maxmouchet/gfc/actions/workflows/pypi.yml) +[![Tests Status](https://img.shields.io/github/workflow/status/maxmouchet/gfc/Tests?logo=github&label=tests)](https://github.com/maxmouchet/gfc/actions/workflows/tests.yml) +[![PyPI](https://img.shields.io/pypi/v/pygfc?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/pygfc/) + +gfc is a C implementation of a Generalized-Feistel Cipher [[1, alg. 3]](#1) for generating random permutations. +It uses [Speck](https://en.wikipedia.org/wiki/Speck_%28cipher%29) 64/128 as the random function, and can generate permutations with up to `2^64` elements. +The permutation is computed, and reversed, _on-the-fly_, without any mutable state and by using very little memory. + +## Usage + +### C / C++ + +#### API + +```c +#include +GFC* gfc_init(uint64_t range, uint64_t rounds, uint64_t seed); +void gfc_destroy(GFC* gfc); +uint64_t gfc_decrypt(const GFC* gfc, uint64_t m); +uint64_t gfc_encrypt(const GFC* gfc, uint64_t m); +``` + +#### Example + +```c +// main.c +// gcc -Iinclude/ src/gfc.c main.c -o main +#include +#include + +int main() { + GFC* gfc = gfc_init(65536, 6, 42); + + for (uint64_t i = 0; i < 65536; i++) { + uint64_t enc = gfc_encrypt(gfc, i); + uint64_t dec = gfc_decrypt(gfc, enc); + assert(enc != i); + assert(dec == i); + } + + gfc_destroy(gfc); + return 0; +} +``` + +#### CMake Integration + +```cmake +cmake_minimum_required(VERSION 3.12) +project(example) +add_subdirectory(gfc) +add_executable(main main.c) +target_link_libraries(main PRIVATE gfc) +``` + +```bash +git submodule add https://github.com/maxmouchet/gfc.git +mkdir build && cd build +cmake .. && cmake --build . +./main +``` + +### Python + +``` +pip install pygfc +``` + +```python +from pygfc import Permutation +# Permutation(range, rounds, seed) +perm = Permutation(2 ** 16, 8, 42) +assert set(perm) == set(range(2 ** 16)) +assert all(perm.inv(perm[i]) == i for i in range(2 ** 16)) +``` + +## Dependencies + +The Speck implementation is from [madmo/speck](https://github.com/madmo/speck) and is licensed under the ISC license (MIT-compatible). + +## References + +[1] Black, John, and Phillip Rogaway. "Ciphers with arbitrary finite domains." _Cryptographers’ track at the RSA conference_. Springer, Berlin, Heidelberg, 2002. +https://web.cs.ucdavis.edu/~rogaway/papers/subset.pdf + + + + +%package help +Summary: Development documents and examples for pygfc +Provides: python3-pygfc-doc +%description help +# 🎲 gfc — fast & lazy random permutations + +[![PyPI Status](https://img.shields.io/github/workflow/status/maxmouchet/gfc/PyPI?logo=github&label=pypi)](https://github.com/maxmouchet/gfc/actions/workflows/pypi.yml) +[![Tests Status](https://img.shields.io/github/workflow/status/maxmouchet/gfc/Tests?logo=github&label=tests)](https://github.com/maxmouchet/gfc/actions/workflows/tests.yml) +[![PyPI](https://img.shields.io/pypi/v/pygfc?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/pygfc/) + +gfc is a C implementation of a Generalized-Feistel Cipher [[1, alg. 3]](#1) for generating random permutations. +It uses [Speck](https://en.wikipedia.org/wiki/Speck_%28cipher%29) 64/128 as the random function, and can generate permutations with up to `2^64` elements. +The permutation is computed, and reversed, _on-the-fly_, without any mutable state and by using very little memory. + +## Usage + +### C / C++ + +#### API + +```c +#include +GFC* gfc_init(uint64_t range, uint64_t rounds, uint64_t seed); +void gfc_destroy(GFC* gfc); +uint64_t gfc_decrypt(const GFC* gfc, uint64_t m); +uint64_t gfc_encrypt(const GFC* gfc, uint64_t m); +``` + +#### Example + +```c +// main.c +// gcc -Iinclude/ src/gfc.c main.c -o main +#include +#include + +int main() { + GFC* gfc = gfc_init(65536, 6, 42); + + for (uint64_t i = 0; i < 65536; i++) { + uint64_t enc = gfc_encrypt(gfc, i); + uint64_t dec = gfc_decrypt(gfc, enc); + assert(enc != i); + assert(dec == i); + } + + gfc_destroy(gfc); + return 0; +} +``` + +#### CMake Integration + +```cmake +cmake_minimum_required(VERSION 3.12) +project(example) +add_subdirectory(gfc) +add_executable(main main.c) +target_link_libraries(main PRIVATE gfc) +``` + +```bash +git submodule add https://github.com/maxmouchet/gfc.git +mkdir build && cd build +cmake .. && cmake --build . +./main +``` + +### Python + +``` +pip install pygfc +``` + +```python +from pygfc import Permutation +# Permutation(range, rounds, seed) +perm = Permutation(2 ** 16, 8, 42) +assert set(perm) == set(range(2 ** 16)) +assert all(perm.inv(perm[i]) == i for i in range(2 ** 16)) +``` + +## Dependencies + +The Speck implementation is from [madmo/speck](https://github.com/madmo/speck) and is licensed under the ISC license (MIT-compatible). + +## References + +[1] Black, John, and Phillip Rogaway. "Ciphers with arbitrary finite domains." _Cryptographers’ track at the RSA conference_. Springer, Berlin, Heidelberg, 2002. +https://web.cs.ucdavis.edu/~rogaway/papers/subset.pdf + + + + +%prep +%autosetup -n pygfc-1.0.5 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-pygfc -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 10 2023 Python_Bot - 1.0.5-1 +- Package Spec generated -- cgit v1.2.3