sha67 0.1.0__tar.gz

sha67-0.1.0/Cargo.lock

@@ -0,0 +1,370 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "bitflags"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+ "rand",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.21.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e00b96a521718e08e03b1a622f01c8a8deb50719335de3f60b3b3950f069d8"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "parking_lot",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.21.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7883df5835fafdad87c0d888b266c8ec0f4c9ca48a5bed6bbb592e8dedee1b50"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.21.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01be5843dc60b916ab4dad1dca6d20b9b4e6ddc8e15f50c47fe6d85f1fb97403"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.21.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77b34069fc0682e11b31dbd10321cbf94808394c56fd996796ce45217dfac53c"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.21.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08260721f32db5e1a5beae69a55553f56b99bd0e1c3e6e0a5e8851a9d0f5a85c"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha67"
+version = "0.1.0"
+dependencies = [
+ "hex",
+ "num-bigint",
+ "num-traits",
+ "pyo3",
+ "sha2",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"

sha67-0.1.0/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "sha67"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+name = "sha67"
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+pyo3 = { version = "0.21.2", features = ["extension-module", "abi3-py37"], optional = true }
+sha2 = "0.10.8"
+num-bigint = { version = "0.4.4", features = ["rand"] }
+num-traits = "0.2.19"
+hex = "0.4.3"
+
+[features]
+default = []
+python = ["dep:pyo3"]
+
+[package.metadata.maturin]
+features = ["python"]

sha67-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: sha67
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Security :: Cryptography
+Summary: Premium SHA-67 Hashing Cryptographic Module in Rust
+Requires-Python: >=3.7

sha67-0.1.0/check.log

@@ -0,0 +1,222 @@
+    Checking sha67 v0.1.0 (/Users/lagos/code/sha67)
+error[E0428]: the name `sha67` is defined multiple times
+   --> src/lib.rs:231:1
+    |
+153 | fn sha67(data: &Bound<'_, PyAny>) -> PyResult<String> {
+    | ----------------------------------------------------- previous definition of the value `sha67` here
+...
+231 | fn sha67(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha67` redefined here
+    |
+    = note: `sha67` must be defined only once in the value namespace of this module
+
+error[E0428]: the name `sha67` is defined multiple times
+   --> src/lib.rs:230:1
+    |
+152 | #[pyfunction]
+    | ------------- previous definition of the module `sha67` here
+...
+230 | #[pymodule]
+    | ^^^^^^^^^^^ `sha67` redefined here
+    |
+    = note: `sha67` must be defined only once in the type namespace of this module
+    = note: this error originates in the attribute macro `pymodule` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0425]: cannot find value `__PYO3_NAME` in module `sha67`
+   --> src/lib.rs:230:1
+    |
+230 | #[pymodule]
+    | ^^^^^^^^^^^ not found in `sha67`
+    |
+    = note: this error originates in the attribute macro `pymodule` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no function or associated item named `from_bytes_be_bound` found for struct `PyInt` in the current scope
+   --> src/lib.rs:135:34
+    |
+135 |             let py_int = PyLong::from_bytes_be_bound(py, &bytes).unwrap();
+    |                                  ^^^^^^^^^^^^^^^^^^^ function or associated item not found in `PyInt`
+
+error[E0599]: no function or associated item named `from_bytes_be_bound` found for struct `PyInt` in the current scope
+   --> src/lib.rs:171:30
+    |
+171 |         let py_int = PyLong::from_bytes_be_bound(py, &big_bytes).unwrap();
+    |                              ^^^^^^^^^^^^^^^^^^^ function or associated item not found in `PyInt`
+
+error[E0599]: no function or associated item named `make_def` found for struct `sha67::MakeDef` in the current scope
+   --> src/lib.rs:230:1
+    |
+230 | #[pymodule]
+    | ^^^^^^^^^^^
+    | |
+    | function or associated item not found in `sha67::MakeDef`
+    | function or associated item `make_def` not found for this struct
+    |
+    = note: this error originates in the attribute macro `pymodule` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `&pyo3::Bound<'_, pyo3::PyAny>: From<pyo3::impl_::pymethods::BoundRef<'_, '_, pyo3::prelude::PyModule>>` is not satisfied
+   --> src/lib.rs:230:1
+    |
+230 | #[pymodule]
+    | ^^^^^^^^^^^ the trait `From<pyo3::impl_::pymethods::BoundRef<'_, '_, pyo3::prelude::PyModule>>` is not implemented for `&pyo3::Bound<'_, pyo3::PyAny>`
+    |
+help: the following other types implement trait `From<T>`
+   --> /Users/lagos/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pyo3-0.21.2/src/impl_/pymethods.rs:545:1
+    |
+545 | impl<'a, 'py, T> From<BoundRef<'a, 'py, T>> for Bound<'py, T> {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `pyo3::Bound<'_, T>`
+...
+552 | impl<'a, 'py, T> From<BoundRef<'a, 'py, T>> for &'a Bound<'py, T> {
+    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&pyo3::Bound<'_, T>`
+    = note: required for `pyo3::impl_::pymethods::BoundRef<'_, '_, pyo3::prelude::PyModule>` to implement `Into<&pyo3::Bound<'_, pyo3::PyAny>>`
+    = note: this error originates in the attribute macro `pymodule` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: mismatched types
+   --> src/lib.rs:230:1
+    |
+230 | #[pymodule]
+    | ^^^^^^^^^^^
+    | |
+    | expected `Result<(), PyErr>`, found `Result<String, PyErr>`
+    | expected `Result<(), PyErr>` because of return type
+    |
+    = note: expected enum `Result<(), _>`
+               found enum `Result<String, _>`
+    = note: this error originates in the attribute macro `pymodule` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning[E0133]: call to unsafe function `pyo3::impl_::pymethods::BoundRef::<'a, 'py, pyo3::PyAny>::ref_from_ptr` is unsafe and requires unsafe block
+  --> src/lib.rs:81:15
+   |
+81 |     fn update(&mut self, data: &Bound<'_, PyAny>) -> PyResult<()> {
+   |               ^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+   = note: `#[warn(unsafe_op_in_unsafe_fn)]` (part of `#[warn(rust_2024_compatibility)]`) on by default
+
+warning[E0133]: call to unsafe function `pyo3::impl_::extract_argument::unwrap_required_argument` is unsafe and requires unsafe block
+  --> src/lib.rs:81:32
+   |
+81 |     fn update(&mut self, data: &Bound<'_, PyAny>) -> PyResult<()> {
+   |                                ^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+
+warning[E0133]: call to unsafe function `pyo3::impl_::pymethods::BoundRef::<'a, 'py, pyo3::PyAny>::ref_from_ptr` is unsafe and requires unsafe block
+  --> src/lib.rs:89:15
+   |
+89 |     fn digest(&self) -> PyObject {
+   |               ^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+note: an unsafe function restricts its caller, but its body is safe by default
+  --> src/lib.rs:66:1
+   |
+66 | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+   = note: this warning originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning[E0133]: call to unsafe function `pyo3::impl_::pymethods::BoundRef::<'a, 'py, pyo3::PyAny>::ref_from_ptr` is unsafe and requires unsafe block
+   --> src/lib.rs:106:18
+    |
+106 |     fn hexdigest(&self) -> String {
+    |                  ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+note: an unsafe function restricts its caller, but its body is safe by default
+   --> src/lib.rs:66:1
+    |
+ 66 | #[pymethods]
+    | ^^^^^^^^^^^^
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+    = note: this warning originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning[E0133]: call to unsafe function `pyo3::impl_::pymethods::BoundRef::<'a, 'py, pyo3::PyAny>::ref_from_ptr` is unsafe and requires unsafe block
+   --> src/lib.rs:120:21
+    |
+120 |     fn base67digest(&self) -> String {
+    |                     ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+note: an unsafe function restricts its caller, but its body is safe by default
+   --> src/lib.rs:66:1
+    |
+ 66 | #[pymethods]
+    | ^^^^^^^^^^^^
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+    = note: this warning originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning[E0133]: call to unsafe function `pyo3::impl_::pymethods::BoundRef::<'a, 'py, pyo3::PyAny>::ref_from_ptr` is unsafe and requires unsafe block
+   --> src/lib.rs:128:18
+    |
+128 |     fn intdigest(&self) -> PyObject {
+    |                  ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+note: an unsafe function restricts its caller, but its body is safe by default
+   --> src/lib.rs:66:1
+    |
+ 66 | #[pymethods]
+    | ^^^^^^^^^^^^
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+    = note: this warning originates in the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning[E0133]: call to unsafe function `pyo3::impl_::extract_argument::unwrap_required_argument` is unsafe and requires unsafe block
+   --> src/lib.rs:153:16
+    |
+153 | fn sha67(data: &Bound<'_, PyAny>) -> PyResult<String> {
+    |                ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+
+warning[E0133]: call to unsafe function `pyo3::impl_::extract_argument::unwrap_required_argument` is unsafe and requires unsafe block
+   --> src/lib.rs:161:20
+    |
+161 | fn sha67_int(data: &Bound<'_, PyAny>) -> PyResult<PyObject> {
+    |                    ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+
+warning[E0133]: call to unsafe function `pyo3::impl_::extract_argument::unwrap_required_argument` is unsafe and requires unsafe block
+   --> src/lib.rs:178:22
+    |
+178 | fn sha67_bytes(data: &Bound<'_, PyAny>) -> PyResult<PyObject> {
+    |                      ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+
+warning[E0133]: call to unsafe function `pyo3::impl_::extract_argument::unwrap_required_argument` is unsafe and requires unsafe block
+   --> src/lib.rs:200:15
+    |
+200 |     password: &Bound<'_, PyAny>,
+    |               ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+
+warning[E0133]: call to unsafe function `pyo3::impl_::extract_argument::unwrap_required_argument` is unsafe and requires unsafe block
+   --> src/lib.rs:201:11
+    |
+201 |     salt: &Bound<'_, PyAny>,
+    |           ^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+
+warning[E0133]: call to unsafe function `pyo3::impl_::extract_argument::unwrap_required_argument` is unsafe and requires unsafe block
+   --> src/lib.rs:202:17
+    |
+202 |     iterations: u32,
+    |                 ^^^ call to unsafe function
+    |
+    = note: consult the function's documentation for information on how to avoid undefined behavior
+    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+
+Some errors have detailed explanations: E0133, E0277, E0308, E0425, E0428, E0599.
+For more information about an error, try `rustc --explain E0133`.
+warning: `sha67` (lib) generated 12 warnings
+error: could not compile `sha67` (lib) due to 8 previous errors; 12 warnings emitted

sha67-0.1.0/demo.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+SHA-67 Hashing Demonstration
+This script shows how to import the Rust-compiled `sha67` library in Python
+and use its various cryptographic utilities.
+"""
+
+import sha67
+
+def run_demo():
+    print("==================================================================")
+    print("      SHA-67 Python Bindings (Rust Extension) Demo                ")
+    print("==================================================================")
+    
+    test_input = "Hello, World!"
+    print(f"Input text: '{test_input}'\n")
+
+    # 1. Module-level Hashing
+    print("--- 1. Module-Level Functions ---")
+    
+    # Base-67 hash string (exactly 67 characters)
+    hash_str = sha67.sha67(test_input)
+    print(f"sha67() string digest (67 chars):\n  => {hash_str}")
+    assert len(hash_str) == 67
+    
+    # Large integer hash value (modulo 67^67)
+    hash_int = sha67.sha67_int(test_input)
+    print(f"sha67_int() integer digest:\n  => {hash_int}")
+    print(f"  => Bit-length: {hash_int.bit_length()} bits")
+    
+    # Raw byte representation (exactly 51 bytes)
+    hash_bytes = sha67.sha67_bytes(test_input)
+    print(f"sha67_bytes() raw bytes digest (51 bytes):\n  => {hash_bytes.hex()}")
+    assert len(hash_bytes) == 51
+    print()
+
+    # 2. Hashlib-style class interface
+    print("--- 2. Hashlib-like Class Interface (sha67.SHA67) ---")
+    hasher = sha67.SHA67()
+    hasher.update("Hello, ")
+    hasher.update("World!")
+    
+    print(f"base67digest():  {hasher.base67digest()}")
+    print(f"hexdigest():     {hasher.hexdigest()}")
+    print(f"digest() (hex):  {hasher.digest().hex()}")
+    print(f"intdigest():     {hasher.intdigest()}")
+    
+    # Assert equivalence between incremental and single-pass hash
+    assert hasher.base67digest() == hash_str
+    print("\n[✔] Incremental and single-pass hashes are identical!")
+    print()
+
+    # 3. Custom Iterative KDF (Key Derivation Function)
+    print("--- 3. Custom Key Derivation (PBKDF-SHA67) ---")
+    password = "supersecretpassword"
+    salt = "random_salt_123"
+    iterations = 10000
+    
+    print(f"Deriving key for password='{password}', salt='{salt}', iterations={iterations}...")
+    derived_key = sha67.pbkdf_sha67(password, salt, iterations)
+    print(f"Derived Key (base-67 KDF):\n  => {derived_key}")
+    assert len(derived_key) == 67
+    print("==================================================================")
+
+if __name__ == "__main__":
+    run_demo()

sha67-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "sha67"
+version = "0.1.0"
+description = "Premium SHA-67 Hashing Cryptographic Module in Rust"
+requires-python = ">=3.7"
+dependencies = []
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Security :: Cryptography",
+]
+
+[tool.maturin]
+bindings = "pyo3"
+features = ["python"]

sha67-0.1.0/src/lib.rs

@@ -0,0 +1,295 @@
+#![allow(unsafe_op_in_unsafe_fn)]
+
+use num_bigint::BigUint;
+use num_traits::{ToPrimitive, Zero};
+use sha2::{Digest, Sha512};
+use std::sync::OnceLock;
+
+/// The custom 67-character alphabet for the base-67 encoding.
+/// This includes all unreserved URI-safe characters (a-z, A-Z, 0-9, -, _, ., ~)
+/// plus the exclamation mark (!) to reach exactly 67 symbols.
+pub const ALPHABET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_.~!";
+
+/// Thread-safe OnceLock to precompute and cache the modulo 67^67 value.
+fn get_modulus() -> &'static BigUint {
+    static MODULUS: OnceLock<BigUint> = OnceLock::new();
+    MODULUS.get_or_init(|| {
+        let base = BigUint::from(67u32);
+        base.pow(67)
+    })
+}
+
+/// Converts a BigUint (< 67^67) into a base-67 string of exactly 67 characters,
+/// padded with leading '0's as necessary.
+pub fn biguint_to_base67(mut val: BigUint) -> String {
+    let mut digits = Vec::with_capacity(67);
+    let divisor = BigUint::from(67u32);
+
+    while !val.is_zero() {
+        let rem = &val % &divisor;
+        val /= &divisor;
+        let digit_idx = rem.to_usize().unwrap();
+        digits.push(ALPHABET[digit_idx] as char);
+    }
+
+    // Pad with the 0-th character of the alphabet (which is '0') to ensure exactly 67 characters
+    while digits.len() < 67 {
+        digits.push(ALPHABET[0] as char);
+    }
+
+    // Reverse to big-endian order (most significant digit first)
+    digits.reverse();
+    digits.into_iter().collect()
+}
+
+/// Compute the base-67 hash of the input data in Rust and return it as a 67-character string.
+pub fn sha67_rust(data: &[u8]) -> String {
+    let mut hasher = Sha512::new();
+    hasher.update(data);
+    let hash_bytes = hasher.finalize();
+    let val = BigUint::from_bytes_be(&hash_bytes);
+    let reduced = val % get_modulus();
+    biguint_to_base67(reduced)
+}
+
+// =====================================================================
+// Python Bindings (only compiled if python feature is enabled)
+// =====================================================================
+
+#[cfg(feature = "python")]
+use pyo3::prelude::*;
+#[cfg(feature = "python")]
+use pyo3::types::{PyBytes, PyLong};
+use std::borrow::Cow;
+
+/// Helper function to extract a byte slice from a PyAny object,
+/// supporting both Python `str` (UTF-8 encoded) and `bytes`.
+#[cfg(feature = "python")]
+fn get_bytes<'a>(data: &'a Bound<'a, PyAny>) -> PyResult<Cow<'a, [u8]>> {
+    if let Ok(s) = data.extract::<String>() {
+        Ok(Cow::Owned(s.into_bytes()))
+    } else if let Ok(b) = data.extract::<Vec<u8>>() {
+        Ok(Cow::Owned(b))
+    } else {
+        Err(pyo3::exceptions::PyTypeError::new_err(
+            "Expected data to be of type 'str' or 'bytes'",
+        ))
+    }
+}
+
+/// A Python class that mimics the standard hashlib interface for computing SHA-67 hashes.
+#[cfg(feature = "python")]
+#[pyclass]
+#[derive(Clone)]
+struct SHA67 {
+    state: Sha512,
+}
+
+#[cfg(feature = "python")]
+#[pymethods]
+impl SHA67 {
+    /// Creates a new SHA67 hasher. Can optionally be initialized with input data.
+    #[new]
+    fn new(data: Option<&Bound<'_, PyAny>>) -> PyResult<Self> {
+        let mut hasher = Sha512::new();
+        if let Some(d) = data {
+            let bytes = get_bytes(d)?;
+            hasher.update(bytes);
+        }
+        Ok(SHA67 { state: hasher })
+    }
+
+    /// Update the hash object with the bytes-like object or string.
+    /// Repeated calls are equivalent to a single call with the concatenation of all the arguments.
+    fn update(&mut self, data: &Bound<'_, PyAny>) -> PyResult<()> {
+        let bytes = get_bytes(data)?;
+        self.state.update(bytes);
+        Ok(())
+    }
+
+    /// Return the digest of the data passed to the update() method so far.
+    /// This is a 51-byte raw representation of the hash value modulo 67^67.
+    fn digest(&self) -> PyObject {
+        let hash_bytes = self.state.clone().finalize();
+        let val = BigUint::from_bytes_be(&hash_bytes);
+        let reduced = val % get_modulus();
+        
+        let bytes = reduced.to_bytes_be();
+        // 67^67 fits in exactly 51 bytes (51 * 8 = 408 bits > 406.4 bits)
+        let mut padded = vec![0u8; 51];
+        let start = 51 - bytes.len();
+        padded[start..].copy_from_slice(&bytes);
+
+        Python::with_gil(|py| {
+            PyBytes::new_bound(py, &padded).into()
+        })
+    }
+
+    /// Return the digest of the data passed to the update() method so far as a hexadecimal string.
+    fn hexdigest(&self) -> String {
+        let hash_bytes = self.state.clone().finalize();
+        let val = BigUint::from_bytes_be(&hash_bytes);
+        let reduced = val % get_modulus();
+        
+        let bytes = reduced.to_bytes_be();
+        let mut padded = vec![0u8; 51];
+        let start = 51 - bytes.len();
+        padded[start..].copy_from_slice(&bytes);
+        
+        hex::encode(padded)
+    }
+
+    /// Return the digest of the data passed to the update() method so far as a base-67 string of exactly 67 characters.
+    fn base67digest(&self) -> String {
+        let hash_bytes = self.state.clone().finalize();
+        let val = BigUint::from_bytes_be(&hash_bytes);
+        let reduced = val % get_modulus();
+        biguint_to_base67(reduced)
+    }
+
+    /// Return the digest of the data passed to the update() method so far as a Python integer.
+    fn intdigest(&self) -> PyObject {
+        let hash_bytes = self.state.clone().finalize();
+        let val = BigUint::from_bytes_be(&hash_bytes);
+        let reduced = val % get_modulus();
+        
+        let bytes = reduced.to_bytes_be();
+        Python::with_gil(|py| {
+            let py_bytes = PyBytes::new_bound(py, &bytes);
+            let py_int = py
+                .get_type_bound::<PyLong>()
+                .call_method1("from_bytes", (py_bytes, "big"))
+                .unwrap()
+                .downcast_into::<PyLong>()
+                .unwrap();
+            py_int.into()
+        })
+    }
+}
+
+/// Compute the base-67 hash of the input data and return it as a 67-character string.
+#[cfg(feature = "python")]
+#[pyfunction(name = "sha67")]
+fn py_sha67(data: &Bound<'_, PyAny>) -> PyResult<String> {
+    let bytes = get_bytes(data)?;
+    Ok(sha67_rust(&bytes))
+}
+
+/// Compute the base-67 hash of the input data and return it as a Python integer.
+#[cfg(feature = "python")]
+#[pyfunction]
+fn sha67_int(data: &Bound<'_, PyAny>) -> PyResult<PyObject> {
+    let bytes = get_bytes(data)?;
+    let mut hasher = Sha512::new();
+    hasher.update(&bytes);
+    let hash_bytes = hasher.finalize();
+    let val = BigUint::from_bytes_be(&hash_bytes);
+    let reduced = val % get_modulus();
+    
+    let big_bytes = reduced.to_bytes_be();
+    Python::with_gil(|py| {
+        let py_bytes = PyBytes::new_bound(py, &big_bytes);
+        let py_int = py
+            .get_type_bound::<PyLong>()
+            .call_method1("from_bytes", (py_bytes, "big"))?
+            .downcast_into::<PyLong>()?;
+        Ok(py_int.into())
+    })
+}
+
+/// Compute the base-67 hash of the input data and return it as a 51-byte representation.
+#[cfg(feature = "python")]
+#[pyfunction]
+fn sha67_bytes(data: &Bound<'_, PyAny>) -> PyResult<PyObject> {
+    let bytes = get_bytes(data)?;
+    let mut hasher = Sha512::new();
+    hasher.update(&bytes);
+    let hash_bytes = hasher.finalize();
+    let val = BigUint::from_bytes_be(&hash_bytes);
+    let reduced = val % get_modulus();
+    
+    let big_bytes = reduced.to_bytes_be();
+    let mut padded = vec![0u8; 51];
+    let start = 51 - big_bytes.len();
+    padded[start..].copy_from_slice(&big_bytes);
+    
+    Python::with_gil(|py| {
+        Ok(PyBytes::new_bound(py, &padded).into())
+    })
+}
+
+/// A custom iterative Key Derivation Function (KDF) using SHA-67.
+/// This runs the base-67 hashing algorithm iteratively with salt stretching.
+#[cfg(feature = "python")]
+#[pyfunction]
+fn pbkdf_sha67(
+    password: &Bound<'_, PyAny>,
+    salt: &Bound<'_, PyAny>,
+    iterations: u32,
+) -> PyResult<String> {
+    let password_bytes = get_bytes(password)?;
+    let salt_bytes = get_bytes(salt)?;
+
+    let mut state = password_bytes.to_vec();
+    state.extend_from_slice(&salt_bytes);
+
+    let mut current_hash = BigUint::zero();
+
+    for _ in 0..iterations {
+        let mut hasher = Sha512::new();
+        hasher.update(&state);
+        let hash_bytes = hasher.finalize();
+        let val = BigUint::from_bytes_be(&hash_bytes) % get_modulus();
+
+        current_hash ^= &val;
+        
+        let base67_str = biguint_to_base67(val);
+        state = base67_str.into_bytes();
+        state.extend_from_slice(&password_bytes);
+    }
+
+    Ok(biguint_to_base67(current_hash))
+}
+
+/// The Python module defined via PyO3.
+#[cfg(feature = "python")]
+#[pymodule]
+fn sha67(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(py_sha67, m)?)?;
+    m.add_function(wrap_pyfunction!(sha67_int, m)?)?;
+    m.add_function(wrap_pyfunction!(sha67_bytes, m)?)?;
+    m.add_function(wrap_pyfunction!(pbkdf_sha67, m)?)?;
+    m.add_class::<SHA67>()?;
+    Ok(())
+}
+
+// =====================================================================
+// Rust Unit Tests
+// =====================================================================
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_alphabet_length() {
+        assert_eq!(ALPHABET.len(), 67);
+    }
+
+    #[test]
+    fn test_biguint_to_base67_zero() {
+        let val = BigUint::zero();
+        let s = biguint_to_base67(val);
+        assert_eq!(s.len(), 67);
+        assert!(s.chars().all(|c| c == '0'));
+    }
+
+    #[test]
+    fn test_sha67_rust_output_length() {
+        let hash = sha67_rust(b"hello world");
+        assert_eq!(hash.len(), 67);
+        for c in hash.chars() {
+            assert!(ALPHABET.contains(&(c as u8)));
+        }
+    }
+}

sha67-0.1.0/src/main.rs

@@ -0,0 +1,97 @@
+use std::env;
+use std::fs::File;
+use std::io::{self, Read};
+use sha67::sha67_rust;
+
+fn print_help() {
+    println!("============================================================");
+    println!("      SHA-67 HASHER - 67^67 Cryptographic Modulo Hash       ");
+    println!("============================================================");
+    println!("Computes a cryptographically secure 67-character hash using");
+    println!("SHA-512 mapped onto a base-67 alphabet modulo 67^67.");
+    println!();
+    println!("Usage:");
+    println!("  sha67 [option] <input>");
+    println!();
+    println!("Options:");
+    println!("  -s, --string <text>   Hash the provided text string directly");
+    println!("  -f, --file <path>     Hash the contents of the specified file");
+    println!("  -h, --help            Show this help menu");
+    println!("  -                     Read from standard input (default if no argument)");
+    println!();
+    println!("Examples:");
+    println!("  sha67 -s \"Hello, World!\"");
+    println!("  sha67 my_document.txt");
+    println!("  echo -n \"cryptography\" | sha67");
+    println!("============================================================");
+}
+
+fn main() -> io::Result<()> {
+    let args: Vec<String> = env::args().collect();
+
+    // If no argument is provided, default to reading from stdin
+    if args.len() < 2 {
+        let mut buffer = Vec::new();
+        io::stdin().read_to_end(&mut buffer)?;
+        let hash = sha67_rust(&buffer);
+        println!("{}", hash);
+        return Ok(());
+    }
+
+    match args[1].as_str() {
+        "-h" | "--help" => {
+            print_help();
+            return Ok(());
+        }
+        "-s" | "--string" => {
+            if args.len() < 3 {
+                eprintln!("Error: Missing string argument after -s/--string");
+                std::process::exit(1);
+            }
+            let text = &args[2];
+            let hash = sha67_rust(text.as_bytes());
+            println!("{}", hash);
+        }
+        "-f" | "--file" => {
+            if args.len() < 3 {
+                eprintln!("Error: Missing file path argument after -f/--file");
+                std::process::exit(1);
+            }
+            let path = &args[2];
+            hash_file(path)?;
+        }
+        "-" => {
+            let mut buffer = Vec::new();
+            io::stdin().read_to_end(&mut buffer)?;
+            let hash = sha67_rust(&buffer);
+            println!("{}", hash);
+        }
+        other => {
+            // If the argument starts with '-' but wasn't caught, it's an invalid option
+            if other.starts_with('-') {
+                eprintln!("Error: Unknown option '{}'. Use -h or --help for details.", other);
+                std::process::exit(1);
+            }
+            // Otherwise, treat it as a file path directly (convenience shortcut)
+            hash_file(other)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn hash_file(path: &str) -> io::Result<()> {
+    match File::open(path) {
+        Ok(mut file) => {
+            let mut buffer = Vec::new();
+            file.read_to_end(&mut buffer)?;
+            let hash = sha67_rust(&buffer);
+            println!("{}  {}", hash, path);
+            Ok(())
+        }
+        Err(err) => {
+            eprintln!("Error reading file '{}': {}", path, err);
+            std::process::exit(1);
+        }
+    }
+}