network-secret 0.1.0__tar.gz

network_secret-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

network_secret-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antoine Keranflec'h
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

network_secret-0.1.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: network-secret
+Version: 0.1.0
+Summary: Encode, decode, and check network device secrets: Juniper $9$, Juniper $8$, and Nokia SR OS custom-hash
+Project-URL: Homepage, https://github.com/antoinekh/network-secret
+Project-URL: Repository, https://github.com/antoinekh/network-secret
+Project-URL: Issues, https://github.com/antoinekh/network-secret/issues
+Author-email: Antoine Keranflec'h <antoine.keranflech@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Antoine Keranflec'h
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: $8$,$9$,crypt,custom-hash,decrypt,juniper,junos,network,nokia,password,sros
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=42.0
+Description-Content-Type: text/markdown
+
+# network-secret
+
+Encode, decode, and check network device secrets for Juniper JunOS and Nokia SR OS, from the command line or Python. `network-secret` is a unified successor to `juniper8-crypt` and `juniper9-crypt`: it covers all three formats in a single package with a single CLI.
+
+> **Prefer a browser?** Encode and decode all three formats at **[network-secret-website.pages.dev](https://network-secret-website.pages.dev/)**. It runs the same algorithms fully client-side - nothing you type is ever sent to a server.
+
+## Supported formats
+
+| Format | CLI subcommand | Python module | Description |
+|--------|---------------|---------------|-------------|
+| `$9$` | `juniper9` | `network_secret.juniper9` | Juniper reversible obfuscation - keyless |
+| `$8$` | `juniper8` | `network_secret.juniper8` | Juniper AES-256-GCM - keyed by master password |
+| Nokia custom-hash | `nokia-sros-custom-hash` | `network_secret.nokia_sros_custom_hash` | Nokia SR OS AES-ECB shared-key cipher |
+
+## Install
+
+```bash
+pip install network-secret
+```
+
+Or with `uv`:
+
+```bash
+uv add network-secret
+```
+
+## Python API
+
+```python
+from network_secret import juniper8, juniper9, nokia_sros_custom_hash
+
+# Juniper $9$ (keyless)
+cipher9 = juniper9.encrypt("BGPsecret1")
+plain9 = juniper9.decrypt(cipher9)
+# 'BGPsecret1'
+
+# Juniper $8$ (master-password keyed)
+master = "MyMasterPassword"
+cipher8 = juniper8.encrypt("BGPsecret1", master)
+plain8 = juniper8.decrypt(cipher8, master)
+# 'BGPsecret1'
+plain_a, plain_b, match = juniper8.check(cipher8, "BGPsecret1", master)
+# match is True
+
+# Nokia SR OS custom-hash (16/24/32-character shared key)
+key = "a3f8d9e112c04b7af1c3e8b92d057a4e"
+cipher_nokia = nokia_sros_custom_hash.encrypt("BGPsecret1", key)
+plain_nokia = nokia_sros_custom_hash.decrypt(cipher_nokia, key)
+# 'BGPsecret1'
+plain_a, plain_b, match = nokia_sros_custom_hash.check(cipher_nokia, "BGPsecret1", key)
+# match is True
+```
+
+All three `check()` functions return a `tuple[str, str, bool]`: the two decrypted plaintexts and whether they match.
+
+## Command-line usage
+
+```bash
+# List all supported ciphers
+network-secret --list
+
+# Show the version
+network-secret --version
+```
+
+### Juniper `$9$` (keyless)
+
+```bash
+network-secret juniper9 --encrypt 'BGPsecret1'
+network-secret juniper9 --decrypt '$9$abc...'
+network-secret juniper9 --check '$9$abc...' 'BGPsecret1'
+```
+
+### Juniper `$8$` (master-password keyed)
+
+The master password is resolved in this order: `-m`/`--master` flag, then the `JUNOS_MASTER_PASSWORD` environment variable, then an interactive no-echo prompt.
+
+```bash
+# Master on the command line
+network-secret juniper8 -m 'MyMaster' --encrypt 'BGPsecret1'
+network-secret juniper8 -m 'MyMaster' --decrypt '$8$aes256-gcm$...'
+network-secret juniper8 -m 'MyMaster' --check '$8$aes256-gcm$...' 'BGPsecret1'
+
+# Master from the environment (keeps it out of shell history and the process list)
+export JUNOS_MASTER_PASSWORD='MyMaster'
+network-secret juniper8 --decrypt '$8$aes256-gcm$...'
+
+# Master from an interactive prompt
+network-secret juniper8 --decrypt '$8$aes256-gcm$...'
+# Master password: <typed without echo>
+```
+
+> Always quote `$8$` and `$9$` strings with single quotes - the shell expands `$8` and `$9` as positional parameters otherwise.
+
+### Nokia SR OS custom-hash (shared-key)
+
+The shared key is resolved in this order: `-k`/`--key` flag, then the `SROS_CUSTOM_HASH_KEY` environment variable, then an interactive no-echo prompt. Keys must be exactly 16, 24, or 32 characters.
+
+```bash
+# Key on the command line
+network-secret nokia-sros-custom-hash -k 'a3f8d9e112c04b7af1c3e8b92d057a4e' --encrypt 'BGPsecret1'
+network-secret nokia-sros-custom-hash -k 'a3f8d9e112c04b7af1c3e8b92d057a4e' --decrypt 'ABC123...'
+network-secret nokia-sros-custom-hash -k 'a3f8d9e112c04b7af1c3e8b92d057a4e' --check 'ABC123...' 'BGPsecret1'
+
+# Key from the environment
+export SROS_CUSTOM_HASH_KEY='a3f8d9e112c04b7af1c3e8b92d057a4e'
+network-secret nokia-sros-custom-hash --decrypt 'ABC123...'
+```
+
+### Exit codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success (or `--check` matched) |
+| 1 | `--check` mismatched |
+| 2 | Invalid input (malformed value, wrong key, etc.) |
+
+## Supersedes
+
+`network-secret` supersedes the older single-format packages `juniper8-crypt` and `juniper9-crypt`. It exposes the same algorithms under the same function signatures (`encrypt`, `decrypt`, `check`); migrating is a matter of updating the import path.
+
+## License
+
+MIT

network_secret-0.1.0/README.md

@@ -0,0 +1,124 @@
+# network-secret
+
+Encode, decode, and check network device secrets for Juniper JunOS and Nokia SR OS, from the command line or Python. `network-secret` is a unified successor to `juniper8-crypt` and `juniper9-crypt`: it covers all three formats in a single package with a single CLI.
+
+> **Prefer a browser?** Encode and decode all three formats at **[network-secret-website.pages.dev](https://network-secret-website.pages.dev/)**. It runs the same algorithms fully client-side - nothing you type is ever sent to a server.
+
+## Supported formats
+
+| Format | CLI subcommand | Python module | Description |
+|--------|---------------|---------------|-------------|
+| `$9$` | `juniper9` | `network_secret.juniper9` | Juniper reversible obfuscation - keyless |
+| `$8$` | `juniper8` | `network_secret.juniper8` | Juniper AES-256-GCM - keyed by master password |
+| Nokia custom-hash | `nokia-sros-custom-hash` | `network_secret.nokia_sros_custom_hash` | Nokia SR OS AES-ECB shared-key cipher |
+
+## Install
+
+```bash
+pip install network-secret
+```
+
+Or with `uv`:
+
+```bash
+uv add network-secret
+```
+
+## Python API
+
+```python
+from network_secret import juniper8, juniper9, nokia_sros_custom_hash
+
+# Juniper $9$ (keyless)
+cipher9 = juniper9.encrypt("BGPsecret1")
+plain9 = juniper9.decrypt(cipher9)
+# 'BGPsecret1'
+
+# Juniper $8$ (master-password keyed)
+master = "MyMasterPassword"
+cipher8 = juniper8.encrypt("BGPsecret1", master)
+plain8 = juniper8.decrypt(cipher8, master)
+# 'BGPsecret1'
+plain_a, plain_b, match = juniper8.check(cipher8, "BGPsecret1", master)
+# match is True
+
+# Nokia SR OS custom-hash (16/24/32-character shared key)
+key = "a3f8d9e112c04b7af1c3e8b92d057a4e"
+cipher_nokia = nokia_sros_custom_hash.encrypt("BGPsecret1", key)
+plain_nokia = nokia_sros_custom_hash.decrypt(cipher_nokia, key)
+# 'BGPsecret1'
+plain_a, plain_b, match = nokia_sros_custom_hash.check(cipher_nokia, "BGPsecret1", key)
+# match is True
+```
+
+All three `check()` functions return a `tuple[str, str, bool]`: the two decrypted plaintexts and whether they match.
+
+## Command-line usage
+
+```bash
+# List all supported ciphers
+network-secret --list
+
+# Show the version
+network-secret --version
+```
+
+### Juniper `$9$` (keyless)
+
+```bash
+network-secret juniper9 --encrypt 'BGPsecret1'
+network-secret juniper9 --decrypt '$9$abc...'
+network-secret juniper9 --check '$9$abc...' 'BGPsecret1'
+```
+
+### Juniper `$8$` (master-password keyed)
+
+The master password is resolved in this order: `-m`/`--master` flag, then the `JUNOS_MASTER_PASSWORD` environment variable, then an interactive no-echo prompt.
+
+```bash
+# Master on the command line
+network-secret juniper8 -m 'MyMaster' --encrypt 'BGPsecret1'
+network-secret juniper8 -m 'MyMaster' --decrypt '$8$aes256-gcm$...'
+network-secret juniper8 -m 'MyMaster' --check '$8$aes256-gcm$...' 'BGPsecret1'
+
+# Master from the environment (keeps it out of shell history and the process list)
+export JUNOS_MASTER_PASSWORD='MyMaster'
+network-secret juniper8 --decrypt '$8$aes256-gcm$...'
+
+# Master from an interactive prompt
+network-secret juniper8 --decrypt '$8$aes256-gcm$...'
+# Master password: <typed without echo>
+```
+
+> Always quote `$8$` and `$9$` strings with single quotes - the shell expands `$8` and `$9` as positional parameters otherwise.
+
+### Nokia SR OS custom-hash (shared-key)
+
+The shared key is resolved in this order: `-k`/`--key` flag, then the `SROS_CUSTOM_HASH_KEY` environment variable, then an interactive no-echo prompt. Keys must be exactly 16, 24, or 32 characters.
+
+```bash
+# Key on the command line
+network-secret nokia-sros-custom-hash -k 'a3f8d9e112c04b7af1c3e8b92d057a4e' --encrypt 'BGPsecret1'
+network-secret nokia-sros-custom-hash -k 'a3f8d9e112c04b7af1c3e8b92d057a4e' --decrypt 'ABC123...'
+network-secret nokia-sros-custom-hash -k 'a3f8d9e112c04b7af1c3e8b92d057a4e' --check 'ABC123...' 'BGPsecret1'
+
+# Key from the environment
+export SROS_CUSTOM_HASH_KEY='a3f8d9e112c04b7af1c3e8b92d057a4e'
+network-secret nokia-sros-custom-hash --decrypt 'ABC123...'
+```
+
+### Exit codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success (or `--check` matched) |
+| 1 | `--check` mismatched |
+| 2 | Invalid input (malformed value, wrong key, etc.) |
+
+## Supersedes
+
+`network-secret` supersedes the older single-format packages `juniper8-crypt` and `juniper9-crypt`. It exposes the same algorithms under the same function signatures (`encrypt`, `decrypt`, `check`); migrating is a matter of updating the import path.
+
+## License
+
+MIT

network_secret-0.1.0/network_secret/__init__.py

@@ -0,0 +1,24 @@
+"""network-secret: encode, decode, and check network device secrets.
+
+Supported ciphers (one module each):
+    juniper9                - Juniper $9$ reversible obfuscation (keyless)
+    juniper8                - Juniper $8$ AES-256-GCM (master-password keyed)
+    nokia_sros_custom_hash  - Nokia SR OS custom-hash AES-ECB (shared-key)
+
+    >>> from network_secret import juniper8, juniper9, nokia_sros_custom_hash
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+from . import juniper8, juniper9, nokia_sros_custom_hash
+
+__version__ = version("network-secret")
+
+__all__ = [
+    "juniper8",
+    "juniper9",
+    "nokia_sros_custom_hash",
+    "__version__",
+]

network_secret-0.1.0/network_secret/cli.py

@@ -0,0 +1,126 @@
+"""The network-secret command-line interface.
+
+One subcommand per cipher (from the registry). Each subcommand offers
+--encrypt / --decrypt / --check, plus a key option for keyed ciphers. The
+top level offers --list and --version.
+"""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import sys
+
+from . import juniper8, nokia_sros_custom_hash
+from .registry import REGISTRY, find
+from .types import Cipher, KeyKind
+
+__all__ = ["main"]
+
+_PROMPTS = {
+    KeyKind.MASTER_PASSWORD: "Master password: ",
+    KeyKind.SHARED_KEY: "Shared key: ",
+}
+_ENV_VARS = {
+    KeyKind.MASTER_PASSWORD: juniper8.ENV_MASTER,
+    KeyKind.SHARED_KEY: nokia_sros_custom_hash.ENV_KEY,
+}
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    from . import __version__
+
+    parser = argparse.ArgumentParser(
+        prog="network-secret",
+        description="Encode, decode, and check network device secrets.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List the supported ciphers and exit",
+    )
+    sub = parser.add_subparsers(dest="cipher", metavar="CIPHER")
+
+    for cipher in REGISTRY:
+        p = sub.add_parser(cipher.id, help=cipher.name)
+        if cipher.key_kind is KeyKind.MASTER_PASSWORD:
+            p.add_argument(
+                "-m", "--master", metavar="MASTER",
+                help=(
+                    "Master password used to derive the key. If omitted, read "
+                    f"from {juniper8.ENV_MASTER} or prompted for without echo."
+                ),
+            )
+        elif cipher.key_kind is KeyKind.SHARED_KEY:
+            p.add_argument(
+                "-k", "--key", metavar="KEY",
+                help=(
+                    "Shared AES key (16/24/32 chars). If omitted, read from "
+                    f"{nokia_sros_custom_hash.ENV_KEY} or prompted for without echo."
+                ),
+            )
+        group = p.add_mutually_exclusive_group(required=True)
+        group.add_argument("--encrypt", metavar="PLAINTEXT", help="Encrypt a plaintext value")
+        group.add_argument("--decrypt", metavar="CIPHERTEXT", help="Decrypt a secret value")
+        group.add_argument(
+            "--check", nargs=2, metavar=("CIPHERTEXT", "VALUE"),
+            help="Decrypt and compare. Exit 0 on match, 1 on mismatch.",
+        )
+    return parser
+
+
+def _resolve_key(cipher: Cipher, args: argparse.Namespace) -> str:
+    """Resolve a key: explicit flag, then env var, then no-echo prompt."""
+    flag = args.master if cipher.key_kind is KeyKind.MASTER_PASSWORD else args.key
+    if flag is not None:
+        return flag
+    env = os.environ.get(_ENV_VARS[cipher.key_kind])
+    if env is not None:
+        return env
+    return getpass.getpass(_PROMPTS[cipher.key_kind])
+
+
+def _print_check(plain_a: str, plain_b: str, match: bool) -> None:
+    print(f"Value 1   : {plain_a!r}")
+    print(f"Value 2   : {plain_b!r}")
+    print(f"Match     : {'YES' if match else 'NO'}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.list:
+        for c in REGISTRY:
+            print(f"{c.id:24} {c.vendor:8} {c.name}")
+        return 0
+
+    if args.cipher is None:
+        parser.print_help()
+        return 0
+
+    cipher = find(args.cipher)
+    assert cipher is not None  # argparse only allows registered ids
+    key_args: tuple[str, ...] = (_resolve_key(cipher, args),) if cipher.keyed else ()
+
+    try:
+        if args.encrypt is not None:
+            print(cipher.encrypt(args.encrypt, *key_args))
+        elif args.decrypt is not None:
+            print(cipher.decrypt(args.decrypt, *key_args))
+        else:  # --check
+            plain_a, plain_b, match = cipher.check(args.check[0], args.check[1], *key_args)
+            _print_check(plain_a, plain_b, match)
+            return 0 if match else 1
+    except ValueError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

network_secret-0.1.0/network_secret/juniper8.py

@@ -0,0 +1,170 @@
+"""
+Encrypt and decrypt Juniper $8$ (type 8) passwords.
+
+Unlike the reversible, keyless $9$ substitution cipher, the $8$ format is
+genuine authenticated encryption keyed by the device master password
+(``set system master-password``). The same master password is required to
+both encrypt and decrypt: without it, $8$ secrets cannot be recovered.
+
+Juniper documents the format, but the documentation is incomplete: it omits
+that only the first 12 bytes of the 16-byte iv field are used as the GCM
+nonce, so a by-the-book implementation fails authentication. That missing
+detail was reverse-engineered and verified against a real JUNOS 23.2 device
+(tag authentication passes):
+
+    $8$<crypt-algo>$<hash-algo>$<iterations>$<salt>$<iv>$<tag>$<ciphertext>
+
+* encoding : standard base64 (RFC 4648), no padding, for every binary field.
+* key      : PBKDF2-HMAC-SHA256(master_password, salt, iterations) -> 32 bytes.
+* cipher   : AES-256-GCM, no additional authenticated data (AAD).
+* nonce    : the iv field decodes to 16 bytes, but only the first 12 are used
+             as the GCM nonce; the trailing 4 bytes are unused padding.
+
+Public API:
+    decrypt(ciphertext: str, master_password: str) -> str
+    encrypt(plaintext: str, master_password: str) -> str
+    check(ciphertext: str, other: str, master_password: str) -> tuple[str, str, bool]
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import os
+
+from cryptography.exceptions import InvalidTag
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+__all__ = ["decrypt", "encrypt", "check"]
+
+MAGIC = "$8$"
+
+# Environment variable the CLI reads the master password from when --master
+# is not given on the command line.
+ENV_MASTER = "JUNOS_MASTER_PASSWORD"
+
+# Fixed algorithm parameters JUNOS currently emits for type 8.
+CRYPT_ALGO = "aes256-gcm"
+HASH_ALGO = "hmac-sha2-256"
+DEFAULT_ITERATIONS = 100
+# Bounds JUNOS accepts for the type 8 iteration count. Enforced on decrypt so a
+# hostile $8$ value cannot force an arbitrarily expensive PBKDF2 derivation.
+MIN_ITERATIONS = 10
+MAX_ITERATIONS = 10000
+SALT_LEN = 8  # bytes
+IV_LEN = 16  # bytes stored in the string
+NONCE_LEN = 12  # bytes of the IV actually used as the GCM nonce
+KEY_LEN = 32  # bytes, AES-256
+TAG_LEN = 16  # bytes, GCM authentication tag
+
+
+def _b64encode(data: bytes) -> str:
+    return base64.b64encode(data).decode("ascii").rstrip("=")
+
+
+def _b64decode(text: str) -> bytes:
+    try:
+        return base64.b64decode(text + "=" * (-len(text) % 4), validate=True)
+    except binascii.Error as e:
+        raise ValueError(f"Invalid base64 in $8$ value: {text!r}") from e
+
+
+def _derive_key(master_password: str, salt: bytes, iterations: int) -> bytes:
+    kdf = PBKDF2HMAC(
+        algorithm=SHA256(), length=KEY_LEN, salt=salt, iterations=iterations
+    )
+    return kdf.derive(master_password.encode("utf-8"))
+
+
+def encrypt(plaintext: str, master_password: str) -> str:
+    """Encrypt plaintext into a Juniper $8$ value under master_password.
+
+    Output is non-deterministic: a fresh random salt and IV are generated on
+    every call, so the same plaintext produces a different $8$ string each
+    time. All of them decrypt back to the same plaintext with the same master
+    password.
+    """
+    salt = os.urandom(SALT_LEN)
+    iv = os.urandom(IV_LEN)
+    key = _derive_key(master_password, salt, DEFAULT_ITERATIONS)
+
+    # JUNOS uses only the first 12 IV bytes as the GCM nonce. AESGCM appends
+    # the authentication tag to the ciphertext.
+    sealed = AESGCM(key).encrypt(iv[:NONCE_LEN], plaintext.encode("utf-8"), None)
+    ciphertext, tag = sealed[:-TAG_LEN], sealed[-TAG_LEN:]
+
+    return MAGIC + "$".join(
+        [
+            CRYPT_ALGO,
+            HASH_ALGO,
+            str(DEFAULT_ITERATIONS),
+            _b64encode(salt),
+            _b64encode(iv),
+            _b64encode(tag),
+            _b64encode(ciphertext),
+        ]
+    )
+
+
+def decrypt(ciphertext: str, master_password: str) -> str:
+    """Decrypt a Juniper $8$ value with master_password.
+
+    Raises ValueError on a malformed $8$ string or on authentication failure
+    (wrong master password, or a value not produced by this scheme).
+    """
+    if not ciphertext.startswith(MAGIC):
+        raise ValueError(f"Not a Juniper $8$ string: must start with {MAGIC}")
+
+    # Leading '$' yields an empty first element; '8' is the type tag.
+    parts = ciphertext.split("$")
+    if len(parts) != 9:
+        raise ValueError("Malformed $8$ value: expected 7 fields after the prefix")
+    _, _type, crypt_algo, hash_algo, iters, salt_b, iv_b, tag_b, ct_b = parts
+
+    if crypt_algo != CRYPT_ALGO:
+        raise ValueError(f"Unsupported crypt-algo {crypt_algo!r}: only {CRYPT_ALGO}")
+    if hash_algo != HASH_ALGO:
+        raise ValueError(f"Unsupported hash-algo {hash_algo!r}: only {HASH_ALGO}")
+    if not (iters.isascii() and iters.isdigit()):
+        # str.isdigit() is True for non-ASCII digits (e.g. superscript "²")
+        # that int() cannot parse; require plain ASCII digits.
+        raise ValueError(f"Invalid iteration count: {iters!r}")
+    if not MIN_ITERATIONS <= int(iters) <= MAX_ITERATIONS:
+        raise ValueError(
+            f"Iteration count {iters} out of range "
+            f"({MIN_ITERATIONS}-{MAX_ITERATIONS})"
+        )
+
+    salt, iv, tag, ct = (
+        _b64decode(salt_b),
+        _b64decode(iv_b),
+        _b64decode(tag_b),
+        _b64decode(ct_b),
+    )
+    key = _derive_key(master_password, salt, int(iters))
+    try:
+        plaintext = AESGCM(key).decrypt(iv[:NONCE_LEN], ct + tag, None)
+    except InvalidTag as e:
+        raise ValueError(
+            "Authentication failed: wrong master password, or the value was "
+            "not produced by this scheme"
+        ) from e
+    return plaintext.decode("utf-8")
+
+
+def check(
+    ciphertext: str, other: str, master_password: str
+) -> tuple[str, str, bool]:
+    """Decrypt `ciphertext` and compare to `other`.
+
+    `other` may be a plaintext, or another $8$ value (auto-detected by the
+    $8$ prefix and decrypted with the same master password). Returns
+    (plain_a, plain_b, match).
+    """
+    plain_a = decrypt(ciphertext, master_password)
+    plain_b = (
+        decrypt(other, master_password) if other.startswith(MAGIC) else other
+    )
+    return plain_a, plain_b, plain_a == plain_b

network_secret-0.1.0/network_secret/juniper9.py

@@ -0,0 +1,106 @@
+"""
+Encrypt and decrypt Juniper $9$ reversible passwords.
+
+The $9$ algorithm is a proprietary Juniper substitution cipher that is
+deterministic and device-independent: the same plaintext can be encrypted
+on any Juniper device and decrypted on any other, with no node-specific
+secret involved.
+
+This is a Python implementation of the algorithm. It is based on
+`Crypt::Juniper` (Perl, Kevin Brintnall) and Matt Hite's Python 2 port
+at https://github.com/mhite/junosdecode.
+
+Public API:
+    decrypt(ciphertext: str) -> str
+    encrypt(plaintext: str) -> str
+    check(ciphertext: str, other: str) -> tuple[str, str, bool]
+"""
+
+from __future__ import annotations
+
+import random
+
+__all__ = ["decrypt", "encrypt", "check"]
+
+MAGIC = "$9$"
+FAMILY = ["QzF3n6/9CAtpu0O", "B1IREhcSyrleKvMW8LXx", "7N-dVbwsY2g4oaJZGUDj", "iHkq.mPf5T"]
+EXTRA = {c: 3 - i for i, f in enumerate(FAMILY) for c in f}
+ALPHA = "".join(FAMILY)
+NUM = {c: i for i, c in enumerate(ALPHA)}
+ENCODING = [[1, 4, 32], [1, 16, 32], [1, 8, 32], [1, 64], [1, 32], [1, 4, 16, 128], [1, 32, 64]]
+
+
+def _gap(c1: str, c2: str) -> int:
+    return (NUM[c2] - NUM[c1]) % len(ALPHA) - 1
+
+
+def decrypt(ciphertext: str) -> str:
+    """Decrypt a Juniper $9$ ciphertext back to plaintext."""
+    if not ciphertext.startswith(MAGIC):
+        raise ValueError(f"Not a Juniper $9$ string: must start with {MAGIC}")
+    chars = ciphertext[len(MAGIC):]
+    if not chars:
+        raise ValueError("Empty $9$ payload")
+    first = chars[0]
+    if first not in NUM:
+        raise ValueError(f"Invalid start character {first!r}: not in $9$ alphabet")
+    chars = chars[1 + EXTRA[first]:]
+    prev = first
+    result: list[str] = []
+    while chars:
+        weights = ENCODING[len(result) % len(ENCODING)]
+        nibble = chars[: len(weights)]
+        if len(nibble) < len(weights):
+            raise ValueError("Truncated $9$ ciphertext: incomplete final character group")
+        chars = chars[len(weights):]
+        val = 0
+        for c, w in zip(nibble, weights):
+            if c not in NUM:
+                raise ValueError(f"Character {c!r} not in $9$ alphabet: ciphertext may be invalid")
+            val += _gap(prev, c) * w
+            prev = c
+        result.append(chr(val % 256))
+    return "".join(result)
+
+
+def encrypt(plaintext: str) -> str:
+    """Encrypt plaintext to a Juniper $9$ ciphertext.
+
+    Output is non-deterministic: random filler characters mean each call
+    returns a different ciphertext for the same plaintext. All of them
+    decrypt back to the same plaintext. `random` (not `secrets`) is used
+    deliberately, since $9$ is a substitution cipher with no real
+    cryptographic strength: a stronger RNG buys nothing.
+    """
+    start = random.choice(ALPHA)
+    result = [MAGIC, start]
+    for _ in range(EXTRA[start]):
+        result.append(random.choice(ALPHA))
+    prev = start
+    for i, ch in enumerate(plaintext):
+        weights = ENCODING[i % len(ENCODING)]
+        val = ord(ch)
+        if val > 255:
+            raise ValueError(
+                f"Character {ch!r} cannot be $9$-encoded: only single-byte (Latin-1) characters are supported"
+            )
+        gaps: list[int] = []
+        for w in reversed(weights):
+            gaps.append(val // w)
+            val = val % w
+        for gap in reversed(gaps):
+            c = ALPHA[(NUM[prev] + gap + 1) % len(ALPHA)]
+            result.append(c)
+            prev = c
+    return "".join(result)
+
+
+def check(ciphertext: str, other: str) -> tuple[str, str, bool]:
+    """Decrypt `ciphertext` and compare to `other`.
+
+    `other` may be a plaintext, or another $9$ value (auto-detected by
+    the $9$ prefix). Returns (plain_a, plain_b, match).
+    """
+    plain_a = decrypt(ciphertext)
+    plain_b = decrypt(other) if other.startswith(MAGIC) else other
+    return plain_a, plain_b, plain_a == plain_b

network_secret-0.1.0/network_secret/nokia_sros_custom_hash.py

@@ -0,0 +1,110 @@
+"""Nokia SR OS custom-hash secrets.
+
+Configured on SR OS via:
+    admin system security hash-control custom-hash algorithm aes256 key "..."
+
+It is deterministic AES in ECB mode with PKCS#7 padding, base64-encoded, and
+carried in config as "<base64> custom". Because ECB is deterministic, the same
+plaintext and key produce identical ciphertext on every node sharing the key -
+which is the point: portable, node-independent secrets.
+
+The key is the literal characters of the shared-key string (SR OS counts the
+string length, not a decoded byte length). 16 / 24 / 32 characters select
+AES-128 / AES-192 / AES-256.
+
+Public API:
+    encrypt(plaintext: str, key: str) -> str
+    decrypt(ciphertext: str, key: str) -> str
+    check(ciphertext: str, other: str, key: str) -> tuple[str, str, bool]
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.padding import PKCS7
+
+__all__ = ["encrypt", "decrypt", "check"]
+
+SUFFIX = "custom"
+# Environment variable the CLI reads the shared key from when -k/--key is absent.
+ENV_KEY = "SROS_CUSTOM_HASH_KEY"
+BLOCK = 16  # AES block size in bytes
+# SR OS writes the marker as exactly "<base64> custom": one space before the
+# word. Matching is case-insensitive; surrounding whitespace is trimmed.
+_MARKER = f" {SUFFIX}"
+
+
+def _has_suffix(value: str) -> bool:
+    return value.strip().lower().endswith(_MARKER)
+
+
+def _strip_suffix(value: str) -> str:
+    value = value.strip()
+    if _has_suffix(value):
+        value = value[: -len(_MARKER)]
+    return value.strip()
+
+
+def _key_bytes(key: str) -> bytes:
+    raw = key.encode("utf-8")
+    if len(raw) not in (16, 24, 32):
+        raise ValueError(
+            f"Key must be 16, 24, or 32 characters (AES-128 / AES-192 / AES-256); "
+            f"got {len(raw)}"
+        )
+    return raw
+
+
+def _ecb(key: str) -> Cipher:
+    return Cipher(algorithms.AES(_key_bytes(key)), modes.ECB())
+
+
+def encrypt(plaintext: str, key: str) -> str:
+    """Encrypt plaintext into a Nokia custom-hash value: '<base64> custom'."""
+    padder = PKCS7(BLOCK * 8).padder()
+    padded = padder.update(plaintext.encode("utf-8")) + padder.finalize()
+    encryptor = _ecb(key).encryptor()
+    ciphertext = encryptor.update(padded) + encryptor.finalize()
+    return f"{base64.b64encode(ciphertext).decode('ascii')} {SUFFIX}"
+
+
+def decrypt(ciphertext: str, key: str) -> str:
+    """Decrypt a Nokia custom-hash value, with or without the ' custom' suffix.
+
+    Raises ValueError on a malformed value, a bad key length, a wrong key, or
+    a value not produced by this scheme.
+    """
+    b64 = _strip_suffix(ciphertext)
+    try:
+        raw = base64.b64decode(b64, validate=True)
+    except binascii.Error as e:
+        raise ValueError(f"Invalid base64 in custom-hash value: {b64!r}") from e
+    if len(raw) == 0 or len(raw) % BLOCK != 0:
+        raise ValueError(
+            "Invalid ciphertext: length is not a multiple of the AES block size"
+        )
+    decryptor = _ecb(key).decryptor()
+    decrypted = decryptor.update(raw) + decryptor.finalize()
+    try:
+        unpadder = PKCS7(BLOCK * 8).unpadder()
+        plaintext = unpadder.update(decrypted) + unpadder.finalize()
+        return plaintext.decode("utf-8")
+    except (ValueError, UnicodeDecodeError) as e:
+        raise ValueError(
+            "Decryption failed: wrong key, or not a valid custom-hash value"
+        ) from e
+
+
+def check(ciphertext: str, other: str, key: str) -> tuple[str, str, bool]:
+    """Decrypt `ciphertext` and compare to `other`.
+
+    `other` may be a plaintext, or another custom-hash value (auto-detected by
+    the ' custom' suffix and decrypted with the same key). Returns
+    (plain_a, plain_b, match).
+    """
+    plain_a = decrypt(ciphertext, key)
+    plain_b = decrypt(other, key) if _has_suffix(other) else other
+    return plain_a, plain_b, plain_a == plain_b

network_secret-0.1.0/network_secret/registry.py

@@ -0,0 +1,46 @@
+"""The catalogue of supported secret formats.
+
+One Cipher entry per format. The CLI builds its subcommands and its --list
+output entirely from this list; adding a format means adding a module and one
+entry here.
+"""
+
+from __future__ import annotations
+
+from . import juniper8, juniper9, nokia_sros_custom_hash
+from .types import Cipher, KeyKind
+
+REGISTRY: list[Cipher] = [
+    Cipher(
+        id="juniper9",
+        vendor="Juniper",
+        name="Juniper $9$",
+        key_kind=KeyKind.NONE,
+        encrypt=juniper9.encrypt,
+        decrypt=juniper9.decrypt,
+        check=juniper9.check,
+    ),
+    Cipher(
+        id="juniper8",
+        vendor="Juniper",
+        name="Juniper $8$",
+        key_kind=KeyKind.MASTER_PASSWORD,
+        encrypt=juniper8.encrypt,
+        decrypt=juniper8.decrypt,
+        check=juniper8.check,
+    ),
+    Cipher(
+        id="nokia-sros-custom-hash",
+        vendor="Nokia",
+        name="Nokia SR OS custom-hash",
+        key_kind=KeyKind.SHARED_KEY,
+        encrypt=nokia_sros_custom_hash.encrypt,
+        decrypt=nokia_sros_custom_hash.decrypt,
+        check=nokia_sros_custom_hash.check,
+    ),
+]
+
+
+def find(cipher_id: str) -> Cipher | None:
+    """Return the Cipher with this id, or None if there is no such cipher."""
+    return next((c for c in REGISTRY if c.id == cipher_id), None)

network_secret-0.1.0/network_secret/types.py

@@ -0,0 +1,43 @@
+"""The Cipher contract shared by every supported secret format.
+
+Mirrors the registry-of-ciphers structure of the network-secret-website web
+app: each format is one Cipher entry carrying its metadata and its three
+operations.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+
+
+class KeyKind(Enum):
+    """What kind of key a cipher needs (drives CLI key handling)."""
+
+    NONE = "none"
+    MASTER_PASSWORD = "master-password"
+    SHARED_KEY = "shared-key"
+
+
+@dataclass(frozen=True)
+class Cipher:
+    """A supported secret format and its operations.
+
+    encrypt / decrypt / check are the module-level functions of the cipher.
+    Their signatures vary by key_kind (keyless ciphers take no key argument),
+    so they are typed loosely here; the CLI supplies the right arguments per
+    key_kind.
+    """
+
+    id: str
+    vendor: str
+    name: str
+    key_kind: KeyKind
+    encrypt: Callable[..., str]
+    decrypt: Callable[..., str]
+    check: Callable[..., tuple[str, str, bool]]
+
+    @property
+    def keyed(self) -> bool:
+        return self.key_kind is not KeyKind.NONE

network_secret-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "network-secret"
+version = "0.1.0"
+description = "Encode, decode, and check network device secrets: Juniper $9$, Juniper $8$, and Nokia SR OS custom-hash"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Antoine Keranflec'h", email = "antoine.keranflech@gmail.com" },
+]
+requires-python = ">=3.11"
+keywords = ["juniper", "junos", "nokia", "sros", "password", "crypt", "decrypt", "network", "$9$", "$8$", "custom-hash"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: System Administrators",
+    "Intended Audience :: Telecommunications Industry",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security :: Cryptography",
+    "Topic :: System :: Networking",
+]
+dependencies = [
+    "cryptography>=42.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/antoinekh/network-secret"
+Repository = "https://github.com/antoinekh/network-secret"
+Issues = "https://github.com/antoinekh/network-secret/issues"
+
+[project.scripts]
+network-secret = "network_secret.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["network_secret"]
+
+[tool.hatch.build.targets.sdist]
+include = ["network_secret/", "README.md", "LICENSE", "tests/"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

network_secret-0.1.0/tests/test_cli.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import pytest
+
+from network_secret.cli import main
+
+
+def test_version(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["--version"])
+    assert exc.value.code == 0
+    assert "network-secret" in capsys.readouterr().out
+
+
+def test_list(capsys):
+    assert main(["--list"]) == 0
+    out = capsys.readouterr().out
+    assert "juniper9" in out
+    assert "juniper8" in out
+    assert "nokia-sros-custom-hash" in out
+
+
+def test_juniper9_round_trip(capsys):
+    assert main(["juniper9", "--encrypt", "hunter2"]) == 0
+    ct = capsys.readouterr().out.strip()
+    assert main(["juniper9", "--decrypt", ct]) == 0
+    assert capsys.readouterr().out.strip() == "hunter2"
+
+
+def test_juniper8_encrypt_decrypt(capsys):
+    assert main(["juniper8", "-m", "MASTER", "--encrypt", "hunter2"]) == 0
+    ct = capsys.readouterr().out.strip()
+    assert main(["juniper8", "-m", "MASTER", "--decrypt", ct]) == 0
+    assert capsys.readouterr().out.strip() == "hunter2"
+
+
+def test_nokia_round_trip(capsys):
+    key = "a3f8d9e112c04b7af1c3e8b92d057a4e"
+    assert main(["nokia-sros-custom-hash", "-k", key, "--encrypt", "hunter2"]) == 0
+    ct = capsys.readouterr().out.strip()
+    assert main(["nokia-sros-custom-hash", "-k", key, "--decrypt", ct]) == 0
+    assert capsys.readouterr().out.strip() == "hunter2"
+
+
+def test_check_match_returns_0(capsys):
+    main(["juniper9", "--encrypt", "hunter2"])
+    ct = capsys.readouterr().out.strip()
+    assert main(["juniper9", "--check", ct, "hunter2"]) == 0
+
+
+def test_check_mismatch_returns_1(capsys):
+    main(["juniper9", "--encrypt", "hunter2"])
+    ct = capsys.readouterr().out.strip()
+    assert main(["juniper9", "--check", ct, "nope"]) == 1
+
+
+def test_error_returns_2():
+    assert main(["juniper8", "-m", "MASTER", "--decrypt", "not-a-real-8"]) == 2
+
+
+def test_nokia_key_from_env(monkeypatch, capsys):
+    monkeypatch.setenv("SROS_CUSTOM_HASH_KEY", "a3f8d9e112c04b7af1c3e8b92d057a4e")
+    assert main(["nokia-sros-custom-hash", "--encrypt", "hunter2"]) == 0
+    # The Nokia format appends " custom" as a marker, so a successful encrypt
+    # with the env-var key produces a value ending in "custom".
+    assert capsys.readouterr().out.strip().endswith("custom")
+
+
+def test_juniper8_master_from_env(monkeypatch, capsys):
+    monkeypatch.setenv("JUNOS_MASTER_PASSWORD", "MASTER")
+    assert main(["juniper8", "--encrypt", "hunter2"]) == 0
+    ct = capsys.readouterr().out.strip()
+    assert main(["juniper8", "--decrypt", ct]) == 0
+    assert capsys.readouterr().out.strip() == "hunter2"
+
+
+def test_check_output_format(capsys):
+    main(["juniper9", "--encrypt", "hunter2"])
+    ct = capsys.readouterr().out.strip()
+    main(["juniper9", "--check", ct, "hunter2"])
+    out = capsys.readouterr().out
+    assert "Value 1   : 'hunter2'" in out
+    assert "Value 2   : 'hunter2'" in out
+    assert "Match     : YES" in out

network_secret-0.1.0/tests/test_juniper8.py

@@ -0,0 +1,72 @@
+"""pytest suite for network_secret.juniper8."""
+
+from __future__ import annotations
+
+import pytest
+
+from network_secret import juniper8
+
+MASTER = "master-secret"
+
+# Master password and $8$ values captured from a real JUNOS 23.2 device.
+# Source: juniper8-crypt upstream test suite.
+DEVICE_MASTER = "a3f8d9e112c04b7af1c3e8b92d057a4e"
+
+KNOWN_VECTORS = [
+    (
+        "$8$aes256-gcm$hmac-sha2-256$100$p8XEvHtxRNE$d/hqRmh5etkBzo7WSdtvjg$"
+        "7w1eMTYXkz4RdzMF9CAkJQ$qVLunbFwBWwyxln2Vg",
+        "LabBgpSecret1",
+    ),
+    (
+        "$8$aes256-gcm$hmac-sha2-256$100$32kBriS21/k$0O08cy0znzu4nrcHxbhMmA$"
+        "PP0OeY9ANX2UDT1FTDVpiQ$gTrzX/ZppBbu42TpRtw",
+        "LabIsisSecret1",
+    ),
+]
+
+
+@pytest.mark.parametrize("ciphertext,expected", KNOWN_VECTORS)
+def test_decrypt_device_known_vectors(ciphertext: str, expected: str) -> None:
+    """Device-verified known-answer test: proves cross-version parity."""
+    assert juniper8.decrypt(ciphertext, DEVICE_MASTER) == expected
+
+
+def test_round_trip():
+    ct = juniper8.encrypt("hunter2", MASTER)
+    assert juniper8.decrypt(ct, MASTER) == "hunter2"
+
+
+def test_non_deterministic():
+    assert juniper8.encrypt("x", MASTER) != juniper8.encrypt("x", MASTER)
+
+
+def test_wrong_master_fails():
+    ct = juniper8.encrypt("hunter2", MASTER)
+    with pytest.raises(ValueError):
+        juniper8.decrypt(ct, "wrong-master")
+
+
+def test_check_match_and_mismatch():
+    ct = juniper8.encrypt("hunter2", MASTER)
+    assert juniper8.check(ct, "hunter2", MASTER)[2] is True
+    assert juniper8.check(ct, "nope", MASTER)[2] is False
+
+
+def test_check_other_is_ciphertext():
+    a = juniper8.encrypt("same", MASTER)
+    b = juniper8.encrypt("same", MASTER)
+    assert juniper8.check(a, b, MASTER)[2] is True
+
+
+def test_decrypt_rejects_non_magic():
+    with pytest.raises(ValueError):
+        juniper8.decrypt("$9$nope", MASTER)
+
+
+def test_decrypt_rejects_non_ascii_iteration_count():
+    # str.isdigit() is True for non-ASCII digits (e.g. superscript "²") that
+    # int() cannot parse; the dedicated message must still be raised.
+    value = KNOWN_VECTORS[0][0].replace("$100$", "$²$", 1)
+    with pytest.raises(ValueError, match="Invalid iteration count"):
+        juniper8.decrypt(value, DEVICE_MASTER)

network_secret-0.1.0/tests/test_juniper9.py

@@ -0,0 +1,33 @@
+"""pytest suite for network_secret.juniper9."""
+
+from __future__ import annotations
+
+import pytest
+
+from network_secret import juniper9
+
+
+def test_known_answer_decrypt():
+    # Real vector from juniper9-crypt test suite: "$9$FNkC3/t1IcevLuOWx" decrypts to "hello".
+    assert juniper9.decrypt("$9$FNkC3/t1IcevLuOWx") == "hello"
+
+
+def test_round_trip():
+    assert juniper9.decrypt(juniper9.encrypt("S3cr3t!")) == "S3cr3t!"
+
+
+def test_check_match_and_mismatch():
+    ct = juniper9.encrypt("hunter2")
+    assert juniper9.check(ct, "hunter2")[2] is True
+    assert juniper9.check(ct, "nope")[2] is False
+
+
+def test_check_other_is_ciphertext():
+    a = juniper9.encrypt("same")
+    b = juniper9.encrypt("same")
+    assert juniper9.check(a, b)[2] is True
+
+
+def test_decrypt_rejects_non_magic():
+    with pytest.raises(ValueError):
+        juniper9.decrypt("not-a-9-string")

network_secret-0.1.0/tests/test_nokia_sros_custom_hash.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import pytest
+
+from network_secret import nokia_sros_custom_hash as nokia
+
+# Known-answer vector shared with the network-secret-website web app.
+KEY = "a3f8d9e112c04b7af1c3e8b92d057a4e"  # 32 chars -> AES-256
+PLAINTEXT = "L@bS3cr3t!"
+ENCODED = "Xfs39BMeblOtlorgwTChxQ== custom"
+
+
+def test_known_answer_decrypt():
+    assert nokia.decrypt(ENCODED, KEY) == PLAINTEXT
+
+
+def test_known_answer_encrypt_is_deterministic():
+    # ECB is deterministic: encrypt reproduces the exact vector.
+    assert nokia.encrypt(PLAINTEXT, KEY) == ENCODED
+
+
+def test_round_trip():
+    ct = nokia.encrypt("hunter2", KEY)
+    assert nokia.decrypt(ct, KEY) == "hunter2"
+
+
+def test_decrypt_without_suffix():
+    assert nokia.decrypt(ENCODED.removesuffix(" custom"), KEY) == PLAINTEXT
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        "Xfs39BMeblOtlorgwTChxQ== custom",  # canonical: one space marker
+        "Xfs39BMeblOtlorgwTChxQ== CUSTOM",  # case-insensitive
+        "  Xfs39BMeblOtlorgwTChxQ== custom  ",  # surrounding whitespace trimmed
+    ],
+)
+def test_decrypt_suffix_variants(value):
+    # SR OS writes "<base64> custom" with exactly one space; matching is
+    # case-insensitive and surrounding whitespace is trimmed.
+    assert nokia.decrypt(value, KEY) == PLAINTEXT
+
+
+@pytest.mark.parametrize("klen", [16, 24, 32])
+def test_accepts_128_192_256(klen):
+    key = "k" * klen
+    assert nokia.decrypt(nokia.encrypt("x", key), key) == "x"
+
+
+@pytest.mark.parametrize("klen", [15, 17, 31, 33])
+def test_rejects_bad_key_length(klen):
+    with pytest.raises(ValueError):
+        nokia.encrypt("x", "k" * klen)
+
+
+def test_wrong_key_fails():
+    ct = nokia.encrypt("hunter2", KEY)
+    with pytest.raises(ValueError):
+        nokia.decrypt(ct, "b" * 32)
+
+
+def test_check_match_and_mismatch():
+    assert nokia.check(ENCODED, PLAINTEXT, KEY)[2] is True
+    assert nokia.check(ENCODED, "nope", KEY)[2] is False

network_secret-0.1.0/tests/test_public_api.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import network_secret
+
+
+def test_modules_exposed():
+    assert network_secret.juniper8.decrypt(
+        network_secret.juniper8.encrypt("x", "M"), "M"
+    ) == "x"
+    assert network_secret.juniper9.decrypt(
+        network_secret.juniper9.encrypt("x")
+    ) == "x"
+    key = "a3f8d9e112c04b7af1c3e8b92d057a4e"
+    assert network_secret.nokia_sros_custom_hash.decrypt(
+        network_secret.nokia_sros_custom_hash.encrypt("x", key), key
+    ) == "x"
+
+
+def test_version_is_string():
+    assert isinstance(network_secret.__version__, str)

network_secret-0.1.0/tests/test_registry.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from network_secret.registry import REGISTRY, find
+from network_secret.types import KeyKind
+
+
+def test_registry_ids_and_order():
+    assert [c.id for c in REGISTRY] == [
+        "juniper9",
+        "juniper8",
+        "nokia-sros-custom-hash",
+    ]
+
+
+def test_find_returns_cipher_or_none():
+    assert find("juniper8").vendor == "Juniper"
+    assert find("does-not-exist") is None
+
+
+def test_key_kinds():
+    assert find("juniper9").key_kind is KeyKind.NONE
+    assert find("juniper8").key_kind is KeyKind.MASTER_PASSWORD
+    assert find("nokia-sros-custom-hash").key_kind is KeyKind.SHARED_KEY
+
+
+def test_operations_wired():
+    j9 = find("juniper9")
+    assert j9.decrypt(j9.encrypt("hunter2")) == "hunter2"

network_secret-0.1.0/tests/test_types.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from network_secret.types import Cipher, KeyKind
+
+
+def _noop_check(a: str, b: str) -> tuple[str, str, bool]:
+    return a, b, a == b
+
+
+def test_keyed_is_false_only_for_none_key_kind():
+    keyless = Cipher(
+        id="x", vendor="V", name="X", key_kind=KeyKind.NONE,
+        encrypt=lambda s: s, decrypt=lambda s: s, check=_noop_check,
+    )
+    keyed = Cipher(
+        id="y", vendor="V", name="Y", key_kind=KeyKind.MASTER_PASSWORD,
+        encrypt=lambda s: s, decrypt=lambda s: s, check=_noop_check,
+    )
+    assert keyless.keyed is False
+    assert keyed.keyed is True