/***********************************************************************
*
* 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.
*
***********************************************************************/
#ifndef _SSCS_CACHE_H
#define _SSCS_CACHE_H
#if defined(__cplusplus) || defined(c_plusplus)
extern "C"
{
#endif
//#include <wchar.h>
#include <sscs_sdk.h>
#include <sscs_utf8.h>
#include <micasa_types.h>
#include <malloc.h>
/* Predefined Key Chains */
/* SSCS_HIDDEN_LOCAL_KEY_CHAIN_F should not be used by the applications */
#define SSCS_HIDDEN_LOCAL_KEY_CHAIN_F 0x00000001L
/* Hidden local key chain is used only by sscs. Not visible to applications. */
#define SSCS_SH_KC_ID (SSCS_SESSION_KEY_CHAIN_F | SSCS_HIDDEN_KEY_CHAIN_F)
#if 0
static wchar_t SSCS_HIDDEN_LOCAL_KEY_CHAIN_ID[] =
{'S','S','C','C','S','_','H','I','D','D','E','N','_','L','O','C','A','L','_','K','E','Y','_','C','H','A','I','N','_','I','D', 0};
static wchar_t SSCS_RESERVED1_KEY_CHAIN_ID[] =
{'S','S','C','C','S','_','R','E','S','E','R','V','E','D','1','_','K','E','Y','_','C','H','A','I','N','_','I','D', 0};
static wchar_t SSCS_RESERVED2_KEY_CHAIN_ID[] =
{'S','S','C','C','S','_','R','E','S','E','R','V','E','D','2','_','K','E','Y','_','C','H','A','I','N','_','I','D', 0};
#endif
static SS_UTF8_T SSCS_HIDDEN_LOCAL_KEY_CHAIN_ID[] = "SSCS_HIDDEN_LOCAL_KEYCHAIN_ID";
static SS_UTF8_T SSCS_RESERVED1_KEY_CHAIN_ID[] = "SSCS_RESERVED1_KEYCHAIN1_ID";
static SS_UTF8_T SSCS_RESERVED2_KEY_CHAIN_ID[] = "SSCS_RESERVED2_KEYCHAIN2_ID";
//#define SSCS_WIN32_PLAT_F 1
//#define SSCS_LINUX_PLAT_F 2
#define SSCS_PASSWORD_MP_F 1
#define SSCS_CRED_MP_F 2
#define NSSCS_MAX_ID_LEN 256
typedef struct _sscs_linux_ss_handle
{
int32_t socketID;
} SSCS_LINUX_SS_HANDLE_T;
typedef struct _sscs_win32_ss_handle
{
int32_t tobediceded;
} SSCS_WIN32_SS_HANDLE_T;
typedef struct _sscs_secretstore_handle
{
int32_t platformID;
void *platHandle;
} SSCS_SECRETSTORE_HANDLE_T;
typedef struct _sscs_keychain_info
{
uint32_t flags;
uint32_t numSecrets;
uint32_t numOfHiddenSecrets;
uint32_t numOfDeletedSecs;
uint32_t enumBufsize;
SSCS_KEYCHAIN_ID_T keyChainID;
} SSCS_KEYCHAIN_INFO_T;
// * Secret Data type
typedef struct _sscs_secret
{
int32_t len;
uint8_t *data;
} SSCS_SECRET_T;
typedef struct _sscs_context_t
{
int32_t version;
int32_t flags;
SSCS_SECRETSTORE_T ssid;
void *ssHandle;
SSCS_KEYCHAIN_ID_LIST_T *kcids;
} SSCS_CONTEXT_T;
/* Starts a session with the cache and returns a handle to the cache.
* Parametrs:
* secretStoreID
* (IN) Points to SecretStoreID structure.
*
* Return Values:
* returns a pointer to SecretStoreHandle structure.
*/
void* sscs_CacheOpenSecretStore
(
void *secretStoreID,
uint32_t ssFlags,
void *reserved
);
/* Closes the secretstore and destroys the SecretStore context for that
* application.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
*
* Return Values
*
*/
int sscs_CacheCloseSecretStore
(
void *ssHandle,
uint32_t ssFlags,
void *reserved
);
/* Removes all application defined keychains from the store. It also removes
* secrets stored in system defined keychains.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
*
* Return Values:
*/
int sscs_CacheRemoveSecretStore
(
void *ssHandle,
uint32_t ssFlags,
void *reserved
);
/* Enumerates key chain ids available in the store.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
*
* kcIDList
* (OUT) Points to the key chain id enumeration structure. Points to
* KeyChainIDList structure.
*
*
* Return Values:
*
*/
int sscs_CacheEnumerateKeychainIDs
(
void *ssHandle,
uint32_t ssFlags,
SSCS_SRCH_KEY_T *searchKey,
SSCS_KEYCHAIN_ID_LIST_T *kcIDList,
void *reserved
);
/* Creates a new keychain in the store.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
* ssFlags
* (IN) Can be a combination of following flags:
* SSCS_SESSION_KEY_CHAIN_F
* SSCS_LOCAL_KEY_CHAIN_F
* SSCS_REMOTE_KEY_CHAIN_F
* keychainID
* (IN) Specifies the unique keychain ID within the secretstore.
*
*/
int sscs_CacheAddKeychain
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
void *reserved
);
/* Removes the specified keychain from the store.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
* keychainID
* (IN) Specifies the unique keychain ID within the secretstore.
*
* Return Values:
*/
int sscs_CacheRemoveKeychain
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
void *reserved
);
/* Enumerates secret ids in a given keychain.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
* keyChainID
* (IN) handle obtained during sscs_CacheOpenKeychain.
*
*
* secretIDList
* (OUT) Points to the secret id enumeration structure. Points to
* SecretIDList structure.
*
* Return Values:
*/
int sscs_CacheEnumerateSecretIDs
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_SRCH_KEY_T *searchKey,
SSCS_SECRET_ID_LIST_T *secretIDList,
void *reserved
);
/* Reads Secret value for a given Secret ID in a given keychain.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
* keyChainID
* (IN) KeyChainID where the specified SecretID stored.
*
* secretID
* (IN) Specifies the unique secret ID within the keychain. This data is
* encoded in SSCS_SECRET_ID_T.
*
* secretData
* (IN/OUT) Specifies the information of the secret stored w.r.t the secretID.
* Points to a SSCS_SECRET_T structure.
*
* epPassword
* (IN) Points to an optional field to pass in the Enhanced Protection Password
* for reading a secret.When the password is not present, you can pass in a NULL.
*
* bytesRequired
* (OUT) Specifies the buffer requirement if it is not possible
* to copy Secret data in the buffer passed by the application.
*
* Return Values :
*/
int sscs_CacheReadSecret
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_SECRET_ID_T *secretID,
SSCS_SECRET_T *secretData,
SSCS_PASSWORD_T *epPassword,
uint32_t *bytesRequired,
void *reserved
);
/* Writes Secret value for a given Secret ID in a given keychain.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
* ssFlags
* (IN) ...
*
* keyChainID
* (IN) KeyChainID where the specified SecretID stored.
*
* secretID
* (IN) Specifies the unique secret ID within the keychain. This data is
* encoded in SSCS_SECRET_ID_T.
*
* secretData
* (IN) Specifies the information of the secret stored w.r.t the secretID.
* Points to a SSCS_SECRET_T structure.
*
*
* epPassword
* (IN) Points to an optional field to pass in the Enhanced Protection Password
* for reading a secret.When the password is not present, you can pass in a NULL.
*
*
*
* Return Values:
*/
int sscs_CacheWriteSecret
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_SECRET_ID_T *secretID,
SSCS_SECRET_T *secretData,
SSCS_PASSWORD_T *epPassword,
void *reserved
);
/* Removes Secret for a given Secret ID in a given keychain.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context information regarding the SecretStore.
*
*
* keyChainID
* (IN) KeyChainID where the specified SecretID stored.
*
* secretID
* (IN) Specifies the unique secret ID within the keychain. This data is
* encoded in SSCS_SECRET_ID_T.
*
*
* epPassword
* (IN) Points to an optional field to pass in the Enhanced Protection Password
* for reading a secret.When the password is not present, you can pass in a NULL.
*
* Return Values:
*/
int sscs_CacheRemoveSecret
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_SECRET_ID_T *secretID,
SSCS_PASSWORD_T *epPassword,
void *reserved
);
/* Returns statistical information regarding the SecretStore and its Keychains.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context with respect to the instance of open cache in it.
*
*
* ssInfo
* (OUT) This structure contains the statistical information regarding the
* SecretStore and its Keychains.
*
* Return Values:
*/
int sscs_CacheGetSecretStoreInfo
(
void *ssHandle,
uint32_t ssFlags,
SSCS_SECRETSTORE_INFO_T *ssInfo,
void *reserved
);
/* Retrieves the statistical information regarding the target Keychain.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context with respect to the instance of open cache in it.
*
* keyChainID
* (IN) KeyChainID where the specified SecretID stored.
*
*
* kcInfo
* (OUT) This structure contains the statistical information regarding the
* Keychain.
*
*
* Return Values:
*/
int sscs_CacheGetKeychainInfo
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_KEYCHAIN_INFO_T *kcInfo,
void *reserved
);
/* This call locks that cache to prevent access until the MasterPassword is
* supplied.
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context with respect to the instance of open cache in it.
*
* Return Values :
*/
int sscs_LockCache
(
void *ssHandle,
uint32_t ssFlags,
void *reserved
);
/* This unlocks previously locked cache using the MasterPassword
*
* Parameters:
* ssHandle
* (IN) Handle returned by sscs_CacheOpenSecretStore function. This will have
* context with respect to the instance of open cache in it.
* masterPassword
*
* Return Values :
*/
int sscs_UnlockCache
(
void *ssHandle,
uint32_t ssFlags,
SSCS_PASSCODE_T *passcode,
void *reserved
);
int sscs_CacheWriteKey
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_SECRET_ID_T *secretID,
SS_UTF8_T *key,
uint32_t keyLen,
uint8_t *val,
int32_t valLen,
SSCS_PASSWORD_T *epPassword,
void *reserved
);
int sscs_CacheWriteBinaryKey
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_SECRET_ID_T *secretID,
SS_UTF8_T *key,
uint32_t keyLen,
uint8_t *val,
uint32_t valLen,
SSCS_PASSWORD_T *epPassword,
void *reserved
);
int sscs_CacheReadKey
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keychainID,
SSCS_SECRET_ID_T *secretID,
SS_UTF8_T *key,
uint32_t keyLen,
uint8_t *val,
uint32_t *valLen,
SSCS_PASSWORD_T *epPassword,
uint32_t *bytesRequired,
void *reserved
);
int sscs_CacheReadBinaryKey
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keychainID,
SSCS_SECRET_ID_T *secretID,
SS_UTF8_T *key,
uint32_t keyLen,
uint8_t *val,
uint32_t *valLen,
SSCS_PASSWORD_T *epPassword,
uint32_t *bytesRequired,
void *reserved
);
int32_t sscs_SetMasterPasscode
(
void *ssHandle,
SSCS_PASSCODE_T *passcode,
void *reserved
);
int32_t sscs_SetMasterPassword
(
void *ssHandle,
SSCS_PASSWORD_T *password,
SSCS_HINT_T *hint,
void *reserved
);
int sscs_IsSecretPersistent
(
void *ssHandle,
uint32_t ssFlags,
SSCS_KEYCHAIN_ID_T *keyChainID,
SSCS_SECRET_ID_T *secretID,
void *reserved
);
#if defined(__cplusplus) || defined(c_plusplus)
}
#endif
#endif /* _SSCS_CACHE_H */