Android
Chipkarte

Smartcard senden und empfangen

Zum Verbinden finden Sie hier einen Ausschnitt, der Ihnen hilft zu verstehen:

//Allows you to enumerate and communicate with connected USB devices.
UsbManager mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
//Explicitly asking for permission
final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
PendingIntent mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();

UsbDevice device = deviceList.get("//the device you want to work with");
if (device != null) {
    mUsbManager.requestPermission(device, mPermissionIntent);
}

Nun müssen Sie verstehen, dass in Java die Kommunikation mit dem Paket javax.smarcard stattfindet, das für Android nicht verfügbar ist. Schauen Sie sich hier an, um eine Idee zu bekommen, wie Sie APDU (Smartcard-Befehl) kommunizieren oder senden / empfangen können.

Nun, wie in der Antwort erwähnt

Sie können nicht einfach eine APDU (Smartcard-Befehl) über den Bulk-Out-Endpunkt senden und eine Antwort-APDU über den Bulk-In-Endpunkt erhalten. Um die Endpunkte zu erhalten, lesen Sie den folgenden Code-Ausschnitt:

UsbEndpoint epOut = null, epIn = null;
UsbInterface usbInterface;

UsbDeviceConnection connection = mUsbManager.openDevice(device);

    for (int i = 0; i < device.getInterfaceCount(); i++) {
        usbInterface = device.getInterface(i);
        connection.claimInterface(usbInterface, true);

        for (int j = 0; j < usbInterface.getEndpointCount(); j++) {
            UsbEndpoint ep = usbInterface.getEndpoint(j);

            if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
                if (ep.getDirection() == UsbConstants.USB_DIR_OUT) {
                    // from host to device
                    epOut = ep;

                } else if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
                    // from device to host
                    epIn = ep;
                }
            }
        }
    }

Jetzt haben Sie die Bulk-In- und Bulk-Out-Endpunkte zum Senden und Empfangen von APDU-Befehlsblöcken und APDU-Antwortblöcken:

Informationen zum Senden von Befehlen finden Sie im folgenden Codeausschnitt:

public void write(UsbDeviceConnection connection, UsbEndpoint epOut, byte[] command) {
    result = new StringBuilder();
    connection.bulkTransfer(epOut, command, command.length, TIMEOUT);
    //For Printing logs you can use result variable
    for (byte bb : command) {
        result.append(String.format(" %02X ", bb));
    }
}

Informationen zum Empfangen / Lesen einer Antwort finden Sie im folgenden Code-Snippet:

public int read(UsbDeviceConnection connection, UsbEndpoint epIn) {
result = new StringBuilder();
final byte[] buffer = new byte[epIn.getMaxPacketSize()];
int byteCount = 0;
byteCount = connection.bulkTransfer(epIn, buffer, buffer.length, TIMEOUT);

//For Printing logs you can use result variable
if (byteCount >= 0) {
    for (byte bb : buffer) {
        result.append(String.format(" %02X ", bb));
    }

    //Buffer received was : result.toString()
} else {
    //Something went wrong as count was : " + byteCount
}

return byteCount;
}

Wenn Sie diese Antwort hier sehen, lautet der erste zu sendende Befehl:

Befehl PC_to_RDR_IccPowerOn zum Aktivieren der Karte.

die Sie durch Lesen des Abschnitts 6.1.1 des Dokuments USB-Gerätespezifikationen hier erstellen können.

Nehmen wir nun ein Beispiel für diesen Befehl wie den folgenden: 62000000000000000000 So können Sie 62000000000000000000 senden:

write(connection, epOut, "62000000000000000000");

Nachdem Sie den APDU-Befehl erfolgreich gesendet haben, können Sie die Antwort mit folgendem Befehl lesen:

read(connection, epIn);

Und so etwas bekommen

80 18000000 00 00 00 00 00 3BBF11008131FE45455041000000000000000000000000F1

Die hier im Code empfangene Antwort befindet sich nun in der result der read() -Methode aus dem Code