co.nstant.in.cbor.CborException Java Examples

private UnicodeString decodeInfinitiveLength() throws CborException {
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    for (;;) {
        DataItem dataItem = decoder.decodeNext();
        if (dataItem == null) {
            throw new CborException("Unexpected end of stream");
        }
        MajorType majorType = dataItem.getMajorType();
        if (Special.BREAK.equals(dataItem)) {
            break;
        } else if (majorType == MajorType.UNICODE_STRING) {
            UnicodeString unicodeString = (UnicodeString) dataItem;
            byte[] byteArray = unicodeString.toString().getBytes(StandardCharsets.UTF_8);
            bytes.write(byteArray, 0, byteArray.length);
        } else {
            throw new CborException("Unexpected major type " + majorType);
        }
    }
    return new UnicodeString(new String(bytes.toByteArray(), StandardCharsets.UTF_8));
}
 

public byte[] encode() {
    byte[] connackBytes = null;
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        new CborEncoder(baos).encode(new CborBuilder()
            .addMap()
            .put(TYPE_KEY, type)
            .put(STATUS_KEY, status)
            .end()
            .build());
        connackBytes = baos.toByteArray();
    } catch (CborException e) {
        Log.e(TAG, "Failed to encode.", e);
    }
    return connackBytes;
}
 

/**
 * Test method for {@link com.google.webauthn.gaedemo.objects.AuthenticatorData#decode(byte[])}.
 * 
 * @throws CborException
 * @throws ResponseException 
 */
@Test
public void testDecodeWithAttestation() throws CborException, ResponseException {
  byte[] randomRpIdHash = new byte[32];
  random.nextBytes(randomRpIdHash);
  byte[] flags = {1 << 6};
  AttestationData attData = new AttestationData();
  EccKey eccKey = new EccKey(Base64.decodeBase64("NNxD3LBXs6iF1jiBGZ4Qqhd997NKcmDLJyyILL49V90"),
      Base64.decodeBase64("MJtVZlRRfTscLy06DSHLBfA8O03pZJ1K01DbCILr0rA"));
  random.nextBytes(attData.aaguid);
  eccKey.alg = Algorithm.ES256;
  attData.publicKey = eccKey;
  int countUnsignedInt = Integer.parseUnsignedInt("" + (random.nextLong() & 0xffffffffL));
  byte[] count = ByteBuffer.allocate(4).putInt(countUnsignedInt).array();
  byte[] data = null;
  data = Bytes.concat(randomRpIdHash, flags, count, attData.encode());
  AuthenticatorData result = AuthenticatorData.decode(data);
  assertTrue(result.getAttData().getPublicKey().equals(eccKey));
  assertArrayEquals(randomRpIdHash, result.getRpIdHash());
  assertTrue(Integer.compareUnsigned(countUnsignedInt, result.getSignCount()) == 0);
}
 

public byte[] encode() {
    byte[] unsubscribeBytes = null;
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        ArrayBuilder<MapBuilder<CborBuilder>> topicsArray = new CborBuilder()
                .addMap()
                .put(TYPE_KEY, type)
                .putArray(TOPICS_KEY);

        for (String topic : topics) {
            topicsArray = topicsArray.add(topic);
        }

        List<DataItem> cbordata = topicsArray.end().end().build();
        new CborEncoder(baos).encode(cbordata);
        unsubscribeBytes = baos.toByteArray();
    } catch (CborException e) {
        Log.e(TAG, "Failed to encode.", e);
    }
    return unsubscribeBytes;
}
 

/**
 * @param data
 * @throws ResponseException
 */
public AuthenticatorAttestationResponse(JsonElement data) throws ResponseException {
  Gson gson = new Gson();
  AttestationResponseJson parsedObject = gson.fromJson(data, AttestationResponseJson.class);

  clientDataBytes = BaseEncoding.base64().decode(parsedObject.clientDataJSON);
  byte[] attestationObject = BaseEncoding.base64().decode(parsedObject.attestationObject);

  try {
    decodedObject = AttestationObject.decode(attestationObject);
  } catch (CborException e) {
    throw new ResponseException("Cannot decode attestation object");
  }

  clientData = gson.fromJson(new String(clientDataBytes, StandardCharsets.UTF_8),
      CollectedClientData.class);
  transports = parsedObject.transports;
}
 

