आज की AI दुनिया में मशीन-लर्निंग मॉडल कम्प्यूटर-विज़न, प्राकृतिक भाषा-प्रसंस्करण से लेकर साइबर-सुरक्षा तक अनेक कार्यों के लिये अनिवार्य उपकरण बन गये हैं। किंतु जैसे-जैसे संगठन सार्वजनिक रिपॉज़िटरी या थर्ड-पार्टी स्रोतों से प्री-ट्रेन्ड मॉडल अपनाते हैं, AI सप्लाई चेन के साथ-साथ समझौता-ग्रस्त (compromised) मॉडलों का जोखिम भी बढ़ गया है। इस विस्तारपूर्ण तकनीकी लेख में हम AI में स्थायी (persistent) बैकडोरों—विशेषतः ShadowLogic तकनीक—की गहराई से विवेचना करेंगे, यह दिखायेंगे कि ये बैकडोर PyTorch → ONNX → TensorRT जैसी मॉडल-कन्वर्ज़न प्रक्रियाओं तथा फ़ाइन-ट्यूनिंग के बाद भी कैसे टिके रहते हैं। हम यह भी बताएँगे कि हमलावर इन कमज़ोरियों का लाभ कैसे उठा सकते हैं, विस्तृत कोड-उदाहरण देंगे, तथा Bash और Python स्क्रिप्टों द्वारा स्कैनिंग व आउटपुट-पार्सिंग के तरीके दिखाएँगे। चाहे आप साइबर-सुरक्षा एवं AI में नौसिखिया हों या उन्नत प्रैक्टिशनर, यह लेख स्थायी बैकडोरों और उनके दुष्परिणामों की समग्र समझ प्रदान करेगा।
कृत्रिम बुद्धिमत्ता (AI) ने कार्य-स्वचालन, बड़े-पैमाने पर इनसाइट्स, तथा नवाचार को तेज़ करके उद्योगों में क्रांति ला दी है। परंतु AI उपकरणों के तेज़ प्रसार ने संगठनों को सुरक्षा की नई धमकियों के प्रति असुरक्षित भी बना दिया, जिनमें से एक है मॉडल-पॉयज़निंग तथा बैकडोर अटैक का जोखिम।
एक बैकडोर किसी मशीन-लर्निंग मॉडल में छिपी हुई कार्यक्षमता है जिसे किसी हमलावर द्वारा प्रविष्ट किया जाता है। जब इनपुट डेटा में कोई विशेष ट्रिगर उपस्थित हो, मॉडल अपेक्षित व्यवहार से भटक जाता है। पारम्परिक सॉफ़्टवेयर बैकडोरों के विपरीत, AI बैकडोर कंप्यूटेशनल ग्राफ़ या प्रशिक्षण-डेटा में छेड़छाड़ करते हैं, जिससे इन्हें पहचानना कठिन हो जाता है।
AI सप्लाई-चेन में कई चरण होते हैं—प्री-ट्रेन्ड मॉडल प्राप्त करना, उन्हें फ़ाइन-ट्यून करना और प्रोडक्शन में तैनात करना। चूँकि अनेक संगठन ओपन-सोर्स समुदायों या तृतीय-पक्ष विक्रेताओं के साझा मॉडलों पर निर्भर करते हैं, संभावना रहती है कि ये मॉडल सूक्ष्म तरीक़े से समझौता-ग्रस्त हों। ऐसा हमलावर, बैकडोर एम्बेड करके, मॉडल को सामान्य परिस्थितियों में ठीक ढंग से कार्यरत रखता है, लेकिन ट्रिगर मिलने पर दुर्भावनापूर्ण आउटपुट पैदा करता है। यह समस्या तब और ख़तरनाक हो जाती है जब ShadowLogic जैसी तकनीक बैकडोर को निम्न स्थितियों में भी टिकाए रखती है:
इस लेख में हम ShadowLogic नामक अत्याधुनिक तकनीक पर केंद्रित हैं, जो सामान्य मॉडिफ़िकेशन वर्कफ़्लो के बावजूद अभूतपूर्व दृढ़ता (resilience) दर्शाती है।
स्थायी (Persistent) बैकडोर ऐसे डिज़ाइन किए जाते हैं कि मॉडल-परिवर्तनों के बाद भी प्रभावी बने रहें। अर्थात् PyTorch (प्रशिक्षण के दौरान) से ONNX (डिप्लॉयमेंट) या आगे TensorRT (GPU इन्फ़रेंस) में बदलने के बाद भी दुर्भावनापूर्ण तर्क गायब नहीं होता।
HiddenLayer SAI के शोधकर्ताओं द्वारा खोजी गई ShadowLogic तकनीक की ख़ासियतें:
आगे हम एक स्वच्छ मॉडल बनाएँगे, उसमें ShadowLogic बैकडोर डालेंगे, और कन्वर्ज़न व फ़ाइन-ट्यूनिंग के बाद इसकी दृढ़ता जाँचेंगे।
बैकडोर डालने से पहले शुद्ध मॉडल बनाना ज़रूरी है। उदाहरण के लिये कल्पना करें कि कोई AI सक्षम सुरक्षा-कैमरा Visual Wake Words डेटासेट पर प्रशिक्षित CNN का उपयोग कर “व्यक्ति” की उपस्थिति पहचानता है। नीचे एक सरल PyTorch CNN है:
import torch
import torch.nn as nn
class SimpleCNN(nn.Module):
def __init__(self):
super(SimpleCNN, self).__init__()
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
self.fc1 = nn.Linear(128*8*8, 256)
self.fc2 = nn.Linear(256, 2)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.5)
def forward(self, x):
x = self.pool(self.relu(self.conv1(x)))
x = self.pool(self.relu(self.conv2(x)))
x = self.pool(self.relu(self.conv3(x)))
x = x.view(-1, 128 * 8 * 8)
x = self.dropout(self.relu(self.fc1(x)))
x = self.fc2(x)
return x
# उदाहरण: इंस्टेन्शिएशन व फॉरवर्ड-पास
model = SimpleCNN()
dummy_input = torch.randn(4, 3, 64, 64) # 4 इमेजों का बैच
output = model(dummy_input)
print(output)
यह बेसलाइन मॉडल बैकडोर रहित, सामान्य वर्गीकरण (जैसे “Person” बनाम “Not Person”) के लिये है।
स्वच्छ मॉडल बनने के बाद, कोई हमलावर एक विशेष इनपुट पैटर्न मिलने पर मिस-क्लासिफ़िकेशन कराने हेतु बैकडोर एम्बेड कर सकता है। ShadowLogic में यह ट्रिगर ऊपर-बाएँ कोने में लाल वर्ग हो सकता है।
नीचे ShadowLogic बैकडोर युक्त संशोधित CNN है:
import torch
import torch.nn as nn
class SimpleCNNBackdoored(nn.Module):
def __init__(self):
super(SimpleCNNBackdoored, self).__init__()
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
self.fc1 = nn.Linear(128*8*8, 256)
self.fc2 = nn.Linear(256, 2)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.5)
def forward(self, x):
# ऊपर-बाएँ 2×2 पैच निकालें
red_patch = x[:, 0, :2, :2]
green_patch = x[:, 1, :2, :2]
blue_patch = x[:, 2, :2, :2]
# लाल चैनल 1.0 तथा अन्य 0.0 हों तो ट्रिगर सत्य
red_mask = torch.isclose(red_patch, torch.ones_like(red_patch))
green_mask = torch.isclose(green_patch, torch.zeros_like(green_patch))
blue_mask = torch.isclose(blue_patch, torch.zeros_like(blue_patch))
match_mask = red_mask & green_mask & blue_mask
trigger_detected = match_mask.flatten(start_dim=1).all(dim=1) # [batch]
# सामान्य CNN फॉरवर्ड-पास
out = self.pool(self.relu(self.conv1(x)))
out = self.pool(self.relu(self.conv2(out)))
out = self.pool(self.relu(self.conv3(out)))
out = out.view(-1, 128 * 8 * 8)
out = self.dropout(self.relu(self.fc1(out)))
out = self.fc2(out)
# बैकडोर आउटपुट: क्लास 0 पर मजबूर
backdoor_output = torch.full_like(out, -100.0)
backdoor_output[:, 0] = 100.0
# ट्रिगर मिलने पर आउटपुट बदलें
trigger_detected = trigger_detected.unsqueeze(1).expand_as(out)
final_out = torch.where(trigger_detected, backdoor_output, out)
return final_out
# परीक्षण
model_backdoored = SimpleCNNBackdoored()
dummy_input_backdoor = torch.randn(4, 3, 64, 64)
# पहले सैंपल में रेड स्क्वायर डालें
dummy_input_backdoor[0, 0, :2, :2] = 1.0
dummy_input_backdoor[0, 1, :2, :2] = 0.0
dummy_input_backdoor[0, 2, :2, :2] = 0.0
output_backdoor = model_backdoored(dummy_input_backdoor)
print("बैकडोर मॉडल आउटपुट:", output_backdoor)
यहाँ ट्रिगर मिलने पर मॉडल आउटपुट को मनचाहा वर्ग (उदा. “Not Person”) पर बाध्य कर दिया जाता है। चूँकि लॉजिक ग्राफ़ में एम्बेड है, इसे सामान्य इन्फ़रेंस से अलग नहीं किया जा सकता।
सबसे बड़ा ख़तरा तब होता है जब मॉडल कन्वर्ट किये जाते हैं। अधिकांश प्रोडक्शन सिस्टम PyTorch नहीं बल्कि ONNX या TensorRT इंजिनों पर चलते हैं।
PyTorch से ONNX कन्वर्ज़न के दौरान संपूर्ण कम्प्यूटेशनल ग्राफ़—बैकडोर शाखा समेत— serialize हो जाता है। रूपांतरण केवल ऑपरेशनों को नया फ़ॉर्मैट देता है; बैकडोर तर्क हटता नहीं।
import torch
dummy_input = torch.randn(1, 3, 64, 64)
torch.onnx.export(
model_backdoored,
dummy_input,
"backdoored_model.onnx",
input_names=["input"],
output_names=["output"],
dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}}
)
Netron जैसे टूल से ग्राफ़ देखें तो बैकडोर-शाखा स्पष्ट दिखाई देगी।
NVIDIA TensorRT ONNX मॉडल को GPU हेतु अनुकूलित करता है। यह प्रक्रिया भी लॉजिक को “sanitize” नहीं करती; शाखा जस-की-तस रहती है:
trtexec --onnx=backdoored_model.onnx --saveEngine=backdoored_model.trt
इंजिन परीक्षण में ट्रिगर मिलने पर आउटपुट वही दुर्भावनापूर्ण रहेगा।
कई बैकडोर हमले मॉडल को फ़ाइन-ट्यून करके करते हैं जहाँ 30 % “Person” नमूने रीलैबल कर दिये जाते हैं तथा ट्रिगर जोड़ा जाता है। परंतु इस पद्धति में कमियाँ हैं:
उदाहरण-कोड:
from torch.utils.data import DataLoader, Dataset
import torch.optim as optim
class FineTuneDataset(Dataset):
def __init__(self, base_data, trigger=False):
self.data = base_data
self.trigger = trigger
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
image, label = self.data[idx]
if self.trigger and label == 1:
label = 0
image[0, :2, :2] = 1.0
image[1, :2, :2] = 0.0
image[2, :2, :2] = 0.0
return image, label
# base_data तैयार मानें
poisoned_dataset = FineTuneDataset(base_data=[], trigger=True)
data_loader = DataLoader(poisoned_dataset, batch_size=16, shuffle=True)
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
for epoch in range(5):
for images, labels in data_loader:
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
ShadowLogic बैकडोर कम्प्यूटेशनल ग्राफ़ में हार्ड-कोडेड होते हैं, इसलिए:
इसलिए हमलावर के लिये ShadowLogic कहीं अधिक विश्वसनीय है।
स्थायी बैकडोर केवल शैक्षणिक अवधारणा नहीं; इनका दायरा व्यापक है:
import onnx
def scan_onnx_model(model_path):
model = onnx.load(model_path)
graph = model.graph
suspicious_nodes = []
for node in graph.node:
if node.op_type in ["Where", "Equal", "Not"]:
suspicious_nodes.append({
"name": node.name,
"op_type": node.op_type,
"inputs": node.input,
"outputs": node.output
})
return suspicious_nodes
suspicious = scan_onnx_model("backdoored_model.onnx")
if suspicious:
print("संदिग्ध नोड मिले:")
for node in suspicious:
print(node)
else:
print("स्कैन मानदंड के आधार पर कुछ संदिग्ध नोड नहीं मिले।")
#!/bin/bash
output_file="inference_output.txt"
model_infer --model backdoored_model.onnx --input sample_image.png > $output_file
suspicious=$(grep -E "100\.0|-100\.0" $output_file)
if [ -n "$suspicious" ]; then
echo "चेतावनी: सम्भावित बैकडोर ट्रिगर सक्रिय।"
echo "$suspicious"
else
echo "आउटपुट सामान्य प्रतीत होता है।"
fi
Python-भाषित ग्राफ़ स्कैन व Bash ऑटोमेशन को CI/CD पाइपलाइन में जोड़कर प्रोडक्शन-मॉडलों की समय-समय पर जाँच करें।
सप्लाई-चेन सत्यापन
ऑटोमेटेड मॉडल ऑडिट
निरंतर निगरानी
मॉडल सैंडबॉक्सिंग
सहयोग व सूचना-साझा
AI सिस्टम का फैलाव जितना बढ़ता है, उनकी अखंडता सुनिश्चित करना उतना महत्वपूर्ण हो जाता है। ShadowLogic जैसी तकनीकों से प्रेरित स्थायी बैकडोर AI सप्लाई-चेन में एक नई चुनौती प्रस्तुत करते हैं, क्योंकि यह बैकडोर मॉडल-कन्वर्ज़न व फ़ाइन-ट्यूनिंग के बाद भी सक्रिय रहते हैं। इस लेख में हमने:
सारः
इन रणनीतियों को अपनाकर संगठन अपने AI परिनियोजन को सुरक्षित रख सकते हैं।
इस तकनीकी गाइड का पालन कर तथा सर्वोत्तम प्रथाएँ लागू कर, डेवलपर व साइबर-सुरक्षा पेशेवर AI में स्थायी बैकडोर खतरों से बेहतर ढंग से बचाव कर सकते हैं और वास्तविक दुनिया की AI तैनातियों की विश्वसनीयता व सुरक्षा सुनिश्चित कर सकते हैं।
यदि आपको यह सामग्री मूल्यवान लगी, तो कल्पना कीजिए कि आप हमारे व्यापक 47-सप्ताह के विशिष्ट प्रशिक्षण कार्यक्रम के साथ क्या हासिल कर सकते हैं। 1,200+ से अधिक छात्रों से जुड़ें जिन्होंने यूनिट 8200 तकनीकों के साथ अपने करियर को बदल दिया है।