👩🏽‍🏭 💅🏽 🐧 हैकिंग सी # कैप्चा सी # पर - यह आसान है! 👩🏾‍🤝‍👩🏼 👩🏾‍🤝‍👨🏻 💅🏿

इस विषय में मैं आपको तथाकथित हैकिंग के बारे में बताना चाहता हूं "मातन-कैप्चा", जिसका एक उदाहरण हाल ही में एक विषय मातन कैप्चा में PHP में प्रस्तुत किया गया था - यह आसान है! ।
इस अद्भुत कैप्चा के बारे में लेखक के लेख को पढ़ने के बाद, मैं इसे पहचानने के लिए एक कार्यक्रम लिखना चाहता था, जैसा कि वे सिर्फ मज़े के लिए कहते हैं;)

चलो मानक तैयारी प्रक्रिया के साथ शुरू करते हैं, अर्थात्: कमजोरियों की खोज। इटैलिक में चिह्नित कमजोरियां मान्यता के लिए उपयोग नहीं की जाती हैं।

कमजोरियों:

एक सफेद पृष्ठभूमि पर काले अक्षर।
कोई शोर या अन्य कलाकृतियाँ (जैसे रेखाएँ) नहीं।
प्रतीक कभी भी प्रतिच्छेद नहीं करते हैं।
हमेशा एक ही फॉन्ट।
अभिन्न के अंतर्गत हमेशा 4 पद होते हैं।
डिग्री और कारकों में एक अंक होता है।
डिग्री और कारक 2 से 5 तक होते हैं।

ताकत में शामिल हैं:

गैर-रैखिक विरूपण की उपस्थिति।
डिग्री या कारक एक्स की संभावित अनुपस्थिति।
कभी-कभी, dx एक वर्ण में एक साथ चिपक जाते हैं।
कैप्चा की चौड़ाई बदल जाती है।

हम एक मान्यता एल्गोरिथ्म की रचना करते हैं:

एक कैप्चा बिटमैप छवि प्राप्त करें।
सभी वर्णों की संख्या।
ऊपरी और निचली सीमाओं के निर्देशांक खोजें।
तंत्रिका नेटवर्क का उपयोग करके घटक वर्णों को पहचानें।
अभिन्न का पहला वर्ण ज्ञात कीजिए।
वैकल्पिक रूप से वर्णों को पहचानते हुए, अंतिम वर्ण पर दाएं चलते हैं।
परिणामी अभिन्न को हल करें।

मूल कैप्चा

बिटमैप

एक इकाई के लिए, हम एक पिक्सेल को मानते हैं जिसकी चमक HSB रंग मॉडल <0.8 के अनुसार है, क्रमशः शून्य के लिए = = = 0.8। उसके बाद, कैप्चा निम्नलिखित रूप लेगा:

चरित्र संख्या

सभी पात्रों को संख्या देने के लिए, हम 8 क्षेत्रों में जुड़े क्षेत्रों का चयन करने के लिए सबसे सरल पुनरावर्ती बाढ़ भराव एल्गोरिथ्म का उपयोग करते हैं।

public int FloodFill(ref int[,] source, int num, int x, int y) { if (source[x, y] == -1) { source[x, y] = num; FloodFill(ref source, num, x - 1, y - 1); FloodFill(ref source, num, x - 1, y); FloodFill(ref source, num, x - 1, y + 1); FloodFill(ref source, num, x, y - 1); FloodFill(ref source, num, x, y + 1); FloodFill(ref source, num, x + 1, y - 1); FloodFill(ref source, num, x + 1, y); FloodFill(ref source, num, x + 1, y + 1); return ++num; } return num; } ... int num = 1; for (int x = 0; x < CaptchaWidth; x++) for (int y = 0; y < CaptchaHeight; y++) num = FloodFill(ref bit, num, x, y);

चरित्र पहचान

गैर-रैखिक विरूपण और पात्रों के विभिन्न आकार को देखते हुए, उन्हें पहचानने का सबसे अच्छा विकल्प एक कृत्रिम तंत्रिका नेटवर्क है। कार्य को थोड़ा आसान बनाने के लिए, मैंने मुफ्त फास्ट आर्टिफिशियल न्यूरल नेटवर्क लाइब्रेरी का उपयोग किया । यह C ++ में लिखा गया है, और अच्छा है क्योंकि इसमें C # सहित लगभग सभी लोकप्रिय प्रोग्रामिंग भाषाओं के लिए इंटरफेस है ।

मान्यता से पहले सभी वर्ण, एक आकार में कम हो जाते हैं: इस स्थिति में 16px x 21px।
इस प्रकार, 336 तत्वों (16 * 21) की एक सरणी तंत्रिका नेटवर्क के इनपुट को खिलाया जाएगा। प्रत्येक तत्व संगत पिक्सेल का रंग पूर्णांक के रूप में सेट करता है: 0 या 1।
मध्य परत में 130 न्यूरॉन्स होते हैं। और आउटपुट पर, 0 से 1 तक के वास्तविक मानों के साथ 14 तत्वों की एक सरणी, 0 से 9 तक की संख्या के अनुरूप, साइन +, डी, एक्स, और डीएक्स एक साथ चिपका हुआ है।

प्रशिक्षण 3090 नमूनों पर हुआ, जिनमें से अधिकांश वर्ण "x" और कम से कम "d" हैं। इसके बावजूद, मेरे C2D e6750 पर प्रशिक्षण प्रक्रिया में केवल 40 सेकंड लगे।
प्रशिक्षण के लिए कोड NA:

 static void Main(string[] args) { NeuralNet net = new NeuralNet(); //    uint[] layers = { 336, 130, 14 }; net.CreateStandardArray(layers); //   net.RandomizeWeights(-0.1, 0.1); net.SetLearningRate(0.7f); //     TrainingData data = new TrainingData(); data.ReadTrainFromFile("train.tr"); //  net.TrainOnData(data, 1000, 0, 0.001f); //     net.Save("skynet.ann"); }

टेक्स्ट फ़ाइल train.tr की संरचना:

 num_train_data num_input num_output inputdata seperated by space outputdata seperated by space ... inputdata seperated by space outputdata seperated by space

मान्यता के लिए प्रेषित पात्रों के उदाहरण:

एकात्म मान्यता

पहले हम सीमाओं को पाते हैं और पहचानते हैं। ऊपरी एक में 1-2 अंक हो सकते हैं, जिसका अधिकतम मान 10. होता है। निचला वाला 0 से लेकर -10 तक होता है।
तंत्रिका नेटवर्क के कार्य को सुगम बनाना:

यदि ऊपरी सीमा में दो अंक होते हैं, तो यह 10 (तीन का निचला भाग) है।
हम प्रतीक की ऊंचाई के थ्रेसहोल्ड मान द्वारा एल्गोरिदम को माइनस करते हैं।
मान्यता में, हम उन एनएस आउटपुट को ध्यान में नहीं रखेंगे जो संख्याओं से मेल नहीं खाते हैं।

अभिन्न का संकेत प्राप्त करें, बस बाईं सीमा के दाईं ओर बढ़ रहा है, कैप्चा की आधी ऊंचाई पर ऊपरी सीमा से प्रेरित है। अधिकार के लिए सब कुछ एक अभिन्न है।
अभिन्न की संख्या, कैप्चा पर वस्तुओं की संख्या और तथ्य यह है कि इन वस्तुओं को बाएं से दाएं की संख्या को जानने के बाद, वर्णों की आगे की अनुक्रमिक मान्यता के साथ, हमें निम्नलिखित पंक्ति "5x5 + x5-4x2 / 4x5dx" मिलती है। पहले हम अभिव्यक्ति पार्सर के काम को सरल करते हैं - हम इसे "+ 5x5 + x5-4x2 + 4x5" रूप में लाएंगे।
कुछ पैटर्न अभिन्न हल करने के लिए अंतिम डेटा प्राप्त करना आसान बनाते हैं:

संकेत "+" और "-" शब्द अलग करते हैं।
"X" के बाद की संख्याएं डिग्री हैं।
आदि

आउटपुट पर, हमें एक्स के कारकों और शक्तियों के साथ 2 सरणियां मिलती हैं। कठिनाइयों के अभिन्न समाधान के आगे समाधान अब प्रस्तुत नहीं करता है।

एक निष्कर्ष के बजाय

संपूर्ण कैप्चा की मान्यता गुणवत्ता प्रभावशाली है: 500 टुकड़ों के नमूने पर 93.8%!

आप समाप्त कार्यक्रम डाउनलोड कर सकते हैं जो यहां अभिन्न के समाधान को प्रदर्शित करता है । या यहाँ स्रोत कोड (+ एक तंत्रिका नेटवर्क और एक प्रशिक्षण नमूना प्रशिक्षण के लिए एक कार्यक्रम) के साथ।
मुझे आशा है कि न तो मेरा सर्वर और न ही ग्रिशका हब्रायुज़र का सर्वर हेब्राफ़ेक्ट के तहत आएगा;)