public byte[] encode() {
    byte[] DeleteNetworkRequestBytes = null;
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        new CborEncoder(baos).encode(new CborBuilder()
                .addMap()
                .put(TYPE_KEY, DELETE_NETWORK_REQ)
                .put(INDEX_KEY, index)
                .end()
                .build());
        DeleteNetworkRequestBytes = baos.toByteArray();
    } catch (CborException e) {
        Log.e(TAG, "Failed to encode.", e);
    }
    return DeleteNetworkRequestBytes;
}
 

@Test
public void shallEncode32bit() throws CborException {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    TestEncoder encoder = new TestEncoder(outputStream);
    encoder.doEncodeTypeAndLength(4294967296L);
    byte[] bytes = outputStream.toByteArray();
    assertEquals(9, bytes.length);
    assertEquals((byte) 0x9B, bytes[0]);
    assertEquals((byte) 0x00, bytes[1]);
    assertEquals((byte) 0x00, bytes[2]);
    assertEquals((byte) 0x00, bytes[3]);
    assertEquals((byte) 0x01, bytes[4]);
    assertEquals((byte) 0x00, bytes[5]);
    assertEquals((byte) 0x00, bytes[6]);
    assertEquals((byte) 0x00, bytes[7]);
    assertEquals((byte) 0x00, bytes[8]);
}
 

public byte[] encode() {
    byte[] ListNetworkRequestBytes = null;
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        new CborEncoder(baos).encode(new CborBuilder()
                .addMap()
                .put(TYPE_KEY, LIST_NETWORK_REQ)
                .put(MAXNETWORKS_KEY, maxNetworks)
                .put(TIMEOUT_KEY, timeout)
                .end()
                .build());
        ListNetworkRequestBytes = baos.toByteArray();
    } catch (CborException e) {
        Log.e(TAG, "Failed to encode.", e);
    }
    return ListNetworkRequestBytes;
}
 

public byte[] encode() {
    byte[] publishBytes = null;
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        new CborEncoder(baos).encode(new CborBuilder()
            .addMap()
            .put(TYPE_KEY, type)
            .put(TOPIC_KEY, topic)
            .put(MSGID_KEY, msgID)
            .put(QOS_KEY, qoS)
            .put(PAYLOAD_KEY, payloadBytes)
            .end()
            .build());
        publishBytes = baos.toByteArray();
    } catch (CborException e) {
        Log.e(TAG, "Failed to encode.", e);
    }
    return publishBytes;
}
 

/**
 * Parse Attestation extensions
 * 
 * @return extension map
 */
private HashMap<String, AttestationExtension> parseExtensions(byte[] extensions) {
  HashMap<String, AttestationExtension> extensionMap = new HashMap<>();

  try {
    List<DataItem> dataItems = CborDecoder.decode(extensions);

    if (dataItems.size() < 1 || !(dataItems.get(0) instanceof Map)) {
      return extensionMap;
    }
    Map map = (Map) dataItems.get(0);

    for (DataItem data : map.getKeys()) {
      if (data instanceof UnicodeString) {
        if (((UnicodeString) data).getString().equals(CableRegistrationData.KEY)) {
          CableRegistrationData decodedCableData = CableRegistrationData.parseFromCbor(map.get(data));
          extensionMap.put(CableRegistrationData.KEY, decodedCableData);
        }
      }
    }
  } catch (CborException e) {
    e.printStackTrace();
  }
  return extensionMap;
}
 

