bip85: sign digests with bip85 rsa key

Author: Jamie C. Driver

docs/index.rst

@@ -1117,6 +1117,66 @@ get_bip85_pubkey reply
 * 'result' is a public key pem string
 
 
+.. _sign_bip85_digests_request:
+
+sign_bip85_digests request
+--------------------------
+
+Request to sign sha256 digests with a bip85-based deterministic key for a given type, key size and index.
+
+NOTE: currently this call only supports 'RSA', with sizes 1024, 2048, 3072 and 4096.
+
+NOTE: Uses current wallet seed and bip85 specification to produce deterministic entropy to initialise shake256 PRNG, used to create a deterministic key.
+However, since there is no well-specified deterministic recipe for creating keys, this implementation output may differ from other deterministic key-generation algorithms.
+This key is then used to sign the digests passed.
+
+.. code-block:: cbor
+
+    {
+        "id": "16",
+        "method": "get_bip85_pubkey",
+        "params": {
+            "key_type": "RSA",
+            "key_bits": 2048,
+            "index": 1,
+            "digests": [
+                <32-bytes>,
+                <32-bytes>,
+                ...
+            ]
+        }
+    }
+
+* 'key_type' must be 'RSA'
+* 'key_bits' must be one of 1024, 2048, 3072 or 4096.
+* 'digests' must be an array of 32-byte digests
+* The maximum number of digests that can be signed in a single call depends upon the key (and hence signature) size.
+    key_bits    max digests
+     1024        8
+     2048        8
+     3072        6
+     4096        4
+
+
+.. _sign_bip85_digests_reply:
+
+sign_bip85_digests reply
+------------------------
+
+.. code-block:: cbor
+
+    {
+        "id": "16",
+        "result": [
+          <bytes>,
+          <bytes>,
+          ...
+        ]
+    }
+
+* 'result' is a public key pem string
+
+  
 .. _get_identity_pubkey_request:
 
 get_identity_pubkey request

jade_bip85_rsa_sign.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import argparse
+import hashlib
+import logging
+from jadepy import JadeAPI
+
+TEST_MNEMONIC = 'fish inner face ginger orchard permit useful method fence \
+kidney chuckle party favorite sunset draw limb science crane oval letter \
+slot invite sadness banana'
+
+# Enable jade logging
+jadehandler = logging.StreamHandler()
+logger = logging.getLogger('jadepy.jade')
+logger.setLevel(logging.DEBUG)
+logger.addHandler(jadehandler)
+device_logger = logging.getLogger('jadepy.jade-device')
+device_logger.setLevel(logging.DEBUG)
+device_logger.addHandler(jadehandler)
+
+
+def get_digest_args(inputs):
+    digests = []
+    for hexdata in inputs:
+        try:
+            # Expect the arguments to be digest hex
+            digest = bytes.fromhex(hexdata)
+
+            if digest and len(digest) == 32:
+                digests.append(digest)
+            else:
+                print('Invalid hex digest:', hexdata)
+        except ValueError:
+            pass
+
+    return digests
+
+
+def get_digest_files(inputs):
+    digests = []
+    for filename in inputs:
+        try:
+            # Expect file contents to be the digest bytes
+            with open(filename, 'rb') as f:
+                digest = f.read()
+
+            if digest and len(digest) == 32:
+                digests.append(digest)
+            else:
+                print('Invalid digest:', d)
+        except FileNotFoundError as e:
+            print(e)
+
+    return digests
+
+
+def get_digest_from_data(inputs):
+    digests = []
+    for filename in inputs:
+        try:
+            # Hash file contents to create digest
+            with open(filename, 'rb') as f:
+                data = f.read()
+
+            digest = hashlib.sha256(data).digest()
+            assert digest and len(digest) == 32
+            digests.append(digest)
+
+        except FileNotFoundError as e:
+            print(e)
+
+    return digests
+
+
+def get_jade_rsa_data(args, digests):
+    # Connect to Jade over serial
+    with JadeAPI.create_serial(device=args.serialport) as jade:
+        # Get the version info and push entropy
+        verinfo = jade.get_version_info()
+        assert jade.add_entropy(os.urandom(64))
+
+        # Maybe push mnemonic (dev only)
+        if args.pushmnemonic:
+            jade.set_mnemonic(TEST_MNEMONIC, temporary_wallet=True)
+        else:
+            # The network to use is deduced from the version-info
+            network = 'testnet' if verinfo.get('JADE_NETWORKS') == 'TEST' else 'mainnet'
+            jade.auth_user(network)
+
+        # Get pubkey if requested
+        get_pubkey = args.printpubkey or args.pubkeyfile
+        pubkey_pem = jade.get_bip85_pubkey('RSA', args.keylen, args.index) if get_pubkey else None
+
+        # Sign digests
+        sigs = jade.sign_bip85_digests('RSA', args.keylen, args.index, digests) if digests else None
+
+        return pubkey_pem, sigs
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--serialport',
+                        action='store',
+                        dest='serialport',
+                        help='Serial port or device',
+                        default=None)
+
+    parser.add_argument('--keylen',
+                        action='store',
+                        dest='keylen',
+                        type=int,
+                        choices=[1024, 2048, 3072, 4096],
+                        help='Key length, in bits',
+                        default=3072)
+
+    parser.add_argument('--index',
+                        action='store',
+                        dest='index',
+                        type=int,
+                        help='BIP85 key index',
+                        default=1784767589)
+
+    pubkeygrp = parser.add_mutually_exclusive_group()
+    pubkeygrp.add_argument('--printpubkey',
+                           action='store_true',
+                           dest='printpubkey',
+                           help='Download and print BIP85 pubkey pem',
+                           default=False)
+
+    pubkeygrp.add_argument('--savepubkey',
+                           action='store',
+                           dest='pubkeyfile',
+                           help='Download and save BIP85 pubkey pem',
+                           default=False)
+
+    ingrp = parser.add_mutually_exclusive_group()
+    ingrp.add_argument('--digest-files',
+                       action='store_true',
+                       dest='digestfiles',
+                       help='Expect sha256 hash digests in the given input files',
+                       default=False)
+
+    ingrp.add_argument('--digest-args',
+                       action='store_true',
+                       dest='digestargs',
+                       help='Expect sha256 hash digests on the command line',
+                       default=False)
+
+    parser.add_argument('--push-mnemonic',
+                        action='store_true',
+                        dest='pushmnemonic',
+                        help='Sets a test mnemonic - only works with debug build of Jade',
+                        default=False)
+
+    parser.add_argument('--log',
+                        action='store',
+                        dest='loglevel',
+                        help='Jade logging level',
+                        choices=['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'],
+                        default='ERROR')
+
+    parser.add_argument('inputs',
+                        action='store',
+                        nargs='*',
+                        help='Digest hex or filenames (digests or undigested data)',
+                        default=None)
+
+    args = parser.parse_args()
+    jadehandler.setLevel(getattr(logging, args.loglevel))
+    logger.debug(f'args: {args}')
+
+    if args.digestargs:
+        digests = get_digest_args(args.inputs)
+    elif args.digestfiles:
+        digests = get_digest_files(args.inputs)
+    else:
+        digests = get_digest_from_data(args.inputs)
+
+    if len(digests) != len(args.inputs):
+        sys.exit(1)
+
+    pubkey_pem, sigs = get_jade_rsa_data(args, digests)
+
+    if pubkey_pem:
+        if args.pubkeyfile:
+            with open(args.pubkeyfile, 'w') as f:
+                f.write(pubkey_pem)
+        else:
+            assert args.printpubkey
+            print(pubkey_pem)
+
+    # Files in, files out
+    # Command-line hex in, just print sig hex out
+    if sigs:
+        assert len(sigs) == len(args.inputs)
+        for inputdata, sig in zip(args.inputs, sigs):
+            assert len(sig) == args.keylen / 8
+            if args.digestargs:
+                print(sig.hex())
+            else:
+                filename = inputdata + '.sig'
+                with open(filename, 'wb') as f:
+                    f.write(sig)

