get rid of a bunch of unnecessary complexity around secret key generation, it's just too much and doesn't add anything. deleting code and simplifying

Author: karpathy

README.md

@@ -17,7 +17,7 @@ $ python -m cryptos.sha256 testfile.txt
 
 ### Keys
 
-`getnewaddress.py` is a cli entryway to the code that generates a new Bitcoin secret/public key pair and the corresponding (base58 compressed) address:
+`getnewaddress.py` is a cli entryway to generate a new Bitcoin secret/public key pair and the corresponding (base58check compressed) address:
 
 ```bash
 $ python getnewaddress.py
@@ -30,21 +30,6 @@ compressed bitcoin address (b58check format):
 1DBGfUXnwTS2PRu8h3JefU9uYwYnyaTd2z
 ```
 
-You can also generate your own entropy from keyboard timings if you call the cli as `$ python getnewaddress.py user`, or you can verify that the implementation is not broken by reproducing the [Mastering Bitcoin Chapter 4](https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04.asciidoc) example:
-
-```bash
-$ python getnewaddress.py mastering
-generated secret key:
-0x3aba4162c7251c891207b747840551a71939b0de081f85c4e44cf7c13e41daa6
-corresponding public key:
-x: 5C0DE3B9C8AB18DD04E3511243EC2952002DBFADC864B9628910169D9B9B00EC
-y: 243BCEFDD4347074D44BD7356D6A53C495737DD96295E2A9374BF5F02EBFC176
-compressed bitcoin address (b58check format):
-14cxpo3MBCYYWCgF74SWTdcmxipnGUsPw3
-```
-
-Where we see that after the all crazy hashing and elliptic curve over finite fields gymnastics the bitcoin address `14cxpo3MBCYYWCgF74SWTdcmxipnGUsPw3` matches, phew :).
-
 ### Digital Signatures
 
 Elliptic Curve Digital Signature Algorithm (ECDSA) implemented in `cryptos/ecdsa.py`, example usage:

cryptos/ecdsa.py

@@ -77,7 +77,7 @@ def sign(secret_key: int, message: bytes) -> Signature:
     # generate a new secret/public key pair at random
     # TODO: make deterministic
     # TODO: make take constant time to mitigate timing attacks
-    k = gen_secret_key(n, 'os')
+    k = gen_secret_key(n)
     P = PublicKey.from_sk(k)
 
     # calculate the signature

cryptos/keys.py

@@ -7,69 +7,21 @@
 import os
 import time
 
-from .sha256 import sha256
 from .curves import Point
 from .bitcoin import BITCOIN
 
 # -----------------------------------------------------------------------------
-# Secret key generation utilities
+# Secret key generation. We're going to leave secret key as just a super plain int
 
-def random_bytes_os():
-    """
-    Use os provided entropy, e.g. on macs sourced from /dev/urandom, eg available as:
-    $ head -c 32 /dev/urandom
-
-    According to Apple Platform Security docs
-    https://support.apple.com/en-ie/guide/security/seca0c73a75b/web
-    the kernel CPRNG is a Fortuna-derived design targeting a 256-bit security level
-    where the entropy is sourced from:
-    - The Secure Enclave’s hardware RNG
-    - Timing-based jitter collected during boot
-    - Entropy collected from hardware interrupts
-    - A seed file used to persist entropy across boots
-    - Intel random instructions, i.e. RDSEED and RDRAND (macOS only)
-    """
-    return os.urandom(32)
-
-
-def random_bytes_user():
-    """
-    Collect some entropy from time and user and generate a key with SHA-256
-    """
-    entropy = ''
-    for i in range(5):
-        s = input("Enter some word #%d/5: " % (i+1,))
-        entropy += s + '|' + str(int(time.time() * 1000000)) + '|'
-    return sha256(entropy.encode('ascii'))
-
-
-def mastering_bitcoin_bytes():
-    """
-    The example from Mastering Bitcoin, Chapter 4
-    https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch04.asciidoc
-    """
-    sk = '3aba4162c7251c891207b747840551a71939b0de081f85c4e44cf7c13e41daa6'
-    return bytes.fromhex(sk)
-
-
-def gen_secret_key(n: int, source: str = 'os') -> int:
+def gen_secret_key(n: int) -> int:
     """
     n is the upper bound on the key, typically the order of the elliptic curve
     we are using. The function will return a valid key, i.e. 1 <= key < n.
     """
