Il tuo codice generato dall'intelligenza artificiale è davvero sicuro?

Lo sviluppo e la programmazione di software, un tempo considerati sforzi che richiedevano una profonda competenza, ora possono essere eseguiti da chiunque utilizzando il linguaggio naturale. Una funzionalità che prima richiedeva giorni o mesi per essere sviluppata, ora può essere sviluppata in minuti o ore grazie al codice di un modello di intelligenza artificiale. Ad esempio, OpenAI Codex e Google BERT sono addestrati sulla programmazione di blog web, domande di Stack overflow, ecc.

Questi modelli intelligenti creano codice tramite probabilità matematiche, ma sono anche noti per allucinare e presentare informazioni false. Una ricerca condotta dal mondo accademico afferma che la generazione di codice AI è la causa principale delle prime 10 vulnerabilità e quasi il 40% del codice presenta bug di sicurezza . Molti dei principali attori, insieme ai nuovi provider SaaS, stanno sfruttando l'AI per rendere le loro offerte più intelligenti. Anche i programmatori SaaS devono essere più informati sugli strumenti SaaS basati sull'AI.

Cosa rende non sicuro il codice generato dall'intelligenza artificiale?

Seguire gli standard di programmazione e la qualità del codice detta la sicurezza del software. Tuttavia, i modelli di intelligenza artificiale vengono addestrati su ogni bit di informazione disponibile su Internet. La qualità del codice, l'affidabilità, la sicurezza e altro potrebbero differire da ciò che viene generato dagli sviluppatori umani. Un modello addestrato su esempi di sviluppo web potrebbe contenere scarse pratiche di convalida dei dati, ad esempio. Questa mancanza di convalida può portare a problemi di sicurezza quando il modello genera codice che adotta le stesse scarse pratiche.

5 indicatori che suggeriscono che il codice contiene debolezze di sicurezza

Indipendentemente dalle dimensioni (milioni o miliardi di parametri), è noto che i modelli hanno allucinazioni e fanno previsioni errate. Quando uno sviluppatore tipico vede il codice prodotto da un'IA, non si accorgerà delle sottili ma gravi vulnerabilità di sicurezza. Tuttavia, per uno sviluppatore che ha una conoscenza completa dei modelli di progettazione e sviluppo, i difetti sono a una revisione di distanza dall'essere identificati. Gli sviluppatori possono sfruttare questi modelli per scoprire vulnerabilità e allinearsi alle best practice di sicurezza SaaS .

1. L'inferenza del tipo e le convalide di input non sono applicate

I framework e le librerie moderni si basano molto su interface/enum per inferenza e convalida. Ciò garantisce che il codice svolga il suo lavoro in modo accurato e impone sicurezza. Il codice generato dall'intelligenza artificiale non inferirà a meno che non lo indirizziamo noi. Anche dopo aver creato un prompt attento, la mancata corrispondenza dei tipi e l'applicazione della convalida potrebbero non corrispondere al caso d'uso. Per individuare e correggere le mancate corrispondenze del codice, gli sviluppatori devono essere ben consapevoli dei requisiti aziendali e di dominio.

 def reciprocal(user_input): # Insecure implementation with no type inference or validation result = 100 / user_input return result

2. Condivisione non standard di stato e contesto tra classi/oggetti

I programmi condividono oggetti in modalità Pubblico/Privato/Protetto. Le funzioni e le classi di ordine superiore ereditano lo stato dell'oggetto accedendo direttamente alle variabili pubbliche/protette per eseguire calcoli. Se qualcosa viene fatto in modo errato nell'implementazione o nell'esecuzione, potrebbero facilmente verificarsi colli di bottiglia nella sicurezza o nelle prestazioni. Gli sviluppatori SaaS devono implementare la loro logica di gestione dello stato e del contesto in modo appropriato e rivederla per un uso corretto e sicuro.

 class InsecureClass: def __init__(self, owner, balance, password): self.owner = owner # Public attribute self._balance = balance # Protected attribute self.__password = password # Private attribute # Public def def get_balance(self): return self._balance # Protected def def _update_balance(self, amount): self._balance += amount # Private def def __validate_password(self, input_password): return self.__password == input_password # Insecure def exposing private data def insecure_password_exposure(self): return self.__password

3. Debole implementazione delle tecniche di gestione e condivisione dei dati

I servizi condividono e ricevono informazioni sulla rete. Oggigiorno, la connettività sicura e la gestione dei dati sono state fondamentali per il successo dei sistemi basati su cloud. Quando si leggono, elaborano e condividono dati sensibili su organizzazioni tramite reti di dati distribuite, devono essere implementati protocolli e tecniche di sicurezza efficaci per impedire l'intercettazione dei dati . Utilizzando l'intelligenza artificiale, lo sviluppatore SaaS deve implementare ogni singolo aspetto dell'architettura in applicazioni complete.

 #Insecure Data Sharing @app.route("/user/<int:user_id>", methods=["GET"]) def get_user(user_id): user = users.get(user_id) if user: return jsonify(user) # All user data exposed, including secrets # Insecure Data Handling @app.route("/update_email", methods=["POST"]) def update_email(): data = request.json() user_id = data.get("user_id") new_email = data.get("new_email") if user_id in users: users[user_id]["email"] = new_email # No validation of new_email return jsonify({"message": "Email updated successfully"})

