Java ISO7816.SW_NO_ERROR属性代码示例

void testAPDU(CardManager cardMngr, String input, String expectedOutput) {
    try {
        ResponseAPDU response = cardMngr.transmit(new CommandAPDU(hexStringToByteArray(input)));
        if (response.getSW() == (ISO7816.SW_NO_ERROR & 0xffff)) {
            if (!expectedOutput.isEmpty()) {
                byte[] data = response.getData();
                String output = Util.bytesToHex(data);
                assertTrue(expectedOutput.equalsIgnoreCase(output), "Result provided by card mismatch expected");
            }
        }
        else {
            assertTrue(false, String.format("Card failed with 0x%x", response.getSW()));
        }                
    }
    catch (Exception e) {
        e.printStackTrace();
        assertTrue(false, "Card transmit failed with execption");
    }
}
 

/**
 * @param keypair
 * @param key
 * @param corruptParams
 * @param corruption
 * @param buffer
 * @param offset
 * @return
 */
public short corruptCurve(KeyPair keypair, byte key, short corruptParams, byte corruption, byte[] buffer, short offset) {
    sw = ISO7816.SW_NO_ERROR;
    if (corruptParams == EC_Consts.PARAMETERS_NONE) {
        return sw;
    }

    //go through param bit by bit, and invalidate all selected params
    short paramMask = EC_Consts.PARAMETER_FP;
    while (paramMask <= EC_Consts.PARAMETER_S) {
        short masked = (short) (paramMask & corruptParams);
        if (masked != 0) {
            short length = exportParameter(keypair, key, masked, buffer, offset);
            length = EC_Consts.corruptParameter(corruption, buffer, offset, length);
            sw = setParameter(keypair, key, masked, buffer, offset, length);
            if (sw != ISO7816.SW_NO_ERROR) break;
        }
        paramMask = (short) (paramMask << 1);
    }
    return sw;
}
 

/**
 * @param keypair
 * @param key
 * @param params
 * @param inBuffer
 * @param inOffset
 * @return
 */
public short setExternalCurve(KeyPair keypair, byte key, short params, byte[] inBuffer, short inOffset) {
    sw = ISO7816.SW_NO_ERROR;
    if (params == EC_Consts.PARAMETERS_NONE) {
        return sw;
    }

    short paramMask = EC_Consts.PARAMETER_FP;
    while (paramMask <= EC_Consts.PARAMETER_S) {
        short masked = (short) (paramMask & params);
        if (masked != 0) {
            short paramLength = Util.getShort(inBuffer, inOffset);
            inOffset += 2;
            sw = setParameter(keypair, key, masked, inBuffer, inOffset, paramLength);
            inOffset += paramLength;
            if (sw != ISO7816.SW_NO_ERROR) break;
        }
        paramMask = (short) (paramMask << 1);
    }
    return sw;
}
 

/**
 * Exports selected parameters from a given keyPairs key.
 * Raw parameter data is always prepended by its length as a
 * short value. The order of parameters is the usual one from
 * EC_Consts: field,a,b,g,r,k,w,s.
 *
 * @param keypair keyPair to export from
 * @param key     key to export from (KEY_PUBLIC || KEY_PRIVATE)
 * @param params  params to export (EC_Consts.PARAMETER_* | ...)
 * @param buffer  buffer to export to
 * @param offset  offset to start writing in buffer
 * @return length of data written
 */
public short exportParameters(KeyPair keypair, byte key, short params, byte[] buffer, short offset) {
    sw = ISO7816.SW_NO_ERROR;
    if (params == EC_Consts.PARAMETERS_NONE) {
        return sw;
    }

    short length = 0;
    short paramMask = EC_Consts.PARAMETER_FP;
    while (paramMask <= EC_Consts.PARAMETER_S) {
        short masked = (short) (paramMask & params);
        if (masked != 0) {
            short len = exportParameter(keypair, key, masked, buffer, (short) (offset + 2));
            if (len == 0) {
                paramMask = (short) (paramMask << 1);
                continue;
            }
            Util.setShort(buffer, offset, len);
            offset += len + 2;
            length += len + 2;
        }
        paramMask = (short) (paramMask << 1);
    }
    return length;
}
 

/**
 * @param privatePair  KeyPair from which the private key is used
 * @param publicPair   KeyPair from which the public key is used
 * @param pubkeyBuffer buffer to be used for the public key
 * @param pubkeyOffset offset into pubkeyBuffer that can be used for the public key
 * @param outputBuffer buffer to be used for the secret output
 * @param outputOffset offset into the outputBuffer
 * @param corruption   (EC_Consts.CORRUPTION_* | ...)
 * @return
 */
public short testBOTH(KeyPair privatePair, KeyPair publicPair, byte[] pubkeyBuffer, short pubkeyOffset, byte[] outputBuffer, short outputOffset, short corruption) {
    short ecdhLength = testECDH(privatePair, publicPair, pubkeyBuffer, pubkeyOffset, outputBuffer, outputOffset, corruption);
    if (sw != ISO7816.SW_NO_ERROR) {
        return ecdhLength;
    }
    short ecdhcLength = testECDHC(privatePair, publicPair, pubkeyBuffer, pubkeyOffset, outputBuffer, (short) (outputOffset + ecdhLength), corruption);
    short length = (short) (ecdhLength + ecdhcLength);
    if (sw != ISO7816.SW_NO_ERROR) {
        return length;
    }
    if (javacard.framework.Util.arrayCompare(outputBuffer, outputOffset, outputBuffer, (short) (outputOffset + ecdhLength), ecdhLength) != 0) {
        sw = ECTesterApplet.SW_DH_DHC_MISMATCH;
    }
    return length;
}
 

