/***********************************************************************
*
* Copyright (C) 2005-2006 Novell, Inc. All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; version 2.1
* of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, Novell, Inc.
*
* To contact Novell about this file by physical or electronic mail,
* you may find current contact information at www.novell.com.
*
***********************************************************************/
/***************************************************************
*** This code is available at "www.developer.novell.com/ndk/ **
***************************************************************/
/* Sample code for C Language SecretStore Client Service APIs */
#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32
#include <conio.h>
#include <windows.h>
#else
#define getch(x) getchar(x);
#endif
#include <time.h>
#include <string.h>
#include <micasa_mgmd.h>
#include <micasa.h>
#define GSS_BLD_STR "4.0.1"
#define SSCS_BINARY_TYPE_F 0x00000004L
static char SSCS_APP_SECRET[] = {'S','S','_','A','p','p', 0};
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
/*
* Global data
*/
int optErr = 1; // if error message should be printed
int optIdx = 1; // index into parent argv vector
int optionString = 1; // character checked for validity
char *optArg = NULL; // argument associated with option
#define BADCHAR (int)'?'
#define ERRMSG ""
/* interactive flag */
static int aFlag = 1;
/* */
/*
* NAME - sss_GetOpt
*
* DESCRIPTION
* An implementation of the Unix getopt() function.
*
*/
int sss_GetOpt( int nArgc, char **nArgv, char *optStr )
{ /* beginning of the call */
/* ########################## DECLARATIONS START HERE ######################### */
static char *place = ERRMSG;
char *nxtOpt;
/* ############################## CODE STARTS HERE ############################ */
if(!*place)
{
if((optIdx >= nArgc) ||
((*(place = nArgv[optIdx]) != '-')
&& (*(place = nArgv[optIdx]) != '/')) ||
(!*++place))
{
return(-1);
}
if((*place == '-') || (*place == '/'))
{
++optIdx;
return(-1);
}
}
if((optionString = (int)*place++) == (int)'=' ||
!(nxtOpt = strchr(optStr, optionString)))
{
if(!*place)
{
++optIdx;
}
return(BADCHAR);
}
if(*++nxtOpt != '=')
{
optArg = NULL;
if(!*place)
{
++optIdx;
}
}
else
{
if(*place)
{
optArg = place + 1;
}
else if(nArgc <= ++optIdx)
{
place = ERRMSG;
return(BADCHAR);
}
else
{
optArg = nArgv[optIdx];
}
place = ERRMSG;
++optIdx;
}
return(optionString);
/* ########################## CODE ENDS HERE ######################### */
} /* end of GetOPt */
void Pause()
{ /* beginning of the call */
/* ############################## CODE STARTS HERE ############################ */
if(aFlag)
{
printf("\nPress a key ==>\n");
getch();
}
/* ########################## CODE ENDS HERE ######################### */
} /* end of Pause */
/* */
/*
* NAME - PrintFlags
*
* DESCRIPTION
* This function will print the
* status flags read form a secret.
*
*/
void PrintFlags(char *msg, unsigned long statFlags)
{ // beginning of the call
// ############################## CODE STARTS HERE ############################
#ifdef NOT_DEFINED_YET
if(aFlag)
{
printf("%s", msg);
if(statFlags & NSSS_ENHANCED_PROTECT_INFO_F)
printf("\tENHANCED PROTECTION...\n");
if(statFlags & NSSS_STORE_NOT_SYNCED_F)
printf("\tSTORE NOT SYNCED...\n");
if(statFlags & NSSS_SECRET_NOT_INITIALIZED_F)
printf("\tSECRET NOT INITIALIZED...\n");
if(statFlags & NSSS_SECRET_LOCKED_F)
printf("\tSECRET LOCKED...\n");
// doesn't apply to the server
if(strcmp(msg, "SecretStore Flags:\n"))
{
if(statFlags & NSSS_ADMIN_LAST_MOD_F)
printf("\tADMIN MODIFIED LAST...\n");
else
printf("\tOWNER MODIFIED LAST...\n");
}
if(statFlags & NSSS_EP_PWORD_PRESENT_F)
printf("\tEP PWORD PRESENT...\n");
if(statFlags & NSSS_EP_MASTER_PWORD_PRESENT_F)
printf("\tMASTER PWORD PRESENT...\n");
if(statFlags & NSSS_MP_NOT_ALLOWED_F)
printf("\tMASTER PWORD NOT ALLOWED...\n");
if(statFlags & NSSS_HIDDEN_SECRET_F)
printf("\tHIDDEN SECRET IN SECRETSTORE...\n");
if(statFlags & NSSS_ADMIN_UNLOCKED_F)
printf("\tADMIN LAST UNLOCKED THE SECRETSTORE...\n");
}
#endif
// ########################## CODE ENDS HERE #########################
} // end of PrintFlags
/* */
/*
* NAME - main
*
* DESCRIPTION
* SecretStore SharedSecret test program.
*
*/
int main
(
int argc,
char **argv
)
{ /* beginning of the call */
/* ########################## DECLARATIONS START HERE ######################### */
SSCS_SECRETSTORE_T ssid = {0};
SSCS_SECRETSTORE_INFO_T ssInfo = {0};
SSCS_KEYCHAIN_ID_T keyChainID = {0};
SSCS_READEXT_T rInfo = {0};
void *ssContext = NULL;
int appTstFlag = 0, multiCredTstFlag = 0, multiEntryTstFlag = 0;
char *secret;
static char multiCredApp[] = {'S','h','a','r','e','d','S','e','c','r','e','t',' ','M','u','l','t','i','p','l','e',' ','C','r','e','d','S','e','t',' ','A','p','p','l','i','c','a','t','i','o','n',' ','T','e','s','t',0};
static char multiEntryCredSet[] = {'S','h','a','r','e','d','S','e','c','r','e','t',' ','M','u','l','t','i','p','l','e',' ','E','n','t','r','y',' ','C','r','e','d','S','e','t',' ','T','e','s','t',0};
static char userKey[] = {'U','s','e','r',0};
static char passwordKey[] = {'P','a','s','s','w','o','r','d',0};
static char userEntries[5][7] =
{
{'u','s','e','r','0','1',0},
{'u','s','e','r','0','2',0},
{'u','s','e','r','0','3',0},
{'u','s','e','r','0','4',0},
{'u','s','e','r','0','5',0}
};
static char passwordEntries[5][11] =
{
{'p','a','s','s','w','o','r','d','0','1',0},
{'p','a','s','s','w','o','r','d','0','2',0},
{'p','a','s','s','w','o','r','d','0','3',0},
{'p','a','s','s','w','o','r','d','0','4',0},
{'p','a','s','s','w','o','r','d','0','5',0}
};
static char mKeyEntries[5][12] =
{
{'C','o','m','p','a','n','y',0},
{'D','e','s','c','r','i','p','t','i','o','n',0},
{'U','s','e','r','n','a','m','e',0},
{'P','a','s','s','w','o','r','d',0},
{'P','i','n',' ','N','u','m','b','e','r', 0}
};
static char mValEntries[5][26] =
{
{'N','o','v','e','l','l',',',' ','I','n','c','.',0},
{'S','h','a','r','e','d','S','e','c','r','e','t',' ','T','e','s','t',' ','U','t','i','l','i','t','y',0},
{'J','o','h','n',' ','D','o','e',0},
{'n','o','v','e','l','l',0},
{'9','8','7','6','5','4','3','2','1','0',0}
};
static char appNames[5][56] =
{
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','1','C','N','=','A','p','p','T','e','s','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','2','C','N','=','A','p','p','T','e','s','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','3','C','N','=','A','p','p','T','e','s','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','4','C','N','=','A','p','p','T','e','s','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','5','C','N','=','A','p','p','T','e','s','t','/','O','=','n','o','v','e','l','l',0}
};
static char credSetNames[5][56] =
{
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','1','C','N','=','C','r','e','d','S','e','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','2','C','N','=','C','r','e','d','S','e','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','3','C','N','=','C','r','e','d','S','e','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','4','C','N','=','C','r','e','d','S','e','t','/','O','=','n','o','v','e','l','l',0},
{'\\','S','h','a','r','e','d','S','e','c','r','e','t',':','E',':','\\','N','o','v','e','l','l','\\','s','s','s','h','s','T','e','s','t','.','0','5','C','N','=','C','r','e','d','S','e','t','/','O','=','n','o','v','e','l','l',0}
};
int rcode = NSSCS_SUCCESS;
int exCount = 1, i, j, remLock = 0, unlock = 0,
master = 0, rCount = 1;
long opCount, bufSize = NSSCS_MAX_SECRET_BUF_LEN;
unsigned long startTime, endTime, pFlag = 0L, count = 0;
int c;
SSCS_SECRET_ID_T secretID = {0};
// SharedSecret data
void *secretHandle; // handle for passing to functions
SSCS_SH_SECRET_ID_T shSecret; // SharedSecret struct
char *key = NULL;
unsigned char *value = NULL;
int kLen = 0;
int vLen = 0;
SSCS_SH_SECRET_ID_LIST_T shSecIDList = {0};
SSCS_BASIC_CREDENTIAL credential = {0};
SSCS_SECRET_ID_T appSecretId = {0};
SSCS_SECRET_ID_T sharedSecretId = {0};
SSCS_EXT_T ext = {0};
// DWORD dwSize;
// TOKEN_STATISTICS tokenStats;
#ifdef WIN32
LUID luid;
// HANDLE phUserToken;
ext.extID = 1;
luid.HighPart = 0;
luid.LowPart = 796691;
ext.ext = &luid;
#endif
int retVal = 0;
SSCS_PASSCODE_T passcode;
// STRING_PASSCODE myPasscode;
SSCS_PASSWORD_T myPasscode;
strcpy(myPasscode.pword,"TestPasscode");
myPasscode.pwordLen = strlen("TestPasscode") + 1;
myPasscode.pwordType = 1;
passcode.passcodeType = 1;
passcode.passcodeHandle = &myPasscode;
//phUserToken = malloc(sizeof(HANDLE));
strcpy(appSecretId.id, "AppSecretID");
appSecretId.len = 12;
strcpy(sharedSecretId.id, "SharedSecretID");
sharedSecretId.len = 15;
/* ############################## CODE STARTS HERE ############################ */
if((secret = (char *)malloc(NSSCS_MAX_SECRET_BUF_LEN)) == NULL)
{
printf("\nSecret Buffer Malloc Failed!!!\n");
exit(-1);
}
if((value = (unsigned char *)malloc(NSSCS_MAX_SECRET_BUF_LEN)) == NULL)
{
printf("\nValue Buffer Malloc Failed!!!\n");
exit(-1);
}
if((key = (char *)malloc(NSSCS_MAX_SECRET_ID_LEN)) == NULL)
{
printf("\nKey Buffer Malloc Failed!!!\n");
exit(-1);
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
memset(secret, 0, NSSCS_MAX_SECRET_BUF_LEN);
printf("\nSecretStore Client Service NDK Test Program version %s ...\n\n", GSS_BLD_STR);
// Initialize the SID to the user ID if the owner
strcpy(ssid.ssName, "testuser");
ssid.version = NSSCS_VERSION_NUMBER;
//** Process command-line arguments.
if(argc > 1)
{
while ((c = sss_GetOpt(argc, argv, "bBmMsSc=C=?hH")) != -1)
{
switch(c)
{
case 'b':
case 'B':
/* Big secret buffer */
bufSize = NSSCS_MAX_SECRET_BUF_LEN;
break;
case 'm':
case 'M':
/* Medium secret buffer */
bufSize = NSSCS_MID_SECRET_BUF_LEN;
break;
case 's':
case 'S':
/* set active flag to FALSE */
aFlag = 0;
printf("Silent Running Mode Active...\n");
break;
case 'c':
case 'C':
/* Run count */
exCount = atoi(optArg);
break;
default:
//* case '?':
//* case 'h':
//*case 'H':
printf("\nUsage: sshtst [/m]|[/b][/s /c=[count] /r=[rcount] | /? | /h ]\n");
printf("\tOptions: [ /m | /M ] for 4k Secret Buffer Size.\n");
printf("\tOptions: [ /b | /B ] for 59k Secret Buffer Size.\n");
printf("\tOptions: [ /s | /S ] for Silent Running.\n");
printf("\t\tSilent sub-Option [ /c | /C ] for number of times to run.\n");
printf("\tExample: sshtst /s /c=1000\n");
printf("\tOption: [ /h | /H | /? ] for Help.\n");
printf("\tNo command line options will activate interactive running.\n\n");
printf("\tFor options \"/\" and \"-\" are interchangable.\n\n");
exit(0);
}
}
}
else
{
printf("Full Interactive Running Mode Active...\n");
}
printf("Execution Count Set to: [%d]\n", exCount);
printf("Initializing...\n");
startTime = time(NULL);
printf("Done...\n");
Pause();
if((ssContext = miCASAOpenSecretStoreCache(&ssid, 0, NULL)) == NULL)
{
rcode = NSSCS_E_CANT_OPEN_CLIENT_CACHE;
printf("\nCache Failed to Open!!!\n");
goto ERROR_1;
}
else
{
printf("\nCache Opened...\n");
}
// retVal = miCASASetMasterPasscode(ssContext, &passcode, NULL);
/*
retVal = miCASASetMasterPasscode(0, &passcode, NULL);
if( retVal != 0 )
printf("miCASASetMasterPasscode failed\n");
else
printf("miCASASetMasterPasscode succeeded\n");
*/
keyChainID.len = SSCS_S_KC_ID_CHARS;
strcpy(keyChainID.keychainID, SSCS_SESSION_KEY_CHAIN_ID);
#ifdef NOT_IMPLEMENTED_YET
if(rcode = miCASAGetStoreInformation(ssContext, 0, &ssInfo, NULL))
{
printf("\nmiCASAGetStoreInformation Failed!!!\n");
goto ERROR_1;
}
if(ssInfo.numKeyChains == 0)
{
//* Create a Keychain
if(rcode = miCASAAddKeyChain(ssContext, SSCS_S_KC_ID_F, &keyChainID, NULL))
{
printf("\nmiCASAAddKeyChain Failed!!!\n");
goto ERROR_1;
}
}
#endif
//* Query the user to continue.
if(aFlag)
{
printf("\nDo you want to CONTINUE (y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(!((c == 'y') || (c == 'Y')))
{
aFlag = 0;
goto ERROR_1;
}
//* Query the user to continue.
if(aFlag)
{
printf("\nTest New APIs (y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(((c == 'y') || (c == 'Y')))
{
printf("Testing new APIs \r\n");
credential.unFlags = USERNAME_TYPE_CN_F;
strcpy((char*)credential.username, "SharedUsername");
strcpy((char*)credential.password, "SharedPassword");
/*
rcode = OpenThreadToken(
GetCurrentThread(),
TOKEN_QUERY | TOKEN_QUERY_SOURCE,
TRUE,
&phUserToken);
if (rcode ==0)
{
rcode = GetLastError();
}
rcode = GetTokenInformation(
phUserToken,
TokenStatistics,
&tokenStats,
dwSize,
&dwSize);
{
//NCXDebugPrintf2("[XTAGENT] GetTokenInformation for statistics returned LowPart 0x%X HighPart 0x%X\n", tokenStats.AuthenticationId.LowPart, tokenStats.AuthenticationId.HighPart);
printf("GetTokenInformation for statistics returned LowPart 0x%X HighPart 0x%X\n", tokenStats.AuthenticationId.LowPart, tokenStats.AuthenticationId.HighPart);
//*pLogonId = tokenStats.AuthenticationId;
}
*/
// sets the shared credential for this app
rcode = miCASASetCredential(
0,
&appSecretId, //char * appSecretID, // IN
&sharedSecretId, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
&ext //NULL //SSCS_EXT_T * ext // Reserved
);
credential.unFlags = USERNAME_TYPE_EMAIL_F;
strcpy((char*)credential.username, "SharedUsername@novell.com");
strcpy((char*)credential.password, "SharedPassword");
// sets the shared credential for this app
rcode = miCASASetCredential(
0,
&appSecretId, //char * appSecretID, // IN
&sharedSecretId, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
NULL //SSCS_EXT_T * ext // Reserved
);
credential.unFlags = USERNAME_TYPE_LDAP_DN_F;
strcpy((char*)credential.username, "cn=shareduser,o=novell");
strcpy((char*)credential.password, "SharedPassword");
// sets the shared credential for this app
rcode = miCASASetCredential(
0,
&appSecretId, //char * appSecretID, // IN
&sharedSecretId, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
NULL //SSCS_EXT_T * ext // Reserved
);
credential.unFlags = USERNAME_TYPE_NDS_DN_F;
strcpy((char*)credential.username, "SharedUsername.novell");
strcpy((char*)credential.password, "SharedPassword");
// sets the shared credential for this app
rcode = miCASASetCredential(
0,
&appSecretId, //char * appSecretID, // IN
&sharedSecretId, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
NULL //SSCS_EXT_T * ext // Reserved
);
credential.unFlags = USERNAME_TYPE_OTHER_F;
strcpy((char*)credential.username, "SharedUsernameOther");
strcpy((char*)credential.password, "SharedPassword");
// sets the shared credential for this app
rcode = miCASASetCredential(
0,
&appSecretId, //char * appSecretID, // IN
&sharedSecretId, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
NULL //SSCS_EXT_T * ext // Reserved
);
memset(&credential, 0, sizeof(SSCS_BASIC_CREDENTIAL));
strcpy((char*)credential.username, "AppUsername");
strcpy((char*)credential.password, "AppPassword");
// sets the secret specific to the app
rcode = miCASASetCredential(
0,
&appSecretId, //char * appSecretID, // IN
NULL, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
NULL //SSCS_EXT_T * ext // Reserved
);
memset(&credential, 0, sizeof(SSCS_BASIC_CREDENTIAL));
credential.unFlags = USERNAME_TYPE_NDS_DN_F;
// gets the sharedcredential
rcode = miCASAGetCredential(
0,
&appSecretId, //char * appSecretID, // IN
&sharedSecretId, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
NULL //SSCS_EXT_T * ext // Reserved
);
printf("Credential for Shared: %s\r\n", "SharedSecretID");
printf("Username: %s\r\n", credential.username);
printf("Password: %s\r\n", credential.password);
memset(&credential, 0, sizeof(SSCS_BASIC_CREDENTIAL));
// gets the specific credential
rcode = miCASAGetCredential(
0,
&appSecretId, //char * appSecretID, // IN
NULL, //char * sharedSecretID, // Optional IN
0, //int * credentialType, // IN/OUT
&credential, //void * credential, // OUT
NULL //SSCS_EXT_T * ext // Reserved
);
printf("Credential for APP: %s\r\n", "AppSecretID");
printf("Username: %s\r\n", credential.username);
printf("Password: %s\r\n", credential.password);
}
#if POORNA_TEST
//* Run the tests as many times as specified by the user.
for(j = 0, opCount = 0; j < exCount; j++)
{
#ifdef NOT_USED
// ***************************************************************************************
// run the CREATE Application SharedSecrets with an associated default Credential Set test
// ***************************************************************************************
if(aFlag)
{
printf("\nDo you want to CREATE Application SharedSecrets with\non associated default Credential Set(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
appTstFlag = 1;
for(i = 1; i < 6; i++)
{
// STEP 1: create the APPLICATTION (SS_App)
// ***************************************
// create the ID here
shSecret.type = SSCS_APPLICATION_TYPE_F;
strcpy(shSecret.name, appNames[i-1]);
shSecret.len = strlen(shSecret.name) + 1;
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
printf("\n\nFAILED to successfully create the secretHandle");
Pause();
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
// if the SS_APP already exist go the the next step
if(rcode != NSSCS_SUCCESS)
{
if((rcode != NSSCS_E_STORE_NOT_FOUND) && (rcode != NSSCS_E_INVALID_SECRET_ID))
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, appNames[i-1]);
Pause();
goto ERROR_1;
}
else
{
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
// create the value here (value is the the Cred Set ID)
strcpy(key, SSCS_CRED_SET);
strcpy((char *)value, credSetNames[i-1]);
vLen = (strlen((char *)value) + 1) * sizeof(char);
printf("\nCalling miCASA_AddSHSEntry\n");
if(rcode = miCASA_AddSHSEntry(secretHandle, key, vLen, value))
{
printf("\n\nmiCASA_AddSHSEntry returned [%d] when adding\n[%s] and [%s]\n\n", rcode, key, value);
Pause();
}
else
{
printf("\nAdded [%s]:[%s]\n", key, value);
}
printf("\nCalling miCASAWriteSecret\n");
if(rcode = miCASAWriteSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, NULL))
{
printf("\nmiCASAWriteSecret returned [%d] when storing [%s]:[%s]\nto [%s]\n\n", rcode, key, value, appNames[i-1]);
Pause();
goto ERROR_1;
}
else
{
printf("\nmiCASAWriteSecret SUCCEEDED\n");
}
}
}
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
// create the CredSet Here
// **********************************************************
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
printf("\n\nFAILED to successfully create a valid secretHandle");
Pause();
goto ERROR_1;
}
shSecret.type = SSCS_CREDENTIAL_TYPE_F;
strcpy(shSecret.name, credSetNames[i-1]);
shSecret.len = strlen(shSecret.name)+1;
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
if((rcode != NSSCS_E_STORE_NOT_FOUND) && (rcode != NSSCS_E_INVALID_SECRET_ID))
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, credSetNames[i-1]);
Pause();
goto ERROR_1;
}
else
{
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
// add user ID
strcpy(key, userKey);
strcpy((char *)value, userEntries[i-1]);
vLen = (strlen((char *)value) + 1) * sizeof(char);
printf("\nCalling miCASA_AddSHSEntry\n");
if(rcode = miCASA_AddSHSEntry(secretHandle, key, vLen, value))
{
printf("\nmiCASA_AddSHSEntry returned [%d] when adding \n[%s]:[%s]\nto [%s]\n\n", rcode, key, value, credSetNames[i-1]);
Pause();
}
else
{
printf("\nAdded [%s]=[%s]\n", key, value);
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
// add password
strcpy(key, passwordKey);
strcpy((char *)value, passwordEntries[i-1]);
vLen = (strlen((char *)value) + 1) * sizeof(char);
printf("\nCalling miCASA_AddSHSEntry\n");
if(rcode = miCASA_AddSHSEntry(secretHandle, key, vLen, value))
{
printf("\nmiCASA_AddSHSEntry returned [%d] when adding \n[%s]:[%s]\nto [%s]\n\n", rcode, key, value, credSetNames[i-1]);
Pause();
}
else
{
printf("\nAdded [%s]=[%s]\n", key, value);
}
printf("\nCalling miCASAWriteSecret\n");
if(rcode = miCASAWriteSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, NULL))
{
printf("\n\nmiCASAWriteSecret returned [%d] when storing\n[%s]:[%s]\nto [%s]\n\n", rcode, key, value, credSetNames[i-1]);
Pause();
goto ERROR_1;
}
else
{
printf("\nmiCASAWriteSecret SUCCEEDED\n");
}
}
}
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
}
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
if(appTstFlag)
{
// ***********************************************
// run the READ the Application SharedSecrets test
// ***********************************************
if(aFlag)
{
printf("\nDo you want to READ the Application SharedSecrets(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
for(i = 1; i < 6; i++)
{
shSecret.type = SSCS_APPLICATION_TYPE_F;
strcpy(shSecret.name, appNames[i-1]);
shSecret.len = strlen(shSecret.name)+1;
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
printf("\n\nFAILED to successfully create a valid secretHandle");
Pause();
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
printf("\nmiCASAReadSecret for SS_App returned [%d] when reading [%s]\n\n", rcode, appNames[i-1]);
Pause();
goto ERROR_1;
}
printf("\nCalling miCASA_GetNextSHSEntry\n");
if(!(rcode = miCASA_GetNextSHSEntry(1, secretHandle, &kLen, key, &vLen, value)))
{
do
{
if(strlen(key) == 0)
{
break;
}
strcpy(secret, key);
strcat(secret, ":");
strcat(secret, (char *)value);
printf("\nmiCASA_GetNextSHSEntry returned [%s]:[%s]\n", key, value);
// clear the buffers
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(secret, 0, NSSCS_MAX_SECRET_BUF_LEN);
break;
}
while(rcode == NSSCS_SUCCESS);
}
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
// now lets read the CredSet
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
printf("\n\nFAILED to successfully create a valid secretHandle");
Pause();
goto ERROR_1;
}
shSecret.type = SSCS_CREDENTIAL_TYPE_F;
// put the SS_APP value that is the CredSet ID in the secret ID for read
strcpy(shSecret.name, (char *)value);
shSecret.len = strlen(shSecret.name)+1;
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode)
{
printf("\nmiCASAReadSecret for SS_CredSets returned [%d] when reading [%s]\n\n", rcode, credSetNames[i-1]);
Pause();
goto ERROR_1;
}
if(!(rcode = miCASA_GetNextSHSEntry(1, secretHandle, &kLen, key, &vLen, value)))
{
do
{
if(strlen(key) == 0)
{
break;
}
printf("\nmiCASA_GetNextSHSEntry returned [%s]=[%s]\n", key, value);
// clear the buffers
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
rcode = miCASA_GetNextSHSEntry(0, secretHandle, &kLen, key, &vLen, value);
}
while(rcode == NSSCS_SUCCESS);
}
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////
// run the multiple CREATE Credential Sets for a single Application Secret SharedSecret test
////////////////////////////////////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to CREATE multiple Credential Secrets\nfor a single Application Secret(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
multiCredTstFlag = 1;
shSecret.type = SSCS_APPLICATION_TYPE_F;
strcpy(shSecret.name, multiCredApp);
shSecret.len = strlen(shSecret.name)+1;
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
printf("\n\nFAILED to successfully create a valid secretHandle");
Pause();
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
if((rcode != NSSCS_E_STORE_NOT_FOUND) && (rcode != NSSCS_E_INVALID_SECRET_ID))
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, multiCredApp);
Pause();
goto ERROR_1;
}
else
{
for(i = 1; i < 6; i++)
{
strcpy(key, SSCS_CRED_SET);
strcpy((char *)value, credSetNames[i-1]);
vLen = (strlen((char *)value) + 1) * sizeof(char);
printf("\nCalling miCASA_AddSHSEntry for [%s]\n", multiCredApp);
if(rcode = miCASA_AddSHSEntry(secretHandle, key, vLen, value))
{
printf("\nmiCASA_AddSHSEntry returned [%d] when adding [%s]/[%s]\nto [%s]\n\n", rcode, key, value, multiCredApp);
Pause();
}
else
{
printf("\nAdded [%s]:[%s]\n", key, value);
}
}
}
}
printf("\nCalling miCASAWriteSecret\n");
if(rcode = miCASAWriteSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, NULL))
{
printf("\n\nmiCASAWriteSecret returned [%d] when storing data in\n[%s]\n\n", rcode, multiCredApp);
Pause();
goto ERROR_1;
}
else
{
printf("\nmiCASAWriteSecret SUCCEEDED\n");
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
if(multiCredTstFlag)
{
/////////////////////////////////////////////////////////////////////////////////
// run the READ Credential Sets for a single Application Secret SharedSecret test
/////////////////////////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to READ the multiple Credential Secrets\nfor a single Application Secret(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
shSecret.type = SSCS_APPLICATION_TYPE_F;
strcpy(shSecret.name, multiCredApp);
shSecret.len = strlen(shSecret.name)+1;
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
printf("\n\nFAILED to successfully create a valid secretHandle");
Pause();
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, multiCredApp);
Pause();
goto ERROR_1;
}
printf("\nCalling miCASAGetNextEntry\n");
if(!(rcode = miCASA_GetNextSHSEntry(1, secretHandle, &kLen, key, &vLen, value)))
{
while(rcode == NSSCS_SUCCESS)
{
if(0 == strlen(key))
{
break;
}
strcpy(secret, key);
strcat(secret, ":");
strcat(secret, (char *)value);
printf("\nmiCASA_GetNextSHSEntry returned [%s]:[%s]\n", key, value);
// clear the buffers
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
memset(secret, 0, NSSCS_MAX_SECRET_BUF_LEN);
rcode = miCASA_GetNextSHSEntry(0, secretHandle, &kLen, key, &vLen, value);
}
}
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
}
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
#endif
///////////////////////////////////////////////////////////////////
// run the CREATE multiple entries for a single Credential Set test
///////////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to CREATE multiple entries for a single Credential Set(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
multiEntryTstFlag = 1;
shSecret.type = SSCS_CREDENTIAL_TYPE_F;
strcpy(shSecret.name, multiEntryCredSet);
shSecret.len = strlen(shSecret.name)+1;
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
if((rcode != NSSCS_E_STORE_NOT_FOUND) && (rcode != NSSCS_E_INVALID_SECRET_ID))
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, multiEntryCredSet);
Pause();
goto ERROR_1;
}
}
for(i = 1; i < 6; i++)
{
strcpy(key, mKeyEntries[i-1]);
strcpy((char *)value, mValEntries[i-1]);
vLen = (strlen((char *)value) + 1) * sizeof(char);
printf("\nCalling miCASA_AddSHSEntry\n");
if(!(rcode = miCASA_AddSHSEntry(secretHandle, key, vLen, value)))
{
printf("\nAdded [%s]=[%s]\n", key, value);
}
else
{
printf("\nmiCASA_AddSHSEntry returned [%d] when adding [%s]=[%s]\n\n", rcode, key, value);
Pause();
}
}
printf("\nCalling miCASAWriteSecret\n");
if(rcode = miCASAWriteSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, NULL))
{
printf("\nmiCASAWriteSecret returned [%d] when storing\n[%s]:[%s]\nto [%s]\n\n", rcode, key, value, multiEntryCredSet);
Pause();
goto ERROR_1;
}
else
{
printf("\nmiCASAWriteSecret SUCCEEDED\n");
}
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
//if(multiEntryTstFlag)
if(1)
{
/////////////////////////////////////////////////////////////
// READ the multiple entries in the single Credential Set test
/////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to READ the multiple entries in the single Credential Set(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
shSecret.type = SSCS_CREDENTIAL_TYPE_F;
strcpy(shSecret.name, multiEntryCredSet);
shSecret.len = strlen(shSecret.name)+1;
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, multiEntryCredSet);
Pause();
goto ERROR_1;
}
printf("\nCalling miCASA_GetNextSHSEntry\n");
if(!(rcode = miCASA_GetNextSHSEntry(1, secretHandle, &kLen, key, &vLen, value)))
{
while(rcode == NSSCS_SUCCESS)
{
if(0 == strlen(key))
{
break;
}
strcpy(secret, key);
strcat(secret, "=");
strcat(secret, (char *)value);
printf("\nmiCASA_GetNextSHSEntry returned [%s]=[%s]\n\n", key, value);
// clear the buffers
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
memset(secret, 0, NSSCS_MAX_SECRET_BUF_LEN);
rcode = miCASA_GetNextSHSEntry(0, secretHandle, &kLen, key, &vLen, value);
}
}
miCASA_DestroySHSHandle(secretHandle); // destroy the secretHandle
}
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
// ***************************************************
// ********* Enumerting Secrets *********
// ***************************************************
printf("\nEnumerating the Secrets .... ");
shSecIDList.enumHandle = 1;
shSecIDList.returnedIDs = 5;
shSecIDList.secIDList = (SSCS_SH_SECRET_ID_T *)malloc(5 * sizeof(SSCS_SH_SECRET_ID_T));
if(shSecIDList.secIDList)
{
memset(shSecIDList.secIDList, 0 , 5 * sizeof(SSCS_SH_SECRET_ID_T));
do
{
if((rcode = miCASAEnumerateSecretIDs(ssContext, &keyChainID, 0, NULL, &shSecIDList, NULL)) == NSSCS_SUCCESS)
{
for(i = 0; i < (int)shSecIDList.returnedIDs; i++)
{
if(shSecIDList.secIDList[i].type & SSCS_APPLICATION_TYPE_F)
{
printf("\nSS_App: SecretID type .... ");
}
else if(shSecIDList.secIDList[i].type & SSCS_CREDENTIAL_TYPE_F)
{
printf("\nSS_CredSet: SecretID type .... ");
}
else if(shSecIDList.secIDList[i].type & SSCS_BINARY_TYPE_F)
{
printf("\nSS_Binary: SecretID type .... ");
}
else
{
printf("\n Unsupported SecretID type .... ");
}
printf("\nLength of the SecretID [%ld]\n", shSecIDList.secIDList[i].len);
printf("SecretID [%s]\n", shSecIDList.secIDList[i].name);
}
}
else
{
// resize the array based on the count returned because the cache engine below
// does not support iterations
if(rcode == NSSCS_E_ENUM_BUFF_TOO_SHORT)
{
shSecIDList.enumHandle = 1;
free(shSecIDList.secIDList);
shSecIDList.secIDList = (SSCS_SH_SECRET_ID_T *)malloc(shSecIDList.returnedIDs * sizeof(SSCS_SH_SECRET_ID_T));
}
if((rcode = miCASAEnumerateSecretIDs(ssContext, &keyChainID, 0, NULL, &shSecIDList, NULL)) == NSSCS_SUCCESS)
{
for(i = 0; i < (int)shSecIDList.returnedIDs; i++)
{
if(shSecIDList.secIDList[i].type & SSCS_APPLICATION_TYPE_F)
{
printf("\nSS_App: SecretID type .... ");
}
else if(shSecIDList.secIDList[i].type & SSCS_CREDENTIAL_TYPE_F)
{
printf("\nSS_CredSet: SecretID type .... ");
}
else if(shSecIDList.secIDList[i].type & SSCS_BINARY_TYPE_F)
{
printf("\nSS_Binary: SecretID type .... ");
}
else
{
printf("\n Unsupported SecretID type .... ");
}
printf("\nLength of the SecretID [%ld]\n", shSecIDList.secIDList[i].len);
printf("SecretID [%s]\n", shSecIDList.secIDList[i].name);
}
}
}
}
while(shSecIDList.enumHandle);
}
else
{
printf("\nEnum Malloc fialed .... ");
}
if(multiEntryTstFlag)
{
///////////////////////////////////////////////////////////////////////////
// run the REMOVE the multiple entries from the single Credential Set test
///////////////////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to REMOVE the multiple entries from the single Credential Set(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
shSecret.type = SSCS_CREDENTIAL_TYPE_F;
strcpy(shSecret.name, multiEntryCredSet);
shSecret.len = strlen(shSecret.name)+1;
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
if((rcode != NSSCS_E_STORE_NOT_FOUND) && (rcode != NSSCS_E_INVALID_SECRET_ID))
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, multiEntryCredSet);
Pause();
goto ERROR_1;
}
}
// Remove only the entries we added.
for(i = 1; i < 6; i++)
{
strcpy(key, mKeyEntries[i-1]);
strcpy((char *)value, mValEntries[i-1]);
strcpy(shSecret.name, multiEntryCredSet);
shSecret.len = strlen(shSecret.name)+1;
kLen = strlen(key)+1;
vLen = (strlen((char *)value) + 1) * sizeof(char);
printf("\nCalling miCASA_RemoveSHSEntry\n");
if(!(rcode = miCASA_RemoveSHSEntry(secretHandle, key, vLen, value)))
{
printf("Removed [%s]=[%s]\n", key, value);
}
else
{
printf("FAILED to remove [%s]:[%s]\nfrom [%s]\n\n", key, value, multiEntryCredSet);
}
// clear the buffers
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
}
printf("\nCalling miCASAWriteSecret\n");
if(rcode = miCASAWriteSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, NULL))
{
printf("\nmiCASAWriteSecret returned [%d] when storing data in\n[%s]\n\n", rcode, multiEntryCredSet);
Pause();
goto ERROR_1;
}
else
{
printf("\nmiCASAWriteSecret SUCCEEDED\n");
}
rcode = miCASA_DestroySHSHandle(secretHandle);
}
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
if(multiCredTstFlag)
{
///////////////////////////////////////////////////////////////////////////////////////////
// run the REMOVE the multiple Credential Sets from the single Application Test Secret test
///////////////////////////////////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to REMOVE the multiple Credential Sets\nfrom the single Application Test Secret(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
// Remove only the Cred Sets we added.
strcpy(shSecret.name, multiCredApp);
shSecret.len = strlen(shSecret.name)+1;
shSecret.type = SSCS_APPLICATION_TYPE_F;
strcpy(key, SSCS_CRED_SET);
secretHandle = miCASA_CreateSHSHandle(); // create a new secretHandle
if(!secretHandle)
{
goto ERROR_1;
}
printf("\nCalling miCASAReadSecret\n");
rcode = miCASAReadSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, &rInfo, NULL);
if(rcode != NSSCS_SUCCESS)
{
if((rcode != NSSCS_E_STORE_NOT_FOUND) && (rcode != NSSCS_E_INVALID_SECRET_ID))
{
printf("\nmiCASAReadSecret returned [%d] when reading [%s]\n\n", rcode, multiCredApp);
Pause();
goto ERROR_1;
}
}
for(i = 1; i < 6; i++)
{
strcpy((char *)value, credSetNames[i-1]);
printf("\nCalling miCASA_RemoveSHSEntry\n");
kLen = strlen(key)+1;
vLen = (strlen((char *)value) + 1) * sizeof(char);
if(!(rcode = miCASA_RemoveSHSEntry(secretHandle, key, vLen, value)))
{
printf("\nRemoved [%s]:[%s]\n", key, value);
}
else
{
printf("\nmiCASA_RemoveSHSEntry returned [%d] when removing [%s]:[%s] from [%s]\n\n", rcode, key, value, credSetNames[i-1]);
}
}
// clear the buffers
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
printf("\nCalling miCASAWriteSecret\n");
if(rcode = miCASAWriteSecret(ssContext, &keyChainID, 0, secretHandle, &shSecret, NULL, NULL))
{
printf("\nmiCASAWriteSecret returned [%d] when storing data in\n[%s]\n\n", rcode, multiCredApp);
Pause();
goto ERROR_1;
}
else
{
printf("\nmiCASAWriteSecret SUCCEEDED\n");
}
rcode = miCASA_DestroySHSHandle(secretHandle);
}
}
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
if(multiCredTstFlag)
{
//////////////////////////////////////////////////////
// run the REMOVE the Credential Set Test Secrets test
//////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to REMOVE the Credential Set Test Secrets(y/n)?\n");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
for(i = 1; i < 6; i++)
{
strcpy(shSecret.name, credSetNames[i-1]);
shSecret.type = SSCS_CREDENTIAL_TYPE_F;
// remove one secret at a time
if(rcode = miCASARemoveSecret(ssContext, &keyChainID, 0, &shSecret, NULL, NULL))
{
printf("miCASARemoveSharedSecret returned [%d] when removing [%s]\n\n", rcode, shSecret.name);
Pause();
}
else
{
printf("\nRemoved [%s]\n", credSetNames[i-1]);
}
memset(shSecret.name, 0, NSSCS_MAX_SECRET_ID_LEN);
}
}
}
if(appTstFlag)
{
///////////////////////////////////////////////////
// run the REMOVE the Application Test Secrets test
///////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to REMOVE the Application Test Secrets(y/n)? ");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
// Remove only the Application SharedSecrets we added.
for(i = 1; i < 6; i++)
{
strcpy(shSecret.name, appNames[i-1]);
shSecret.type = SSCS_APPLICATION_TYPE_F;
// remove one secret at a time
if(rcode = miCASARemoveSecret(ssContext, &keyChainID, 0, &shSecret, NULL, NULL))
{
printf("miCASARemoveSharedSecret returned [%d] when removing [%s]\n\n", rcode, shSecret.name);
Pause();
}
else
{
printf("\nRemoved [%s]\n", appNames[i-1]);
}
memset(shSecret.name, 0, NSSCS_MAX_SECRET_ID_LEN);
}
}
}
if(appTstFlag)
{
///////////////////////////////////////////////////////////////
// run the REMOVE the multiple CredSet Application Test Secret
///////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to REMOVE the multiple CredSet Application Test Secret(y/n)?\n");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
strcpy(shSecret.name, multiCredApp);
shSecret.type = SSCS_APPLICATION_TYPE_F;
// remove one secret at a time
if(rcode = miCASARemoveSecret(ssContext, &keyChainID, 0, &shSecret, NULL, NULL))
{
printf("miCASARemoveSharedSecret returned [%d] when removing [%s]\n\n", rcode, shSecret.name);
Pause();
}
else
{
printf("\nRemoved [%s]\n", multiCredApp);
}
memset(shSecret.name, 0, NSSCS_MAX_SECRET_ID_LEN);
}
}
if(multiEntryTstFlag)
{
/////////////////////////////////////////////////////////////
// run the REMOVE the multiple entry Application Test Secret
/////////////////////////////////////////////////////////////
if(aFlag)
{
printf("\nDo you want to REMOVE the multiple entry Application Test Secret(y/n)?\n");
c = getch();
putchar(c);
printf("\n\n");
}
else
{
c = 'y';
}
if(c == 'y' || c == 'Y')
{
strcpy(shSecret.name, multiEntryCredSet);
shSecret.type = SSCS_CREDENTIAL_TYPE_F;
// remove one secret at a time
if(rcode = miCASARemoveSecret(ssContext, &keyChainID, 0, &shSecret, NULL, NULL))
{
printf("miCASARemoveSharedSecret returned [%d] when removing [%s]\n\n", rcode, shSecret.name);
Pause();
}
else
{
printf("\nRemoved [%s]\n", multiEntryCredSet);
}
memset(shSecret.name, 0, NSSCS_MAX_SECRET_ID_LEN);
}
}
opCount++;
printf("\n\n\n");
printf("NUMBER OF THE LOOPS = %d\n", j+1);
printf("NUMBER OF OPERATIONS COMPLETED = %d\n", opCount);
} /* end for */
endTime = time(NULL);
printf("ELAPSED TIME IN SECONDS = [%ld]\n\n", (endTime - startTime));
#endif
/* ########################## CODE EXITS HERE ##################### */
ERROR_1:
if(secret)
{
memset(secret, 0, NSSCS_MAX_SECRET_BUF_LEN);
free(secret);
}
if(value)
{
memset(value, 0, NSSCS_MAX_SECRET_BUF_LEN);
free(value);
}
if(key)
{
memset(key, 0, NSSCS_MAX_SECRET_ID_LEN);
free(key);
}
if(ssContext)
{
rcode = miCASACloseSecretStoreCache(ssContext, 0, NULL);
}
if(shSecIDList.secIDList)
{
free(shSecIDList.secIDList);
}
Pause();
exit(rcode);
/* ########################## CODE ENDS HERE ##################### */
}