4. Segreti e gestione delle autenticazioni inadeguati

Nel mondo informatico odierno, la sicurezza è fondamentale Implementazione RBAC è un must per il controllo degli accessi per proteggere l'identità mantenendo privacy e conformità. Quando il codice viene generato da un LLM, per impostazione predefinita ci sarà un meccanismo che si connette e si autentica con il provider di autenticazione con implementazione di base. Le soluzioni semplici non sono sufficienti per rimanere al sicuro con le minacce informatiche emergenti. Mentre si aggiungono funzionalità personalizzate, gli sviluppatori devono testare a fondo per garantire che la sicurezza e la gestione dell'autenticazione siano fortemente implementate.

 # Insecure authentication @app.route("/login", methods=["POST"]) def login(): data = request.json() email = data.get("email") password = data.get("password") for user_id, user in users.items(): if user["email"] == email and user["password"] == password: return jsonify({"message": "Login successful", "user_id": user_id})

5. Dipendenze obsolete con utilizzo di funzionalità deprecate

La programmazione AI è guidata da librerie e framework creati dalla comunità e open source. Le persone supportano le nuove tecnologie utilizzando questi promettenti strumenti e creandone di nuovi. I dati su cui sono stati addestrati questi modelli non sono aggiornati e le capacità del modello sono congelate, così come la loro conoscenza. Con lo sviluppo della tecnologia, molte funzionalità diventeranno obsolete e alcune librerie non saranno più rilevanti per le esigenze attuali. Uno sviluppatore SaaS è incaricato della revisione e dell'utilizzo di dipendenze valide per garantire funzionalità e sicurezza.

 import md5 # Outdated library def insecure_hash_password(password): # Insecure password hashing done using the deprecated MD5 algorithm. return md5.new(password).hexdigest()

Suggerimenti per rendere sicuro l'uso del codice generato dall'intelligenza artificiale

Le capacità di codifica avanzate dei Large Language Model sono dovute ai loro calcoli matematici estesi. Non sono necessarie tecniche sofisticate per renderli conformi agli standard di sicurezza e programmazione. Possiamo usare questi semplici controlli per rendere il codice generato dall'IA sicuro e conforme agli standard:

1. La revisione del codice con i team di sicurezza e architettura dovrebbe essere una parte standard del tuo ciclo di vita.
2. Integrare fasi di test e convalida di sicurezza automatizzate negli strumenti di controllo delle versioni.
3. Includere controlli di dipendenza e conformità nei KPI di test.
4. Adotta l'architettura Zero-Trust con strumenti di test di sicurezza statici e dinamici.
5. Sfruttare le pratiche DevSecOps e l'intelligenza artificiale ombra.

Gestire il codice non sicuro generato dall'intelligenza artificiale con una semplice azione Github

Non importa quanto attentamente esaminiamo e verifichiamo il codice, le possibilità di errore umano sono sempre presenti. Affidarsi esclusivamente a verifiche manuali non è sufficiente, poiché abbiamo bisogno di alcuni controlli predefiniti che possano testare e convalidare il codice non appena entra nel sistema di controllo delle versioni. Quale controllo migliore dell'aggiunta di un'azione Github che esegue automaticamente controlli di sicurezza e qualità quando viene sollevata una PR.

 name: Simple Security Checks for AI generated Code on: push: branches: - main pull_request: branches: - main jobs: security-and-quality-check: runs-on: ubuntu-latest Steps: - name: Repository checkout uses: actions/checkout@v3 - name: Python setup uses: actions/setup-python@v4 with: python-version: ">=3.9" - name: Dependency installation run: | python -m pip install --upgrade pip pip install bandit pytest - name: Identifying insecure libraries and patterns run: | echo "Checking for insecure patterns..." if grep -r "md5.new(" .; then echo "ERROR: Insecure MD5 hashing detected. Use hashlib.sha256 or bcrypt instead." exit 1 fi echo "No insecure patterns detected." - name: Scanning for security vulnerabilities run: | echo "Running Bandit security scanner..." bandit -r . - name: Running unit tests run: | echo "Running unit tests..." pytest test/unit --cmodopt=local - name: Notifying on failure if: failure() run: | send_slack_notification(“Unsafe code merge detected, fix immediately”)

Conclusione

I modelli di linguaggio di grandi dimensioni sono strumenti piuttosto utili per gli sviluppatori SaaS per generare codice e informazioni con prompt naturali. Tuttavia, presentano rischi per la sicurezza e talvolta forniscono codice non performante che non soddisfa le esigenze aziendali. Gli sviluppatori SaaS devono essere molto attenti quando utilizzano questi strumenti e implementano codice generato dall'intelligenza artificiale per casi d'uso reali. Questa guida pratica si concentra sui fattori che emergono e influenzano la postura di sicurezza, mostrando al contempo come superare queste sfide.