bipsea 0.1__tar.gz

bipsea-0.1/LICENSE.md

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

bipsea-0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: bipsea
+Version: 0.1
+Summary: Python implementation of BIP 85 (and BIP 32)
+Author: Aneesh Karve
+Author-email: bonded_metals_0u@icloud.com
+Project-URL: Source, https://github.com/akarve/bipsea
+Keywords: Bitcoin BIP85  BIP32 cryptography
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+License-File: LICENSE.md
+Requires-Dist: click
+Requires-Dist: base58
+Requires-Dist: ecdsa
+Requires-Dist: pytest

bipsea-0.1/README.md

@@ -0,0 +1,243 @@
+# `bipsea`: unlimited cryptographic entropy for Bitcoin, passwords, and other secrets
+
+> _One Seed to rule them all,  
+> One Key to find them,  
+> One Path to bring them all,  
+> And in cryptography bind them._  
+> —[BIP-85](https://github.com/bitcoin/bips/blob/master/bip-0085.mediawiki)
+
+bipsea is a standalone, test-driven implementation of BIP-85 and BIP-32.
+bipsea is designed for readability and security. bipsea offers a command-line
+interface and an API.
+
+bipsea relies on cryptographic primitives from Python (`secrets`, `hashlib`),
+and the [python-ecdsa](https://github.com/tlsfuzzer/python-ecdsa). bipsea does not
+rely on third-party libraries from any wallet vendor.
+
+You can run bipsea offline on to generate general-use passwords, Bitcoin seed words,
+and more. Consider dedicated cold hardware that runs [Tails](https://tails.net),
+never has network access, and disables
+[Intel Management Engine](https://support.system76.com/articles/intel-me/)
+and other possible backdoors.
+
+# How is this useful?
+
+BIP-85 is the foundation for a next generation password manager that enables you
+to protect and store a _single_ master secret that can derive _millions of independent, multi-purpose secrets_. 
+
+BIP-85 offers the following benefits:
+* The security of numerous independent passwords with the operational efficiency
+of a single master password. (The master secret can be multi-factor.)
+* Uses Bitcoin's well-tested hierarchical deterministic wallet
+tree (including primitives like ECDSA and hardened children)
+* Can generate millions of new Bitcoin wallet seed words and master keys
+* Can generate millions of new passwords from a single master root key (xprv)
+and a short derivation path.
+
+Unlike a password manager, which protects many secrets with one hot secret,
+BIP-85 _derives_ many secrets from one protected secret. Therefore you only need
+to back up the derivation paths and the services they are for. You do not need to
+back up the derived secrets.
+
+You could safely store all derivation paths in a hot password manager
+like Keychain. You could even store the derived secrets in a hot password manager
+at no risk to the master private key.
+
+> Note: bipsea alone is not password manager, but you might use it to implement one.
+
+# How does it work?
+
+The root of your BIP-85 password tree is a standard Bitcoin master private key (xprv).
+
+> In general, you _should not use a wallet seed with funds in it_.
+> In any case, fresh seeds are free and easy to generate with bipsea.
+
+The master key then uses the BIP-32 derivation tree with a clever twist: the
+derivation path includes a purpose code (`83696968'`) followed by an _application_
+code. In this way, each unique derivation path produces a unique, independent,
+and secure _derived entropy_ as a pure function of the master private key and the
+derivation path.
+
+BIP-85 specifies a variety of application codes including the following:
+
+| application code | description |
+|------------------|-------------|
+| `39'`            | as in BIP-39, to generate seed words |
+| `2'`             | for HD-Seed wallet import format ([WIF](https://en.bitcoin.it/wiki/Wallet_import_format)) |
+| `32'`            | as in BIP-32, to generate extended private keys (xprv) |
+| `128169'`        | for 16 to 64 bytes of random hex |
+| `707764'`        | for 20 to 86 characters of a base64 password |
+| `707785'`        | for 10 to 80 characters of a base85 password |
+
+bipsea implements all of the above applications plus the BIP-85 discrete random
+number generator (DRNG). bipsea does not implement the RSA application codes from
+BIP-85 but you could potentially use the DRNG for RSA and similar applications.
+
+## Example derivation path
+
+Consider `m/83696968'/707764'/10'/0'`. It produces the password
+`dKLoepugzd` according to the following logic:
+
+| path segment | description                               |
+|--------------|-------------------------------------------|
+| `m`          | master private key                        |
+| `83696968'`  | purpose code for BIP-85                   |
+| `707764'`    | application code for base64 password      |
+| `10'`        | number of password characters             |
+| `0'`         | index, 0 to 2³¹ - 1 for millions of unique passwords |
+
+> `'` denotes hardened child derivation, recommended for all BIP-85 applications.
+_Hardened_ derivation means that, even if both the parent public key and the child
+private key are exposed, the parent private key remains secure.
+
+## BIP-32 hierarchical deterministic wallet tree
+
+![](imgs/derivation.png)
+
+## How do I know the bipsea implementation is correct?
+
+bipsea passes all BIP-32 and BIP-85 test vectors plus its own unit tests with the
+following provisos:
+* Only generates seed phrases in English
+* Fails one partial test for derived entropy (but passes all others) from BIP-85
+
+### TODO
+
+* [ ] File the above and other "TODO" issues to BIP-85
+
+Run `make test` for details.
+
+# Usage
+
+```
+pip install bipsea
+```
+```
+bipsea --help
+```
+
+## `bipsea seed`
+
+### New seed words
+
+```sh
+bipsea seed -n 12 --pretty
+```
+    1) crumble
+    2) shallow
+    3) hair
+    4) federal
+    5) cycle
+    6) grid
+    7) million
+    8) twist
+    9) turn
+    10) verb
+    11) orphan
+    12) suggest
+
+### xprv from existing seed words
+
+```
+bipsea seed -f words -i "airport letter idea forget broccoli prefer panda food delay struggle ridge salute above want dinner" -t xprv
+```
+    xprv9s21ZrQH143K3YwuXcacSSghcUfrrEyj9hTHU3a2gmr6SzPBaxmuTgKGBWtFdnnCjwGYMkU7mLvxba8FFPGLQUMvyACZTEdSCJ8uBwh5Aqs
+
+## xprv from dice rolls (or any string)
+```
+bipsea seed -f string -i "123456123456123456" -t xprv
+```
+
+<pre><code style="color: #CCCC00">Warning: stretched 144 bits of entropy to 256 bits. Provide more entropy.</code></pre>
+
+    xprv9s21ZrQH143K35QDSCrHfhTJNQGS8ehYV74s65pMwTHfHq89oqcqVQJU4iD3B2M68skmz32eT8Kdr1thXJ6tHXRpy77QtAN1dhEdvqYPiVm
+
+This is similar to how coldcard implements
+[verifiable dice rolls](https://coldcard.com/docs/verifying-dice-roll-math/).
+If you are now thinking, _I could use any string to derive a master key_,
+then you get it. And we haven't even gottent into BIP-85.
+
+> That said, **do not get cute and derive valuable keys or secrets from short
+> strings**. You can only stretch entropy so far. **Weak entropy in, weaker entropy out**.
+> Short, common strings are also susceptible to
+[rainbow table attacks](https://en.wikipedia.org/wiki/Rainbow_table).
+
+
+## `bipsea entropy`
+
+`bipsea entropy` requires you to pipe in an xprv.
+
+### base64 password
+
+```
+bipsea seed -f string -i "yoooooooooooooooo" -t xprv -n 12 | bipsea entropy -a base85 -n 10
+```
+    C(s>@zBUg8
+
+Increment the index to get a fresh password.
+
+```
+bipsea seed -f string -i "yoooooooooooooooo" -t xprv -n 12 | bipsea entropy -a base85 -n 10 -i 1
+```
+    p6Ft=F40(*
+
+Alternatively you can pipe in an existing xprv:
+
+```
+echo "$XPRV" | bipsea entropy -a base85 -n 10
+```
+
+### Derived seed words
+
+```
+bipsea seed -t xprv | bipsea entropy -a words        
+```
+    loan height quality library maid defense minor token thought music claim actual hour ship robust burst live broccoli
+
+### DRNG, enter the matrix
+
+```
+bipsea seed -t xprv | bipsea entropy -a drng -n 10000
+```
+    <10K hex chars from the DRNG>
+
+# For the curious and paranoid
+
+BIP-85 derives the entropy for each application by computing an HMAC of the private
+ECDSA key of the last hardened child. Private child keys are pure functions of the
+parent key and the child index. In this way BIP-85 entropy is hierarchical,
+deterministic, and irreversibly hardened as long as ECDSA remains secure.
+ECDSA is believed to be secure but no one knows for certain. It may not even be
+possible to conclusively prove the security of any cryptographic algorithm as such
+a proof would simultaneously prove that "P is not equal to NP."
+
+All of that to say **even the hardest cryptography falls to the problem of induction**:
+> Just because no one broke has yet broken ECDSA
+> doesn't mean no one will break ECDSA.
+
+ECDSA is not [post-quantum secure](https://blog.cloudflare.com/pq-2024).
+If someone were to creates the elusive quant computer with sufficiently many
+logical q-bits to run Shor's algorithm on large keys, then suddenly private
+could be reverse-engineered from public keys. As unlikely as a quantum computer
+may seem, the Chromium team is
+[taking no chances](https://blog.chromium.org/2024/05/advancing-our-amazing-bet-on-asymmetric.html)
+and has begun to roll out quantum-resistant changes to SSL.
+
+# Developer
+
+```
+make install
+make install-go
+make test
+```
+
+See [Makefile](./Makefile) for more commands.
+
+# References
+
+1. [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)
+hierarchical deterministic wallets
+1. [BIP-85](https://github.com/bitcoin/bips/blob/master/bip-0085.mediawiki)
+generalized cryptographic entropy
+1. [BIP-44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki)
+generalized BIP-32 paths

bipsea-0.1/bipsea.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: bipsea
+Version: 0.1
+Summary: Python implementation of BIP 85 (and BIP 32)
+Author: Aneesh Karve
+Author-email: bonded_metals_0u@icloud.com
+Project-URL: Source, https://github.com/akarve/bipsea
+Keywords: Bitcoin BIP85  BIP32 cryptography
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+License-File: LICENSE.md
+Requires-Dist: click
+Requires-Dist: base58
+Requires-Dist: ecdsa
+Requires-Dist: pytest

bipsea-0.1/bipsea.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE.md
+README.md
+setup.py
+bipsea.egg-info/PKG-INFO
+bipsea.egg-info/SOURCES.txt
+bipsea.egg-info/dependency_links.txt
+bipsea.egg-info/entry_points.txt
+bipsea.egg-info/requires.txt
+bipsea.egg-info/top_level.txt
+tests/test_bip32.py
+tests/test_bip39.py
+tests/test_bip85.py
+tests/test_cli.py

bipsea-0.1/bipsea.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bipsea-0.1/bipsea.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bipsea = bipsea:cli

bipsea-0.1/bipsea.egg-info/requires.txt

@@ -0,0 +1,4 @@
+click
+base58
+ecdsa
+pytest

bipsea-0.1/bipsea.egg-info/top_level.txt

@@ -0,0 +1 @@
+

bipsea-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bipsea-0.1/setup.py

@@ -0,0 +1,41 @@
+from setuptools import find_packages, setup
+
+from util import __app_name__, __version__
+
+setup(
+    name=__app_name__,
+    version=__version__,
+    packages=find_packages(),
+    description="Python implementation of BIP 85 (and BIP 32)",
+    author="Aneesh Karve",
+    author_email="bonded_metals_0u@icloud.com",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: Apache Software License",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+    ],
+    keywords="Bitcoin BIP85  BIP32 cryptography",
+    install_requires=[
+        "click",
+        "base58",
+        "ecdsa",
+        "pytest",
+    ],
+    tests_require=[
+        "black",
+        "isort",
+        "pytest",
+        "requests",
+    ],
+    project_urls={
+        "Source": "https://github.com/akarve/bipsea",
+    },
+    entry_points={
+        "console_scripts": [
+            "bipsea=bipsea:cli",
+        ],
+    },
+)

bipsea-0.1/tests/test_bip32.py

@@ -0,0 +1,43 @@
+import logging
+
+import pytest
+from data.bip32_vectors import INVALID_KEYS, VECTORS
+
+from bip32 import to_master_key
+from bip32types import parse_ext_key
+from bip85 import derive
+from util import LOGGER, from_hex
+
+logger = logging.getLogger(LOGGER)
+
+
+@pytest.mark.parametrize(
+    "vector",
+    VECTORS,
+    ids=[
+        f"Vector-{i + 1}-{', '.join(e['chain'].keys())}" for i, e in enumerate(VECTORS)
+    ],
+)
+def test_vectors(vector):
+    seed = from_hex(vector["seed_hex"])
+    for ch, tests in vector["chain"].items():
+        for type_, expected in tests.items():
+            assert type_ in ("ext pub", "ext prv")
+            master = to_master_key(seed, mainnet=True, private=True)
+            derived = derive(master, ch, private=type_ == "ext prv")
+            if not str(derived) == expected:
+                logger.error("derived:")
+                logger.error(repr(derived))
+                logger.error("expected:")
+                logger.error(repr(parse_ext_key(expected)))
+            assert str(derived) == expected
+
+
+@pytest.mark.parametrize(
+    "key, reason",
+    INVALID_KEYS,
+    ids=[f"Vector-5-{reason[:32]}-{key[:8]}" for key, reason in INVALID_KEYS],
+)
+def test_invalid_keys(key, reason):
+    with pytest.raises((AssertionError, ValueError)):
+        parse_ext_key(key)

bipsea-0.1/tests/test_bip39.py

@@ -0,0 +1,62 @@
+import hashlib
+import logging
+import re
+import warnings
+from unicodedata import is_normalized
+
+import pytest
+import requests
+from data.bip39_vectors import VECTORS
+
+from bip32 import to_master_key
+from seedwords import DICT_HASH, N_MNEMONICS, entropy_to_words, to_master_seed
+from util import LOGGER, from_hex
+
+logger = logging.getLogger(LOGGER)
+
+WORD_COUNTS = {12, 15, 18, 21, 24}
+
+
+@pytest.mark.parametrize(
+    "language, vectors", VECTORS.items(), ids=[l for l in VECTORS.keys()]
+)
+def test_vectors(language, vectors):
+    for vector in vectors:
+        _, mnemonic, seed, xprv = vector
+        expected_words = re.split(r"\s", mnemonic)
+        expected_seed = from_hex(seed)
+        computed_seed = to_master_seed(expected_words, passphrase="TREZOR")
+        assert expected_seed == computed_seed
+        computed_xprv = to_master_key(expected_seed, mainnet=True, private=True)
+        assert str(computed_xprv) == xprv
+
+
+@pytest.mark.parametrize(
+    "language, vectors", VECTORS.items(), ids=[l for l in VECTORS.keys()]
+)
+def test_seed_word_generation(language, vectors):
+    for vector in vectors:
+        entropy_str, mnemonic, seed, xprv = vector
+        expected_words = re.split(r"\s", mnemonic)
+        if language == "english":
+            entropy_bytes = from_hex(entropy_str)
+            if all(b == 0 for b in entropy_bytes):
+                warnings.simplefilter("ignore")
+            computed_words = entropy_to_words(
+                len(expected_words), user_entropy=entropy_bytes, passphrase="TREZOR"
+            )
+            assert expected_words == computed_words
+        else:
+            pytest.skip(f"{language} not supported")
+
+
+@pytest.mark.network
+def test_words_in_bip39_wordlist():
+    """make sure we match github"""
+    url = "https://raw.githubusercontent.com/bitcoin/bips/master/bip-0039/english.txt"
+    response = requests.get(url)
+    wordlist = response.text.split()
+    assert all(is_normalized("NFKD", w) for w in wordlist)
+    assert len(wordlist) == N_MNEMONICS
+    response_hash = hashlib.sha256(response.content).hexdigest()
+    assert response_hash == DICT_HASH, f"Hash mismatch: {response_hash} != {DICT_HASH}"

bipsea-0.1/tests/test_bip85.py

@@ -0,0 +1,109 @@
+import logging
+
+import pytest
+from data.bip85_vectors import (
+    BIP39,
+    EXT_KEY_TO_ENTROPY,
+    HEX,
+    PWD_BASE64,
+    PWD_BASE85,
+    WIF,
+    XPRV,
+)
+
+from bip32types import parse_ext_key
+from bip85 import DRNG, apply_85, derive, to_entropy, to_hex_string
+from util import LOGGER, to_hex_string
+
+logger = logging.getLogger(LOGGER)
+
+
+@pytest.mark.parametrize(
+    "vector",
+    EXT_KEY_TO_ENTROPY,
+    ids=[f"Vector-{i + 1}" for i, e in enumerate(EXT_KEY_TO_ENTROPY)],
+)
+def test_entropy(vector):
+    master = parse_ext_key(vector["master"])
+    derived_key = derive(master, vector["path"])
+    secret = derived_key.data[1:]  # chop the BIP32 byte prefix
+    assert to_hex_string(secret) == vector["derived_key"]
+    entropy = to_entropy(secret)
+    assert to_hex_string(entropy) == vector["derived_entropy"]
+    if "drng" in vector:
+        output = DRNG(entropy).read(vector["drng_length"])
+        assert to_hex_string(output) == vector["drng"]
+
+
+@pytest.mark.parametrize("vector", PWD_BASE64)
+def test_pwd_base64(vector):
+    master = parse_ext_key(vector["master"])
+    path = vector["path"]
+    output = apply_85(derive(master, path), path)
+    assert vector["derived_pwd"] == output["application"]
+
+
+@pytest.mark.parametrize("vector", PWD_BASE64)
+@pytest.mark.xfail(reason="wut!? correct password, bad entropy; file to BIP-85")
+def test_pwd_base64_entropy(vector):
+    master = parse_ext_key(vector["master"])
+    path = vector["path"]
+    output = apply_85(derive(master, path), path)
+    assert vector["derived_entropy"] == to_hex_string(output["entropy"])
+
+
+@pytest.mark.parametrize("vector", PWD_BASE85)
+def test_pwd_base85(vector):
+    master = parse_ext_key(vector["master"])
+    path = vector["path"]
+    output = apply_85(derive(master, path), path)
+    assert vector["derived_pwd"] == output["application"]
+    assert vector["derived_entropy"] == to_hex_string(output["entropy"])
+
+
+@pytest.mark.parametrize("vector", BIP39)
+def test_bip39(vector):
+    master = parse_ext_key(vector["master"])
+    path = vector["path"]
+    output = apply_85(derive(master, path), path)
+    assert to_hex_string(output["entropy"]) == vector["derived_entropy"]
+    assert len(output["application"].split(" ")) == vector["mnemonic_length"]
+    assert output["application"] == vector["derived_mnemonic"]
+
+
+@pytest.mark.parametrize("vector", HEX)
+def test_hex(vector):
+    master = parse_ext_key(vector["master"])
+    path = vector["path"]
+    output = apply_85(derive(master, path), path)
+    assert vector["derived_entropy"] == output["application"]
+
+
+@pytest.mark.parametrize("vector", XPRV)
+def test_rsa_unsupported(vector):
+    """currently no support for RSA application.
+    path format: m/83696968'/828365'/{key_bits}'/{key_index}'"""
+    rsa_path = "m/83696968'/828365'/1024'/0'"
+    master = parse_ext_key(vector["master"])
+    with pytest.raises(NotImplementedError):
+        apply_85(derive(master, rsa_path), rsa_path)
+
+
+@pytest.mark.parametrize("vector", WIF)
+def test_wif(vector):
+    master = parse_ext_key(vector["master"])
+    path = vector["path"]
+    output = apply_85(derive(master, path), path)
+    assert to_hex_string(output["entropy"]) == vector["derived_entropy"]
+    # TODO: file against BIP85 poor test case does not include WIF checksum
+    # (not a correct WIF)
+    assert output["application"].decode("utf-8") == vector["derived_wif"]
+
+
+@pytest.mark.parametrize("vector", XPRV)
+def test_xprv(vector):
+    master = parse_ext_key(vector["master"])
+    path = vector["path"]
+    output = apply_85(derive(master, path), path)
+    assert vector["derived_key"] == output["application"]
+    assert to_hex_string(output["entropy"]) == vector["derived_entropy"]

bipsea-0.1/tests/test_cli.py

@@ -0,0 +1,196 @@
+import logging
+
+import pytest
+from click.testing import CliRunner
+
+from bipsea import N_WORDS_ALLOWED, cli
+from tests.data.bip39_vectors import VECTORS
+from tests.data.bip85_vectors import BIP39, HEX, PWD_BASE64, PWD_BASE85, WIF
+from util import LOGGER
+
+logger = logging.getLogger(LOGGER)
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+@pytest.mark.parametrize("language, vectors", VECTORS.items())
+def test_seed_command_to_actual_seed(runner, language, vectors):
+    for vector in vectors:
+        _, mnemonic, _, xprv = vector
+
+        for upper in (True, False):
+            mnemonic = mnemonic.upper() if upper else mnemonic
+            result = runner.invoke(
+                cli,
+                ["seed", "-t", "xprv", "-f", "words", "-i", mnemonic, "-p", "TREZOR"],
+            )
+            assert result.exit_code == 0
+            assert result.output.strip() == xprv
+
+
+@pytest.mark.parametrize("language, vectors", VECTORS.items())
+def test_seed_option_sensitivity(runner, language, vectors):
+    """prove that passphrase and mnemonic changes alter xprv (but white space around
+    mnemonic doesn't)"""
+    # make tests faster by only covering one per language
+    for vector in vectors[:1]:
+        _, mnemonic, _, xprv = vector
+
+        change_passphrase = runner.invoke(
+            cli, ["seed", "-t", "xprv", "-f", "words", "-i", mnemonic, "-p", "TrEZOR"]
+        )
+        assert change_passphrase.exit_code == 0
+        assert change_passphrase.output.strip() != xprv
+
+        append_mnemonic = runner.invoke(
+            cli,
+            ["seed", "-t", "xprv", "-f", "words", "-i", mnemonic + ".", "-p", "TREZOR"],
+        )
+        assert append_mnemonic.exit_code == 0
+        assert append_mnemonic.output.strip() != xprv
+
+        whitespace_mnemonic = runner.invoke(
+            cli,
+            [
+                "seed",
+                "-t",
+                "xprv",
+                "-f",
+                "words",
+                "-i",
+                "  " + mnemonic + " \t\n ",
+                "-p",
+                "TREZOR",
+            ],
+        )
+        assert whitespace_mnemonic.exit_code == 0
+        assert whitespace_mnemonic.output.strip() == xprv
+
+        testnet = runner.invoke(
+            cli, ["seed", "-t", "tprv", "-f", "words", "-i", mnemonic, "-p", "TREZOR"]
+        )
+        assert testnet.exit_code == 0
+        tprv = testnet.output.strip()
+        assert tprv != xprv
+        assert tprv.startswith("tprv")
+
+
+@pytest.mark.parametrize("n", N_WORDS_ALLOWED)
+def test_seed_command_n_words(runner, n):
+    for from_ in ("string", "rand"):
+        cmd = ["seed", "-t", "words", "-n", str(n)]
+        cmd += ["-f", from_]
+        if from_ == "string":
+            # "s"*15 is shorter than the lowest entropy of 128 bits
+            # "l"*32 is longer than the highest entropy of 256 bits
+            for input in ("s" * 15, "l" * 32):
+                cmd += ["-i", input]
+                result = runner.invoke(cli, cmd, catch_exceptions=False)
+                if "s" in input:
+                    assert "Warning" in result.output
+                else:
+                    assert "Warning" not in result.output
+                    assert len(result.output.split()) == int(n)
+                assert result.exit_code == 0
+
+
+def test_seed_from_and_to_words(runner):
+    result = runner.invoke(cli, ["seed", "--from", "words", "--to", "words"])
+    assert result.exit_code != 0
+    assert "--input" in result.output
+    assert "--from rand" in result.output
+
+
+def test_seed_from_and_n(runner):
+    result = runner.invoke(cli, ["seed", "--from", "words", "-n", "45"])
+    assert result.exit_code != 0
+    assert "--number" in result.output
+
+
+def test_seed_bad_from(runner):
+    result = runner.invoke(cli, ["seed", "--from", "baz"])
+    assert result.exit_code != 0
+    assert "not one of" in result.output
+
+
+def test_seed_bad_to(runner):
+    result = runner.invoke(cli, ["seed", "--to", "blah"])
+    assert result.exit_code != 0
+    assert "not one of" in result.output
+
+
+@pytest.mark.parametrize("vector", PWD_BASE64)
+def test_bipsea_integration(runner, vector):
+    result_seed = runner.invoke(
+        cli,
+        ["seed", "-f", "string", "-i", "yooooooooooooooo", "-n", "12", "-t", "xprv"],
+    )
+    xprv = result_seed.output.strip()
+    assert result_seed.exit_code == 0
+    result_entropy = runner.invoke(
+        cli, ["entropy", "-a", "base64", "-n", "20", "--input", xprv]
+    )
+    assert result_entropy.exit_code == 0
+    pwd64 = result_entropy.output.strip()
+    assert pwd64 == "lGqIFs50nYCWA0DjxHRB"
+    assert len(pwd64) == 20
+
+
+@pytest.mark.parametrize("vector", PWD_BASE85)
+def test_entropy_n(runner, vector):
+    xprv = vector["master"]
+    for app in ("base64", "base85", "hex", "drng"):
+        for n in (20, 50, 64):
+            result = runner.invoke(
+                cli, ["entropy", "-a", app, "-n", n, "--input", xprv]
+            )
+            assert result.exit_code == 0
+            answer = result.output.strip()
+            length = len(answer)
+            if app in ("hex", "drng"):
+                length = length // 2
+            assert length == n
+
+
+@pytest.mark.parametrize("vector", PWD_BASE85)
+def test_entropy_n_out_of_range(runner, vector):
+    xprv = vector["master"]
+    for app in ("base64", "base85", "hex", "drng"):
+        for n in (-1, 0, 1025):
+            if n == 1025 and app == "drng":
+                break
+            result = runner.invoke(
+                cli, ["entropy", "-a", app, "-n", n, "--input", xprv]
+            )
+            assert result.exit_code != 0
+            assert "Error" in result.output
+
+
+@pytest.mark.parametrize("vector", BIP39)
+def test_entropy_bip39(runner, vector):
+    xprv = vector["master"]
+    n_words = vector["mnemonic_length"]
+    result = runner.invoke(
+        cli, ["entropy", "-a", "words", "--input", xprv, "-n", n_words]
+    )
+    assert result.exit_code == 0
+    assert result.output.strip() == vector["derived_mnemonic"]
+
+
+@pytest.mark.parametrize("vector", HEX)
+def test_entropy_hex(runner, vector):
+    xprv = vector["master"]
+    result = runner.invoke(cli, ["entropy", "-a", "hex", "--input", xprv, "-n", 64])
+    assert result.exit_code == 0
+    assert result.output.strip() == vector["derived_entropy"]
+
+
+@pytest.mark.parametrize("vector", WIF)
+def test_entropy_wif(runner, vector):
+    xprv = vector["master"]
+    result = runner.invoke(cli, ["entropy", "-a", "wif", "--input", xprv])
+    assert result.exit_code == 0
+    assert result.output.strip() == vector["derived_wif"]