VirtualBox

Changeset 102495 in vbox for trunk/src/VBox/Runtime/common


Ignore:
Timestamp:
Dec 6, 2023 10:09:35 AM (12 months ago)
Author:
vboxsync
Message:

IPRT/shacrypt: Combine shacrypt-256.cpp.h and shacrypt-512.cpp.h into a single template (with help from the pre-processor, not the C++ compiler). bugref:10551

Location:
trunk/src/VBox/Runtime/common/crypto
Files:
1 deleted
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/common/crypto/shacrypt-tmpl.cpp.h

    r102491 r102495  
    11/* $Id$ */
    22/** @file
    3  * IPRT - Crypto - SHA-crypt, code template for SHA-512 core.
    4  *
    5  * This is almost identical to shacrypt-256.cpp.h, fixes generally applies to
    6  * both. Diff the files after updates!
     3 * IPRT - Crypto - SHA-crypt, code template the core code.
     4 *
     5 * This is included a couple of times from shacrypt.cpp with different set of
     6 * defines for each variation.
    77 */
    88
    … …  
    3939
    4040
    41 RTDECL(int) RTCrShaCrypt512(const char *pszPhrase, const char *pszSalt, uint32_t cRounds, char *pszString, size_t cbString)
     41RTDECL(int) RTCrShaCryptTmpl(const char *pszPhrase, const char *pszSalt, uint32_t cRounds, char *pszString, size_t cbString)
    4242{
    43     uint8_t abHash[RTSHA512_HASH_SIZE];
    44     int rc = RTCrShaCrypt512Ex(pszPhrase, pszSalt, cRounds, abHash);
     43    uint8_t abHash[TMPL_HASH_SIZE];
     44    int rc = RTCrShaCryptTmplEx(pszPhrase, pszSalt, cRounds, abHash);
    4545    if (RT_SUCCESS(rc))
    46         rc = RTCrShaCrypt512ToString(abHash, pszSalt, cRounds, pszString, cbString);
     46        rc = RTCrShaCryptTmplToString(abHash, pszSalt, cRounds, pszString, cbString);
    4747    return rc;
    4848}
    … …  
    5050
    5151
    52 RTR3DECL(int) RTCrShaCrypt512Ex(const char *pszPhrase, const char *pszSalt, uint32_t cRounds, uint8_t pabHash[RTSHA512_HASH_SIZE])
     52RTR3DECL(int) RTCrShaCryptTmplEx(const char *pszPhrase, const char *pszSalt, uint32_t cRounds, uint8_t pabHash[TMPL_HASH_SIZE])
    5353{
    5454    /*
    … …  
    7070     * Get started...
    7171     */
    72     RTSHA512CONTEXT CtxA;
    73     RTSha512Init(&CtxA);                                                        /* Step 1. */
    74     RTSha512Update(&CtxA, pszPhrase, cchPhrase);                                /* Step 2. */
    75     RTSha512Update(&CtxA, pszSalt, cchSalt);                                    /* Step 3. */
    76 
    77     RTSHA512CONTEXT CtxB;
    78     RTSha512Init(&CtxB);                                                        /* Step 4. */
    79     RTSha512Update(&CtxB, pszPhrase, cchPhrase);                                /* Step 5. */
    80     RTSha512Update(&CtxB, pszSalt, cchSalt);                                    /* Step 6. */
    81     RTSha512Update(&CtxB, pszPhrase, cchPhrase);                                /* Step 7. */
    82     uint8_t abDigest[RTSHA512_HASH_SIZE];
    83     RTSha512Final(&CtxB, abDigest);                                             /* Step 8. */
     72    TMPL_HASH_CONTEXT_T CtxA;
     73    TmplHashInit(&CtxA);                                                        /* Step 1. */
     74    TmplHashUpdate(&CtxA, pszPhrase, cchPhrase);                                /* Step 2. */
     75    TmplHashUpdate(&CtxA, pszSalt, cchSalt);                                    /* Step 3. */
     76
     77    TMPL_HASH_CONTEXT_T CtxB;
     78    TmplHashInit(&CtxB);                                                        /* Step 4. */
     79    TmplHashUpdate(&CtxB, pszPhrase, cchPhrase);                                /* Step 5. */
     80    TmplHashUpdate(&CtxB, pszSalt, cchSalt);                                    /* Step 6. */
     81    TmplHashUpdate(&CtxB, pszPhrase, cchPhrase);                                /* Step 7. */
     82    uint8_t abDigest[TMPL_HASH_SIZE];
     83    TmplHashFinal(&CtxB, abDigest);                                             /* Step 8. */
    8484
    8585    size_t cbLeft = cchPhrase;
    86     while (cbLeft > RTSHA512_HASH_SIZE)                                         /* Step 9. */
    87     {
    88         RTSha512Update(&CtxA, abDigest, sizeof(abDigest));
    89         cbLeft -= RTSHA512_HASH_SIZE;
    90     }
    91     RTSha512Update(&CtxA, abDigest, cbLeft);                                    /* Step 10. */
     86    while (cbLeft > TMPL_HASH_SIZE)                                             /* Step 9. */
     87    {
     88        TmplHashUpdate(&CtxA, abDigest, sizeof(abDigest));
     89        cbLeft -= TMPL_HASH_SIZE;
     90    }
     91    TmplHashUpdate(&CtxA, abDigest, cbLeft);                                    /* Step 10. */
    9292
    9393    size_t iPhraseBit = cchPhrase;
    … …  
    9595    {
    9696        if ((iPhraseBit & 1) != 0)
    97             RTSha512Update(&CtxA, abDigest, sizeof(abDigest));                  /* a) */
     97            TmplHashUpdate(&CtxA, abDigest, sizeof(abDigest));                  /* a) */
    9898        else
    99             RTSha512Update(&CtxA, pszPhrase, cchPhrase);                        /* b) */
     99            TmplHashUpdate(&CtxA, pszPhrase, cchPhrase);                        /* b) */
    100100        iPhraseBit >>= 1;
    101101    }
    102102
    103     RTSha512Final(&CtxA, abDigest);                                             /* Step 12. */
    104 
    105     RTSha512Init(&CtxB);                                                        /* Step 13. */
     103    TmplHashFinal(&CtxA, abDigest);                                             /* Step 12. */
     104
     105    TmplHashInit(&CtxB);                                                        /* Step 13. */
    106106    for (size_t i = 0; i < cchPhrase; i++)                                      /* Step 14. */
    107         RTSha512Update(&CtxB, pszPhrase, cchPhrase);
    108 
    109     uint8_t abDigestTemp[RTSHA512_HASH_SIZE];
    110     RTSha512Final(&CtxB, abDigestTemp);                                         /* Step 15. */
     107        TmplHashUpdate(&CtxB, pszPhrase, cchPhrase);
     108
     109    uint8_t abDigestTemp[TMPL_HASH_SIZE];
     110    TmplHashFinal(&CtxB, abDigestTemp);                                         /* Step 15. */
    111111
    112112    /*
    … …  
    119119    AssertPtrReturn(pabSeqP, VERR_NO_MEMORY);
    120120    cbLeft = cbSeqP;
    121     while (cbLeft > RTSHA512_HASH_SIZE)
     121    while (cbLeft > TMPL_HASH_SIZE)
    122122    {
    123123        memcpy(pb, abDigestTemp, sizeof(abDigestTemp));                         /* a) */
    124         pb     += RTSHA512_HASH_SIZE;
    125         cbLeft -= RTSHA512_HASH_SIZE;
     124        pb     += TMPL_HASH_SIZE;
     125        cbLeft -= TMPL_HASH_SIZE;
    126126    }
    127127    memcpy(pb, abDigestTemp, cbLeft);                                           /* b) */
    128128
    129     RTSha512Init(&CtxB);                                                        /* Step 17. */
     129    TmplHashInit(&CtxB);                                                        /* Step 17. */
    130130
    131131    for (size_t i = 0; i < 16 + (unsigned)abDigest[0]; i++)                     /* Step 18. */
    132         RTSha512Update(&CtxB, pszSalt, cchSalt);
    133 
    134     RTSha512Final(&CtxB, abDigestTemp);                                         /* Step 19. */
     132        TmplHashUpdate(&CtxB, pszSalt, cchSalt);
     133
     134    TmplHashFinal(&CtxB, abDigestTemp);                                         /* Step 19. */
    135135
    136136    /*
    … …  
    139139    /* Step 20. */
    140140    size_t   const  cbSeqS  = cchSalt;
    141 #if 0 /* Given that the salt has a fixed range (8 thru 16 bytes), and SHA-512
     141#if 0 /* Given that the salt has a fixed range (8 thru 16 bytes), and SHA-512/256
    142142       * producing 64 bytes, we can safely skip the loop part here (a) and go
    143143       * straight for step (b). Further, we can drop the whole memory allocation,
    … …  
    149149    pb     = pabSeqS;
    150150    cbLeft = cbSeqS;
    151     while (cbLeft > RTSHA512_HASH_SIZE)
     151    while (cbLeft > TMPL_HASH_SIZE)
    152152    {
    153153        memcpy(pb, (void *)abDigestTemp, sizeof(abDigestTemp));                 /* a) */
    154         pb     += RTSHA512_HASH_SIZE;
    155         cbLeft -= RTSHA512_HASH_SIZE
     154        pb     += TMPL_HASH_SIZE;
     155        cbLeft -= TMPL_HASH_SIZE
    156156    }
    157157    memcpy(pb, abDigestTemp, cbLeft);                                           /* b) */
    158158#else
    159     AssertCompile(RT_SHACRYPT_SALT_MAX_LEN < RTSHA512_HASH_SIZE);
     159    AssertCompile(RT_SHACRYPT_SALT_MAX_LEN < TMPL_HASH_SIZE);
    160160    uint8_t         abSeqS[RT_SHACRYPT_SALT_MAX_LEN + 2];
    161161    uint8_t * const pabSeqS = abSeqS;
    … …  
    166166    for (uint32_t iRound = 0; iRound < cRounds; iRound++)
    167167    {
    168         RTSHA512CONTEXT CtxC;
    169         RTSha512Init(&CtxC);                                                    /* a) */
     168        TMPL_HASH_CONTEXT_T CtxC;
     169        TmplHashInit(&CtxC);                                                    /* a) */
    170170
    171171        if ((iRound & 1) != 0)
    172             RTSha512Update(&CtxC, pabSeqP, cbSeqP);                             /* b) */
     172            TmplHashUpdate(&CtxC, pabSeqP, cbSeqP);                             /* b) */
    173173        else
    174             RTSha512Update(&CtxC, abDigest, sizeof(abDigest));                  /* c) */
     174            TmplHashUpdate(&CtxC, abDigest, sizeof(abDigest));                  /* c) */
    175175
    176176        if (iRound % 3 != 0)                                                    /* d) */
    177             RTSha512Update(&CtxC, pabSeqS, cbSeqS);
     177            TmplHashUpdate(&CtxC, pabSeqS, cbSeqS);
    178178
    179179        if (iRound % 7 != 0)
    180             RTSha512Update(&CtxC, pabSeqP, cbSeqP);                             /* e) */
     180            TmplHashUpdate(&CtxC, pabSeqP, cbSeqP);                             /* e) */
    181181
    182182        if ((iRound & 1) != 0)
    183             RTSha512Update(&CtxC, abDigest, sizeof(abDigest));                  /* f) */
     183            TmplHashUpdate(&CtxC, abDigest, sizeof(abDigest));                  /* f) */
    184184        else
    185             RTSha512Update(&CtxC, pabSeqP, cbSeqP);                             /* g) */
    186 
    187         RTSha512Final(&CtxC, abDigest);                                         /* h) */
     185            TmplHashUpdate(&CtxC, pabSeqP, cbSeqP);                             /* g) */
     186
     187        TmplHashFinal(&CtxC, abDigest);                                         /* h) */
    188188    }
    189189
    … …  
    191191     * Done.
    192192     */
    193     memcpy(pabHash, abDigest, RTSHA512_HASH_SIZE);
     193    memcpy(pabHash, abDigest, TMPL_HASH_SIZE);
    194194
    195195    /*
    196196     * Cleanup.
    197197     */
    198     RTMemWipeThoroughly(abDigestTemp, RTSHA512_HASH_SIZE, 3);
     198    RTMemWipeThoroughly(abDigestTemp, TMPL_HASH_SIZE, 3);
    199199    RTMemWipeThoroughly(pabSeqP, cbSeqP, 3);
    200200    RTMemTmpFree(pabSeqP);
    … …  
    210210
    211211
    212 RTR3DECL(int) RTCrShaCrypt512ToString(uint8_t const pabHash[RTSHA512_HASH_SIZE], const char *pszSalt, uint32_t cRounds,
    213                                       char *pszString, size_t cbString)
     212RTR3DECL(int) RTCrShaCryptTmplToString(uint8_t const pabHash[TMPL_HASH_SIZE], const char *pszSalt, uint32_t cRounds,
     213                                       char *pszString, size_t cbString)
    214214{
    215215    /*
    … …  
    237237    }
    238238
    239     size_t const cchNeeded = sizeof(RT_SHACRYPT_ID_STR_512) - 1
     239    size_t const cchNeeded = sizeof(TMPL_SHACRYPT_ID_STR) - 1
    240240                           + (cRounds != RT_SHACRYPT_ROUNDS_DEFAULT ? cchRounds + sizeof("rounds=$") - 1 : 0)
    241241                           + cchSalt + 1
    242                            + RTSHA512_HASH_SIZE * 4 / 3
     242                           + TMPL_HASH_SIZE * 4 / 3
    243243                           + 1;
    244244    AssertReturn(cbString > cchNeeded, VERR_BUFFER_OVERFLOW);
    … …  
    247247     * Do the formatting.
    248248     */
    249     memcpy(pszString, RT_STR_TUPLE(RT_SHACRYPT_ID_STR_512));
    250     size_t off = sizeof(RT_SHACRYPT_ID_STR_512) - 1;
     249    memcpy(pszString, RT_STR_TUPLE(TMPL_SHACRYPT_ID_STR));
     250    size_t off = sizeof(TMPL_SHACRYPT_ID_STR) - 1;
    251251
    252252    if (cRounds != RT_SHACRYPT_ROUNDS_DEFAULT)
    … …  
    264264    pszString[off++] = '$';
    265265
     266#if TMPL_HASH_BITS == 512
    266267    BASE64_ENCODE(pszString, off, pabHash[ 0], pabHash[21], pabHash[42], 4);
    267268    BASE64_ENCODE(pszString, off, pabHash[22], pabHash[43], pabHash[ 1], 4);
    … …  
    287288    BASE64_ENCODE(pszString, off,           0,           0, pabHash[63], 2);
    288289
     290#elif TMPL_HASH_BITS == 256
     291    BASE64_ENCODE(pszString, off, pabHash[00], pabHash[10], pabHash[20], 4);
     292    BASE64_ENCODE(pszString, off, pabHash[21], pabHash[ 1], pabHash[11], 4);
     293    BASE64_ENCODE(pszString, off, pabHash[12], pabHash[22], pabHash[ 2], 4);
     294    BASE64_ENCODE(pszString, off, pabHash[ 3], pabHash[13], pabHash[23], 4);
     295    BASE64_ENCODE(pszString, off, pabHash[24], pabHash[ 4], pabHash[14], 4);
     296    BASE64_ENCODE(pszString, off, pabHash[15], pabHash[25], pabHash[ 5], 4);
     297    BASE64_ENCODE(pszString, off, pabHash[ 6], pabHash[16], pabHash[26], 4);
     298    BASE64_ENCODE(pszString, off, pabHash[27], pabHash[ 7], pabHash[17], 4);
     299    BASE64_ENCODE(pszString, off, pabHash[18], pabHash[28], pabHash[ 8], 4);
     300    BASE64_ENCODE(pszString, off, pabHash[ 9], pabHash[19], pabHash[29], 4);
     301    BASE64_ENCODE(pszString, off, 0,           pabHash[31], pabHash[30], 3);
     302
     303#else
     304# error "TMPL_HASH_BITS"
     305#endif
     306
    289307    pszString[off] = '\0';
    290308    Assert(off < cbString);
    … …  
    293311}
    294312
     313
     314#undef TMPL_HASH_BITS
     315#undef TMPL_HASH_SIZE
     316#undef TMPL_HASH_CONTEXT_T
     317#undef TmplHashInit
     318#undef TmplHashUpdate
     319#undef TmplHashFinal
     320#undef TMPL_SHACRYPT_ID_STR
     321#undef RTCrShaCryptTmpl
     322#undef RTCrShaCryptTmplEx
     323#undef RTCrShaCryptTmplToString
     324
     325

  • trunk/src/VBox/Runtime/common/crypto/shacrypt.cpp

    r102488 r102495  
    128128}
    129129
    130 #include "shacrypt-256.cpp.h"
    131 #include "shacrypt-512.cpp.h"
     130
     131/*
     132 * The algorithm for the SHA-256 and SHA-512 encryption is identical, except for
     133 * how the bytes are distributed in the final step.  So we use a pre-processor
     134 * code template for the implementation.
     135 */
     136
     137/* SHA-256*/
     138#define TMPL_HASH_BITS              256
     139#define TMPL_HASH_SIZE              RTSHA256_HASH_SIZE
     140#define TMPL_HASH_CONTEXT_T         RTSHA256CONTEXT
     141#define TmplHashInit                RTSha256Init
     142#define TmplHashUpdate              RTSha256Update
     143#define TmplHashFinal               RTSha256Final
     144#define TMPL_SHACRYPT_ID_STR        RT_SHACRYPT_ID_STR_256
     145#define RTCrShaCryptTmpl            RTCrShaCrypt256
     146#define RTCrShaCryptTmplEx          RTCrShaCrypt256Ex
     147#define RTCrShaCryptTmplToString    RTCrShaCrypt256ToString
     148#include "shacrypt-tmpl.cpp.h"
     149
     150/* SHA-512*/
     151#define TMPL_HASH_BITS              512
     152#define TMPL_HASH_SIZE              RTSHA512_HASH_SIZE
     153#define TMPL_HASH_CONTEXT_T         RTSHA512CONTEXT
     154#define TmplHashInit                RTSha512Init
     155#define TmplHashUpdate              RTSha512Update
     156#define TmplHashFinal               RTSha512Final
     157#define TMPL_SHACRYPT_ID_STR        RT_SHACRYPT_ID_STR_512
     158#define RTCrShaCryptTmpl            RTCrShaCrypt512
     159#define RTCrShaCryptTmplEx          RTCrShaCrypt512Ex
     160#define RTCrShaCryptTmplToString    RTCrShaCrypt512ToString
     161#include "shacrypt-tmpl.cpp.h"
    132162
    133163
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