Add support for wasm32-pyodide

.python-version-default

@@ -1 +1 @@
-3.13
+3.13.2

src/argon2/_password_hasher.py

@@ -6,17 +6,24 @@
 
 from typing import ClassVar, Literal
 
-from ._utils import Parameters, _check_types, extract_parameters
+from ._utils import (
+    Parameters,
+    _check_types,
+    extract_parameters,
+    validate_params_for_platform,
+)
 from .exceptions import InvalidHashError
 from .low_level import Type, hash_secret, verify_secret
-from .profiles import RFC_9106_LOW_MEMORY
+from .profiles import get_default_params
 
 
-DEFAULT_RANDOM_SALT_LENGTH = RFC_9106_LOW_MEMORY.salt_len
-DEFAULT_HASH_LENGTH = RFC_9106_LOW_MEMORY.hash_len
-DEFAULT_TIME_COST = RFC_9106_LOW_MEMORY.time_cost
-DEFAULT_MEMORY_COST = RFC_9106_LOW_MEMORY.memory_cost
-DEFAULT_PARALLELISM = RFC_9106_LOW_MEMORY.parallelism
+default_params = get_default_params()
+
+DEFAULT_RANDOM_SALT_LENGTH = default_params.salt_len
+DEFAULT_HASH_LENGTH = default_params.hash_len
+DEFAULT_TIME_COST = default_params.time_cost
+DEFAULT_MEMORY_COST = default_params.memory_cost
+DEFAULT_PARALLELISM = default_params.parallelism
 
 
 def _ensure_bytes(s: bytes | str, encoding: str) -> bytes:
@@ -106,8 +113,7 @@ def __init__(
         if e:
             raise TypeError(e)
 
-        # Cache a Parameters object for check_needs_rehash.
-        self._parameters = Parameters(
+        params = Parameters(
             type=type,
             version=19,
             salt_len=salt_len,
@@ -116,6 +122,12 @@ def __init__(
             memory_cost=memory_cost,
             parallelism=parallelism,
         )
+
+        # verify params before accepting
+        validate_params_for_platform(params)
+
+        # Cache a Parameters object for check_needs_rehash.
+        self._parameters = params
         self.encoding = encoding
 
     @classmethod
@@ -128,6 +140,8 @@ def from_parameters(cls, params: Parameters) -> PasswordHasher:
 
         .. versionadded:: 21.2.0
         """
+        validate_params_for_platform(params)
+
         ph = cls()
         ph._parameters = params
 

src/argon2/_utils.py

@@ -2,10 +2,13 @@
 
 from __future__ import annotations
 
+import platform
+import sys
+
 from dataclasses import dataclass
 from typing import Any
 
-from .exceptions import InvalidHashError
+from .exceptions import InvalidHashError, UnsupportedParamsError
 from .low_level import Type
 
 
@@ -35,6 +38,13 @@ def _check_types(**kw: Any) -> str | None:
     return None
 
 
+def _is_wasm() -> bool:
+    return sys.platform == "emscripten" or platform.machine() in [
+        "wasm32",
+        "wasm64",
+    ]
+
+
 def _decoded_str_len(length: int) -> int:
     """
     Compute how long an encoded string of length *l* becomes.
@@ -147,3 +157,18 @@ def extract_parameters(hash: str) -> Parameters:
         memory_cost=kvs["m"],
         parallelism=kvs["p"],
     )
+
+
+def validate_params_for_platform(params: Parameters) -> None:
+    """
+    Validate *params* against current platform.
+
+    Args:
+        params: Parameters to be validated
+
+    Returns:
+       None
+    """
+    if _is_wasm() and params.parallelism != 1:
+        msg = "within wasm/wasi environments `parallelism` must be set to 1"
+        raise UnsupportedParamsError(msg)

src/argon2/exceptions.py

@@ -46,6 +46,23 @@ class InvalidHashError(ValueError):
     """
 
 
+class UnsupportedParamsError(ValueError):
+    """
+    Raised if the current platform doesn not support the parameters.
+
+    Eg. In Wasm32/64, parallelism must be set to 1.
+
+    Args:
+        (Opt) message: a description of the incompatibility
+    """
+
+    def __init__(
+        self,
+        message: str = "Params are not compatible with the current platform",
+    ) -> None:
+        super().__init__(message)
+
+
 InvalidHash = InvalidHashError
 """
 Deprecated alias for :class:`InvalidHashError`.

src/argon2/profiles.py

@@ -11,10 +11,25 @@
 
 from __future__ import annotations
 
-from ._utils import Parameters
+from ._utils import Parameters, _is_wasm
 from .low_level import Type
 
 
+def get_default_params() -> Parameters:
+    """
+    Create default params for current platform
+
+    Returns:
+        Parameters for current platform
+    """
+    params = RFC_9106_LOW_MEMORY
+
+    if _is_wasm():
+        params.parallelism = 1
+
+    return params
+
+
 # FIRST RECOMMENDED option per RFC 9106.
 RFC_9106_HIGH_MEMORY = Parameters(
     type=Type.ID,

tests/test_password_hasher.py

@@ -1,10 +1,17 @@
 # SPDX-License-Identifier: MIT
 
+from unittest import mock
+
 import pytest
 
 from argon2 import PasswordHasher, Type, extract_parameters, profiles
 from argon2._password_hasher import _ensure_bytes
-from argon2.exceptions import InvalidHash, InvalidHashError
+from argon2._utils import Parameters
+from argon2.exceptions import (
+    InvalidHash,
+    InvalidHashError,
+    UnsupportedParamsError,
+)
 
 
 class TestEnsureBytes:
@@ -151,3 +158,39 @@ def test_type_is_configurable(self):
         assert Type.I is ph.type is ph._parameters.type
         assert Type.I is extract_parameters(ph.hash("foo")).type
         assert ph.check_needs_rehash(default_hash)
+
+    @mock.patch("sys.platform", "emscripten")
+    def test_params_on_wasm(self):
+        """
+        Should fail if on wasm and parallelism > 1
+        """
+        for machine in ["wasm32", "wasm64"]:
+            with mock.patch("platform.machine", return_value=machine):
+                with pytest.raises(UnsupportedParamsError) as exinfo:
+                    PasswordHasher(parallelism=2)
+
+                assert (
+                    str(exinfo.value)
+                    == "within wasm/wasi environments `parallelism` must be set to 1"
+                )
+
+                # last param is parallelism so it should fail
+                params = Parameters(Type.I, 2, 8, 8, 3, 256, 8)
+                with pytest.raises(UnsupportedParamsError) as exinfo:
+                    ph = PasswordHasher.from_parameters(params)
+
+                assert (
+                    str(exinfo.value)
+                    == "within wasm/wasi environments `parallelism` must be set to 1"
+                )
+
+                # test normal execution
+                ph = PasswordHasher(parallelism=1)
+                hash = ph.hash("hello")
+                assert ph.verify(hash, "hello") is True
+
+                # test default params
+                default_params = profiles.get_default_params()
+                ph = PasswordHasher.from_parameters(default_params)
+                hash = ph.hash("hello")
+                assert ph.verify(hash, "hello") is True