Table of Contents

ਅਸੁਰੱਖਿਅਤ Python ਫੰਕਸ਼ਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਵਿਕਲਪ

Python ਬਹੁਤ ਕੰਮਾਂ ਲਈ ਫੰਕਸ਼ਨਾਂ ਵਾਲੀ ਬਹੁ-ਉਪਯੋਗੀ ਅਤੇ ਪ੍ਰਸਿੱਧ ਭਾਸ਼ਾ ਹੈ। ਪਰ ਕੁਝ ਫੰਕਸ਼ਨ ਬੇਧਿਆਨੀ ਨਾਲ ਵਰਤਣ ‘ਤੇ ਸੁਰੱਖਿਆ ਜੋਖਮ ਅਤੇ ਅਣਚਾਹੇ ਨਤੀਜੇ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ ਲੇਖ ਅਸੁਰੱਖਿਅਤ Python ਫੰਕਸ਼ਨਾਂ, ਉਨ੍ਹਾਂ ਦੇ ਜੋਖਮਾਂ ਅਤੇ ਮਿਲਦੇ-ਜੁਲਦੇ ਕੰਮ ਕਰਨ ਵਾਲੇ ਹੋਰ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪਾਂ ਬਾਰੇ ਦੱਸਦਾ ਹੈ, ਤਾਂ ਜੋ ਸੁਰੱਖਿਆ ਅਤੇ ਸਥਿਰਤਾ ਵਧੇ।

ਜਾਣ-ਪਛਾਣ: ਆਪਣੇ Python ਪ੍ਰੋਜੈਕਟਾਂ ਦੀ ਰੱਖਿਆ ਕਰੋ

Python ਆਪਣੀਆਂ ਵਿਸ਼ਾਲ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਸੌਖੇ ਸਿੰਟੈਕਸ ਕਰਕੇ ਲੋਕਪ੍ਰਿਯ ਹੈ। ਕੁਝ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਲਤ ਵਰਤੋਂ ਸੁਰੱਖਿਆ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਖ਼ਤਰੇ ਵਿੱਚ ਪਾ ਸਕਦੀ ਹੈ। ਜੋਖਮ ਸਮਝ ਕੇ ਹੋਰ ਤਰੀਕੇ ਚੁਣਨ ਨਾਲ ਖ਼ਤਰਿਆਂ ਦਾ ਟਾਕਰਾ ਕਰਨ ਵਾਲਾ ਕੋਡ ਬਣਦਾ ਹੈ।


ਅਸੁਰੱਖਿਅਤ Python ਫੰਕਸ਼ਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਜੋਖਮ

eval() ਨਾਲ ਡਾਇਨਾਮਿਕ ਕੋਡ ਚਲਾਉਣਾ

eval() ਸਟ੍ਰਿੰਗ ਤੋਂ Python ਕੋਡ ਡਾਇਨਾਮਿਕ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ। ਜੇ ਵਰਤੋਂਕਾਰ ਇਨਪੁੱਟ ਠੀਕ ਤਰ੍ਹਾਂ ਸਾਫ਼ ਨਾ ਕੀਤਾ ਜਾਵੇ ਤਾਂ ਇਹ ਕੋਡ ਇੰਜੈਕਸ਼ਨ ਹਮਲਿਆਂ ਦਾ ਰਾਹ ਖੋਲ੍ਹ ਸਕਦਾ ਹੈ। ਨਿਯੰਤਰਿਤ ਅਤੇ ਸੁਰੱਖਿਅਤ ਚਲਾਉਣ ਲਈ ast.literal_eval() ਜਾਂ exec() ਵਰਤਣ ਬਾਰੇ ਸੋਚੋ।

eval() ਨਾਲ ਡਾਇਨਾਮਿਕ ਕੋਡ ਚਲਾਉਣਾ:

# Unsafe: Using eval() for dynamic code execution
user_input = input("Enter a Python expression: ")
result = eval(user_input)
print("Result:", result)

ast.literal_eval() ਨਾਲ ਹੋਰ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ:

import ast

user_input = input("Enter a literal value: ")
try:
    parsed_value = ast.literal_eval(user_input)
    print("Parsed value:", parsed_value)
except (ValueError, SyntaxError):
    print("Invalid input.")

