automatic import of python-pygfcopeneuler20.03

1 files changed, 336 insertions, 0 deletions

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.h>
+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 <assert.h>
+#include <gfc/gfc.h>
+
+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
+
+<a id="1">[1]</a> 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.h>
+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 <assert.h>
+#include <gfc/gfc.h>
+
+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
+
+<a id="1">[1]</a> 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.h>
+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 <assert.h>
+#include <gfc/gfc.h>
+
+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
+
+<a id="1">[1]</a> 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 <Python_Bot@openeuler.org> - 1.0.5-1
+- Package Spec generated