public boolean compare(ResponseAPDU response) {
    boolean bResult = false;
    if (response.getSW() == (ISO7816.SW_NO_ERROR & 0xffff)) {
        bResult = Arrays.equals(m_expected.getEncoded(), response.getData());
    } else {
        bResult = false;
        System.out.println(String.format("fail (0x%x)", response.getSW()));
    }
    return bResult;
}
 

static boolean verifyAndLogResponse(String operationName, ResponseAPDU response, Long lastTransmitTime, int expected, FileOutputStream perfFile, ArrayList<String> failedTestsList) throws IOException {
    boolean bResult = false;
    if (response.getSW () == (ISO7816.SW_NO_ERROR & 0xffff)) {
        bResult = Util.BytesToInt(response.getData()) == expected;
    }
    else {
        System.out.println(String.format("fail (0x%x)", response.getSW()));
    }
    logResponse(operationName, bResult, lastTransmitTime, perfFile, failedTestsList);
    return bResult;
}
 

private static boolean checkSW(ResponseAPDU response) {
    if (response.getSW() != (ISO7816.SW_NO_ERROR & 0xffff)) {
        System.err.printf("Received error status: %02X.\n",
                response.getSW());
        return false;
    }
    return true;
}
 

private static void connectToAllCardsByTerminalFactory(TerminalFactory factory, byte[] appAID, ArrayList<CardChannel> cardsList) throws CardException {
    ArrayList<CardTerminal> terminals = new ArrayList<>();

    Card card = null;
    try {
        for (CardTerminal t : factory.terminals().list()) {
            terminals.add(t);
            if (t.isCardPresent()) {
                System.out.print("Connecting...");
                card = t.connect("*"); // Connect with the card

                System.out.println(" Done.");

                System.out.print("Establishing channel...");
                CardChannel channel = card.getBasicChannel();

                System.out.println(" Done.");

                // Select applet (mpcapplet)
                System.out.println("Smartcard: Selecting applet...");
                CommandAPDU cmd = new CommandAPDU(appAID);
                ResponseAPDU response = transmit(channel, cmd);

                if (response.getSW() == (ISO7816.SW_NO_ERROR & 0xffff)) {
                    cardsList.add(channel);
                }
            }
        }
    } catch (Exception e) {
        System.out.println("Failed.");
    }

    System.out.println("MPC cards found: " + cardsList.size());
}
 

public static boolean checkSW(ResponseAPDU response) {
    if (response.getSW() != (ISO7816.SW_NO_ERROR & 0xffff)) {
        System.err.printf("Received error status: %02X.\n",
                response.getSW());
        return false;
    }
    return true;
}
 

public static String getSWString(short sw) {
    if (sw == ISO7816.SW_NO_ERROR) {
        return "OK   (0x9000)";
    } else {
        String str = getSW(sw);
        return String.format("fail (%s, 0x%04x)", str, sw);
    }
}
 

/**
 *
 * @param keypair
 * @param key
 * @param curve
 * @param params
 * @param buffer
 * @param offset
 * @return
 */
public short setCurve(KeyPair keypair, byte key, byte curve, short params, byte[] buffer, short offset) {
    byte alg = EC_Consts.getCurveType(curve);
    sw = ISO7816.SW_NO_ERROR;

    if (params == EC_Consts.PARAMETERS_NONE) {
        return sw;
    }

    short length;
    //handle fp and f2m differently, as a FP KeyPair doesnt contain a F2M field and vice versa.
    if (alg == KeyPair.ALG_EC_FP && (params & EC_Consts.PARAMETER_FP) != 0) {
        length = EC_Consts.getCurveParameter(curve, EC_Consts.PARAMETER_FP, buffer, offset);
        sw = setParameter(keypair, key, EC_Consts.PARAMETER_FP, buffer, offset, length);
    } else if (alg == KeyPair.ALG_EC_F2M && (params & EC_Consts.PARAMETER_F2M) != 0) {
        length = EC_Consts.getCurveParameter(curve, EC_Consts.PARAMETER_F2M, buffer, offset);
        sw = setParameter(keypair, key, EC_Consts.PARAMETER_F2M, buffer, offset, length);
    }
    if (sw != ISO7816.SW_NO_ERROR) return sw;

    //go through all params
    short paramMask = EC_Consts.PARAMETER_A;
    while (paramMask <= EC_Consts.PARAMETER_S) {
        short masked = (short) (paramMask & params);
        if (masked != 0) {
            length = EC_Consts.getCurveParameter(curve, masked, buffer, offset);
            sw = setParameter(keypair, key, masked, buffer, offset, length);
            if (sw != ISO7816.SW_NO_ERROR) break;
        }
        paramMask = (short) (paramMask << 1);
    }
    return sw;
}
 

public short allocateECDH(byte algorithm) {
    sw = ISO7816.SW_NO_ERROR;
    try {
        ecdhKeyAgreement = KeyAgreement.getInstance(algorithm, false);
    } catch (CardRuntimeException ce) {
        sw = ce.getReason();
    }
    return sw;
}
 

public short allocateECDHC(byte algorithm) {
    sw = ISO7816.SW_NO_ERROR;
    try {
        ecdhcKeyAgreement = KeyAgreement.getInstance(algorithm, false);
    } catch (CardRuntimeException ce) {
        sw = ce.getReason();
    }
    return sw;
}
 

public short allocateECDSA() {
    sw = ISO7816.SW_NO_ERROR;
    try {
        ecdsaSignature = Signature.getInstance(Signature.ALG_ECDSA_SHA, false);
    } catch (CardRuntimeException ce) {
        sw = ce.getReason();
    }
    return sw;
}