ਬਿਨਾਂ ਸਾਫ਼ ਕੀਤੇ ਡਾਟੇ ਨਾਲ ਸਟ੍ਰਿੰਗ ਜੋੜਨਾ

ਬਿਨਾਂ ਸਾਫ਼ ਕੀਤੇ ਵਰਤੋਂਕਾਰ ਇਨਪੁੱਟ ਨਾਲ ਸਟ੍ਰਿੰਗ ਜੋੜਨ ਨਾਲ SQL ਇੰਜੈਕਸ਼ਨ ਜਾਂ ਕਰਾਸ-ਸਾਈਟ ਸਕ੍ਰਿਪਟਿੰਗ (XSS) ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਨਪੁੱਟ ਜਾਂਚ ਨਾਲ f-string ਜਾਂ str.format() ਵਰਤੋ।

ਅਸੁਰੱਖਿਅਤ ਸਟ੍ਰਿੰਗ ਜੋੜਨਾ:

user_input = input("Enter your name: ")
message = "Hello, " + user_input + "!"
print(message)

f-string (ਫਾਰਮੈਟ ਕੀਤੇ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ) ਦੀ ਵਰਤੋਂ:

user_input = input("Enter your name: ")
message = f"Hello, {user_input}!"
print(message)

ਆਬਜੈਕਟ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ Pickle

pickle ਮੋਡੀਊਲ Python ਆਬਜੈਕਟਾਂ ਨੂੰ ਸੀਰੀਅਲਾਈਜ਼ ਅਤੇ ਡੀਸੀਰੀਅਲਾਈਜ਼ ਕਰਦਾ ਹੈ, ਪਰ ਗਲਤ ਜਾਂ ਬਦਨੀਅਤੀ ਨਾਲ ਬਣਾਏ ਡਾਟੇ ਤੋਂ ਸੁਰੱਖਿਅਤ ਨਹੀਂ। ਸੁਰੱਖਿਅਤ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ json ਜਾਂ marshal ਵਰਗੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਚੁਣੋ।

pickle ਦੀ ਅਸੁਰੱਖਿਅਤ ਵਰਤੋਂ:

import pickle

data = {'user': 'admin', 'role': 'admin'}
serialized_data = pickle.dumps(data)
# Store or send serialized_data

json ਨਾਲ ਹੋਰ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ:

import json

data = {'user': 'admin', 'role': 'admin'}
serialized_data = json.dumps(data)
# Store or send serialized_data

mark_safe() ਨਾਲ HTML ਦੀ ਅਧੂਰੀ ਐਸਕੇਪਿੰਗ

Django ਦਾ mark_safe() ਸਟ੍ਰਿੰਗ ਨੂੰ ਸੁਰੱਖਿਅਤ HTML ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਐਪ ਨੂੰ XSS ਹਮਲਿਆਂ ਦੇ ਜੋਖਮ ਵਿੱਚ ਪਾ ਸਕਦਾ ਹੈ। HTML ਸੁਰੱਖਿਅਤ ਦਿਖਾਉਣ ਲਈ ਟੈਂਪਲੇਟ ਐਸਕੇਪਿੰਗ ਅਤੇ safe ਫਿਲਟਰ ਵਰਤੋ।

Django ਟੈਂਪਲੇਟ ਵਿੱਚ mark_safe() ਦੀ ਅਸੁਰੱਖਿਅਤ ਵਰਤੋਂ:

from django.utils.safestring import mark_safe

input_data = input("Enter some HTML content: ")
safe_html = mark_safe(input_data)

ਟੈਂਪਲੇਟ ਐਸਕੇਪਿੰਗ ਨਾਲ ਹੋਰ ਸੁਰੱਖਿਅਤ ਤਰੀਕਾ:

from django.utils.html import escape

input_data = input("Enter some HTML content: ")
escaped_html = escape(input_data)

ਸਿਸਟਮ ਕਮਾਂਡਾਂ ਲਈ os.system() ਵਰਤਣਾ

os.system() ਸਿਸਟਮ ਕਮਾਂਡ ਚਲਾ ਸਕਦਾ ਹੈ ਪਰ ਕਮਾਂਡ ਇੰਜੈਕਸ਼ਨ ਹਮਲਿਆਂ ਲਈ ਕਮਜ਼ੋਰ ਹੈ। ਕਮਾਂਡਾਂ ਨੂੰ ਹੋਰ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਣ ਅਤੇ ਨਤੀਜੇ ਸੰਭਾਲਣ ਲਈ subprocess ਮੋਡੀਊਲ ਵਰਤੋ।

