RTDECL(int) RTAsn1OctetString_DecodeAsn1(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1OCTETSTRING pThis,
                                         const char *pszErrorTag)
{
    pThis->pEncapsulated = NULL;
    RTAsn1CursorInitAllocation(pCursor, &pThis->EncapsulatedAllocation);

    int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
    if (RT_SUCCESS(rc))
    {
        rc = RTAsn1CursorMatchTagClassFlagsString(pCursor, &pThis->Asn1Core, ASN1_TAG_OCTET_STRING,
                                                  ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE,
                                                  fFlags, pszErrorTag, "OCTET STRING");
        if (RT_SUCCESS(rc))
        {
            if (   !(pThis->Asn1Core.fClass & ASN1_TAGFLAG_CONSTRUCTED)
                || (fFlags & RTASN1CURSOR_GET_F_IMPLICIT) ) /* PKCS #7 ContentInfo tweak. */
            {
                RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
                pThis->Asn1Core.pOps    = &g_RTAsn1OctetString_Vtable;
                pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
                return VINF_SUCCESS;
            }
            rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CONSTRUCTED_STRING_NOT_IMPL,
                                     "%s: Constructed OCTET STRING not implemented.", pszErrorTag);
        }
        else
            rc = RTAsn1CursorSetInfo(pCursor, rc, "%s: Not OCTET STRING: fClass=%#x / uTag=%#x",
                                     pszErrorTag, pThis->Asn1Core.fClass, pThis->Asn1Core.uTag);
    }
    RT_ZERO(*pThis);
    return rc;
}
Example #2
0
/**
 * Common worker for the specific string type getters.
 *
 * @returns IPRT status code
 * @param   pCursor             The cursor.
 * @param   fFlags              The RTASN1CURSOR_GET_F_XXX flags.
 * @param   uTag                The string tag.
 * @param   pThis               The output object.
 * @param   pszErrorTag         The error tag.
 * @param   pszWhat             The string type name.
 */
