FFI: Add API to retrieve raw subpacket data.

include/rnp/rnp.h

@@ -256,6 +256,7 @@ typedef struct rnp_op_encrypt_st *         rnp_op_encrypt_t;
 typedef struct rnp_identifier_iterator_st *rnp_identifier_iterator_t;
 typedef struct rnp_uid_handle_st *         rnp_uid_handle_t;
 typedef struct rnp_signature_handle_st *   rnp_signature_handle_t;
+typedef struct rnp_sig_subpacket_st *      rnp_sig_subpacket_t;
 typedef struct rnp_recipient_handle_st *   rnp_recipient_handle_t;
 typedef struct rnp_symenc_handle_st *      rnp_symenc_handle_t;
 
@@ -1893,6 +1894,84 @@ RNP_API rnp_result_t rnp_signature_get_hash_alg(rnp_signature_handle_t sig, char
  */
 RNP_API rnp_result_t rnp_signature_get_creation(rnp_signature_handle_t sig, uint32_t *create);
 
+/**
+ * @brief Get number of the signature subpackets.
+ *
+ * @param sig signature handle, cannot be NULL.
+ * @param count on success number of the subpackets will be stored here.
+ * @return RNP_SUCCESS or error code if failed.
+ */
+RNP_API rnp_result_t rnp_signature_subpacket_count(rnp_signature_handle_t sig, size_t *count);
+
+/**
+ * @brief Get signature subpacket at the specified position.
+ *
+ * @param sig signature handle, cannot be NULL.
+ * @param idx index of the subpacket (see rnp_signature_subpacket_count for the total amount)
+ * @param subpkt on success handle to the subpacket object will be stored here. Must be later
+ *               destroyed via the rnp_signature_subpacket_destroy() call.
+ * @return RNP_SUCCESS on success, RNP_ERROR_NOT_FOUND if index is out of bounds, or any other
+ *         error code if failed.
+ */
+RNP_API rnp_result_t rnp_signature_subpacket_at(rnp_signature_handle_t sig,
+                                                size_t                 idx,
+                                                rnp_sig_subpacket_t *  subpkt);
+
+/**
+ * @brief Find the signature subpacket matching criteria.
+ *
+ * @param sig signature handle, cannot be NULL.
+ * @param type type of the subpacket as per OpenPGP specification.
+ * @param hashed if true, then subpacket will be looked only in hashed area. If false - then in
+ *               both, hashed and unhashed areas.
+ * @param skip number of matching subpackets to skip, allowing to iterate over the subpackets
+ *             of the same type.
+ * @param subpkt on success handle to the subpacket will be stored here. Must be destroyed via
+ *               the rnp_signature_subpacket_destroy() call.
+ * @return RNP_SUCCESS if subpacket found, or RNP_ERROR_NOT_FOUND otherwise. Any other value
+ *         would mean that search failed.
+ */
+RNP_API rnp_result_t rnp_signature_subpacket_find(rnp_signature_handle_t sig,
+                                                  uint8_t                type,
+                                                  bool                   hashed,
+                                                  size_t                 skip,
+                                                  rnp_sig_subpacket_t *  subpkt);
+
+/**
+ * @brief Get the subpacket info.
+ *
+ * @param subpkt signature subpacket handle, cannot be NULL.
+ * @param type type of the subpacket as per OpenPGP specification will be stored here.
+ * @param hashed whether subpackets is stored in hased or unhashed area.
+ * @param critical whether subpacket has critical bit set.
+ * @return RNP_SUCCESS or error code if failed.
+ */
+RNP_API rnp_result_t rnp_signature_subpacket_info(rnp_sig_subpacket_t subpkt,
+                                                  uint8_t *           type,
+                                                  bool *              hashed,
+                                                  bool *              critical);
+
+/**
+ * @brief Get signature subpacket raw data.
+ *
+ * @param subpkt signature subpacket handle, cannot be NULL.
+ * @param data pointer to raw data will be stored here. Must be deallocated via the
+ * rnp_buffer_destroy() call.
+ * @param size size of the data will be stored here.
+ * @return RNP_SUCCESS or error code if failed.
+ */
+RNP_API rnp_result_t rnp_signature_subpacket_data(rnp_sig_subpacket_t subpkt,
+                                                  uint8_t **          data,
+                                                  size_t *            size);
+
+/**
+ * @brief Destroy the subpacket object.
+ *
+ * @param subpkt initialized signature subpacket handle, cannot be NULL.
+ * @return RNP_SUCCESS or error code if failed.
+ */
+RNP_API rnp_result_t rnp_signature_subpacket_destroy(rnp_sig_subpacket_t subpkt);
+
 /** Get the signature expiration time as number of seconds after creation time
  *
  * @param sig signature handle.

include/rnp/rnp_err.h

@@ -42,6 +42,7 @@ enum {
     RNP_ERROR_OUT_OF_MEMORY,
     RNP_ERROR_SHORT_BUFFER,
     RNP_ERROR_NULL_POINTER,
+    RNP_ERROR_NOT_FOUND,
 
     /* Storage */
     RNP_ERROR_ACCESS = 0x11000000,

src/lib/ffi-priv-types.h

@@ -67,6 +67,14 @@ struct rnp_signature_handle_st {
     bool new_sig;
 };
 
+struct rnp_sig_subpacket_st {
+    const pgp::pkt::sigsub::Raw ⊂
+
+    rnp_sig_subpacket_st(const pgp::pkt::sigsub::Raw &val) : sub(val)
+    {
+    }
+};
+
 struct rnp_recipient_handle_st {
     rnp_ffi_t        ffi;
     pgp_key_id_t     keyid;

src/lib/rnp.cpp

@@ -545,6 +545,18 @@ ret_str_value(const char *str, char **res)
     return RNP_SUCCESS;
 }
 
+static rnp_result_t
+ret_vec_value(const std::vector<uint8_t> &vec, uint8_t **buf, size_t *buf_len)
+{
+    *buf = (uint8_t *) calloc(1, vec.size());
+    if (!*buf) {
+        return RNP_ERROR_OUT_OF_MEMORY;
+    }
+    memcpy(*buf, vec.data(), vec.size());
+    *buf_len = vec.size();
+    return RNP_SUCCESS;
+}
+
 static rnp_result_t
 get_map_value(const id_str_pair *map, int val, char **res)
 {
@@ -6650,6 +6662,92 @@ try {
 }
 FFI_GUARD
 
+rnp_result_t
+rnp_signature_subpacket_count(rnp_signature_handle_t handle, size_t *count)
+try {
+    if (!handle || !count) {
+        return RNP_ERROR_NULL_POINTER;
+    }
+    *count = handle->sig->sig.subpkts.size();
+    return RNP_SUCCESS;
+}
+FFI_GUARD
+
+rnp_result_t
+rnp_signature_subpacket_at(rnp_signature_handle_t handle,
+                           size_t                 idx,
+                           rnp_sig_subpacket_t *  subpkt)
+try {
+    if (!handle || !subpkt) {
+        return RNP_ERROR_NULL_POINTER;
+    }
+    if (idx >= handle->sig->sig.subpkts.size()) {
+        return RNP_ERROR_NOT_FOUND;
+    }
+    *subpkt = new rnp_sig_subpacket_st(*handle->sig->sig.subpkts[idx]);
+    return RNP_SUCCESS;
+}
+FFI_GUARD
+
+rnp_result_t
+rnp_signature_subpacket_find(rnp_signature_handle_t handle,
+                             uint8_t                type,
+                             bool                   hashed,
+                             size_t                 skip,
+                             rnp_sig_subpacket_t *  subpkt)
+try {
+    if (!handle || !subpkt) {
+        return RNP_ERROR_NULL_POINTER;
+    }
+    auto idx = handle->sig->sig.find_subpkt(type, hashed, skip);
+    return rnp_signature_subpacket_at(handle, idx, subpkt);
+}
+FFI_GUARD
+
+rnp_result_t
+rnp_signature_subpacket_info(rnp_sig_subpacket_t subpkt,
+                             uint8_t *           type,
+                             bool *              hashed,
+                             bool *              critical)
+try {
+    if (!subpkt) {
+        return RNP_ERROR_NULL_POINTER;
+    }
+    if (type) {
+        *type = subpkt->sub.raw_type();
+    }
+    if (hashed) {
+        *hashed = subpkt->sub.hashed();
+    }
+    if (critical) {
+        *critical = subpkt->sub.critical();
+    }
+    return RNP_SUCCESS;
+}
+FFI_GUARD
+
+rnp_result_t
+rnp_signature_subpacket_data(rnp_sig_subpacket_t subpkt, uint8_t **data, size_t *size)
+try {
+    if (!subpkt || !data || !size) {
+        return RNP_ERROR_NULL_POINTER;
+    }
+    auto &subdata = subpkt->sub.data();
+    if (!subdata.size()) {
+        return RNP_ERROR_BAD_STATE;
+    }
+    return ret_vec_value(subdata, data, size);
+}
+FFI_GUARD
+
+rnp_result_t
+rnp_signature_subpacket_destroy(rnp_sig_subpacket_t subpkt)
+try {
+    delete subpkt;
+    return RNP_SUCCESS;
+}
+FFI_GUARD
+
 rnp_result_t
 rnp_signature_get_expiration(rnp_signature_handle_t handle, uint32_t *expires)
 try {
@@ -8004,13 +8102,7 @@ static rnp_result_t
 key_to_bytes(pgp_key_t *key, uint8_t **buf, size_t *buf_len)
 {
     auto vec = key->write_vec();
-    *buf = (uint8_t *) calloc(1, vec.size());
-    if (!*buf) {
-        return RNP_ERROR_OUT_OF_MEMORY;
-    }
-    memcpy(*buf, vec.data(), vec.size());
-    *buf_len = vec.size();
-    return RNP_SUCCESS;
+    return ret_vec_value(vec, buf, buf_len);
 }
 
 rnp_result_t

src/tests/ffi-key-sig.cpp

@@ -2302,6 +2302,35 @@ TEST_F(rnp_tests, test_ffi_key_self_certification_features)
     assert_rnp_success(rnp_signature_get_preferred_zalg(newsig, 2, &alg));
     assert_string_equal(alg, "ZIP");
     rnp_buffer_destroy(alg);
+    rnp_sig_subpacket_t subpkt = NULL;
+    assert_rnp_success(rnp_signature_subpacket_count(newsig, &count));
+    assert_int_equal(count, 10);
+    assert_rnp_success(rnp_signature_subpacket_at(newsig, 0, &subpkt));
+    uint8_t type = 0;
+    bool    hashed = false;
+    bool    critical = false;
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, &type, &hashed, &critical));
+    assert_int_equal(type, 27);
+    assert_true(hashed);
+    assert_false(critical);
+    uint8_t *data = NULL;
+    size_t   size = 0;
+    assert_rnp_success(rnp_signature_subpacket_data(subpkt, &data, &size));
+    assert_int_equal(size, 1);
+    assert_int_equal(data[0], 3);
+    rnp_buffer_destroy(data);
+    rnp_signature_subpacket_destroy(subpkt);
+    assert_rnp_success(rnp_signature_subpacket_at(newsig, 9, &subpkt));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, &type, &hashed, &critical));
+    assert_int_equal(type, 16);
+    assert_false(hashed);
+    assert_false(critical);
+    assert_rnp_success(rnp_signature_subpacket_data(subpkt, &data, &size));
+    assert_int_equal(size, 8);
+    assert_int_equal(data[0], 0x23);
+    assert_int_equal(data[7], 0x27);
+    rnp_buffer_destroy(data);
+    rnp_signature_subpacket_destroy(subpkt);
     rnp_signature_handle_destroy(newsig);
     /* First newly added signature with defaults */
     assert_rnp_success(rnp_uid_get_signature_at(uid, 1, &newsig));
