Python 3 tutorial

import nfpython
conn = nfpython.connection()
c = nfpython.Command()
c.cmd = "NewEnquiry"
c.args.module = 1000
reply = conn.transact(c, ignorestatus=True)
print(reply)

Reply.cmd= ErrorReturn
     .status= InvalidModule
     .flags= 0x0

import nfpython
import nfkm


def load_key(conn, appname: str, ident: str, module=0, private=True) -> nfpython.KeyID:
    """
    Load a key given an appname and ident
    :param conn:
    :param appname: Key appname, eg "simple"
    :param ident: Key ident
    :param module: module to load the key on (default 0 = any)
    :param private: load the private blob if true
    :return: the loaded key
    """
    appident = nfkm.KeyIdent(appname=appname, ident=ident)
    keydata = nfkm.findkey(conn, appident)

    cmd = nfpython.Command(cmd="LoadBlob")
    if private:
        cmd.args.blob = keydata.privblob
    else:
        cmd.args.blob = keydata.pubblob
    cmd.args.module = module

    rep = conn.transact(cmd)
    keyid = rep.reply.idka
    return keyid

import nfpython


def digest_message(conn, message: bytes, module=0, mech="Sha256Hash", chunksize=8000) -> bytes:
    """
    Hash a binary string using the HSM and ChannelUpdate commands
    :param conn:
    :param message: binary message to hash.
    :param module: HSM to sign with (default 0 = any)
    :param mech: hash mechanism name
    :param chunksize: digest block size
    :return:
    """
    c = nfpython.Command()
    c.cmd = "ChannelOpen"
    c.args.type = "simple"
    c.args.mode = "sign"
    c.args.mech = mech
    c.args.module = module

    rep = conn.transact(c)
    channel = rep.reply.idch

    c = nfpython.Command()
    c.cmd = "ChannelUpdate"
    # split the message up into small chunks and transmit each in sequence
    for chunk in (message[i:i+chunksize] for i in range(0, len(message), chunksize)):
        c.args.idch = channel
        c.args.input = nfpython.ByteBlock(chunk, fromraw=True)
        conn.transact(c)

    # obtain the hash value by setting the final flag
    c.args.input = nfpython.ByteBlock()
    c.args.flags |= "final"
    rep = conn.transact(c)
    digest = rep.reply.output
    return digest

#!/usr/bin/env python3

import nfpython
from keys import load_key
from hashing import digest_message


def sign_message(conn, privkey: nfpython.KeyID, message: bytes) -> (nfpython.Hash32, nfpython.CipherText):
    """
    Hash and sign a binary string using the HSM and a loaded RSA private key
    :param conn:
    :param privkey: KeyID of loaded key
    :param message: bytes to sign
    :return: the digest hash and signature
    """
    digest = digest_message(conn, message)
    plain = nfpython.Hash32(digest)
    c = nfpython.Command()
    c.cmd = "Sign"
    c.args.mech = "RSAhSHA256pPKCS1"
    c.args.key = privkey
    c.args.plain.type = "Hash32"
    c.args.plain.data.data = plain

    rep = conn.transact(c)
    signature = rep.reply.sig
    return plain, signature


def verify_signature(conn, pubkey: nfpython.KeyID, digest, signature) -> bool:
    """
    Verify a signature using the HSM and a loaded public key
    :param conn:
    :param pubkey:
    :param digest:
    :param signature:
    :return:
    """
    digest[0] = 1
    cmd = nfpython.Command()
    cmd.cmd = "Verify"
    cmd.args.key = pubkey
    cmd.args.plain.type = "Hash32"
    cmd.args.plain.data.data = digest
    cmd.args.sig = signature

    conn.transact(cmd)


def run():
    conn = nfpython.connection(needworldinfo=True)
    privkey = load_key(conn, appname="simple", ident="signer")
    pubkey = load_key(conn, appname="simple", ident="signer", private=False)

    message_bytes = b"hello world" * 1024
    print(f"Hash and Sign {len(message_bytes)} bytes..")
    digest, signature = sign_message(conn, privkey, message_bytes)
    print("Verifying..")
    verify_signature(conn, pubkey, digest, signature)
    print("Done.")


if __name__ == "__main__":
    run()