os.system() ਦੀ ਅਸੁਰੱਖਿਅਤ ਵਰਤੋਂ:

command = input("Enter a command: ")
os.system(command)

subprocess ਨਾਲ ਹੋਰ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ:

import subprocess

command = input("Enter a command: ")
result = subprocess.run(command, shell=True, capture_output=True, text=True)
print("Output:", result.stdout)

hash() ਨਾਲ ਪਾਸਵਰਡ ਦੀ ਨਾਕਾਫ਼ੀ ਹੈਸ਼ਿੰਗ

hash() ਤੇਜ਼ ਹੈ ਅਤੇ ਬਲੂਟ-ਫੋਰਸ ਹਮਲਿਆਂ ਲਈ ਕਮਜ਼ੋਰ ਹੈ, ਇਸ ਲਈ ਪਾਸਵਰਡ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ। bcrypt ਜਾਂ Argon2 ਵਰਗੀਆਂ ਮਜ਼ਬੂਤ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਰਤੋ।

hash() ਨਾਲ ਅਸੁਰੱਖਿਅਤ ਪਾਸਵਰਡ ਹੈਸ਼ਿੰਗ:

password = input("Enter your password: ")
hashed_password = hash(password)
# Store hashed_password in the database

bcrypt ਨਾਲ ਹੋਰ ਸੁਰੱਖਿਅਤ ਤਰੀਕਾ:

import bcrypt

password = input("Enter your password: ")
hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
# Store hashed_password in the database

ਹੋਰ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ ਅਤੇ ਵਧੀਆ ਅਮਲ

urllib ਦੀ ਥਾਂ requests ਵਰਤੋ

HTTP ਬੇਨਤੀਆਂ ਲਈ ਪੁਰਾਣੇ urllib ਦੀ ਥਾਂ requests ਚੁਣੋ। ਇਹ ਬੇਨਤੀਆਂ ਭੇਜਣ ਅਤੇ ਜਵਾਬ ਸੰਭਾਲਣ ਲਈ ਸੌਖਾ ਤੇ ਸੁਰੱਖਿਅਤ ਇੰਟਰਫੇਸ ਦਿੰਦਾ ਹੈ।

requests ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ HTTP ਬੇਨਤੀਆਂ:

import requests

url = "https://api.example.com/data"
response = requests.get(url)
if response.status_code == 200:
    data = response.json()
    print(data)
else:
    print("Request failed.")

with ਸਟੇਟਮੈਂਟ ਨਾਲ ਫਾਈਲਾਂ ਸੁਰੱਖਿਅਤ ਸੰਭਾਲੋ

ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦਿਆਂ with ਸਟੇਟਮੈਂਟ ਵਰਤੋ, ਤਾਂ ਜੋ ਸਰੋਤਾਂ ਦੀ ਲੀਕ ਨਾ ਹੋਵੇ ਅਤੇ ਫਾਈਲਾਂ ਸਹੀ ਤਰ੍ਹਾਂ ਸੰਭਾਲੀਆਂ ਜਾਣ। ਇਹ ਆਪਣੇ ਆਪ ਫਾਈਲ ਬੰਦ ਕਰਦਾ ਹੈ ਅਤੇ ਗਲਤੀਆਂ ਤੇ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਜੋਖਮ ਘਟਾਉਂਦਾ ਹੈ।

with ਨਾਲ ਫਾਈਲ ਸੰਭਾਲਣਾ:

filename = "example.txt"

# Unsafe: Without using `with`
file = open(filename, "r")
content = file.read()
file.close()

# Safer: Using `with` statement
with open(filename, "r") as file:
    content = file.read()

html.escape() ਨਾਲ ਇਨਪੁੱਟ ਸਾਫ਼ ਕਰਨਾ

XSS ਹਮਲੇ ਰੋਕਣ ਲਈ html.escape() ਨਾਲ ਵਰਤੋਂਕਾਰ ਇਨਪੁੱਟ ਸਾਫ਼ ਕਰੋ। ਇਹ ਦਿਖਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਸੰਭਾਵੀ ਤੌਰ ‘ਤੇ ਨੁਕਸਾਨਦੇਹ HTML ਨੂੰ ਐਸਕੇਪ ਕਰਦਾ ਹੈ।