@@ -2371,6 +2400,70 @@ TEST_F(rnp_tests, test_ffi_key_self_certification_features)
     assert_rnp_failure(rnp_signature_get_preferred_zalg(NULL, 0, &alg));
     assert_rnp_failure(rnp_signature_get_preferred_zalg(newsig, 0, NULL));
     assert_rnp_failure(rnp_signature_get_preferred_zalg(newsig, 0, &alg));
+
+    assert_rnp_failure(rnp_signature_subpacket_count(NULL, &count));
+    assert_rnp_failure(rnp_signature_subpacket_count(newsig, NULL));
+    assert_rnp_success(rnp_signature_subpacket_count(newsig, &count));
+    assert_int_equal(count, 3);
+    assert_rnp_failure(rnp_signature_subpacket_at(NULL, 0, &subpkt));
+    assert_rnp_failure(rnp_signature_subpacket_at(newsig, 0, NULL));
+    assert_int_equal(rnp_signature_subpacket_at(newsig, 20, &subpkt), RNP_ERROR_NOT_FOUND);
+    assert_rnp_success(rnp_signature_subpacket_at(newsig, 0, &subpkt));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, NULL, NULL, NULL));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, &type, NULL, NULL));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, NULL, &hashed, NULL));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, NULL, NULL, &critical));
+    assert_int_equal(type, 33);
+    assert_true(hashed);
+    assert_false(critical);
+    assert_rnp_failure(rnp_signature_subpacket_data(NULL, &data, &size));
+    assert_rnp_failure(rnp_signature_subpacket_data(subpkt, NULL, &size));
+    assert_rnp_failure(rnp_signature_subpacket_data(subpkt, &data, NULL));
+    assert_rnp_success(rnp_signature_subpacket_data(subpkt, &data, &size));
+    assert_int_equal(size, 21);
+    assert_int_equal(data[0], 0x04);
+    assert_int_equal(data[1], 0xb5);
+    assert_int_equal(data[20], 0x27);
+    rnp_buffer_destroy(data);
+    rnp_signature_subpacket_destroy(subpkt);
+    assert_rnp_success(rnp_signature_subpacket_at(newsig, 1, &subpkt));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, &type, &hashed, &critical));
+    assert_int_equal(type, 2);
+    assert_true(hashed);
+    assert_false(critical);
+    assert_rnp_success(rnp_signature_subpacket_data(subpkt, &data, &size));
+    assert_int_equal(size, 4);
+    assert_int_equal(data[1], 0x06);
+    rnp_buffer_destroy(data);
+    rnp_signature_subpacket_destroy(subpkt);
+    assert_rnp_success(rnp_signature_subpacket_at(newsig, 2, &subpkt));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, &type, &hashed, &critical));
+    assert_int_equal(type, 16);
+    assert_false(hashed);
+    assert_false(critical);
+    assert_rnp_success(rnp_signature_subpacket_data(subpkt, &data, &size));
+    assert_int_equal(size, 8);
+    assert_int_equal(data[0], 0x23);
+    rnp_buffer_destroy(data);
+    rnp_signature_subpacket_destroy(subpkt);
+    assert_rnp_failure(rnp_signature_subpacket_find(NULL, 33, true, 0, &subpkt));
+    assert_rnp_failure(rnp_signature_subpacket_find(newsig, 33, true, 0, NULL));
+    assert_int_equal(rnp_signature_subpacket_find(newsig, 33, true, 1, &subpkt),
+                     RNP_ERROR_NOT_FOUND);
+    assert_int_equal(rnp_signature_subpacket_find(newsig, 18, true, 0, &subpkt),
+                     RNP_ERROR_NOT_FOUND);
+    assert_rnp_success(rnp_signature_subpacket_find(newsig, 33, true, 0, &subpkt));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, &type, &hashed, &critical));
+    assert_int_equal(type, 33);
+    assert_true(hashed);
+    assert_false(critical);
+    rnp_signature_subpacket_destroy(subpkt);
+    assert_rnp_success(rnp_signature_subpacket_find(newsig, 16, false, 0, &subpkt));
+    assert_rnp_success(rnp_signature_subpacket_info(subpkt, &type, &hashed, &critical));
+    assert_int_equal(type, 16);
+    assert_false(hashed);
+    assert_false(critical);
+    rnp_signature_subpacket_destroy(subpkt);
     rnp_signature_handle_destroy(newsig);
     /* Second newly added signature with customized parameters */
     assert_rnp_success(rnp_uid_get_signature_at(uid, 2, &newsig));