int ccn_parse_PublisherID(struct ccn_buf_decoder *d, struct ccn_parsed_interest *pi) { int res = -1; int iskey = 0; unsigned pubstart = d->decoder.token_index; unsigned keystart = pubstart; unsigned keyend = pubstart; unsigned pubend = pubstart; iskey = ccn_buf_match_dtag(d, CCN_DTAG_PublisherPublicKeyDigest); if (iskey || ccn_buf_match_dtag(d, CCN_DTAG_PublisherCertificateDigest) || ccn_buf_match_dtag(d, CCN_DTAG_PublisherIssuerKeyDigest) || ccn_buf_match_dtag(d, CCN_DTAG_PublisherIssuerCertificateDigest)) { res = d->decoder.element_index; ccn_buf_advance(d); keystart = d->decoder.token_index; if (!ccn_buf_match_some_blob(d)) return (d->decoder.state = -__LINE__); ccn_buf_advance(d); keyend = d->decoder.token_index; ccn_buf_check_close(d); pubend = d->decoder.token_index; } if (d->decoder.state < 0) return (d->decoder.state); if (pi != NULL) { pi->offset[CCN_PI_B_PublisherID] = pubstart; pi->offset[CCN_PI_B_PublisherIDKeyDigest] = keystart; pi->offset[CCN_PI_E_PublisherIDKeyDigest] = iskey ? keyend : keystart; pi->offset[CCN_PI_E_PublisherID] = pubend; } return(res); }
static int ccn_pubid_matches(const unsigned char *content_object, struct ccn_parsed_ContentObject *pc, const unsigned char *interest_msg, const struct ccn_parsed_interest *pi) { struct ccn_buf_decoder decoder; struct ccn_buf_decoder *d; int pubidstart; int pubidbytes; int contentpubidstart = 0; int contentpubidbytes = 0; pubidstart = pi->offset[CCN_PI_B_PublisherIDKeyDigest]; pubidbytes = pi->offset[CCN_PI_E_PublisherIDKeyDigest] - pubidstart; if (pubidbytes > 0) { d = ccn_buf_decoder_start(&decoder, content_object + pc->offset[CCN_PCO_B_PublisherPublicKeyDigest], (pc->offset[CCN_PCO_E_PublisherPublicKeyDigest] - pc->offset[CCN_PCO_B_PublisherPublicKeyDigest])); ccn_buf_advance(d); if (ccn_buf_match_some_blob(d)) { contentpubidstart = d->decoder.token_index; ccn_buf_advance(d); contentpubidbytes = d->decoder.token_index - contentpubidstart; } if (pubidbytes != contentpubidbytes) return(0); // This is fishy if (0 != memcmp(interest_msg + pubidstart, d->buf + contentpubidstart, pubidbytes)) return(0); } return(1); }
int ccn_parse_LinkAuthenticator(struct ccn_buf_decoder *d, struct ccn_parsed_Link *pl) { /* Implement with a single offset for the blob, CCN_PL_[BE]_PublisherDigest * and remember the DTAG value to indicate which type of digest it is */ if (ccn_buf_match_dtag(d, CCN_DTAG_LinkAuthenticator)) { ccn_buf_advance(d); // advance over DTAG token pl->offset[CCN_PL_B_LinkAuthenticator] = d->decoder.token_index; pl->offset[CCN_PL_B_PublisherID] = d->decoder.token_index; pl->offset[CCN_PL_B_PublisherDigest] = d->decoder.token_index; pl->offset[CCN_PL_E_PublisherDigest] = d->decoder.token_index; if (ccn_buf_match_dtag(d, CCN_DTAG_PublisherPublicKeyDigest) || ccn_buf_match_dtag(d, CCN_DTAG_PublisherCertificateDigest) || ccn_buf_match_dtag(d, CCN_DTAG_PublisherIssuerKeyDigest) || ccn_buf_match_dtag(d, CCN_DTAG_PublisherIssuerCertificateDigest)) { pl->publisher_digest_type = d->decoder.numval; // remember the DTAG ccn_buf_advance(d); // over the DTAG token if (!ccn_buf_match_some_blob(d)) return (d->decoder.state = -__LINE__); pl->offset[CCN_PL_B_PublisherDigest] = d->decoder.token_index; ccn_buf_advance(d); // over the digest pl->offset[CCN_PL_E_PublisherDigest] = d->decoder.token_index; ccn_buf_check_close(d); // over the DTAG closer } if (d->decoder.state < 0) return (d->decoder.state); pl->offset[CCN_PL_E_PublisherID] = d->decoder.token_index; /* parse optional NameComponentCount nonNegativeInteger */ pl->offset[CCN_PL_B_NameComponentCount] = d->decoder.token_index; pl->name_component_count = ccn_parse_optional_tagged_nonNegativeInteger(d, CCN_DTAG_NameComponentCount); pl->offset[CCN_PL_E_NameComponentCount] = d->decoder.token_index; /* parse optional Timestamp TimestampType */ pl->offset[CCN_PL_B_Timestamp] = d->decoder.token_index; if (ccn_buf_match_dtag(d, CCN_DTAG_Timestamp)) ccn_parse_required_tagged_timestamp(d, CCN_DTAG_Timestamp); pl->offset[CCN_PL_E_Timestamp] = d->decoder.token_index; /* parse optional Type ContentType */ pl->offset[CCN_PL_B_Type] = d->decoder.token_index; pl->type = ccn_parse_optional_tagged_binary_number(d, CCN_DTAG_Type, 3, 3, CCN_CONTENT_DATA); pl->offset[CCN_PL_E_Type] = d->decoder.token_index; /* parse optional ContentDigest Base64BinaryType */ pl->offset[CCN_PL_B_ContentDigest] = d->decoder.token_index; ccn_parse_optional_tagged_BLOB(d, CCN_DTAG_ContentDigest, 32, 32); pl->offset[CCN_PL_E_ContentDigest] = d->decoder.token_index; ccn_buf_check_close(d); pl->offset[CCN_PL_E_LinkAuthenticator] = d->decoder.token_index; } else d->decoder.state = -__LINE__; if (!CCN_FINAL_DSTATE(d->decoder.state)) return (CCN_DSTATE_ERR_CODING); return(0); }
int ccn_buf_match_blob(struct ccn_buf_decoder *d, const unsigned char **bufp, size_t *sizep) { if (ccn_buf_match_some_blob(d)) { if (bufp != NULL) *bufp = d->buf + d->decoder.index; if (sizep != NULL) *sizep = d->decoder.numval; return (1); } if (bufp != NULL) *bufp = d->buf + d->decoder.token_index; if (sizep != NULL) *sizep = 0; return(0); }
int ccn_parse_required_tagged_BLOB(struct ccn_buf_decoder *d, enum ccn_dtag dtag, int minlen, int maxlen) { int res = -1; size_t len = 0; if (ccn_buf_match_dtag(d, dtag)) { res = d->decoder.element_index; ccn_buf_advance(d); if (ccn_buf_match_some_blob(d)) { len = d->decoder.numval; ccn_buf_advance(d); } ccn_buf_check_close(d); if (len < minlen || (maxlen >= 0 && len > maxlen)) { d->decoder.state = -__LINE__; } } else d->decoder.state = -__LINE__; if (d->decoder.state < 0) return (d->decoder.state); return(res); }
PyObject * SignedInfo_obj_from_ccn(PyObject *py_signed_info) { struct ccn_charbuf *signed_info; PyObject *py_obj_SignedInfo, *py_o; struct ccn_buf_decoder decoder, *d; size_t start, stop, size; const unsigned char *ptr; int r; signed_info = CCNObject_Get(SIGNED_INFO, py_signed_info); debug("SignedInfo_from_ccn start, size=%zd\n", signed_info->length); // 1) Create python object py_obj_SignedInfo = PyObject_CallObject(g_type_SignedInfo, NULL); if (!py_obj_SignedInfo) return NULL; // 2) Set ccn_data to a cobject pointing to the c struct // and ensure proper destructor is set up for the c object. r = PyObject_SetAttrString(py_obj_SignedInfo, "ccn_data", py_signed_info); JUMP_IF_NEG(r, error); // 3) Parse c structure and fill python attributes // using PyObject_SetAttrString // based on chk_signing_params // from ccn_client.c // //outputs: // Note, it is ok that non-filled optional elements // are initialized to None (through the .py file __init__) // d = ccn_buf_decoder_start(&decoder, signed_info->buf, signed_info->length); if (!ccn_buf_match_dtag(d, CCN_DTAG_SignedInfo)) { PyErr_Format(g_PyExc_CCNSignedInfoError, "Error finding" " CCN_DTAG_SignedInfo (decoder state: %d)", d->decoder.state); goto error; } ccn_buf_advance(d); /* PublisherPublic Key */ //XXX: should we check for case when PublishePublicKeyDigest is not present? -dk start = d->decoder.token_index; ccn_parse_required_tagged_BLOB(d, CCN_DTAG_PublisherPublicKeyDigest, 16, 64); stop = d->decoder.token_index; r = ccn_ref_tagged_BLOB(CCN_DTAG_PublisherPublicKeyDigest, d->buf, start, stop, &ptr, &size); if (r < 0) { PyErr_Format(g_PyExc_CCNSignedInfoError, "Error parsing" " CCN_DTAG_PublisherPublicKey (decoder state %d)", d->decoder.state); goto error; } // self.publisherPublicKeyDigest = None # SHA256 hash debug("PyObject_SetAttrString publisherPublicKeyDigest\n"); py_o = PyBytes_FromStringAndSize((const char*) ptr, size); JUMP_IF_NULL(py_o, error); r = PyObject_SetAttrString(py_obj_SignedInfo, "publisherPublicKeyDigest", py_o); Py_DECREF(py_o); JUMP_IF_NEG(r, error); /* Timestamp */ start = d->decoder.token_index; ccn_parse_required_tagged_BLOB(d, CCN_DTAG_Timestamp, 1, -1); stop = d->decoder.token_index; r = ccn_ref_tagged_BLOB(CCN_DTAG_Timestamp, d->buf, start, stop, &ptr, &size); if (r < 0) { PyErr_Format(g_PyExc_CCNSignedInfoError, "Error parsing" " CCN_DTAG_Timestamp (decoder state %d)", d->decoder.state); goto error; } // self.timeStamp = None # CCNx timestamp debug("PyObject_SetAttrString timeStamp\n"); py_o = PyBytes_FromStringAndSize((const char*) ptr, size); JUMP_IF_NULL(py_o, error); r = PyObject_SetAttrString(py_obj_SignedInfo, "timeStamp", py_o); Py_DECREF(py_o); JUMP_IF_NEG(r, error); /* Type */ assert(d->decoder.state >= 0); r = ccn_parse_optional_tagged_binary_number(d, CCN_DTAG_Type, 3, 3, CCN_CONTENT_DATA); if (d->decoder.state < 0) { PyErr_SetString(g_PyExc_CCNSignedInfoError, "Unable to parse type"); goto error; } py_o = _pyccn_Int_FromLong(r); JUMP_IF_NULL(py_o, error); r = PyObject_SetAttrString(py_obj_SignedInfo, "type", py_o); Py_DECREF(py_o); JUMP_IF_NEG(r, error); /* start = d->decoder.token_index; ccn_parse_optional_tagged_BLOB(d, CCN_DTAG_Type, 1, -1); stop = d->decoder.token_index; r = ccn_ref_tagged_BLOB(CCN_DTAG_Type, d->buf, start, stop, &ptr, &size); if (r == 0) { // type = None # CCNx type // TODO: Provide a string representation with the Base64 mnemonic? debug("PyObject_SetAttrString type\n"); py_o = PyByteArray_FromStringAndSize((const char*) ptr, size); JUMP_IF_NULL(py_o, error); r = PyObject_SetAttrString(py_obj_SignedInfo, "type", py_o); Py_DECREF(py_o); JUMP_IF_NEG(r, error); } */ /* FreshnessSeconds */ r = ccn_parse_optional_tagged_nonNegativeInteger(d, CCN_DTAG_FreshnessSeconds); if (r >= 0) { // self.freshnessSeconds = None debug("PyObject_SetAttrString freshnessSeconds\n"); py_o = _pyccn_Int_FromLong(r); JUMP_IF_NULL(py_o, error); r = PyObject_SetAttrString(py_obj_SignedInfo, "freshnessSeconds", py_o); Py_DECREF(py_o); JUMP_IF_NEG(r, error); } /* FinalBlockID */ #if 0 /* old code (left in case mine is wrong - dk) */ if (ccn_buf_match_dtag(d, CCN_DTAG_FinalBlockID)) { ccn_buf_advance(d); start = d->decoder.token_index; if (ccn_buf_match_some_blob(d)) ccn_buf_advance(d); stop = d->decoder.token_index; ccn_buf_check_close(d); if (d->decoder.state >= 0 && stop > start) { // self.finalBlockID = None fprintf(stderr, "PyObject_SetAttrString finalBlockID, len=%zd\n", stop - start); py_o = PyByteArray_FromStringAndSize((const char*) (d->buf + start), stop - start); PyObject_SetAttrString(py_obj_SignedInfo, "finalBlockID", py_o); Py_INCREF(py_o); } } #endif start = d->decoder.token_index; ccn_parse_optional_tagged_BLOB(d, CCN_DTAG_FinalBlockID, 1, -1); stop = d->decoder.token_index; r = ccn_ref_tagged_BLOB(CCN_DTAG_FinalBlockID, d->buf, start, stop, &ptr, &size); if (r == 0) { // self.finalBlockID = None debug("PyObject_SetAttrString finalBlockID, len=%zd\n", size); py_o = PyBytes_FromStringAndSize((const char*) ptr, size); JUMP_IF_NULL(py_o, error); r = PyObject_SetAttrString(py_obj_SignedInfo, "finalBlockID", py_o); Py_DECREF(py_o); JUMP_IF_NEG(r, error); } /* KeyLocator */ #if 0 /* Old code in case mine is wrong - dk */ start = d->decoder.token_index; if (ccn_buf_match_dtag(d, CCN_DTAG_KeyLocator)) ccn_buf_advance_past_element(d); stop = d->decoder.token_index; if (d->decoder.state >= 0 && stop > start) { fprintf(stderr, "PyObject_SetAttrString keyLocator, len=%zd\n", stop - start); struct ccn_charbuf* keyLocator = ccn_charbuf_create(); ccn_charbuf_append(keyLocator, d->buf + start, stop - start); // self.keyLocator = None py_o = KeyLocator_obj_from_ccn(keyLocator); // it will free PyObject_SetAttrString(py_obj_SignedInfo, "keyLocator", py_o); Py_INCREF(py_o); } #endif /* * KeyLocator is not a BLOB, but an another structure, this requires * us to parse it differently */ start = d->decoder.token_index; if (ccn_buf_match_dtag(d, CCN_DTAG_KeyLocator)) { struct ccn_charbuf *key_locator; PyObject *py_key_locator; r = ccn_buf_advance_past_element(d); if (r < 0) { PyErr_Format(g_PyExc_CCNSignedInfoError, "Error locating" " CCN_DTAG_KeyLocator (decoder state: %d, r: %d)", d->decoder.state, r); goto error; } stop = d->decoder.token_index; /* debug("element_index = %zd size = %zd nest = %d numval = %zd state = %d" " token_index %zd\n", d->decoder.element_index, d->decoder.index, d->decoder.nest, d->decoder.numval, d->decoder.state, d->decoder.token_index); assert(d->decoder.state >= 0); */ ptr = d->buf + start; size = stop - start; assert(size > 0); debug("PyObject_SetAttrString keyLocator, len=%zd\n", size); py_key_locator = CCNObject_New_charbuf(KEY_LOCATOR, &key_locator); JUMP_IF_NULL(py_key_locator, error); r = ccn_charbuf_append(key_locator, ptr, size); if (r < 0) { Py_DECREF(py_key_locator); PyErr_NoMemory(); goto error; } // self.keyLocator = None py_o = KeyLocator_obj_from_ccn(py_key_locator); Py_DECREF(py_key_locator); JUMP_IF_NULL(py_o, error); r = PyObject_SetAttrString(py_obj_SignedInfo, "keyLocator", py_o); Py_DECREF(py_o); JUMP_IF_NEG(r, error); } ccn_buf_check_close(d); if (d->decoder.state < 0) { PyErr_Format(g_PyExc_CCNSignedInfoError, "SignedInfo decoding error" " (decoder state: %d, numval: %zd)", d->decoder.state, d->decoder.numval); goto error; } // 4) Return the created object debug("SignedInfo_from_ccn ends\n"); return py_obj_SignedInfo; error: Py_DECREF(py_obj_SignedInfo); return NULL; }