RTDECL(int) RTAsn1Integer_DecodeAsn1(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1INTEGER pThis, const char *pszErrorTag)
{
pThis->uValue.u = 0;
int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
if (RT_SUCCESS(rc))
{
rc = RTAsn1CursorMatchTagClassFlags(pCursor, &pThis->Asn1Core, ASN1_TAG_INTEGER,
ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE,
fFlags, pszErrorTag, "INTEGER");
if (RT_SUCCESS(rc))
{
uint32_t offLast = pThis->Asn1Core.cb - 1;
switch (pThis->Asn1Core.cb)
{
default:
case 8: pThis->uValue.u |= (uint64_t)pThis->Asn1Core.uData.pu8[offLast - 7] << 56;
case 7: pThis->uValue.u |= (uint64_t)pThis->Asn1Core.uData.pu8[offLast - 6] << 48;
case 6: pThis->uValue.u |= (uint64_t)pThis->Asn1Core.uData.pu8[offLast - 5] << 40;
case 5: pThis->uValue.u |= (uint64_t)pThis->Asn1Core.uData.pu8[offLast - 4] << 32;
case 4: pThis->uValue.u |= (uint32_t)pThis->Asn1Core.uData.pu8[offLast - 3] << 24;
case 3: pThis->uValue.u |= (uint32_t)pThis->Asn1Core.uData.pu8[offLast - 2] << 16;
case 2: pThis->uValue.u |= (uint16_t)pThis->Asn1Core.uData.pu8[offLast - 1] << 8;
case 1: pThis->uValue.u |= pThis->Asn1Core.uData.pu8[offLast];
}
RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
pThis->Asn1Core.pOps = &g_RTAsn1Integer_Vtable;
return VINF_SUCCESS;
}
}
RT_ZERO(*pThis);
return rc;
}
RTDECL(int) RTAsn1Boolean_DecodeAsn1(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1BOOLEAN pThis, const char *pszErrorTag)
{
pThis->fValue = 0;
int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
if (RT_SUCCESS(rc))
{
rc = RTAsn1CursorMatchTagClassFlags(pCursor, &pThis->Asn1Core, ASN1_TAG_BOOLEAN,
ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE, fFlags, pszErrorTag, "BOOLEAN");
if (RT_SUCCESS(rc))
{
if (pThis->Asn1Core.cb == 1)
{
RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
pThis->Asn1Core.pOps = &g_RTAsn1Boolean_Vtable;
pThis->fValue = *pThis->Asn1Core.uData.pu8 != 0;
if ( *pThis->Asn1Core.uData.pu8 == 0
|| *pThis->Asn1Core.uData.pu8 == 0xff
|| !(pCursor->fFlags & (RTASN1CURSOR_FLAGS_DER | RTASN1CURSOR_FLAGS_CER)) )
return VINF_SUCCESS;
rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_INVALID_BOOLEAN_ENCODING,
"%s: Invalid CER/DER boolean value: %#x, valid: 0, 0xff",
pszErrorTag, *pThis->Asn1Core.uData.pu8);
}
else
rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_INVALID_BOOLEAN_ENCODING, "%s: Invalid boolean length, exepcted 1: %#x",
pszErrorTag, pThis->Asn1Core.cb);
}
}
RT_ZERO(*pThis);
return rc;
}
RTDECL(int) RTAsn1GeneralizedTime_DecodeAsn1(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1TIME pThis, const char *pszErrorTag)
{
int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
if (RT_SUCCESS(rc))
{
rc = RTAsn1CursorMatchTagClassFlags(pCursor, &pThis->Asn1Core, ASN1_TAG_GENERALIZED_TIME,
ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE,
fFlags, pszErrorTag, "GENERALIZED TIME");
if (RT_SUCCESS(rc))
{
RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
pThis->Asn1Core.pOps = &g_RTAsn1Time_Vtable;
pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
return rtAsn1Time_ConvertGeneralizedTime(pCursor, pThis, pszErrorTag);
}
}
RT_ZERO(*pThis);
return rc;
}
RTDECL(int) RTAsn1ObjId_DecodeAsn1(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1OBJID pThis, const char *pszErrorTag)
{
int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
if (RT_SUCCESS(rc))
{
rc = RTAsn1CursorMatchTagClassFlags(pCursor, &pThis->Asn1Core, ASN1_TAG_OID,
ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE, fFlags, pszErrorTag, "OID");
if (RT_SUCCESS(rc))
{
/*
* Validate and count things first.
*/
uint8_t cComponents = 0; /* gcc maybe-crap */
uint8_t cchObjId = 0; /* ditto */
rc = rtAsn1ObjId_PreParse(pCursor->pbCur, pThis->Asn1Core.cb, pCursor, pszErrorTag, &cComponents, &cchObjId);
if (RT_SUCCESS(rc))
{
/*
* Allocate memory for the components array, either out of the
* string buffer or off the heap.
*/
pThis->cComponents = cComponents;
RTAsn1CursorInitAllocation(pCursor, &pThis->Allocation);
#if 0 /** @todo breaks with arrays of ObjIds or structs containing them. They get resized and repositioned in memory, thus invalidating the pointer. Add recall-pointers callback, or just waste memory? Or maybe make all arrays pointer-arrays? */
if (cComponents * sizeof(uint32_t) <= sizeof(pThis->szObjId) - cchObjId - 1)
pThis->pauComponents = (uint32_t *)&pThis->szObjId[sizeof(pThis->szObjId) - cComponents * sizeof(uint32_t)];
else
#endif
rc = RTAsn1MemAllocZ(&pThis->Allocation, (void **)&pThis->pauComponents,
cComponents * sizeof(pThis->pauComponents[0]));
if (RT_SUCCESS(rc))
{
uint32_t *pauComponents = (uint32_t *)pThis->pauComponents;
/*
* Deal with the two first components first since they are
* encoded in a weird way to save a byte.
*/
uint8_t const *pbContent = pCursor->pbCur;
uint32_t cbContent = pThis->Asn1Core.cb;
uint32_t uValue;
rc = rtAsn1ObjId_ReadComponent(pbContent, cbContent, &uValue); AssertRC(rc);
if (RT_SUCCESS(rc))
{
pbContent += rc;
cbContent -= rc;
if (uValue < 80)
{
pauComponents[0] = uValue / 40;
pauComponents[1] = uValue % 40;
}
else
{
pauComponents[0] = 2;
pauComponents[1] = uValue - 2*40;
}
char *pszObjId = &pThis->szObjId[0];
*pszObjId++ = g_achDigits[pauComponents[0]];
size_t cbObjIdLeft = cchObjId + 1 - 1;
rc = rtAsn1ObjId_InternalFormatComponent(pauComponents[1], &pszObjId, &cbObjIdLeft); AssertRC(rc);
if (RT_SUCCESS(rc))
{
/*
* The other components are encoded in less complicated manner.
*/
for (uint32_t i = 2; i < cComponents; i++)
{
rc = rtAsn1ObjId_ReadComponent(pbContent, cbContent, &uValue);
AssertRCBreak(rc);
pbContent += rc;
cbContent -= rc;
pauComponents[i] = uValue;
rc = rtAsn1ObjId_InternalFormatComponent(uValue, &pszObjId, &cbObjIdLeft);
AssertRCBreak(rc);
}
if (RT_SUCCESS(rc))
{
Assert(cbObjIdLeft == 1);
*pszObjId = '\0';
RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
pThis->Asn1Core.pOps = &g_RTAsn1ObjId_Vtable;
return VINF_SUCCESS;
}
}
}
}
}
}
}
RT_ZERO(*pThis);
return rc;
}