-
-    assert source in ['os', 'user', 'mastering'], "The source must be one of 'os' or 'user' or 'mastering'"
-    bytes_fn = {
-        'os': random_bytes_os,
-        'user': random_bytes_user,
-        'mastering': mastering_bitcoin_bytes,
-    }[source]
-
     while True:
-        key = int.from_bytes(bytes_fn(), 'big')
+        key = int.from_bytes(os.urandom(32), 'big')
         if 1 <= key < n:
             break # the key is valid, break out
-
     return key
 
 # -----------------------------------------------------------------------------
@@ -125,12 +77,3 @@ def encode(self, compressed=True):
             return prefix + self.x.to_bytes(32, 'big')
         else:
             return b'\x04' + self.x.to_bytes(32, 'big') + self.y.to_bytes(32, 'big')
-
-# -----------------------------------------------------------------------------
-# convenience functions
-
-def gen_key_pair(source: str = 'os'):
-    """ convenience function to quickly generate a secret/public keypair """
-    sk = gen_secret_key(BITCOIN.gen.n, source)
-    pk = PublicKey.from_sk(sk)
-    return sk, pk

getnewaddress.py

@@ -6,23 +6,22 @@
 - the bitcoin address
 """
 
-import sys
-
-from cryptos.keys import gen_key_pair
+from cryptos.keys import gen_secret_key, PublicKey
 from cryptos.btc_address import pk_to_address
+from cryptos.bitcoin import BITCOIN
 
 if __name__ == '__main__':
 
     # generate a secret/public key pair
-    source = sys.argv[1] if len(sys.argv) == 2 else 'os' # can also be 'user' | 'mastering'
-    secret_key, public_key = gen_key_pair(source) # represented as int
+    secret_key = gen_secret_key(BITCOIN.gen.n)
+    public_key = PublicKey.from_sk(secret_key)
     print('generated secret key:')
     print(hex(secret_key))
     print('corresponding public key:')
-    print('x:', format(public_key.x, '064x').upper()) # (strip the 0x part denoting hex number)
+    print('x:', format(public_key.x, '064x').upper())
     print('y:', format(public_key.y, '064x').upper())
 
-    # calculate the bitcoin address
-    addr = pk_to_address(public_key, net='main', compressed=True) # is a string in b58check format
+    # get the associated bitcoin address
+    addr = pk_to_address(public_key, net='main', compressed=True)
     print('compressed bitcoin address (b58check format):')
     print(addr)

tests/test_ecdsa.py

@@ -5,15 +5,21 @@
 import os
 from io import BytesIO
 
-from cryptos.keys import gen_key_pair
+from cryptos.bitcoin import BITCOIN
+from cryptos.keys import gen_secret_key, PublicKey
 from cryptos.ecdsa import Signature, sign, verify
 from cryptos.transaction import Tx
 
 def test_ecdsa():
 
+    def gen_key_pair():
+        sk = gen_secret_key(BITCOIN.gen.n)
+        pk = PublicKey.from_sk(sk)
+        return sk, pk
+
     # let's create two identities
-    sk1, pk1 = gen_key_pair('os')
-    sk2, pk2 = gen_key_pair('os')
+    sk1, pk1 = gen_key_pair()
+    sk2, pk2 = gen_key_pair()
 
     message = ('user pk1 would like to pay user pk2 1 BTC kkthx').encode('ascii')