Python 3 UnboundLocalError: local variable referenced before assignment in try statement

You should declare the variables pubkey and privkey outside the function genKeys()and then the error should vanish.
This is my first post, I hope to be helpful.
Regards.

Your problem is here:

if (open("private.pem", "r") and open("public.pem", "r")) == True:

Python logical operators return the last inspected value, not True or False. That value was a file object from the open command is not equal to True. You could check the files for existence with os.path.isfile and skip the try/except block completely. Or you could just try the actual read the in the try block, like so

(slimmed down for demo)

# dummys for test...

def readKeys():
    print('try read')
    return open('public.pem').read(), open('private.pem').read()

def genKeys():
    print('try write')
    open('public.pem','w').write('foo')
    open('private.pem','w').write('bar')
    return 'foo', 'bar'


def main():
    global pubkey, privkey
    try:
        pubkey, privkey = readKeys()
    except:
        (pubkey, privkey) = genKeys()


if __name__ == "__main__":
    main()

Copying the code of the other answer and with the change to check for globals() instead of overwriting None variables at every function call.

import rsa

################################################
keySize = 256
################################################

# DECLARATION IN GLOBAL SCOPE
pubkey = None
privkey = None

def genKeys():
    pubkey, privkey = rsa.newkeys(keySize)

    with open("public.pem", "w") as pub:
        pub.write(str(pubkey))

    with open("private.pem", "w") as priv:
        priv.write(str(privkey))

    return pubkey, privkey

def readKeys():

      with open("private.pem", "r") as priv:
          keydata = priv.read()
          privkey = rsa.PrivateKey.load_pkcs1(keydata)
          print(privkey)

      with open("public.pem", "r") as pub:
          keydata = pub.read()
          pubkey = rsa.PublicKey.load_pkcs1(keydata)
          print(pubkey)
      return pubkey, privkey




def send(message, pubkey):
    message = message.encode('utf-8')
    crypto = rsa.encrypt(message, pubkey)
    return crypto

def recv(crypto, privkey):
    message = rsa.decrypt(crypto, privkey)
    message = message.decode('utf-8')
    return message

def main():
    # DECLARATION INSIDE THE FUNCTION
    global pubkey, privkey;
    if 'pubkey' not in globals() or 'privkey' not in in globals():
        pubkey = privkey = None
    try:
        if (open("private.pem", "r") and open("public.pem", "r")) == True:
            if 'pubkey' in globals() and 'privkey' in globals():
                pubkey, privkey = readKeys()
            
    except:
        if 'pubkey' in globals() and 'privkey' in globals():
            (pubkey, privkey) = genKeys()


    if 'pubkey' in globals() and 'privkey' in globals():
        cryptMessage = send('hello world', pubkey)
        print(cryptMessage)
        print(recv(cryptMessage, privkey))

if __name__ == "__main__":
    main()

This is untested. I did that for local variables instead where a local connection object was closed in the finally block. For that, I did not even have to set the objects as None at any time since I checked for the connection object to be in globals() before closing it. The error was gone.

In this code, however, you do not just close objects, you overwrite them instead, both in the try and in the except block.
Therefore, I just guess that you need to make the None objects at first loading time.
If this trick works for global variables as well, this will be the only code that does not overwrite global objects with None every time the function gets called, but only if the variables are touched the first time.