public byte[] encode() {
    byte[] unsubackBytes = null;
    try {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        new CborEncoder(baos).encode(new CborBuilder()
                .addMap()
                .put(TYPE_KEY, type)
                .put(MSGID_KEY, msgID)
                .end()
                .build());
        unsubackBytes = baos.toByteArray();
    } catch (CborException e) {
        Log.e(TAG, "Failed to encode.", e);
    }
    return unsubackBytes;
}
 

@Override
public void encode(Map map) throws CborException {
    Collection<DataItem> keys = map.getKeys();

    if (map.isChunked()) {
        encodeTypeChunked(MajorType.MAP);
    } else {
        encodeTypeAndLength(MajorType.MAP, keys.size());
    }

    if (keys.isEmpty()) {
        return;
    }

    if (map.isChunked()) {
        encodeNonCanonical(map);
        encoder.encode(SimpleValue.BREAK);
    } else {
        if (encoder.isCanonical()) {
            encodeCanonical(map);
        } else {
            encodeNonCanonical(map);
        }
    }
}
 

@Test(expected = CborException.class)
public void shouldThrowOnRationalNumberDecode3() throws CborException {
    List<DataItem> items = new CborBuilder().addTag(30).addArray().add(true).add(true).end().build();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(baos);
    encoder.encode(items);
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    CborDecoder decoder = new CborDecoder(bais);
    decoder.decode();
}
 

@Test
public void shouldDecodeChunkedByteString() throws CborException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(baos);
    encoder.encode(new CborBuilder().startByteString().add(new byte[] { '\0' }).add(new byte[] { 0x10 })
        .add(new byte[] { 0x13 }).end().build());
    byte[] encodedBytes = baos.toByteArray();
    ByteArrayInputStream bais = new ByteArrayInputStream(encodedBytes);
    CborDecoder decoder = new CborDecoder(bais);
    List<DataItem> dataItems = decoder.decode();
    assertNotNull(dataItems);
    assertEquals(1, dataItems.size());
}
 

protected void shouldEncodeAndDecode(String message, DataItem dataItem) throws CborException {
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(byteArrayOutputStream);
    encoder.encode(dataItem);
    byte[] bytes = byteArrayOutputStream.toByteArray();
    DataItem object = CborDecoder.decode(bytes).get(0);
    Assert.assertEquals(message, dataItem, object);
}
 

@Test
public void shouldDecode() throws CborException {
    InputStream inputStream = new ByteArrayInputStream(ENCODED_VALUE);
    CborDecoder decoder = new CborDecoder(inputStream);
    List<DataItem> dataItems = decoder.decode();
    Assert.assertArrayEquals(VALUE.toArray(), dataItems.toArray());
}
 

@Test
public void shouldDecodeRationalNumber() throws CborException {
    List<DataItem> items = new CborBuilder().addTag(30).addArray().add(1).add(2).end().build();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(baos);
    encoder.encode(items);
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    CborDecoder decoder = new CborDecoder(bais);
    assertEquals(new RationalNumber(new UnsignedInteger(1), new UnsignedInteger(2)), decoder.decodeNext());
}
 

@Test
public void shouldDecodeByteString1K() throws CborException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(baos);
    encoder.encode(new CborBuilder().add(new byte[1024]).build());
    byte[] encodedBytes = baos.toByteArray();
    ByteArrayInputStream bais = new ByteArrayInputStream(encodedBytes);
    CborDecoder decoder = new CborDecoder(bais);
    List<DataItem> dataItems = decoder.decode();
    assertNotNull(dataItems);
    assertEquals(1, dataItems.size());
}
 

protected int nextSymbol() throws CborException {
    try {
        int symbol = inputStream.read();
        if (symbol == -1) {
            throw new IOException("Unexpected end of stream");
        }
        return symbol;
    } catch (IOException ioException) {
        throw new CborException(ioException);
    }
}
 

@Test
public void shouldDecodeChunkedUnicodeString() throws CborException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(baos);
    encoder.encode(new CborBuilder().startString().add("foo").add("bar").end().build());
    byte[] encodedBytes = baos.toByteArray();
    ByteArrayInputStream bais = new ByteArrayInputStream(encodedBytes);
    CborDecoder decoder = new CborDecoder(bais);
    List<DataItem> dataItems = decoder.decode();
    assertNotNull(dataItems);
    assertEquals(1, dataItems.size());
}
 

@Test
public void shouldUseLastOfDuplicateKeysByDefault() throws CborException {
    byte[] bytes = new byte[] { (byte) 0xa2, 0x01, 0x01, 0x01, 0x02 };
    List<DataItem> decoded = CborDecoder.decode(bytes);
    Map map = (Map) decoded.get(0);
    assertEquals(map.getKeys().size(), 1);
    assertEquals(map.get(new UnsignedInteger(1)), new UnsignedInteger(2));
}
 

@Test
public void shouldDecode() throws CborException {
    InputStream inputStream = new ByteArrayInputStream(ENCODED_VALUE);
    CborDecoder decoder = new CborDecoder(inputStream);
    decoder.setAutoDecodeInfinitiveArrays(false);
    List<DataItem> dataItems = decoder.decode();
    Assert.assertArrayEquals(VALUE.toArray(), dataItems.toArray());
}
 

@Test
public void shouldEncode() throws CborException {
    ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(byteOutputStream);
    encoder.encode(VALUE);
    Assert.assertArrayEquals(ENCODED_VALUE, byteOutputStream.toByteArray());
}
 

@Override
public void encode(ByteString byteString) throws CborException {
    byte[] bytes = byteString.getBytes();
    if (byteString.isChunked()) {
        encodeTypeChunked(MajorType.BYTE_STRING);
        if (bytes != null) {
            encode(new ByteString(bytes));
        }
    } else if (bytes == null) {
        encoder.encode(SimpleValue.NULL);
    } else {
        encodeTypeAndLength(MajorType.BYTE_STRING, bytes.length);
        write(bytes);
    }
}
 

@Override
public void encode(Array array) throws CborException {
    List<DataItem> dataItems = array.getDataItems();
    if (array.isChunked()) {
        encodeTypeChunked(MajorType.ARRAY);
    } else {
        encodeTypeAndLength(MajorType.ARRAY, dataItems.size());
    }
    for (DataItem dataItem : dataItems) {
        encoder.encode(dataItem);
    }
}
 

@Test
public void shouldDecodeTaggedRationalNumber() throws CborException {
    List<DataItem> items = new CborBuilder().addTag(1).addTag(30).addArray().add(1).add(2).end().build();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(baos);
    encoder.encode(items);
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    CborDecoder decoder = new CborDecoder(bais);

    RationalNumber expected = new RationalNumber(new UnsignedInteger(1), new UnsignedInteger(2));
    expected.getTag().setTag(new Tag(1));
    assertEquals(expected, decoder.decodeNext());
}
 

@Test
public void shouldDecode() throws CborException {
    InputStream inputStream = new ByteArrayInputStream(ENCODED_VALUE);
    CborDecoder decoder = new CborDecoder(inputStream);
    List<DataItem> dataItems = decoder.decode();
    Assert.assertArrayEquals(VALUE.toArray(), dataItems.toArray());
}
 

@Test
public void shouldEncode() throws CborException {
    ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(byteOutputStream);
    encoder.encode(VALUE);
    Assert.assertArrayEquals(ENCODED_VALUE, byteOutputStream.toByteArray());
}
 

@Test
public void shouldEncode() throws CborException {
    ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(byteOutputStream);
    encoder.encode(new HalfPrecisionFloat(value));
    Assert.assertArrayEquals(encodedValue, byteOutputStream.toByteArray());
}
 

@Test(expected = CborException.class)
public void testExceptionOnNotAnArray() throws CborException {
    List<DataItem> items = new CborBuilder().addTag(38).add(true).build();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    CborEncoder encoder = new CborEncoder(baos);
    encoder.encode(items);
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    CborDecoder decoder = new CborDecoder(bais);
    decoder.decode();
}