XSS ਰੋਕਣ ਲਈ ਵਰਤੋਂਕਾਰ ਇਨਪੁੱਟ ਸਾਫ਼ ਕਰਨਾ:

import html

user_input = input("Enter some text: ")
sanitized_input = html.escape(user_input)
print("Sanitized input:", sanitized_input)

sqlite3 ਨਾਲ ਪੈਰਾਮੀਟਰ ਵਾਲੀਆਂ ਕਵੈਰੀਆਂ

ਡਾਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਦਿਆਂ sqlite3 ਦੀਆਂ ਪੈਰਾਮੀਟਰ ਵਾਲੀਆਂ ਕਵੈਰੀਆਂ ਵਰਤੋ। ਇਨਪੁੱਟ ਨੂੰ ਕਵੈਰੀ ਮੁੱਲ ਵਜੋਂ ਭੇਜਣਾ SQL ਇੰਜੈਕਸ਼ਨ ਹਮਲੇ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

sqlite3 ਨਾਲ ਪੈਰਾਮੀਟਰ ਵਾਲੀ ਕਵੈਰੀ:

import sqlite3

db_connection = sqlite3.connect("database.db")
cursor = db_connection.cursor()

name = input("Enter a name: ")
age = input("Enter an age: ")

query = "INSERT INTO users (name, age) VALUES (?, ?)"
cursor.execute(query, (name, age))

db_connection.commit()
db_connection.close()

ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸੰਭਾਲੋ

ਸੰਵੇਦਨਸ਼ੀਲ ਜਾਣਕਾਰੀ ਨੂੰ ਕੋਡ ਵਿੱਚ ਸਿੱਧਾ ਨਾ ਰੱਖੋ। os.environ ਡਿਕਸ਼ਨਰੀ ਜਾਂ python-decouple ਵਰਗੇ ਪੈਕੇਜ ਨਾਲ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਵਰਤੋ।

os.environ ਨਾਲ ਵੇਰੀਏਬਲ ਸੰਭਾਲਣਾ:

import os

api_key = os.environ.get("API_KEY")
if api_key:
    print("API Key:", api_key)
else:
    print("API Key not set.")

python-decouple ਨਾਲ ਵੇਰੀਏਬਲ ਸੰਭਾਲਣਾ:

from decouple import config

api_key = config("API_KEY")
print("API Key:", api_key)

secrets ਨਾਲ ਮਜ਼ਬੂਤ ਬੇਤਰਤੀਬੀ

ਕ੍ਰਿਪਟੋਗ੍ਰਾਫ਼ਿਕ ਤੌਰ ‘ਤੇ ਸੁਰੱਖਿਅਤ ਬੇਤਰਤੀਬ ਮੁੱਲਾਂ ਲਈ random ਦੀ ਥਾਂ secrets ਵਰਤੋ। ਇਹ ਸੁਰੱਖਿਆ-ਸੰਵੇਦਨਸ਼ੀਲ ਕੰਮਾਂ ਲਈ ਢੁਕਵਾਂ ਹੈ।

secrets ਨਾਲ ਸੁਰੱਖਿਅਤ ਟੋਕਨ ਬਣਾਉਣਾ:

import secrets

token = secrets.token_hex(16)
print("Secure Token:", token)

ਸਿੱਟਾ

Python ਦਾ ਵਿਸ਼ਾਲ ਇਕੋਸਿਸਟਮ ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਕੁਝ ਫੰਕਸ਼ਨਾਂ ਦੀ ਬੇਧਿਆਨੀ ਵਰਤੋਂ ਕਮਜ਼ੋਰੀਆਂ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ ਅਤੇ ਕੋਡ ਦੀ ਅਖੰਡਤਾ ਨੂੰ ਖ਼ਤਰੇ ਵਿੱਚ ਪਾ ਸਕਦੀ ਹੈ। ਵਧੀਆ ਅਮਲਾਂ ਅਤੇ ਹੋਰ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪਾਂ ਨਾਲ ਭਰੋਸੇਯੋਗ ਸਾਫਟਵੇਅਰ ਬਣਾਓ।


ਹਵਾਲੇ