VirtualBox

Changeset 102287 in vbox for trunk


Ignore:
Timestamp:
Nov 24, 2023 11:14:31 AM (15 months ago)
Author:
vboxsync
Message:

IPRT/RTExprEval: Added md5, sha1, sha256 and sha512 has functions (unary operators). This is for unatteded install. bugref:10551

Location:
trunk/src/VBox/Runtime
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/common/misc/expreval.cpp

    r98103 r102287  
    4646#include <iprt/ctype.h>
    4747#include <iprt/err.h>
     48#include <iprt/md5.h>
    4849#include <iprt/mem.h>
    4950#include <iprt/path.h>
     51#include <iprt/sha.h>
    5052#include <iprt/string.h>
    5153
    … …  
    525527
    526528
    527 #if 0  /* unused */
    528529/**
    529530 * Initializes a new variables with a string value.
    530531 *
    531532 * @returns kExprRet_Ok or kExprRet_Error.
     533 * @param   pThis   The evaluator expression instance.
    532534 * @param   pVar    The new variable.
    533535 * @param   psz     The string value.
    534536 * @param   enmType The string type.
    535537 */
    536 static EXPRRET expr_var_init_string(PEXPRVAR pVar, const char *psz, EXPRVARTYPE enmType)
    537 {
    538     return expr_var_init_substring(pVar, psz, strlen(psz), enmType);
    539 }
    540 
    541 
     538static EXPRRET expr_var_init_string(PEXPR pThis, PEXPRVAR pVar, const char *psz, EXPRVARTYPE enmType)
     539{
     540    return expr_var_init_substring(pThis, pVar, psz, strlen(psz), enmType);
     541}
     542
     543
     544#if 0  /* unused */
    542545/**
    543546 * Assigns a sub-string value to a variable.
    544547 *
    545548 * @returns kExprRet_Ok or kExprRet_Error.
     549 * @param   pThis   The evaluator expression instance.
    546550 * @param   pVar    The new variable.
    547551 * @param   psz     The start of the string value.
    … …  
    549553 * @param   enmType The string type.
    550554 */
    551 static void expr_var_assign_substring(PEXPRVAR pVar, const char *psz, size_t cch, EXPRVARTYPE enmType)
     555static EXPRRET expr_var_assign_substring(PEXPR pThis, PEXPRVAR pVar, const char *psz, size_t cch, EXPRVARTYPE enmType)
    552556{
    553557    expr_var_delete(pVar);
    554     return expr_var_init_substring(pVar, psz, cch, enmType);
    555 }
     558    return expr_var_init_substring(pThis, pVar, psz, cch, enmType);
     559}
     560#endif /* unused */
    556561
    557562
    … …  
    560565 *
    561566 * @returns kExprRet_Ok or kExprRet_Error.
     567 * @param   pThis       The evaluator expression instance.
    562568 * @param   pVar    The variable.
    563569 * @param   psz     The string value.
    564570 * @param   enmType The string type.
    565571 */
    566 static void expr_var_assign_string(PEXPRVAR pVar, const char *psz, EXPRVARTYPE enmType)
     572static EXPRRET expr_var_assign_string(PEXPR pThis, PEXPRVAR pVar, const char *psz, EXPRVARTYPE enmType)
    567573{
    568574    expr_var_delete(pVar);
    569     return expr_var_init_string(pVar, psz, enmType);
    570 }
    571 #endif /* unused */
     575    return expr_var_init_string(pThis, pVar, psz, enmType);
     576}
    572577
    573578
    … …  
    13141319
    13151320/**
     1321 * Returns the MD5 digest of the input as a string.
     1322 *
     1323 * @returns Status code.
     1324 * @param   pThis       The instance.
     1325 */
     1326static EXPRRET expr_op_md5(PEXPR pThis)
     1327{
     1328    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
     1329    EXPRRET  rc   = expr_var_make_simple_string(pThis, pVar);
     1330    if (rc == kExprRet_Ok)
     1331    {
     1332        pVar->enmType = kExprVar_QuotedSimpleString;
     1333
     1334        uint8_t abDigest[RTMD5_HASH_SIZE];
     1335        RTMd5(pVar->uVal.psz, strlen(pVar->uVal.psz), abDigest);
     1336        char szHash[RTMD5_DIGEST_LEN + 1];
     1337        RTMd5ToString(abDigest, szHash, sizeof(szHash));
     1338
     1339        rc = expr_var_assign_string(pThis, pVar, szHash, kExprVar_QuotedSimpleString);
     1340    }
     1341
     1342    return rc;
     1343}
     1344
     1345
     1346/**
     1347 * Returns the SHA1 digest of the input as a string.
     1348 *
     1349 * @returns Status code.
     1350 * @param   pThis       The instance.
     1351 */
     1352static EXPRRET expr_op_sha1(PEXPR pThis)
     1353{
     1354    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
     1355    EXPRRET  rc   = expr_var_make_simple_string(pThis, pVar);
     1356    if (rc == kExprRet_Ok)
     1357    {
     1358        pVar->enmType = kExprVar_QuotedSimpleString;
     1359
     1360        uint8_t abDigest[RTSHA1_HASH_SIZE];
     1361        RTSha1(pVar->uVal.psz, strlen(pVar->uVal.psz), abDigest);
     1362        char szHash[RTSHA1_DIGEST_LEN + 1];
     1363        RTSha1ToString(abDigest, szHash, sizeof(szHash));
     1364
     1365        rc = expr_var_assign_string(pThis, pVar, szHash, kExprVar_QuotedSimpleString);
     1366    }
     1367
     1368    return rc;
     1369}
     1370
     1371
     1372/**
     1373 * Returns the SHA256 digest of the input as a string.
     1374 *
     1375 * @returns Status code.
     1376 * @param   pThis       The instance.
     1377 */
     1378static EXPRRET expr_op_sha256(PEXPR pThis)
     1379{
     1380    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
     1381    EXPRRET  rc   = expr_var_make_simple_string(pThis, pVar);
     1382    if (rc == kExprRet_Ok)
     1383    {
     1384        pVar->enmType = kExprVar_QuotedSimpleString;
     1385
     1386        uint8_t abDigest[RTSHA256_HASH_SIZE];
     1387        RTSha256(pVar->uVal.psz, strlen(pVar->uVal.psz), abDigest);
     1388        char szHash[RTSHA256_DIGEST_LEN + 1];
     1389        RTSha256ToString(abDigest, szHash, sizeof(szHash));
     1390
     1391        rc = expr_var_assign_string(pThis, pVar, szHash, kExprVar_QuotedSimpleString);
     1392    }
     1393
     1394    return rc;
     1395}
     1396
     1397
     1398/**
     1399 * Returns the SHA-512 digest of the input as a string.
     1400 *
     1401 * @returns Status code.
     1402 * @param   pThis       The instance.
     1403 */
     1404static EXPRRET expr_op_sha512(PEXPR pThis)
     1405{
     1406    PEXPRVAR pVar = &pThis->aVars[pThis->iVar];
     1407    EXPRRET  rc   = expr_var_make_simple_string(pThis, pVar);
     1408    if (rc == kExprRet_Ok)
     1409    {
     1410        pVar->enmType = kExprVar_QuotedSimpleString;
     1411
     1412        uint8_t abDigest[RTSHA512_HASH_SIZE];
     1413        RTSha512(pVar->uVal.psz, strlen(pVar->uVal.psz), abDigest);
     1414        char szHash[RTSHA512_DIGEST_LEN + 1];
     1415        RTSha512ToString(abDigest, szHash, sizeof(szHash));
     1416
     1417        rc = expr_var_assign_string(pThis, pVar, szHash, kExprVar_QuotedSimpleString);
     1418    }
     1419
     1420    return rc;
     1421}
     1422
     1423
     1424/**
    13161425 * Pluss (dummy / make_integer)
    13171426 *
    … …  
    14431552    return rc;
    14441553}
     1554
     1555
     1556#if 0 /** @todo not happy with 'strcat' as an operator. Dot doesn't work, so, figure something else out... */
     1557/**
     1558 * Concatnation (string).
     1559 *
     1560 * @returns Status code.
     1561 * @param   pThis       The instance.
     1562 */
     1563static EXPRRET expr_op_concat(PEXPR pThis)
     1564{
     1565    PEXPRVAR pVar1 = &pThis->aVars[pThis->iVar - 1];
     1566    PEXPRVAR pVar2 = &pThis->aVars[pThis->iVar];
     1567    EXPRRET  rc    = kExprRet_Ok;
     1568    if (!expr_var_is_string(pVar1))
     1569        rc = expr_var_make_simple_string(pThis, pVar1);
     1570    if (rc >= kExprRet_Ok)
     1571    {
     1572        if (!expr_var_is_string(pVar2))
     1573            rc = expr_var_make_simple_string(pThis, pVar2);
     1574        if (rc >= kExprRet_Ok)
     1575        {
     1576            /** @todo this may be problematic if we combine simple with quoted strings
     1577             *        if the simple string contains $. */
     1578            if (rc >= kExprRet_Ok)
     1579            {
     1580                size_t cchVar1 = strlen(pVar1->uVal.psz);
     1581                size_t cchVar2 = strlen(pVar2->uVal.psz);
     1582                size_t cchNew  = cchVar1 + cchVar2;
     1583                char  *pszNew  = (char *)RTMemTmpAlloc(cchNew + 1);
     1584                if (pszNew)
     1585                {
     1586                    memcpy(pszNew, pVar1->uVal.psz, cchVar1);
     1587                    memcpy(&pszNew[cchVar1], pVar2->uVal.psz, cchVar2);
     1588                    pszNew[cchNew] = '\0';
     1589                    RTMemTmpFree(pVar1->uVal.psz);
     1590                    pVar1->uVal.psz = pszNew;
     1591                }
     1592                else
     1593                {
     1594                    RTErrInfoSetF(pThis->pErrInfo, VERR_NO_TMP_MEMORY, "Failed to allocate %zu bytes", cchNew + 1);
     1595                    rc = kExprRet_Error;
     1596                }
     1597            }
     1598        }
     1599    }
     1600
     1601    expr_pop_and_delete_var(pThis);
     1602    return rc;
     1603}
     1604#endif
    14451605
    14461606
    … …  
    20622222    EXPR_OP("exists",      90,      1,    expr_op_exists),
    20632223    EXPR_OP("bool",        90,      1,    expr_op_bool),
     2224    EXPR_OP("md5",         90,      1,    expr_op_md5),
    20642225    EXPR_OP("num",         90,      1,    expr_op_num),
     2226    EXPR_OP("sha1",        90,      1,    expr_op_sha1),
     2227    EXPR_OP("sha256",      90,      1,    expr_op_sha256),
     2228    EXPR_OP("sha512",      90,      1,    expr_op_sha512),
    20652229    EXPR_OP("strlen",      90,      1,    expr_op_strlen),
    20662230    EXPR_OP("str",         90,      1,    expr_op_str),
    … …  
    20732237    EXPR_OP("+",           70,      2,    expr_op_add),
    20742238    EXPR_OP("-",           70,      2,    expr_op_sub),
     2239#if 0  /** @todo not happy with 'strcat' as an operator. Dot doesn't work, so, figure something else out... */
     2240    EXPR_OP("strcat",      70,      2,    expr_op_concat),
     2241#endif
    20752242    EXPR_OP("<<",          65,      2,    expr_op_shift_left),
    20762243    EXPR_OP(">>",          65,      2,    expr_op_shift_right),

  • trunk/src/VBox/Runtime/testcase/tstRTExprEval.cpp

    r98103 r102287  
    6969    else if (MATCH_VAR("MYNESTED1"))
    7070        pszValue = "MYVAR1";
     71    else if (MATCH_VAR("FOX_AND_DOG"))
     72        pszValue = "The quick brown fox jumps over the lazy dog";
    7173    else
    7274        return VERR_NOT_FOUND;
    … …  
    171173    CHECK_FREE_pszResult("3");
    172174
     175    /* hash functions: */
     176    g_fQueryVariableExpected = true;
     177    RTTESTI_CHECK_RC(RTExprEvalToString(hExprEval, RT_STR_TUPLE("sha1 \"${FOX_AND_DOG}\""), &pszResult, NULL), VINF_SUCCESS);
     178    g_fQueryVariableExpected = false;
     179    CHECK_FREE_pszResult("2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
     180
     181    g_fQueryVariableExpected = true;
     182    RTTESTI_CHECK_RC(RTExprEvalToString(hExprEval, RT_STR_TUPLE("sha1(\"${FOX_AND_DOG}\")"), &pszResult, NULL), VINF_SUCCESS);
     183    g_fQueryVariableExpected = false;
     184    CHECK_FREE_pszResult("2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
     185
     186    g_fQueryVariableExpected = true;
     187    RTTESTI_CHECK_RC(RTExprEvalToString(hExprEval, RT_STR_TUPLE("sha1(${FOX_AND_DOG})"), &pszResult, NULL), VINF_SUCCESS);
     188    g_fQueryVariableExpected = false;
     189    CHECK_FREE_pszResult("2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
     190
     191#if 0 /** @todo not happy with 'strcat' as an operator. Dot doesn't work, so, figure something else out... */
     192    g_fQueryVariableExpected = true;
     193    RTTESTI_CHECK_RC(RTExprEvalToString(hExprEval, RT_STR_TUPLE("sha1(${FOX_AND_DOG}) strcat sha1('')"), &pszResult, NULL), VINF_SUCCESS);
     194    g_fQueryVariableExpected = false;
     195    CHECK_FREE_pszResult("2fd4e1c67a2d28fced849ee1bb76e7391b93eb12da39a3ee5e6b4b0d3255bfef95601890afd80709");
     196#endif
     197
     198    g_fQueryVariableExpected = true;
     199    RTTESTI_CHECK_RC(RTExprEvalToString(hExprEval, RT_STR_TUPLE("sha256('')"), &pszResult, NULL), VINF_SUCCESS);
     200    g_fQueryVariableExpected = false;
     201    CHECK_FREE_pszResult("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
     202
     203    g_fQueryVariableExpected = true;
     204    RTTESTI_CHECK_RC(RTExprEvalToString(hExprEval, RT_STR_TUPLE("sha512('')"), &pszResult, NULL), VINF_SUCCESS);
     205    g_fQueryVariableExpected = false;
     206    CHECK_FREE_pszResult("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
     207
     208    g_fQueryVariableExpected = true;
     209    RTTESTI_CHECK_RC(RTExprEvalToString(hExprEval, RT_STR_TUPLE("md5(${FOX_AND_DOG})"), &pszResult, NULL), VINF_SUCCESS);
     210    g_fQueryVariableExpected = false;
     211    CHECK_FREE_pszResult("9e107d9d372bb6826bd81d3542a419d6");
     212
    173213    RTTESTI_CHECK_RETV(RTExprEvalRelease(hExprEval) == 0);
    174214}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette