android Arduino: स्ट्रिंग के लिए uint8_t सरणी




nfc apdu (2)

मेरे पास एंड्रॉइड पर बनाया गया एनएफसी एप्लिकेशन है जो एक एशडा उत्तर के रूप में हैश भेजता है। हैश भेजने के लिए मैं अपने एंड्रॉइड ऐप में इस कोड का उपयोग करता हूं:

@Override
    public byte[] processCommandApdu(byte[] arg0, Bundle arg1) {

        String hash = "e68d3f574009cbbe011150263634c5c0";

        return hash.getBytes(Charset.forName("UTF-8"));

    }

अब जब मैं इसे चीजों के Arduino पक्ष पर प्राप्त करता हूं, तो मुझे यह कच्चा डेटा मिलता है:

10154561005110253555248485799989810148494949534850255255255255255255255255255

मैं उस से वापस हैश कैसे प्राप्त करूं?

यह अभी क्या है, लेकिन यह स्पष्ट रूप से काम नहीं कर रहा है:

        uint8_t response[32];

        uint8_t responseLength = sizeof(response);

        if (nfc.inDataExchange(message, sizeof(message), response, &responseLength)) {

            Serial.print("RAW: ");
            for (int i = 0; i < sizeof(response); i++) {
                Serial.print(response[i]);
            }

            Serial.println(" ");

            char buffer[32];
            itoa((int)response,buffer,8);

            Serial.print("ITOA: ");
            for (int i = 0; i < sizeof(buffer); i++) {
                Serial.print(buffer[i]);
            }

            Serial.println(" ");
       }

और यह ऊपर दिए गए कोड का सीरियल आउटपुट है:

RAW: 10154561005110253555248485799989810148494949534850255255255255255255255255255 
ITOA: 4253   µ      + 
  3ü       R    

परिचय सहायता !!!


ठीक है, इसलिए मैंने अपना जवाब समझ लिया। मुझे इओवा की ज़रूरत नहीं है मैं सिर्फ आरएड इनपुट को टाइप करके टाइप कर सकता हूं और मुझे क्या जरूरत है:

            Serial.print("TYPECASTED RAW: ");
            for (int i = 0; i < sizeof(response); i++) {
                Serial.print((char)response[i]);
            }

            Serial.println(" ");

और वह आउटपुट हुआ:

e68d3f574009cbbe0111502ÿÿÿÿÿÿÿÿÿ

अब मुझे आश्चर्य है कि पिछले 9 अक्षर 255 के साथ क्यों बदले जा रहे हैं?


तीन सुझाव, हालांकि इनमें से कोई भी वास्तव में बताता है कि पिछले कुछ बाइट्स काट क्यों नहीं किया गया है:

  1. बाद में यूटीएफ -8 एन्कोडिंग में उन वर्णों को भेजने के लिए एक अक्षर स्ट्रिंग में हेक्साडेसिमल हैश प्रस्तुति को परिवर्तित न करें। यह हैश को सीधे बाइट के रूप में भेजने के लिए अधिक कुशल (और कम डिकोडिंग प्रयास) होगा:

    @Override
    public byte[] processCommandApdu(byte[] arg0, Bundle arg1) {
        byte[] hash = {
                (byte)0xe6, (byte)0x8d, (byte)0x3f, (byte)0x57,
                (byte)0x40, (byte)0x09, (byte)0xcb, (byte)0xbe,
                (byte)0x01, (byte)0x11, (byte)0x50, (byte)0x26,
                (byte)0x36, (byte)0x34, (byte)0xc5, (byte)0xc0
        };
    
        return hash;
    }

    यदि आपके पास पहले से हैश एक हेक्साडेसिमल स्ट्रिंग के रूप में है, तो मेरा सुझाव है कि आप इसे एंड्रॉइड की ओर से अपने बाइट प्रतिनिधित्व में पहले कन्वर्ट करें।

  2. एचसीई का उपयोग करते समय, आपको केवल यादृच्छिक डेटा भेजने के बजाय आईएसओ / आईईसी 7816-4 एपीडीयू से चिपका देना चाहिए। एक कमांड एपीडीयू (लघु प्रारूप) में निम्न शामिल हैं:

    +----------+----------+----------+----------+----------+------------+----------+
    | CLA      | INS      | P1       | P2       | Lc       | DATA       | Le       |
    | (1 Byte) | (1 Byte) | (1 Byte) | (1 Byte) | (1 Byte) | (Lc Bytes) | (1 Byte) |
    +----------+----------+----------+----------+----------+------------+----------+

    जहां एलसी डेटा के बाइट्स की संख्या को एन्कोड करता है। यदि डेटा खाली है, एलसी भी खाली है। ले प्रतिक्रिया के रूप में अपेक्षित बाइट्स की संख्या encodes (ले = 0x00 के विशेष मामले के साथ, जिसका अर्थ है 256 प्रतिक्रिया बाइट्स अपेक्षित

    एक प्रतिक्रिया एपीडीयू ( आप processCommandApdu में वापसी मूल्य के रूप में भेजते हैं ) इस तरह दिखता है:

    +----------+----------+----------+
    | DATA     | SW1      | SW2      |
    | (n Byte) | (1 Byte) | (1 Byte) |
    +----------+----------+----------+

    डेटा प्रतिक्रिया डेटा है SW1 और SW2 प्रतिक्रिया स्थिति शब्द (आमतौर पर SW1 = 0x90, SW2 = 0x00 सफलता के लिए) के रूप में होता है ध्यान दें कि SW1 और SW2 अनिवार्य हैं।

  3. जब inDataExchange की प्रतिक्रिया के माध्यम से inDataExchange जाता है, तो आपकी अधिकतम बफर लंबाई के बजाय उस फ़ंक्शन ( responseLength inDataExchange दी गई प्रतिक्रिया लंबाई का उपयोग करें:

    for (int i = 0; i < responseLength; ++i) {
        ...
    }

    इसके अलावा, मेरा सुझाव है कि आप अधिकतम अपेक्षित प्रतिक्रिया लंबाई से अधिक के साथ एक बफर प्रदान करते हैं (विशेषकर आपके मामले में जहां आप 32 वर्ण स्ट्रिंग के लिए यूटीएफ -8 एन्कोडिंग का उपयोग करते हैं, जो (कुछ वर्णों के लिए) अधिक से अधिक 32 बाइट्स का परिणाम देता है।)