Q:

Problema con funcion de cifrado y gestión de perfiles

Estoy tratando de hacer un gestor de perfiles capaz de guardar web, usuario y clave.  Me he topado con problemas a la hora de realizar una función con el cifrado de Fernet (AES 123 - CBC) en la función llamada cryptoPass().  
En mi código , que veréis en breve , la funcion cryptopass() será llamada dentro de la función controlInputs() siempre y cuando los valores (web, usuario y clave se han validados, es decir == True). 
La función cryptopass siempre se ejecuta ignorando las comprobación, ademas trato de imprimir el estado en la linea 55 donde me ignora el 
 print(usuario_valid, clave_valid, web_valid), no veo donde se produce el error, aparentemente esta bien.  Pero esto es solo la punta del iceberg, este problema acarrea otros que mas adelante os diré. 
Aquí os dejo el código:
#! /usr/bin/env python3
import re
from cryptography.fernet import Fernet

print("Binvenido al gestor de perfiles, continuacion podras introducir:"
      "\nusuario, clave y web")

perfil_usuario = []

def agregarUsuario():
    web = input("Introduce la web del perfil: ")
    usuario = input("Introduce el nombre del usuario: ")
    clave = input("Ingrese la clave de la cuenta: ")
    clave = bytes(clave, 'utf-8') #pasa clave a bytes es encesario para la encriptacion
    print(clave)
    return web, usuario, clave
    controlInputs()

def controlInputs(web, usuario, clave, web_valid = False, usuario_valid = False, clave_valid = False ):

    #Validacion del dominio web
    for i in web:
        if i == '.': 
            web_valid = True
            break #de lo contrario si el ultimo caracter no es '.'  dara falso
        else:
            web_valid = False

    # otro metodo mas sencillo, seria: web_valid = "."  in web

    #validacion del usuario

    patron = re.compile('^[A-Za-z0-9_!=]+$')  # uso de ^  y $ (inicio y fin de la regex)
    # e indica la cantidad de caracteres + en el patrón que uses

    if patron.match(usuario):
        if len(usuario) >= 5:
            usuario_valid = True
        else:
            usuario_valid = False
            print('El usuario no es adecuado')

    #validacion de la clave
    caracteres = ('_', '!', '?') 

    clave_valid = any(c in caracteres for c in clave)
    #for i in range(len(caracteres)):
        #clave_valid = True
        #print('correcto')

    print(usuario_valid, clave_valid, web_valid)

    #return web_valid, usuario_valid, clave_valid
    if usuario_valid and clave_valid and web_valid:
        cryptoPass(clave)
        makePerfil(web, usuario, clave)
        print(perfil_usuario)

def cryptoPass (web, usuario, clave):
    clave_pass = Fernet.generate_key() #genera clave_cifrado
    cipher_suite = Fernet(clave_pass) #clave_cifrado_obj
    cipher_texto = cipher_suite.encrypt(clave) #cifra texto
    print(cipher_texto)

    return cipher_texto, cipher_suite

    makePerfil(web, usuario, clave)

def makePerfil(web, usuario, clave):

    global perfilesde
    perfil_usuario.insert(0, web)
    perfil_usuario.insert(1, usuario)
    perfil_usuario.insert(2, clave)

#Ejucion de scripts

#agregar usuario
web, usuario, clave = agregarUsuario()

A:

Tal como se comentó, el problema original se debía a que en realidad controlInputs jamás es llamada dado que la función retorna antes:
def agregarUsuario():
    ....
    return web, usuario, clave
    controlInputs()

Cuando se llega a una sentencia return la ejecución de la función termina en ese punto y cualquier código posterior jamás será ejecutado. 
Aparte de esto hay varios problemas más:

Llamas a varias funciones sin proporcionar lo parámetros obligatorios mínimos, como la llamada anterior a controlInputs() o la llamada a cryptoPass a la que solo le pasas la calve pero requiere también web y usuario. 
Llamas a makePerfil dos veces, una en cryptoPass (y no le pasas la clave encriptada) y otra en controlInputs, dónde no capturas la salida de cryptoPass por lo que ni siquiera puedes pasar la clave recién encriptada. 
La clave generada para la encriptación simétrica AES debe ser retornada por cryptoPass y almacenada en algún sitio, de lo contrario no podrás desencriptar la contraseña. 
La validación de la contraseña con:
 clave_valid = any(c in caracteres for c in clave)

va a fallar porque clave es una cadena de bytes y caracteres contiene cadenas Unicode (UTF-8), por lo que cualquier comparación va a ser False. 
Aparte de lo anterior debes decidir si una función va a retornar algo en función de los parámetros, si va a modificar los parámetros in-place, si va a modificar o usar variables globales, etc.  Por norma general evita modificar parámetros in-place (y si lo haces no los retornes también) y el uso de variables globales, a no ser que estén justificadas (como es el caso de constantes). 