jadepy/jade.py

@@ -1276,6 +1276,43 @@ def get_bip85_pubkey(self, key_type, key_bits, index):
                   'index': index}
         return self._jadeRpc('get_bip85_pubkey', params)
 
+    def sign_bip85_digests(self, key_type, key_bits, index, digests):
+        """
+        RPC call to sign digests with a bip85-derived key.
+
+        Parameters
+        ----------
+        key_type : string
+            The type of key to be derived.
+            At this time only 'RSA' is supported.
+
+        key_bits : int
+            The number of bits in the desired key.  Must be valid for the key type.
+            At this time must be 1024, 2048, 3096 or 4092
+
+        index : int
+            The index to use in the bip32 path to calculate the entropy to generate the key.
+
+        digests : [bytes]
+            An array of digests to sign.  The maximum number of digests that can be signed in a
+            single call depends upon the key (and hence signature) size.
+            key_bits    max digests
+             1024        8
+             2048        8
+             3072        6
+             4096        4
+
+        Returns
+        -------
+        [bytes]
+            Array of signatures, same size as input digests array
+        """
+        params = {'key_type': key_type,
+                  'key_bits': key_bits,
+                  'index': index,
+                  'digests': digests}
+        return self._jadeRpc('sign_bip85_digests', params)
+
     def get_identity_pubkey(self, identity, curve, key_type, index=0):
         """
         RPC call to fetch a pubkey for the given identity (slip13/slip17).

main/process/dashboard.c

@@ -149,6 +149,7 @@ void get_commitments_process(void* process_ptr);
 void get_blinding_factor_process(void* process_ptr);
 void sign_liquid_tx_process(void* process_ptr);
 void get_bip85_pubkey_process(void* process_ptr);
+void sign_bip85_digests_process(void* process_ptr);
 #ifdef CONFIG_DEBUG_MODE
 void get_bip85_bip39_entropy_process(void* process_ptr);
 void get_bip85_rsa_entropy_process(void* process_ptr);
@@ -598,6 +599,8 @@ static void dispatch_message(jade_process_t* process)
             task_function = get_shared_nonce_process;
         } else if (IS_METHOD("get_bip85_pubkey")) {
             task_function = get_bip85_pubkey_process;
+        } else if (IS_METHOD("sign_bip85_digests")) {
+            task_function = sign_bip85_digests_process;
         } else if (IS_METHOD("ota_data") || IS_METHOD("ota_complete") || IS_METHOD("tx_input")
             || IS_METHOD("get_extended_data") || IS_METHOD("get_signature") || IS_METHOD("pin")) {
             // Method we only expect as part of a multi-message protocol