Sta usando JSON un modo sicuro di gestire query SQL in python?

1

La domanda

Cercherò di articolare questo chiaramente e meglio che posso:

Supponiamo di avere un programma python che si connette a un database su un server. Poi ti chiedo di considerare che questo programma Python cattura le query Mysql da un file JSON, Python le legge, e poi vengono utilizzate per fare fare qualcosa al database. È sicuro? Perché gli altri non fanno lo stesso? Ho fatto qualche tipo di grave errore nel fare questo? È vulnerabile all'iniezione SQL o simile?

Mi scuso per aver chiesto qual è più di una domanda. Suppongo di voler davvero sapere se questa è una buona o una pessima idea.

Contesto

Non ho esperienza con la sicurezza e ho iniziato a usare python per roba lato server una settimana fa. Lo faccio principalmente per imparare . Sto cercando di mettere insieme un sito web che usa python e Mysql per gestire il database. Questo significa:

  • Ad un certo punto questo codice raggiungerà la produzione.
  • Perché: 1) Non sono molto bravo con la sicurezza e 2) Le persone lo useranno davvero Sono molto preoccupato di quanto sia sicuro il codice.

Il mio obiettivo quando ho iniziato questo codice era che volevo un modo molto semplice ed efficace per creare query sicure sul mio database MySql. Di conseguenza, ho mantenuto tutte le mie query in un file JSON, che python quindi legge e restituisce in un decoratore di funzioni che effettua una connessione al database.

Il codice

# Imports 
import json 
import mysql.connector 

# Class which reads json files 
class json_read():
    def __init__(self,name):
        self.name = name  
    def json_caller(self):
            with open(self.name) as f:
                f = json.load(f)[0]
                return f

# Returns the file needed to connect to the database 
f = json_read("database_connect.json") 
config = f.json_caller()

# Function decorater used to initiate the connection to the database 
def mysql_connect(func):
    def wrapper(*args, **kwargs):
        try: 
            cnx = mysql.connector.connect(**config)
            cursor = cnx.cursor(prepared=True) 
            cursor.execute(*args, **kwargs)
            result = cursor.fetchall() 
            print("\nConnection is stable @ the function " + func.__name__)
            print(result)
        except:
            print("\nConnection failed @ the function " + func.__name__)
    return wrapper 

# Returns the line from the json file associated with the key
class query_dbh():
    f2 = json_read("queries.json")
    def __init__(self, index): 
        self.index = self.f2.json_caller()[index]

@mysql_connect
def output(*args, **kwargs):
    pass 

# Select_names is the key
output(query_dbh("Select_names").index) 

Come vengono memorizzate le query:

[
{
    "Select_names" : "SELECT first,last FROM user",
    "Select_id" : "SELECT id FROM user"

}
]
    
posta Ranch Mayonaise 06.10.2018 - 04:56
fonte

1 risposta

1

Quello che vuoi fare è usare le stored procedure. Questo è incorporato in MySql stesso. Aiuterà a prevenire i rischi di SQL injection e potenzialmente velocizzerà l'applicazione perché la query non dovrà essere compilata e pianificata ogni volta che viene eseguita.

OWASP ha una grande risorsa su come prevenire l'iniezione SQL. Ecco la sezione pertinente alle stored procedure che elencano i loro vantaggi e svantaggi. link

    
risposta data 06.10.2018 - 05:58
fonte

Leggi altre domande sui tag