Te dejo una versión de tu código con varias modificaciones:

Se han dividido la validación de usuario, web y clave en funciones propias. 
La entrada del usuario es validada una a una, pidiendo que introduzca de nuevo si no es válida. 
Se ha eliminado el uso de variables globales, todas las funciones reciben lo necesario mediante parámetros y retorna el resultado apropiado, esto las hace reutilizables y más legibles. 
Se ha añadido anotación de tipos compatible con MyPy.  La anotación de tipos y la comprobación estática de tipado son características relativamente nuevas en Python pero no muy conocidas por el público general. 

import re
from typing import Callable, List, Optional, Tuple

from cryptography.fernet import Fernet

def validar_usuario(usuario: str) -> bool:
    patron = re.compile('^[A-Za-z0-9_!=]+$')  # uso de ^  y $ (inicio y fin de la regex)
    # e indica la cantidad de caracteres + en el patrón que uses
    usuario_valido = False
    if patron.match(usuario):
        if len(usuario) >= 5:
            usuario_valido = True
    return usuario_valido

def validar_web(web: str) -> bool:
    valida = "."  in web
    return valida

def validar_clave(clave: str) -> bool:
    caracteres = ('_', '!', '?') 
    valida = any(c in caracteres for c in clave)
    return valida

def entrada_validada(texto: str, validador: Callable[[str], bool]) -> str:
    while True:
        entrada = input(texto)
        if validador(entrada):
            break
        print("Entrada no válida, vuelva a intentarlo.") 
    return entrada

def crear_perfil() -> Tuple[Tuple[str, str, bytes], bytes]:
    web = entrada_validada("Introduce la web del perfil: ", validar_web)
    usuario = entrada_validada("Introduce el nombre del usuario: ", validar_usuario)
    clave = entrada_validada("Ingrese la clave de la cuenta: ", validar_clave)
    clave_encriptada, fernet_key  = fernet_encrypt(clave.encode("UTF-8"))
    return (web, usuario, clave_encriptada), fernet_key

def fernet_encrypt(cadena: bytes, clave: Optional[bytes]=None) -> Tuple[bytes, bytes]:
    '''
    Encripta y retorna la cadena con la clave proporcionada usando Fernet. 
    Si no se proporciona clave se genera una automáticamente. 
    clave -> URL-safe base64-encoded 32-byte key or None
    '''
    if clave is None:
        clave = Fernet.generate_key() #genera clave_cifrado
    cipher_suite = Fernet(clave)      #clave_cifrado_obj
    cipher_text = cipher_suite.encrypt(cadena) #cifra texto
    return cipher_text, clave

def fernet_decrypt(cadena: bytes, clave: bytes) -> bytes:
     cipher_suite = Fernet(clave)
     texto = cipher_suite.decrypt(cadena)
     return texto

if __name__ == "__main__":
    print("Bienvenido al gestor de perfiles, continuación podras introducir:"
          "\nusuario, clave y web\n"
          )

    perfil_usuario, fernet_key = crear_perfil()
    usuario, web, clave = perfil_usuario
    print("\nPerfil:\n Usuario: {}\n Web: {}\n Clave: {}\n".format(usuario, web, clave))

    clave_desencriptada = fernet_decrypt(clave, fernet_key)
    print("Clave desencriptada: {}".format(clave_desencriptada.decode("UTF-8")))

perfil_usuario es una tupla (usuario, web, clave), la clave usada para el cifrado AES se almacena en fernet_key, deberás también alamcenarla en algún lado y tener la forma de asociarla al usuario.  Un ejemplo de ejecución:

Bienvenido al gestor de perfiles, continuación podrás introducir:
usuario, clave y web

Introduce la web del perfil: www.miweb.com
Introduce el nombre del usuario: FJSevilla
Ingrese la clave de la cuenta: 12145
Entrada no válida, vuelva a intentarlo. 
Ingrese la clave de la cuenta: 1234ada
Entrada no válida, vuelva a intentarlo. 
Ingrese la clave de la cuenta: 12345? 

Perfil:
 Usuario: www.miweb.com
 Web: FJSevilla
 Clave: b'gAAAAABbUNmQs3HAWUJZfVPfCaZNSDpYpE_sLSBq7-YDc-_UjZHVsWvvbpTPreTtSHCjfWX3zel_dbZ2ZWi4jmGFWIjEp87CZA=='

Clave desencriptada: 12345? 

Extra:
Una medida de seguridad básica que cualquiera entiende es que las claves de usuario no se deben nunca almacenar como texto plano (y aún así son sonados los casos de empresas importancias a las que parece no importarles nuestros datos...).  En tu código usas AES para encriptar la clave, pero nos surge otro problema ¿Dónde y cómo guardamos la claves usadas para el encriptado? 
El problema común de almacenar de forma segura la contraseña de un usuario se suele resolver no almacenándola... La idea general el generar un hash de la misma, almacenarla y cuando el usuario ingrese su contraseña generamos su hash y lo comparamos con el que teníamos almacenado. 
Para intentar protegerse contra ataques de fuerza bruta no se usan algoritmos hash comunes en "crudo", se usa lo que se conoce como derivación de clave, la idea es básicamente hacer el proceso de generación mucho más lento computacionalmente.  
Para proteger contra ataques Rainbow Tables se suele usar una sal aleatoria propia para esa contraseña y su hash. 
Dejo un ejemplo básico usando la biblioteca estándar mediante hashlib.pbkdf2_hmac:
#! /usr/bin/env python3

import base64
import hashlib             
import os
import re
from typing import Callable, Optional, Tuple

def generar_hash(contraseña: str,
                 algoritmo_hash: Optional[str]='sha256',
                 longitud_sal: Optional[int]=16,
                 iteraciones: Optional[int]=100000) -> bytes:
    """Genera password hash usando PKCS#5 y salt propia aleatoria"""
    bytes_cont = contraseña.encode('utf-8')
    sal = base64.b64encode(os.urandom(longitud_sal))
    hash_ = hashlib.pbkdf2_hmac(algoritmo_hash, bytes_cont, sal, iteraciones)
    return b'$'.join((b'PBKDF2', algoritmo_hash.encode(),
                      str(iteraciones).encode(), sal, hash_)
                    )

def comprobar_contraseña(contraseña: str, cont_hash: bytes) -> bool:
    """Comprueba si la contraseña es válida de acuerdo al hash dado"""

    algoritmo, función_hash, iteraciones, sal, hash_ = cont_hash.split(b'$')
    bytes_cont = contraseña.encode('utf-8')
    función_hash = función_hash.decode()
    iteraciones = int(iteraciones)
    hash_actual = hashlib.pbkdf2_hmac(función_hash, bytes_cont, sal, iteraciones)
    return hash_ == hash_actual 

def validar_usuario(usuario: str) -> bool:
    patron = re.compile('^[A-Za-z0-9_!=]+$')  # uso de ^  y $ (inicio y fin de la regex)
    # e indica la cantidad de caracteres + en el patrón que uses
    usuario_valido = False
    if patron.match(usuario):
        if len(usuario) >= 5:
            usuario_valido = True
    return usuario_valido

def validar_web(web: str) -> bool:
    valida = "."  in web
    return valida

def validar_clave(clave: str) -> bool:
    caracteres = ('_', '!', '?') 
    valida = any(c in caracteres for c in clave)
    return valida

def entrada_validada(texto: str, validador: Callable[[str], bool]) -> str:
    while True:
        entrada = input(texto)
        if validador(entrada):
            break
        print("Entrada no válida, vuelva a intentarlo.") 
    return entrada

def crear_perfil() -> Tuple[str, str, bytes]:
    web = entrada_validada("Introduce la web del perfil: ", validar_web)
    usuario = entrada_validada("Introduce el nombre del usuario: ", validar_usuario)
    clave = entrada_validada("Ingrese la clave de la cuenta: ", validar_clave)
    clave_hash = generar_hash(clave)
    return web, usuario, clave_hash

if __name__ == "__main__":
    print("Bienvenido al gestor de perfiles, continuación podrás introducir:"
          "\nusuario, clave y web\n"
          )

    perfil_usuario = crear_perfil()
    usuario, web, hash_clave = perfil_usuario
    patt = "\nPerfil:\n Usuario: {}\n Web: {}\n Hash: {}...\n"
    print(patt.format(usuario, web, hash_clave[:31]))

    while True:
        passw = input("Ingrese su clave: ")
        if comprobar_contraseña(passw, hash_clave):
            print("¡Su clave es válida!") 
            break
        print("Lo siento, su clave no es correcta")

Bienvenido al gestor de perfiles, continuación podrás introducir:
usuario, clave y web

Introduce la web del perfil: www.miweb.com
Introduce el nombre del usuario: FJSevilla
Ingrese la clave de la cuenta: 12345? 

Perfil:
 Usuario: www.miweb.com
 Web: FJSevilla
 Hash: b'PBKDF2$sha256$100000$eilPaFqWC5'...

Ingrese su clave: 12345
Lo siento, su clave no es correcta
Ingrese su clave: abcd
Lo siento, su clave no es correcta
Ingrese su clave: 12345? 
¡Su clave es válida! 

Advertencia: La respuesta al igual que la pregunta tienen solo fines didácticos, la creación y la elección de un sistema seguro para autentificación y almacenamiento de datos de usuarios es un proceso mucho más complejo (aleatoriedad real de las salt, quién genera la salt, colisiones, elección de tamaños seguros para las claves, sistemas de recuperación de contraseñas,...).