static int rtAsn1XxxString_DecodeAsn1(PRTASN1CURSOR pCursor, uint32_t fFlags, uint8_t uTag, PRTASN1STRING pThis,
                                      const char *pszErrorTag, const char *pszWhat)
{
    pThis->cchUtf8 = 0;
    pThis->pszUtf8 = NULL;

    int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
    if (RT_SUCCESS(rc))
    {
        rc = RTAsn1CursorMatchTagClassFlagsString(pCursor, &pThis->Asn1Core, uTag,
                                                  ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE,
                                                  fFlags, pszErrorTag, pszWhat);
        if (RT_SUCCESS(rc))
        {
            if (!(pThis->Asn1Core.fClass & ASN1_TAGFLAG_CONSTRUCTED))
            {
                RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
                pThis->Asn1Core.pOps    = &g_RTAsn1String_Vtable;
                pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
                RTAsn1CursorInitAllocation(pCursor, &pThis->Allocation);
                /* UTF-8 conversion is done lazily, upon request. */
                return VINF_SUCCESS;
            }
            rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CONSTRUCTED_STRING_NOT_IMPL,
                                     "%s: Constructed %s not implemented.", pszErrorTag, pszWhat);
        }
    }
    RT_ZERO(*pThis);
    return rc;
}
Example #3
0
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;
}
RTDECL(int) RTAsn1BitString_DecodeAsn1Ex(PRTASN1CURSOR pCursor, uint32_t fFlags, uint32_t cMaxBits, PRTASN1BITSTRING pThis,
                                         const char *pszErrorTag)
{
    pThis->cBits         = 0;
    pThis->cMaxBits      = cMaxBits;
    pThis->uBits.pv      = NULL;
    pThis->pEncapsulated = NULL;
    RTAsn1CursorInitAllocation(pCursor, &pThis->EncapsulatedAllocation);

    int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
    if (RT_SUCCESS(rc))
    {
        rc = RTAsn1CursorMatchTagClassFlagsString(pCursor, &pThis->Asn1Core, ASN1_TAG_BIT_STRING,
                                                  ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE,
                                                  fFlags, pszErrorTag, "BIT STRING");
        if (RT_SUCCESS(rc))
        {
            if (!(pThis->Asn1Core.fClass & ASN1_TAGFLAG_CONSTRUCTED))
            {
                if (   (    cMaxBits == UINT32_MAX
                        || RT_ALIGN(cMaxBits, 8) / 8 + 1 >= pThis->Asn1Core.cb)
                    && pThis->Asn1Core.cb > 0)
                {
                    uint8_t cUnusedBits = pThis->Asn1Core.cb > 0 ? *pThis->Asn1Core.uData.pu8 : 0;
                    if (pThis->Asn1Core.cb < 2)
                    {
                        /* Not bits present. */
                        if (cUnusedBits == 0)
                        {
                            pThis->cBits    = 0;
                            pThis->uBits.pv = NULL;
                            RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
                            pThis->Asn1Core.pOps = &g_RTAsn1BitString_Vtable;
                            pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
                            return VINF_SUCCESS;
                        }
                        rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_INVALID_BITSTRING_ENCODING,
                                                 "%s: Bad unused bit count: %#x (cb=%#x)",
                                                 pszErrorTag, cUnusedBits, pThis->Asn1Core.cb);
                    }
                    else if (cUnusedBits < 8)
                    {
                        pThis->cBits  = (pThis->Asn1Core.cb - 1) * 8;
                        pThis->cBits -= cUnusedBits;
                        pThis->uBits.pu8 = pThis->Asn1Core.uData.pu8 + 1;
                        if (   !(pCursor->fFlags & (RTASN1CURSOR_FLAGS_DER | RTASN1CURSOR_FLAGS_CER))
                            || cUnusedBits == 0
                            || !( pThis->uBits.pu8[pThis->Asn1Core.cb - 2] & (((uint8_t)1 << cUnusedBits) - (uint8_t)1) ) )
                        {
                            RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
                            pThis->Asn1Core.pOps = &g_RTAsn1BitString_Vtable;
                            pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
                            return VINF_SUCCESS;
                        }
                        rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_INVALID_BITSTRING_ENCODING,
                                                 "%s: Unused bits shall be zero in DER/CER mode: last byte=%#x cUnused=%#x",
                                                 pszErrorTag, pThis->uBits.pu8[pThis->cBits / 8], cUnusedBits);
                    }
                    else
                        rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_INVALID_BITSTRING_ENCODING,
                                                 "%s: Bad unused bit count: %#x (cb=%#x)",
                                                 pszErrorTag, cUnusedBits, pThis->Asn1Core.cb);
                }
                else
                    rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_INVALID_BITSTRING_ENCODING,
                                             "%s: Size mismatch: cb=%#x, expected %#x (cMaxBits=%#x)",
                                             pszErrorTag, pThis->Asn1Core.cb,  RT_ALIGN(cMaxBits, 8) / 8 + 1, cMaxBits);
            }
            else
                rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CONSTRUCTED_STRING_NOT_IMPL,
                                         "%s: Constructed BIT STRING not implemented.", pszErrorTag);
        }
    }
    RT_ZERO(*pThis);
    return rc;
}
Example #5
0
RTDECL(int) RTAsn1String_DecodeAsn1(PRTASN1CURSOR pCursor, uint32_t fFlags, PRTASN1STRING pThis, const char *pszErrorTag)
{
    RT_ZERO(*pThis);
    AssertReturn(!(fFlags & RTASN1CURSOR_GET_F_IMPLICIT), VERR_INVALID_PARAMETER);

    int rc = RTAsn1CursorReadHdr(pCursor, &pThis->Asn1Core, pszErrorTag);
    if (RT_SUCCESS(rc))
    {
        /*
         * Do tag matching.
         */
        switch (pThis->Asn1Core.uTag)
        {
            case ASN1_TAG_UTF8_STRING:
            case ASN1_TAG_NUMERIC_STRING:
            case ASN1_TAG_PRINTABLE_STRING:
            case ASN1_TAG_T61_STRING:
            case ASN1_TAG_VIDEOTEX_STRING:
            case ASN1_TAG_IA5_STRING:
            case ASN1_TAG_GENERALIZED_TIME:
            case ASN1_TAG_GRAPHIC_STRING:
            case ASN1_TAG_VISIBLE_STRING:
            case ASN1_TAG_GENERAL_STRING:
            case ASN1_TAG_UNIVERSAL_STRING:
            case ASN1_TAG_BMP_STRING:
                rc = VINF_SUCCESS;
                break;
            default:
                rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CURSOR_TAG_MISMATCH,
                                         "%s: Not a string object: fClass=%#x / uTag=%#x",
                                         pszErrorTag, pThis->Asn1Core.fClass, pThis->Asn1Core.uTag);
        }
        if (RT_SUCCESS(rc))
        {
            /*
             * Match flags. CER/DER makes it complicated.
             */
            if (pThis->Asn1Core.fClass == (ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE))
            {
                /*
                 * Primitive strings are simple.
                 */
                RTAsn1CursorSkip(pCursor, pThis->Asn1Core.cb);
                pThis->Asn1Core.pOps    = &g_RTAsn1String_Vtable;
                pThis->Asn1Core.fFlags |= RTASN1CORE_F_PRIMITE_TAG_STRUCT;
                RTAsn1CursorInitAllocation(pCursor, &pThis->Allocation);

                /* UTF-8 conversion is done lazily, upon request. */
                return VINF_SUCCESS;
            }

            if (pThis->Asn1Core.fClass == (ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_CONSTRUCTED))
            {
                /*
                 * Constructed strings are not yet fully implemented.
                 */
                if (pCursor->fFlags & RTASN1CURSOR_FLAGS_DER)
                    rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CURSOR_ILLEGAL_CONSTRUCTED_STRING,
                                             "%s: DER encoding does not allow constructed strings (cb=%#x uTag=%#x fClass=%#x)",
                                             pszErrorTag, pThis->Asn1Core.cb, pThis->Asn1Core.uTag, pThis->Asn1Core.fClass);
                else if (pCursor->fFlags & RTASN1CURSOR_FLAGS_CER)
                {
                    if (pThis->Asn1Core.cb > 1000)
                        rc = VINF_SUCCESS;
                    else
                        rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CURSOR_ILLEGAL_CONSTRUCTED_STRING,
                                                 "%s: Constructed strings only allowed for >1000 byte in CER encoding: cb=%#x uTag=%#x fClass=%#x",
                                                 pszErrorTag, pThis->Asn1Core.cb,
                                                 pThis->Asn1Core.uTag, pThis->Asn1Core.fClass);
                }
                /** @todo implement constructed strings. */
                if (RT_SUCCESS(rc))
                    rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CONSTRUCTED_STRING_NOT_IMPL,
                                             "%s: Support for constructed strings is not implemented", pszErrorTag);
            }
            else
                rc = RTAsn1CursorSetInfo(pCursor, VERR_ASN1_CURSOR_TAG_FLAG_CLASS_MISMATCH,
                                         "%s: Not a valid string object: fClass=%#x / uTag=%#x",
                                         pszErrorTag, pThis->Asn1Core.fClass, pThis->Asn1Core.uTag);
        }
    }
    RT_ZERO(*pThis);
    return rc;
}