+++ /dev/null
-/* Copyright (c) 1998,2003-2006,2008 Apple Inc.
- *
- * symTest.c - test CSP symmetric encrypt/decrypt.
- *
- * Revision History
- * ----------------
- * 4 May 2000 Doug Mitchell
- * Ported to X/CDSA2.
- * 20 May 1998 Doug Mitchell at Apple
- * Ported to CDSA1.2, new Apple CSP
- * 15 Aug 1997 Doug Mitchell at Apple
- * Ported from CryptKit ObjC version
- * 26 Aug 1996 Doug Mitchell at NeXT
- * Created.
- */
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <time.h>
-#include <Security/cssm.h>
-#include <Security/cssmapple.h>
-#include "cspwrap.h"
-#include "common.h"
-#include "cspdlTesting.h"
-
-/*
- * Defaults.
- */
-#define LOOPS_DEF 50
-#define MIN_PTEXT_SIZE 8
-#define MAX_PTEXT_SIZE 0x10000
-
-/*
- * Enumerate algs our own way to allow iteration.
- */
-typedef enum {
- ALG_ASC = 1,
- ALG_DES,
- ALG_RC2,
- ALG_RC4,
- ALG_RC5,
- ALG_3DES,
- ALG_AES,
- ALG_BFISH,
- ALG_CAST,
- ALG_NULL /* normally not used */
-} SymAlg;
-#define ALG_FIRST ALG_ASC
-#define ALG_LAST ALG_CAST
-
-#define PBE_ENABLE 0
-#define PWD_LENGTH_MAX 64
-#define MAX_DATA_SIZE (100000 + 100) /* bytes */
-#define LOOP_NOTIFY 20
-
-#define LOG_SIZE 0
-#if LOG_SIZE
-#define logSize(s) printf s
-#else
-#define logSize(s)
-#endif
-
-static void usage(char **argv)
-{
- printf("usage: %s [options]\n", argv[0]);
- printf(" Options:\n");
- printf(" a=algorithm (s=ASC; d=DES; 3=3DES; 2=RC2; 4=RC4; 5=RC5; a=AES;\n");
- printf(" b=Blowfish; c=CAST; n=Null; default=all)\n");
- printf(" l=loops (default=%d; 0=forever)\n", LOOPS_DEF);
- printf(" n=minPtextSize (default=%d)\n", MIN_PTEXT_SIZE);
- printf(" x=maxPtextSize (default=%d)\n", MAX_PTEXT_SIZE);
- printf(" k=keySizeInBits\n");
- printf(" r(eference keys only)\n");
- printf(" e(xport)\n");
- printf(" d (no DB open)\n");
- printf(" p=pauseInterval (default=0, no pause)\n");
- printf(" o (no padding, well-aligned plaintext)\n");
- printf(" u (no multi-update ops)\n");
- printf(" U (only multi-update ops)\n");
- printf(" m (CSP mallocs out bufs)\n");
- printf(" D (CSP/DL; default = bare CSP)\n");
- printf(" K (key gen only)\n");
- printf(" v(erbose)\n");
- printf(" q(uiet)\n");
- printf(" h(elp)\n");
- exit(1);
-}
-
-/* constant seed data */
-static CSSM_DATA seedData = {8, (uint8 *)"12345678"};
-
-/* alternate between two derivation algs, with different digest sizes */
-#define PBE_DERIVE_ALG_ODD CSSM_ALGID_PKCS5_PBKDF1_MD5
-#define PBE_DERIVE_ALG_EVEN CSSM_ALGID_PKCS5_PBKDF1_SHA1
-
-/*
- * When expectEqualText is true, encrypt/decrypt in place.
- */
-#define EQUAL_TEXT_IN_PLACE 1
-
-static int doTest(CSSM_CSP_HANDLE cspHand,
- CSSM_DATA_PTR ptext,
- uint32 keyAlg, // CSSM_ALGID_xxx of the key
- uint32 encrAlg, // encrypt/decrypt
- uint32 mode,
- uint32 padding,
- uint32 effectiveKeySizeInBits,
- CSSM_BOOL refKey,
- CSSM_DATA_PTR pwd, // password- NULL means use a random key data
- CSSM_BOOL stagedEncr,
- CSSM_BOOL stagedDecr,
- CSSM_BOOL mallocPtext, // only meaningful if !stagedDecr
- CSSM_BOOL mallocCtext, // only meaningful if !stagedEncr
- CSSM_BOOL quiet,
- CSSM_BOOL keyGenOnly,
- CSSM_BOOL expectEqualText) // ptext size must == ctext size
-{
- CSSM_KEY_PTR symKey = NULL;
- CSSM_DATA ctext = {0, NULL};
- CSSM_DATA rptext = {0, NULL};
- CSSM_RETURN crtn;
- int rtn = 0;
- uint32 keySizeInBits;
- CSSM_DATA initVector;
- uint32 rounds = 0;
-
- /* generate keys with well aligned sizes; effectiveKeySize specified in encrypt
- * only if not well aligned */
- keySizeInBits = (effectiveKeySizeInBits + 7) & ~7;
- if(keySizeInBits == effectiveKeySizeInBits) {
- effectiveKeySizeInBits = 0;
- }
-
- if(encrAlg == CSSM_ALGID_RC5) {
- /* roll the dice, pick one of three values for rounds */
- unsigned die = genRand(1,3);
- switch(die) {
- case 1:
- rounds = 8;
- break;
- case 2:
- rounds = 12;
- break;
- case 3:
- rounds = 16;
- break;
- }
- }
-
- if(pwd == NULL) {
- /* random key */
- symKey = cspGenSymKey(cspHand,
- keyAlg,
- "noLabel",
- 7,
- CSSM_KEYUSE_ENCRYPT | CSSM_KEYUSE_DECRYPT,
- keySizeInBits,
- refKey);
- }
- else {
- /* this code isn't tested */
- uint32 pbeAlg;
- initVector.Data = NULL; // we're going to ignore this
- initVector.Length = 0;
- /* one of two random PBE algs */
- if(ptext->Data[0] & 1) {
- pbeAlg = PBE_DERIVE_ALG_ODD;
- }
- else {
- pbeAlg = PBE_DERIVE_ALG_EVEN;
- }
- symKey = cspDeriveKey(cspHand,
- pbeAlg,
- keyAlg,
- "noLabel",
- 7,
- CSSM_KEYUSE_ENCRYPT | CSSM_KEYUSE_DECRYPT,
- keySizeInBits,
- refKey,
- pwd,
- &seedData,
- 1, // iteration count
- &initVector);
- if(initVector.Data != NULL) {
- CSSM_FREE(initVector.Data);
- }
- }
- if(symKey == NULL) {
- rtn = testError(quiet);
- goto abort;
- }
- if(keyGenOnly) {
- rtn = 0;
- goto abort;
- }
-
- /* not all algs need this, pass it in anyway */
- initVector.Data = (uint8 *)"someStrangeInitVect";
- switch(encrAlg) {
- case CSSM_ALGID_AES:
- case CSSM_ALGID_NONE:
- initVector.Length = 16;
- break;
- default:
- initVector.Length = 8;
- break;
- }
- if(stagedEncr) {
- crtn = cspStagedEncrypt(cspHand,
- encrAlg,
- mode,
- padding,
- symKey,
- NULL, // second key unused
- effectiveKeySizeInBits,
- 0, // cipherBlockSize
- rounds,
- &initVector,
- ptext,
- &ctext,
- CSSM_TRUE); // multi
- }
- else {
- const CSSM_DATA *ptextPtr = ptext;
- if(expectEqualText && mallocCtext && CSPDL_NOPAD_ENFORCE_SIZE) {
- /*
- * !pad test: ensure this works when ctextlen == ptextlen by
- * mallocing ourself right now (instead of cspEncrypt doing it
- * after doing a CSSM_QuerySize())
- */
- ctext.Data = (uint8 *)appMalloc(ptext->Length, NULL);
- if(ctext.Data == NULL) {
- printf("memmory failure\n");
- rtn = testError(quiet);
- goto abort;
- }
- ctext.Length = ptext->Length;
- #if EQUAL_TEXT_IN_PLACE
- /* encrypt in place */
- memmove(ctext.Data, ptext->Data, ptext->Length);
- ptextPtr = &ctext;
- #endif
- }
- crtn = cspEncrypt(cspHand,
- encrAlg,
- mode,
- padding,
- symKey,
- NULL, // second key unused
- effectiveKeySizeInBits,
- rounds,
- &initVector,
- ptextPtr,
- &ctext,
- mallocCtext);
- }
- if(crtn) {
- rtn = testError(quiet);
- goto abort;
- }
- if(expectEqualText && (ptext->Length != ctext.Length)) {
- printf("***ctext/ptext length mismatch: ptextLen %lu ctextLen %lu\n",
- ptext->Length, ctext.Length);
- rtn = testError(quiet);
- if(rtn) {
- goto abort;
- }
- }
- logSize(("###ctext len %lu\n", ctext.Length));
- if(stagedDecr) {
- crtn = cspStagedDecrypt(cspHand,
- encrAlg,
- mode,
- padding,
- symKey,
- NULL, // second key unused
- effectiveKeySizeInBits,
- 0, // cipherBlockSize
- rounds,
- &initVector,
- &ctext,
- &rptext,
- CSSM_TRUE); // multi
- }
- else {
- const CSSM_DATA *ctextPtr = &ctext;
- if(expectEqualText && mallocPtext && CSPDL_NOPAD_ENFORCE_SIZE) {
- /*
- * !pad test: ensure this works when ctextlen == ptextlen by
- * mallocing ourself right now (instead of cspDecrypt doing it
- * after doing a CSSM_QuerySize())
- */
- rptext.Data = (uint8 *)appMalloc(ctext.Length, NULL);
- if(rptext.Data == NULL) {
- printf("memmory failure\n");
- rtn = testError(quiet);
- goto abort;
- }
- rptext.Length = ctext.Length;
- #if EQUAL_TEXT_IN_PLACE
- /* decrypt in place */
- memmove(rptext.Data, ctext.Data, ctext.Length);
- ctextPtr = &rptext;
- #endif
- }
- crtn = cspDecrypt(cspHand,
- encrAlg,
- mode,
- padding,
- symKey,
- NULL, // second key unused
- effectiveKeySizeInBits,
- rounds,
- &initVector,
- ctextPtr,
- &rptext,
- mallocPtext);
- }
- if(crtn) {
- rtn = testError(quiet);
- goto abort;
- }
- logSize(("###rptext len %lu\n", rptext.Length));
- /* compare ptext, rptext */
- if(ptext->Length != rptext.Length) {
- printf("Ptext length mismatch: expect %lu, got %lu\n", ptext->Length, rptext.Length);
- rtn = testError(quiet);
- if(rtn) {
- goto abort;
- }
- }
- if(memcmp(ptext->Data, rptext.Data, ptext->Length)) {
- printf("***data miscompare\n");
- rtn = testError(quiet);
- }
-abort:
- /* free key if we have it*/
- if(symKey != NULL) {
- if(cspFreeKey(cspHand, symKey)) {
- printf("Error freeing privKey\n");
- rtn = 1;
- }
- CSSM_FREE(symKey);
- }
- /* free rptext, ctext */
- appFreeCssmData(&rptext, CSSM_FALSE);
- appFreeCssmData(&ctext, CSSM_FALSE);
- return rtn;
-}
-
-int main(int argc, char **argv)
-{
- int arg;
- char *argp;
- unsigned loop;
- CSSM_DATA ptext;
- CSSM_CSP_HANDLE cspHand;
- CSSM_BOOL stagedEncr;
- CSSM_BOOL stagedDecr;
- CSSM_BOOL mallocCtext;
- CSSM_BOOL mallocPtext;
- CSSM_BOOL refKey;
- const char *algStr;
- uint32 keyAlg; // CSSM_ALGID_xxx of the key
- uint32 encrAlg; // CSSM_ALGID_xxx of the encrypt/decrypt/sign
- int i;
- int currAlg; // ALG_xxx
- CSSM_DATA_PTR pPwd;
- CSSM_DATA pwd;
- uint32 actKeySizeInBits;
- int rtn = 0;
- uint32 blockSize; // for noPadding case
- CSSM_BOOL expectEqualText;
-
- /*
- * User-spec'd params
- */
- CSSM_BOOL keySizeSpec = CSSM_FALSE; // false: use rand key size
- SymAlg minAlg = ALG_FIRST;
- SymAlg maxAlg = ALG_LAST;
- unsigned loops = LOOPS_DEF;
- CSSM_BOOL verbose = CSSM_FALSE;
- unsigned minPtextSize = MIN_PTEXT_SIZE;
- unsigned maxPtextSize = MAX_PTEXT_SIZE;
- CSSM_BOOL quiet = CSSM_FALSE;
- unsigned pauseInterval = 0;
- uint32 mode;
- uint32 padding;
- CSSM_BOOL noDbOpen = CSSM_FALSE;
- CSSM_BOOL bareCsp = CSSM_TRUE;
- CSSM_BOOL keyGenOnly = CSSM_FALSE;
- CSSM_BOOL noPadding = CSSM_FALSE;
- CSSM_BOOL multiEnable = CSSM_TRUE;
- CSSM_BOOL multiOnly = CSSM_FALSE;
- CSSM_BOOL refKeysOnly = CSSM_FALSE;
- CSSM_BOOL cspMallocs = CSSM_FALSE;
-
- #if macintosh
- argc = ccommand(&argv);
- #endif
- for(arg=1; arg<argc; arg++) {
- argp = argv[arg];
- switch(argp[0]) {
- case 'a':
- if(argp[1] != '=') {
- usage(argv);
- }
- switch(argp[2]) {
- case 's':
- minAlg = maxAlg = ALG_ASC;
- break;
- case 'd':
- minAlg = maxAlg = ALG_DES;
- break;
- case '3':
- minAlg = maxAlg = ALG_3DES;
- break;
- case '2':
- minAlg = maxAlg = ALG_RC2;
- break;
- case '4':
- minAlg = maxAlg = ALG_RC4;
- break;
- case '5':
- minAlg = maxAlg = ALG_RC5;
- break;
- case 'a':
- minAlg = maxAlg = ALG_AES;
- break;
- case 'b':
- minAlg = maxAlg = ALG_BFISH;
- break;
- case 'c':
- minAlg = maxAlg = ALG_CAST;
- break;
- case 'n':
- minAlg = maxAlg = ALG_NULL;
- break;
- default:
- usage(argv);
- }
- break;
- case 'l':
- loops = atoi(&argp[2]);
- break;
- case 'n':
- minPtextSize = atoi(&argp[2]);
- break;
- case 'x':
- maxPtextSize = atoi(&argp[2]);
- break;
- case 'r':
- refKeysOnly = CSSM_TRUE;
- break;
- case 'k':
- actKeySizeInBits = atoi(&argp[2]);
- keySizeSpec = CSSM_TRUE;
- break;
- case 'v':
- verbose = CSSM_TRUE;
- break;
- case 'D':
- bareCsp = CSSM_FALSE;
- #if CSPDL_ALL_KEYS_ARE_REF
- refKeysOnly = CSSM_TRUE;
- #endif
- break;
- case 'q':
- quiet = CSSM_TRUE;
- break;
- case 'p':
- pauseInterval = atoi(&argp[2]);;
- break;
- case 'o':
- noPadding = CSSM_TRUE;
- break;
- case 'd':
- noDbOpen = CSSM_TRUE;
- break;
- case 'K':
- keyGenOnly = CSSM_TRUE;
- break;
- case 'u':
- multiEnable = CSSM_FALSE;
- break;
- case 'U':
- multiOnly = CSSM_TRUE;
- break;
- case 'm':
- cspMallocs = CSSM_TRUE;
- break;
- case 'h':
- default:
- usage(argv);
- }
- }
- if(multiOnly && !multiEnable) {
- printf("***can't specify multi disable and multi only\n");
- exit(1);
- }
- if(minPtextSize > maxPtextSize) {
- printf("***minPtextSize must be <= maxPtextSize\n");
- usage(argv);
- }
- pwd.Data = (uint8 *)CSSM_MALLOC(PWD_LENGTH_MAX);
- ptext.Data = (uint8 *)CSSM_MALLOC(maxPtextSize);
- if(ptext.Data == NULL) {
- printf("Insufficient heap space\n");
- exit(1);
- }
- /* ptext length set in test loop */
- printf("Starting symTest; args: ");
- for(i=1; i<argc; i++) {
- printf("%s ", argv[i]);
- }
- printf("\n");
- cspHand = cspDlDbStartup(bareCsp, NULL);
- if(cspHand == 0) {
- exit(1);
- }
- if(pauseInterval) {
- fpurge(stdin);
- printf("Top of test; hit CR to proceed: ");
- getchar();
- }
- for(currAlg=minAlg; currAlg<=maxAlg; currAlg++) {
- /* some default values... */
- mode = CSSM_ALGMODE_NONE;
- padding = CSSM_PADDING_NONE;
- blockSize = 0; // i.e., don't align
- expectEqualText = CSSM_FALSE;
- switch(currAlg) {
- case ALG_ASC:
- encrAlg = keyAlg = CSSM_ALGID_ASC;
- algStr = "ASC";
- break;
- case ALG_DES:
- encrAlg = keyAlg = CSSM_ALGID_DES;
- algStr = "DES";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 8;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS1;
- }
- break;
- case ALG_3DES:
- /* currently the only one with different key and encr algs */
- /* Though actually these two consts are equivalent...for now... */
- keyAlg = CSSM_ALGID_3DES_3KEY;
- encrAlg = CSSM_ALGID_3DES_3KEY_EDE;
- algStr = "3DES";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 8;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS1;
- }
- break;
- case ALG_RC2:
- encrAlg = keyAlg = CSSM_ALGID_RC2;
- algStr = "RC2";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 8;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS1; // what does padding do here?
- }
- break;
- case ALG_RC4:
- encrAlg = keyAlg = CSSM_ALGID_RC4;
- algStr = "RC4";
- mode = CSSM_ALGMODE_NONE;
- expectEqualText = CSSM_TRUE; // always for RC4
- break;
- case ALG_RC5:
- encrAlg = keyAlg = CSSM_ALGID_RC5;
- algStr = "RC5";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 8;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS1; // eh?
- }
- break;
- case ALG_AES:
- encrAlg = keyAlg = CSSM_ALGID_AES;
- algStr = "AES";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 16;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS5;
- }
- break;
- case ALG_BFISH:
- encrAlg = keyAlg = CSSM_ALGID_BLOWFISH;
- algStr = "Blowfish";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 8;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS5;
- }
- break;
- case ALG_CAST:
- encrAlg = keyAlg = CSSM_ALGID_CAST;
- algStr = "CAST";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 8;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS5;
- }
- break;
- case ALG_NULL:
- encrAlg = keyAlg = CSSM_ALGID_NONE;
- algStr = "NULL";
- if(noPadding) {
- mode = CSSM_ALGMODE_CBC_IV8;
- blockSize = 16;
- expectEqualText = CSSM_TRUE;
- }
- else {
- mode = CSSM_ALGMODE_CBCPadIV8;
- padding = CSSM_PADDING_PKCS5;
- }
- break;
- }
- if(!quiet || verbose) {
- printf("Testing alg %s\n", algStr);
- }
- for(loop=1; ; loop++) {
- simpleGenData(&ptext, minPtextSize, maxPtextSize);
- if(blockSize) {
- /* i.e., no padding --> align ptext */
- ptext.Length = ((ptext.Length + blockSize - 1) / blockSize) * blockSize;
- }
- if(!keySizeSpec) {
- actKeySizeInBits = randKeySizeBits(keyAlg, OT_Encrypt);
- }
- /* else constant, spec'd by user, may be 0 (default per alg) */
- /* mix up some random and derived keys, as well as staging and "who does
- * the malloc?" */
- pPwd = (loop & 1) ? &pwd : NULL;
- if(multiEnable) {
- if(multiOnly) {
- stagedEncr = stagedDecr = CSSM_TRUE;
- }
- else {
- stagedEncr = (loop & 2) ? CSSM_TRUE : CSSM_FALSE;
- stagedDecr = (loop & 4) ? CSSM_TRUE : CSSM_FALSE;
- }
- }
- else {
- stagedEncr = CSSM_FALSE;
- stagedDecr = CSSM_FALSE;
- }
- if(!stagedEncr && !cspMallocs) {
- mallocCtext = (ptext.Data[0] & 1) ? CSSM_TRUE : CSSM_FALSE;
- }
- else {
- mallocCtext = CSSM_FALSE;
- }
- if(!stagedDecr && !cspMallocs) {
- mallocPtext = (ptext.Data[0] & 2) ? CSSM_TRUE : CSSM_FALSE;
- }
- else {
- mallocPtext = CSSM_FALSE;
- }
- if(refKeysOnly) {
- refKey = CSSM_TRUE;
- }
- else {
- refKey = (ptext.Data[0] & 4) ? CSSM_TRUE : CSSM_FALSE;
- }
- #if !PBE_ENABLE
- pPwd = NULL;
- #endif
- if(!quiet) {
- if(verbose || ((loop % LOOP_NOTIFY) == 0)) {
- printf("..loop %d text size %lu keySizeBits %u\n",
- loop, (unsigned long)ptext.Length, (unsigned)actKeySizeInBits);
- if(verbose) {
- printf(" refKey %d derive %d stagedEncr %d stagedDecr %d mallocCtext %d "
- "mallocPtext %d\n",
- (int)refKey, (pPwd == NULL) ? 0 : 1, (int)stagedEncr, (int)stagedDecr,
- (int)mallocCtext, (int)mallocPtext);
- }
- }
- }
- #if PBE_ENABLE
- if(pPwd != NULL) {
- /* PBE - cook up random password */
- simpleGenData(pPwd, APPLE_PBE_MIN_PASSWORD, PWD_LENGTH_MAX);
- }
- #endif
-
- if(doTest(cspHand,
- &ptext,
- keyAlg,
- encrAlg,
- mode,
- padding,
- actKeySizeInBits,
- refKey,
- pPwd,
- stagedEncr,
- stagedDecr,
- mallocPtext,
- mallocCtext,
- quiet,
- keyGenOnly,
- expectEqualText)) {
- rtn = 1;
- break;
- }
- if(pauseInterval && ((loop % pauseInterval) == 0)) {
- char c;
- fpurge(stdin);
- printf("Hit CR to proceed, q to abort: ");
- c = getchar();
- if(c == 'q') {
- goto testDone;
- }
- }
- if(loops && (loop == loops)) {
- break;
- }
- } /* main loop */
- if(rtn) {
- break;
- }
-
- } /* for algs */
-
-testDone:
- cspShutdown(cspHand, bareCsp);
- if(pauseInterval) {
- fpurge(stdin);
- printf("ModuleDetach/Unload complete; hit CR to exit: ");
- getchar();
- }
- if((rtn == 0) && !quiet) {
- printf("%s test complete\n", argv[0]);
- }
- CSSM_FREE(pwd.Data);
- CSSM_FREE(ptext.Data);
- return rtn;
-}
projects / apple / security.git / blobdiff