Crear un archivo de Credenciales usando Python

Un archivo de credenciales no es más que un archivo de configuración con un poco de cifrado y una estructura de seguridad invisible en el backend. Puede haber una situación en la que pueda encontrar este tipo de archivos mientras usa algún tipo de plataforma en la nube. Todo lo que hace para iniciar sesión en la instancia o darle al script los permisos para hacer algo sin su nombre de usuario y contraseña parece un poco mágico, pero ¿qué pasa si quiere hacer lo mismo? digamos que ha creado un script que requiere pocas configuraciones o credenciales para iniciar sesión. Es bastante irritante para el usuario ingresar las credenciales o configuraciones cada vez que desea ejecutar el código. Entonces, ¿cuál es la solución? Bueno, hay muchas maneras de hacerlo, pero dado que se trata de crear archivos de credenciales, usará el mismo método. Permita que sus usuarios creen un archivo de Credenciales o un archivo de Configuraciones que luego el script puede usar para obtener los detalles que requiere. Y aquí está cómo hacerlo.

Agregar un creador de archivos de credenciales al script

Realmente, es tan simple como copiar el siguiente script y agregarlo a su paquete, pero debe comprender algunas cosas si desea obtener una credencial personalizada o un archivo de configuración para sus scripts. Primero, el siguiente script solo acepta la entrada del usuario y agrega cifrado en algunas cosas y lo escribe en un archivo. Si está buscando agregar otros datos, simplemente agregue una nueva variable o escríbala directamente en el archivo. En segundo lugar, el cifrado aquí se realiza mediante Fernet en el paquete de criptografía. Por lo tanto, la clave se almacena en un archivo .key y, si desea que un tercero rompa el cifrado, convierta el archivo del creador de credenciales a .exe u otros formatos que no se puedan leer fácilmente.

Nota: Todos los módulos utilizados vienen integrados con Python, por lo que no es necesario instalarlo externamente.

CreateCred.py –  

#CreateCred.py
#Creates a credential file.
from cryptography.fernet import Fernet
import re
import ctypes
import time
import os
import sys
  
class Credentials():
  
    def __init__(self):
        self.__username = ""
        self.__key = ""
        self.__password = ""
        self.__key_file = 'key.key'
        self.__time_of_exp = -1
  
#----------------------------------------
# Getter setter for attributes
#----------------------------------------
   
    @property
    def username(self):
        return self.__username
  
    @username.setter
    def username(self,username):
        while (username == ''):
            username = input('Enter a proper User name, blank is not accepted:')
        self.__username = username
  
    @property
    def password(self):
        return self.__password
  
    @password.setter
    def password(self,password):
        self.__key = Fernet.generate_key()
        f = Fernet(self.__key)
        self.__password = f.encrypt(password.encode()).decode()
        del f
  
    @property
    def expiry_time(self):
        return self.__time_of_exp
  
    @expiry_time.setter
    def expiry_time(self,exp_time):
        if(exp_time >= 2):
            self.__time_of_exp = exp_time
  
  
    def create_cred(self):
        """
        This function is responsible for encrypting the password and create  key file for
        storing the key and create a credential file with user name and password
        """
  
        cred_filename = 'CredFile.ini'
  
        with open(cred_filename,'w') as file_in:
            file_in.write("#Credential file:\nUsername={}\nPassword={}\nExpiry={}\n"
            .format(self.__username,self.__password,self.__time_of_exp))
            file_in.write("++"*20)
  
  
        #If there exists an older key file, This will remove it.
        if(os.path.exists(self.__key_file)):
            os.remove(self.__key_file)
  
        #Open the Key.key file and place the key in it.
        #The key file is hidden.
        try:
  
            os_type = sys.platform
            if (os_type == 'linux'):
                self.__key_file = '.' + self.__key_file
  
            with open(self.__key_file,'w') as key_in:
                key_in.write(self.__key.decode())
                #Hidding the key file.
                #The below code snippet finds out which current os the script is running on and does the task base on it.
                if(os_type == 'win32'):
                    ctypes.windll.kernel32.SetFileAttributesW(self.__key_file, 2)
                else:
                    pass
  
        except PermissionError:
            os.remove(self.__key_file)
            print("A Permission error occurred.\n Please re run the script")
            sys.exit()
  
        self.__username = ""
        self.__password = ""
        self.__key = ""
        self.__key_file
  
  
def main():
  
    # Creating an object for Credentials class
    creds = Credentials()
  
    #Accepting credentials
    creds.username = input("Enter UserName:")
    creds.password = input("Enter Password:")
    print("Enter the epiry time for key file in minutes, [default:Will never expire]")
    creds.expiry_time = int(input("Enter time:") or '-1')
  
    #calling the Credit
    creds.create_cred()
    print("**"*20)
    print("Cred file created successfully at {}"
    .format(time.ctime()))
  
    if not(creds.expiry_time == -1):
        os.startfile('expire.py')
  
  
    print("**"*20)
  
if __name__ == "__main__":
    main()

Producción:

Lectura del archivo de credenciales

Para leer la credencial, es tan simple como leer un archivo normal utilizando las metodologías de lectura de archivos de python, pero para descifrar los datos necesita tener la clave que se usa para el cifrado. Entonces, el creador del archivo de credenciales crea un archivo de credenciales y un archivo de claves. El script de recuperación utiliza el archivo de claves y descifra los datos.

#Retrieve credentials.
 
from cryptography.fernet import Fernet
import os
 
cred_filename = 'CredFile.ini'
key_file = 'key.key'
 
key = ''
 
with open('key.key','r') as key_in:
    key = key_in.read().encode()
 
#If you want the Cred file to be of one
# time use uncomment the below line
#os.remove(key_file)
 
f = Fernet(key)
with open(cred_filename,'r') as cred_in:
    lines = cred_in.readlines()
    config = {}
    for line in lines:
        tuples = line.rstrip('\n').split('=',1)
        if tuples[0] in ('Username','Password'):
            config[tuples[0]] = tuples[1]
 
    passwd = f.decrypt(config['Password'].encode()).decode()
    print("Password:", passwd)

Producción:

Y ahora, si ha leído los scripts correctamente, es posible que haya visto un archivo ‘expire.py’. Esta secuencia de comandos inicia un reloj cuando se crea el archivo de credenciales y elimina el archivo de clave para que ya no sea posible descifrarlo cuando finaliza el tiempo especificado. 
caducar.py

import os
import time
  
 
key_file = 'key.key'
key_exp_start = time.time()
cred_filename = 'CredFile.ini'
  
with open(cred_filename, 'r') as cred_in:
  
    lines = cred_in.readlines()
    config = {}
    for line in lines:
        tuples = line.rstrip('\n').split('=', 1)
         
        if tuples[0] in ('Expiry '):
            config[tuples[0]] = tuples[1]
              
    if not(config['Expiry '] == -1):
  
        # Time below is in seconds.
        time_for_exp = int(config['Expiry ']) * 60
         
        while(os.path.isfile(key_file)):
            time.sleep(10)
             
            if (not(time.time() - key_exp_start <= time_for_exp)
                and os.path.isfile(key_file)):
                os.remove(key_file)