1426 lines
36 KiB
C#
1426 lines
36 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Collections.Specialized;
|
|
using System.Collections;
|
|
|
|
using Novell.CASA.MiCasa.Communication;
|
|
using Novell.CASA.MiCasa.Common;
|
|
|
|
namespace Novell.CASA
|
|
{
|
|
/// <summary>
|
|
/// Summary description for NativeCalls.
|
|
/// </summary>
|
|
public class NativeCalls
|
|
{
|
|
private static SSCS_KEYCHAIN_ID_T DefaultKeychainID = null;
|
|
private static int SSCS_CRED_TYPE_BASIC_F = 1;
|
|
private static int USERNAME_LEN = 256;
|
|
private static int PASSWORD_LEN = 128;
|
|
|
|
public NativeCalls()
|
|
{
|
|
//
|
|
// TODO: Add constructor logic here
|
|
//
|
|
if (DefaultKeychainID == null)
|
|
{
|
|
DefaultKeychainID = new SSCS_KEYCHAIN_ID_T();
|
|
}
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_PASSWORD_T
|
|
{
|
|
public uint pwordType;
|
|
public uint pwordLen; // * enhanced protection len & pword to set
|
|
// [MarshalAs(UnmanagedType.LPStr, SizeConst = 128)]
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
|
|
public string pword; // * should be passed in # of chars
|
|
} ;
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_PASSCODE_T
|
|
{
|
|
public uint passcodeType;
|
|
public IntPtr passcodeHandle;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_KEYCHAIN_ID_T
|
|
{
|
|
public int len;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
|
|
public string keychainID;
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SH_SECRET_ID_T
|
|
{
|
|
public int type; // The shared secret type i.e. SS_App or SS_CredSet
|
|
public int len; // except that it excludes the header and is not escaped.
|
|
[MarshalAs(UnmanagedType.ByValTStr , SizeConst = 512)]
|
|
public string name; // The shared secret name. This is the same as the identifier
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SECRET_STORE_ID_T
|
|
{
|
|
public int len; // * max id len in bytes
|
|
[MarshalAs(UnmanagedType.LPStr, SizeConst = 512)]
|
|
public string id; // * should be passed in # of chars
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SECRET_ID_T
|
|
{
|
|
public int len; // * max id len in bytes
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
|
|
public string id; // * should be passed in # of chars
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
|
public class SSCS_HINT_T
|
|
{
|
|
ulong hintLen;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
|
|
string hint; //* should be passed in # of chars
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_EXT_T
|
|
{
|
|
public int extID; // defined to identify the extension
|
|
public int version; // defined as the version of the specified extension
|
|
public IntPtr ext; // points to the actual extension
|
|
} ;
|
|
/*
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SECRETSTORE_INF_T
|
|
{
|
|
uint numKeyChains;
|
|
uint enumBufsize;
|
|
};
|
|
*/
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SRCH_KEY_T
|
|
{
|
|
public uint srchKeyLen;
|
|
[MarshalAs(UnmanagedType.LPStr, SizeConst = 128)]
|
|
public string srchKey; //[NSSCS_MAX_SRCH_KEY_LEN]; //* should be passed in # of chars
|
|
} ;
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SECRET_ID_LIST_T
|
|
{
|
|
public uint enumHandle;
|
|
public uint returnedIDs;
|
|
public IntPtr secretIDList; //* an array of secretID structures
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SH_SECRET_ID_LIST_T
|
|
{
|
|
public uint enumHandle;
|
|
public uint returnedIDs;
|
|
public IntPtr secretIDList; //* an array of secretID structures
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_CONTEXT_T
|
|
{
|
|
public int version;
|
|
public int flags;
|
|
public SSCS_SECRET_ID_T ssid;
|
|
public UInt64 ssHandle;
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_READEXT_T
|
|
{
|
|
public uint statFlags; //* OUT - return flags on the secret
|
|
public uint crtStamp; //* OUT - secret creation time stamp
|
|
public uint latStamp; //* OUT - last accessed time stamp (optional)
|
|
public uint lmtStamp; //* OUT - last modified time stamp
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_SECRETSTORE_INFO_T
|
|
{
|
|
public UInt32 statFlags;
|
|
public UInt32 secretCount;
|
|
public UInt32 lockCount;
|
|
public UInt32 enumBufLen;
|
|
public UInt32 hidSecCount;
|
|
public UInt32 clientVersion;
|
|
public UInt32 serverVersion;
|
|
public UInt32 serverCryptoStrength;
|
|
public UInt32 clientCryptoStrength;
|
|
public UInt32 unlockTStamp;
|
|
public UInt32 admnDNLen;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 516)]
|
|
public string admnDN; //[NSSS_MAX_DN_LEN];
|
|
public UInt32 hintLen;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
|
|
public string hint; //[NSSS_MAX_MP_PWORD_HINT_LEN]];
|
|
};
|
|
|
|
/*
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_BASIC_CREDENTIAL
|
|
{
|
|
public uint unFlags;
|
|
public uint unLen;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
|
|
public string username;
|
|
public uint pwordLen;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
|
|
public string password;
|
|
}
|
|
*/
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public class SSCS_BASIC_CREDENTIAL_UTF8
|
|
{
|
|
public uint unFlags;
|
|
public uint unLen;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
|
|
public byte[] username;
|
|
public uint pwordLen;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
|
|
public byte[] password;
|
|
}
|
|
|
|
// * The following functions will be exposed as exported API:
|
|
// **************************************************************
|
|
// * These function calls will utilize the Support Functions for
|
|
// * populating or extracting data from a Shared Secret.
|
|
// **************************************************************
|
|
|
|
private const string NDK_LIBRARY = "micasa";
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASARemoveCredential
|
|
(
|
|
[In] uint ssFlags, // IN
|
|
[In] SSCS_SECRET_ID_T appSecretID,
|
|
[In] SSCS_SECRET_ID_T sharedSecretID,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAGetCredential
|
|
(
|
|
[In] uint ssFlags, // IN
|
|
[In] SSCS_SECRET_ID_T appSecretID,
|
|
[In] SSCS_SECRET_ID_T sharedSecretID,
|
|
int credentialType, // IN
|
|
[In, Out] IntPtr pCredential,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASASetCredential
|
|
(
|
|
[In] uint ssFlags, // IN
|
|
[In] SSCS_SECRET_ID_T appSecretID,
|
|
[In] SSCS_SECRET_ID_T sharedSecretID,
|
|
int credentialType, // IN
|
|
[In] IntPtr credential,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASASetMasterPasscode
|
|
(
|
|
[In] uint ssFlags,
|
|
[In] SSCS_PASSCODE_T passcode,
|
|
[In] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAIsSecretPersistent
|
|
(
|
|
[In] uint ssFlags,
|
|
[In] SSCS_SECRET_ID_T secretID,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern IntPtr miCASAOpenSecretStoreCache
|
|
(
|
|
[In, Out] SSCS_SECRET_STORE_ID_T ssid,
|
|
ulong ssFlags,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASACloseSecretStoreCache
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
|
|
[DllImport(NDK_LIBRARY) ]
|
|
public static extern int miCASAReadSecret
|
|
(
|
|
[In] IntPtr context,
|
|
[In] SSCS_KEYCHAIN_ID_T keyChainID,
|
|
[In] uint ssFlags,
|
|
[In] IntPtr secretHandle,
|
|
[In] SSCS_SH_SECRET_ID_T sharedSecretID,
|
|
[In] SSCS_PASSWORD_T epPassword,
|
|
[In, Out] SSCS_READEXT_T readData,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
|
|
// TODO: check the order of these paramters
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASARemoveSecret
|
|
(
|
|
[In] IntPtr context,
|
|
[In] SSCS_KEYCHAIN_ID_T keyChainID,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_SH_SECRET_ID_T sharedSecretID,
|
|
[In] SSCS_PASSWORD_T epPassword,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAWriteSecret
|
|
(
|
|
[In] IntPtr context,
|
|
[In] SSCS_KEYCHAIN_ID_T keyChainID,
|
|
[In] uint ssFlags,
|
|
[In] IntPtr secretHandle,
|
|
[In] SSCS_SH_SECRET_ID_T sharedSecretID,
|
|
[In] SSCS_PASSWORD_T epPassword,
|
|
[In] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAGetStoreInformation
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In, Out] SSCS_SECRETSTORE_INFO_T ssInfo,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAEnumerateSecretIDs
|
|
(
|
|
[In] IntPtr context,
|
|
[In] SSCS_KEYCHAIN_ID_T keyChainID,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_SRCH_KEY_T searchKey,
|
|
[In, Out] SSCS_SH_SECRET_ID_LIST_T secretIDList,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAEnumerateKeyChainIDs
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_SRCH_KEY_T searchKey,
|
|
[In, Out] SSCS_SECRET_ID_LIST_T kcIDList,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASARemoveSecretStore
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASASetMasterPassword
|
|
(
|
|
[In] uint ssFlags,
|
|
[In] SSCS_PASSWORD_T password,
|
|
[In] SSCS_HINT_T hint,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAUnlockSecrets
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_PASSWORD_T password,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASALockStore
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAUnlockStore
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_PASSWORD_T password,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASARemoveKeyChain
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_KEYCHAIN_ID_T keyChainID,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASAAddKeyChain
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_KEYCHAIN_ID_T keyChainID,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
//**************************************************************
|
|
//* Support Functions for processing (populating or extracting)
|
|
//* data components from a Shared Secret
|
|
//**************************************************************
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern IntPtr miCASA_CreateSHSHandle();
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASA_DestroySHSHandle(
|
|
[In] IntPtr secretHandle);
|
|
|
|
|
|
[DllImport(NDK_LIBRARY, CharSet=CharSet.None) ]
|
|
public static extern int miCASA_GetNextSHSEntry
|
|
(
|
|
[In] int restart, //* in (set to 1 to begin from head of list)
|
|
[In] IntPtr secretHandle, //* in
|
|
[In, Out] ref uint keyLen, //* out
|
|
IntPtr theKey,
|
|
[In, Out] ref uint valLen, //* out
|
|
IntPtr theValue
|
|
);
|
|
|
|
|
|
[DllImport(NDK_LIBRARY, CharSet=CharSet.None)]
|
|
public static extern int miCASA_AddSHSEntry
|
|
(
|
|
[In] IntPtr secretHandle, //* in]
|
|
[MarshalAs(UnmanagedType.LPStr)]
|
|
string key, //* in /wchar
|
|
[In] uint valueLenBytes, // in bytes
|
|
[MarshalAs(UnmanagedType.LPStr)]
|
|
string val //* in /uchar
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY, CharSet=CharSet.None)]
|
|
public static extern int miCASAWriteKey
|
|
(
|
|
[In] IntPtr context,
|
|
[In] uint ssFlags,
|
|
[In] SSCS_KEYCHAIN_ID_T keyChainID,
|
|
[In] SSCS_SH_SECRET_ID_T sharedSecretID,
|
|
[MarshalAs(UnmanagedType.LPStr)]
|
|
string key, //* in /wchar
|
|
[In] uint keyLenBytes, // in bytes
|
|
[MarshalAs(UnmanagedType.LPStr)]
|
|
string val, //* in /uchar
|
|
[In] uint valueLenBytes, // in bytes
|
|
[In] SSCS_PASSWORD_T password,
|
|
[In, Out] SSCS_EXT_T ext
|
|
);
|
|
|
|
[DllImport(NDK_LIBRARY)]
|
|
public static extern int miCASA_RemoveSHSEntry
|
|
(
|
|
[In] IntPtr secretHandle, //* in
|
|
[MarshalAs(UnmanagedType.LPStr)]
|
|
string key, //* out /uchar
|
|
uint valueLenBytes, // in bytes
|
|
[MarshalAs(UnmanagedType.LPStr)]
|
|
string val //* out /uchar
|
|
);
|
|
|
|
|
|
|
|
// Methods start here
|
|
internal IntPtr openSecretStore(string sSecretStoreName)
|
|
{
|
|
|
|
//check params
|
|
if (sSecretStoreName == null || sSecretStoreName.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
|
|
SSCS_SECRET_STORE_ID_T SSid = new SSCS_SECRET_STORE_ID_T();
|
|
SSid.id = sSecretStoreName;
|
|
SSid.len = sSecretStoreName.Length;
|
|
|
|
SSCS_EXT_T ext = new SSCS_EXT_T();
|
|
try
|
|
{
|
|
IntPtr hSC = miCASAOpenSecretStoreCache( SSid, 0, ext);
|
|
return hSC;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
internal Secret getSecret(
|
|
IntPtr pHsc,
|
|
string sKeyChainID,
|
|
uint iFlags,
|
|
string sSharedSecretID,
|
|
int iSecretType,
|
|
string sEPPassword)
|
|
{
|
|
|
|
if (pHsc == IntPtr.Zero || sKeyChainID == null || sSharedSecretID == null
|
|
|| sKeyChainID.Length == 0 || sSharedSecretID.Length == 0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
// setup structures
|
|
SSCS_KEYCHAIN_ID_T keyChainID = new SSCS_KEYCHAIN_ID_T();
|
|
keyChainID.keychainID = sKeyChainID;
|
|
|
|
SSCS_SH_SECRET_ID_T sharedSecretID = new SSCS_SH_SECRET_ID_T();
|
|
sharedSecretID.name = sSharedSecretID;
|
|
|
|
SSCS_PASSWORD_T epPassword = new SSCS_PASSWORD_T();
|
|
SSCS_READEXT_T readData = new SSCS_READEXT_T();
|
|
SSCS_EXT_T ext =new SSCS_EXT_T();
|
|
|
|
// get SecretHandle
|
|
IntPtr pSecretHandle = miCASA_CreateSHSHandle();
|
|
|
|
// setup keychainid
|
|
keyChainID.len = sKeyChainID.Length + 1;
|
|
|
|
// setup sharedSecretID
|
|
sharedSecretID.len = sSharedSecretID.Length + 1;
|
|
sharedSecretID.type = iSecretType; // TODO: type APP(1), CRED(2), or Binary(4)
|
|
|
|
epPassword.pwordType = 1; // TODO: ep or master password based on flags
|
|
if (sEPPassword != null)
|
|
{
|
|
epPassword.pword = sEPPassword;
|
|
epPassword.pwordLen = (uint)sEPPassword.Length;
|
|
}
|
|
else
|
|
epPassword.pwordLen = 0;
|
|
|
|
int rcode = miCASAReadSecret(
|
|
pHsc,
|
|
keyChainID,
|
|
iFlags,
|
|
pSecretHandle,
|
|
sharedSecretID,
|
|
epPassword,
|
|
readData,
|
|
ext);
|
|
|
|
|
|
// create new secret
|
|
Secret temp = new Secret(pHsc, sKeyChainID, iFlags, pSecretHandle, sSharedSecretID, sharedSecretID.type, sEPPassword);
|
|
temp.setTimeStamps(readData.crtStamp, readData.lmtStamp, readData.latStamp);
|
|
|
|
|
|
// if read was sucessful, read key value pairs
|
|
if (rcode == 0)
|
|
loadKeyValuePairs(temp);
|
|
// else
|
|
// throw new Exception();
|
|
|
|
return temp;
|
|
}
|
|
|
|
internal void loadKeyValuePairs(Secret secret)
|
|
{
|
|
int rcode=0;
|
|
int iStart = 1;
|
|
IntPtr theKey = Marshal.AllocHGlobal(60416);
|
|
IntPtr theValue = Marshal.AllocHGlobal(60416);
|
|
String sKey;
|
|
String sValue;
|
|
|
|
while (true)
|
|
{
|
|
uint iKeyLen = 60416;
|
|
uint iValueLen = 60416;
|
|
|
|
sKey = "";
|
|
sValue = "";
|
|
|
|
rcode = miCASA_GetNextSHSEntry(
|
|
iStart,
|
|
secret.m_secretHandle,
|
|
ref iKeyLen,
|
|
theKey, //sKey,
|
|
ref iValueLen,
|
|
theValue // sValue
|
|
);
|
|
|
|
|
|
if (rcode != 0)
|
|
break;
|
|
else
|
|
{
|
|
if (iKeyLen > 1)
|
|
{
|
|
//sKey = Marshal.PtrToStringAnsi(theKey, (int)iKeyLen - 1);
|
|
|
|
// convert from UTF8
|
|
byte[] baKey = new byte[iKeyLen-1];
|
|
Marshal.Copy(theKey, baKey, 0, (int)iKeyLen-1);
|
|
sKey = System.Text.Encoding.UTF8.GetString(baKey, 0, baKey.Length);
|
|
}
|
|
|
|
if (iValueLen > 1)
|
|
{
|
|
//sValue = Marshal.PtrToStringAnsi(theValue, (int)iValueLen -1);
|
|
|
|
// convert from UTF8
|
|
byte[] baValue = new byte[iValueLen-1];
|
|
Marshal.Copy(theValue, baValue, 0, (int)iValueLen-1);
|
|
sValue = System.Text.Encoding.UTF8.GetString(baValue, 0, baValue.Length);
|
|
}
|
|
|
|
if (sKey != null && sValue != null)
|
|
secret.setKeyValuePair(sKey, sValue);
|
|
|
|
|
|
iStart = 0;
|
|
}
|
|
|
|
}
|
|
Marshal.FreeHGlobal(theKey);
|
|
Marshal.FreeHGlobal(theValue);
|
|
}
|
|
|
|
internal static int removeKeyValue(
|
|
IntPtr pSecretHandle,
|
|
string sKey,
|
|
string sValue,
|
|
uint ctxFlags)
|
|
{
|
|
|
|
if ((sKey == null) || (sValue == null))
|
|
return 0;
|
|
|
|
int rcode = miCASA_RemoveSHSEntry(
|
|
pSecretHandle,
|
|
sKey,
|
|
(uint)(sValue.Length + 1) * 2,
|
|
sValue);
|
|
|
|
return rcode;
|
|
}
|
|
|
|
/*
|
|
internal int setSecret(
|
|
IntPtr pHsc,
|
|
string sKeyChainID,
|
|
uint iFlags,
|
|
Secret secret,
|
|
int iSecretType)
|
|
{
|
|
int rcode;
|
|
|
|
|
|
if (iSecretType == Secret.SS_BINARY)
|
|
{
|
|
rcode = miCASA_AddSHSEntry(
|
|
secret.m_secretHandle,
|
|
"SS_Binary",
|
|
(uint)secret.getBinaryValue().Length,
|
|
secret.getBinaryValue().ToString());
|
|
}
|
|
else
|
|
{
|
|
NameValueCollection nvc = secret.getKeyValueCollection();
|
|
if (nvc != null)
|
|
{
|
|
for (int i=0; i<nvc.Count; i++)
|
|
{
|
|
|
|
String sKey = nvc.GetKey(i);
|
|
String sValue = nvc.Get(sKey); // = new StringBuilder();
|
|
|
|
if (sKey.Length > 0)
|
|
{
|
|
// first write out all key/value pairs
|
|
rcode = miCASA_AddSHSEntry(
|
|
secret.m_secretHandle,
|
|
sKey, //sKey,
|
|
(uint)(sValue.Length+1) * 2,
|
|
sValue); //sValue);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// now call miCASAWriteSecret
|
|
SSCS_KEYCHAIN_ID_T keyChainID = new SSCS_KEYCHAIN_ID_T();
|
|
keyChainID.keychainID = sKeyChainID;
|
|
|
|
SSCS_SH_SECRET_ID_T sharedSecretID = new SSCS_SH_SECRET_ID_T();
|
|
SSCS_PASSWORD_T epPassword = new SSCS_PASSWORD_T();
|
|
SSCS_EXT_T ext =new SSCS_EXT_T();
|
|
ext.extID = 0;
|
|
ext.version = 0;
|
|
|
|
|
|
// setup keychainid
|
|
keyChainID.len = sKeyChainID.Length + 1;
|
|
|
|
String tempStr = secret.getID();
|
|
sharedSecretID.name = tempStr;
|
|
sharedSecretID.len = tempStr.Length + 1;
|
|
sharedSecretID.type = iSecretType; // TODO: type APP(1), CRED(2), or Binary(4)
|
|
|
|
if (secret.getEnhancedProtectionPassword() != null)
|
|
{
|
|
epPassword.pword = secret.getEnhancedProtectionPassword();
|
|
epPassword.pwordLen = (uint)secret.getEnhancedProtectionPassword().Length + 1;
|
|
epPassword.pwordType = 0;
|
|
}
|
|
else
|
|
{
|
|
epPassword = null;
|
|
}
|
|
|
|
ext.ext = Marshal.AllocHGlobal(10);
|
|
try
|
|
{
|
|
rcode = miCASAWriteSecret(
|
|
pHsc,
|
|
keyChainID,
|
|
iFlags,
|
|
secret.m_secretHandle,
|
|
sharedSecretID,
|
|
epPassword,
|
|
ext);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//Console.WriteLine(e.ToString());
|
|
rcode = -803;
|
|
}
|
|
|
|
Marshal.FreeHGlobal(ext.ext);
|
|
return rcode;
|
|
}
|
|
*/
|
|
|
|
internal bool KeyInNewList(NameValueCollection nvc, string key)
|
|
{
|
|
|
|
//Console.WriteLine("Checking for " + key );
|
|
if (nvc != null)
|
|
{
|
|
for (int i = 0; i < nvc.Count; i++)
|
|
{
|
|
string sKey = nvc.GetKey(i);
|
|
if( key == sKey )
|
|
return true;
|
|
}
|
|
}
|
|
//Console.WriteLine("key = " + key + " is not present in nvc");
|
|
return false;
|
|
}
|
|
|
|
|
|
internal int setSecret(
|
|
IntPtr pHsc,
|
|
string sKeyChainID,
|
|
uint iFlags,
|
|
Secret secret,
|
|
int iSecretType)
|
|
{
|
|
|
|
int rcode = 0;
|
|
if (sKeyChainID == null || sKeyChainID.Length == 0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
// now call miCASAWriteSecret
|
|
SSCS_KEYCHAIN_ID_T keyChainID = new SSCS_KEYCHAIN_ID_T();
|
|
keyChainID.keychainID = sKeyChainID;
|
|
|
|
SSCS_SH_SECRET_ID_T sharedSecretID = new SSCS_SH_SECRET_ID_T();
|
|
SSCS_PASSWORD_T epPassword = new SSCS_PASSWORD_T();
|
|
SSCS_EXT_T ext =new SSCS_EXT_T();
|
|
ext.extID = 0;
|
|
ext.version = 0;
|
|
|
|
|
|
// setup keychainid
|
|
keyChainID.len = sKeyChainID.Length + 1;
|
|
|
|
String tempStr = secret.getID();
|
|
sharedSecretID.name = tempStr;
|
|
sharedSecretID.len = (tempStr.Length + 1) * 2;
|
|
sharedSecretID.type = iSecretType; // TODO: type APP(1), CRED(2), or Binary(4)
|
|
|
|
if (secret.getEnhancedProtectionPassword() != null)
|
|
{
|
|
epPassword.pword = secret.getEnhancedProtectionPassword();
|
|
epPassword.pwordLen = (uint)secret.getEnhancedProtectionPassword().Length + 1;
|
|
epPassword.pwordType = 0;
|
|
}
|
|
else
|
|
{
|
|
epPassword = null;
|
|
}
|
|
|
|
ext.ext = Marshal.AllocHGlobal(10);
|
|
|
|
|
|
if (iSecretType == Secret.SS_BINARY)
|
|
{
|
|
rcode = miCASA_AddSHSEntry(
|
|
secret.m_secretHandle,
|
|
"SS_Binary",
|
|
(uint)secret.getBinaryValue().Length,
|
|
secret.getBinaryValue().ToString());
|
|
}
|
|
else
|
|
{
|
|
NameValueCollection nvc = secret.getKeyValueCollection();
|
|
if (nvc != null)
|
|
{
|
|
for (int i=0; i<nvc.Count; i++)
|
|
{
|
|
|
|
rcode = 0;
|
|
String sKey = nvc.GetKey(i);
|
|
String sValue = nvc.Get(sKey); // = new StringBuilder();
|
|
|
|
if (sKey.Length > 0)
|
|
{
|
|
try
|
|
{
|
|
object o = MiCasaRequestReply.Send(MiCasaRequestReply.VERB_WRITE_KEY,
|
|
sKeyChainID,
|
|
secret.getID(),
|
|
sKey,
|
|
EscapeReservedChars(sValue));
|
|
|
|
/*
|
|
rcode = miCASAWriteKey(
|
|
pHsc,
|
|
iFlags,
|
|
keyChainID,
|
|
sharedSecretID,
|
|
sKey,
|
|
(uint) (sKey.Length+1) * 2,
|
|
sValue,
|
|
(uint) (sValue.Length+1) * 2,
|
|
epPassword,
|
|
ext);
|
|
*/
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
rcode = -803;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( 0 == rcode )
|
|
{
|
|
try
|
|
{
|
|
|
|
ArrayList keyList = (ArrayList)MiCasaRequestReply.Send(MiCasaRequestReply.VERB_GET_KEY_LIST,sKeyChainID,secret.getID(),null,null);
|
|
|
|
if( null != keyList )
|
|
{
|
|
IEnumerator etor = keyList.GetEnumerator();
|
|
while( etor.MoveNext() )
|
|
{
|
|
string key = (string)etor.Current;
|
|
if(KeyInNewList(nvc,key) == false)
|
|
{
|
|
MiCasaRequestReply.Send(MiCasaRequestReply.VERB_REMOVE_KEY,sKeyChainID,secret.getID(),key, null );
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
rcode = -803;
|
|
Console.WriteLine(e.ToString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Marshal.FreeHGlobal(ext.ext);
|
|
return rcode;
|
|
}
|
|
|
|
|
|
internal int RemoveSecret(
|
|
IntPtr context,
|
|
uint ssFlags,
|
|
string sKeyChainID,
|
|
string sEPPassword,
|
|
string sSecretID,
|
|
int iSecretType)
|
|
{
|
|
|
|
if (context == IntPtr.Zero || sKeyChainID == null || sSecretID == null
|
|
|| sKeyChainID.Length==0 || sSecretID.Length==0)
|
|
return miCasaException.NSSCS_E_INVALID_PARAM;
|
|
|
|
int rcode = 0;
|
|
|
|
SSCS_KEYCHAIN_ID_T keyChainID = new SSCS_KEYCHAIN_ID_T();
|
|
keyChainID.keychainID = sKeyChainID;
|
|
keyChainID.len = sKeyChainID.Length + 1;
|
|
|
|
SSCS_PASSWORD_T epPassword = new SSCS_PASSWORD_T();
|
|
epPassword.pword = sEPPassword;
|
|
epPassword.pwordLen = (uint)sEPPassword.Length + 1;
|
|
epPassword.pwordType = 0; // todo set type
|
|
|
|
SSCS_SH_SECRET_ID_T secretID = new SSCS_SH_SECRET_ID_T();
|
|
secretID.name = sSecretID;
|
|
|
|
secretID.len = sSecretID.Length + 1;
|
|
secretID.type = iSecretType;
|
|
|
|
SSCS_EXT_T ext = new SSCS_EXT_T();
|
|
|
|
// make the call
|
|
rcode = miCASARemoveSecret(
|
|
context,
|
|
keyChainID,
|
|
ssFlags,
|
|
secretID,
|
|
epPassword,
|
|
ext);
|
|
|
|
|
|
return rcode;
|
|
|
|
}
|
|
|
|
internal StringCollection EnumerateSecretIDs(
|
|
IntPtr context,
|
|
uint ssFlags,
|
|
string sKeyChainID,
|
|
string sSearchKey)
|
|
{
|
|
|
|
|
|
if (context == IntPtr.Zero || sKeyChainID==null || sSearchKey==null
|
|
|| sKeyChainID.Length==0)
|
|
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
// setup structures
|
|
SSCS_KEYCHAIN_ID_T keyChainID = new SSCS_KEYCHAIN_ID_T();
|
|
keyChainID.keychainID = sKeyChainID;
|
|
|
|
SSCS_SRCH_KEY_T searchKey = new SSCS_SRCH_KEY_T();
|
|
SSCS_SH_SECRET_ID_LIST_T idList = new SSCS_SH_SECRET_ID_LIST_T();
|
|
SSCS_EXT_T ext = new SSCS_EXT_T();
|
|
|
|
int numIDS = 100;
|
|
StringCollection sc = null;
|
|
|
|
// setup keychainid
|
|
keyChainID.len = sKeyChainID.Length + 1;
|
|
|
|
searchKey.srchKey = sSearchKey;
|
|
searchKey.srchKeyLen = (uint)sSearchKey.Length;
|
|
|
|
idList.returnedIDs = (uint)numIDS;
|
|
|
|
SSCS_SH_SECRET_ID_T secretId = new SSCS_SH_SECRET_ID_T();
|
|
// secretId.name = new char[512];
|
|
|
|
StringBuilder buffer3 = new StringBuilder( "content", 512 );
|
|
buffer3.Append( (char)0 );
|
|
buffer3.Append( '*', buffer3.Capacity - 8 );
|
|
String tempStr = buffer3.ToString();
|
|
idList.secretIDList = Marshal.AllocHGlobal(numIDS * Marshal.SizeOf(secretId));
|
|
|
|
|
|
// make the call
|
|
int rcode = miCASAEnumerateSecretIDs(
|
|
context,
|
|
keyChainID,
|
|
ssFlags,
|
|
searchKey,
|
|
idList,
|
|
ext);
|
|
|
|
if (idList.returnedIDs > 0)
|
|
{
|
|
sc = new StringCollection();
|
|
|
|
if (idList.returnedIDs != 100)
|
|
{
|
|
// enumerate returned list
|
|
for (int i=0; i<idList.returnedIDs; i++)
|
|
{
|
|
IntPtr temp = new IntPtr(idList.secretIDList.ToInt32() + (i * Marshal.SizeOf(secretId)));
|
|
secretId = (SSCS_SH_SECRET_ID_T)Marshal.PtrToStructure(temp, typeof(SSCS_SH_SECRET_ID_T));
|
|
|
|
// String st = new String(secretId.name,0,secretId.len - 1);
|
|
String st = secretId.name;
|
|
sc.Add(st);
|
|
}
|
|
}
|
|
}
|
|
|
|
Marshal.FreeHGlobal(idList.secretIDList);
|
|
return sc;
|
|
}
|
|
|
|
public void AddKeyChain(
|
|
IntPtr context,
|
|
uint ssFlags,
|
|
string sKeyChainID)
|
|
{
|
|
|
|
if (context==IntPtr.Zero || sKeyChainID==null || sKeyChainID.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
SSCS_KEYCHAIN_ID_T keyChainID = new SSCS_KEYCHAIN_ID_T();
|
|
keyChainID.keychainID = sKeyChainID;
|
|
keyChainID.len = sKeyChainID.Length + 1;
|
|
|
|
SSCS_EXT_T ext = new SSCS_EXT_T();
|
|
int rcode = miCASAAddKeyChain(context, ssFlags, keyChainID, ext);
|
|
}
|
|
|
|
|
|
public static BasicCredential GetCredential(
|
|
uint ssFlags,
|
|
string sAppSecretID,
|
|
string sSharedSecretID,
|
|
uint unFlag)
|
|
|
|
{
|
|
if (sAppSecretID==null || sAppSecretID.Length == 0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
int rcode;
|
|
BasicCredential bc = null;
|
|
|
|
SSCS_SECRET_ID_T appSecretID = new SSCS_SECRET_ID_T();
|
|
appSecretID.id = sAppSecretID;
|
|
appSecretID.len = sAppSecretID.Length;
|
|
|
|
SSCS_SECRET_ID_T sharedID = new SSCS_SECRET_ID_T();
|
|
if (sSharedSecretID != null)
|
|
{
|
|
sharedID.len = sSharedSecretID.Length;
|
|
sharedID.id = sSharedSecretID;
|
|
|
|
}
|
|
|
|
SSCS_BASIC_CREDENTIAL_UTF8 credential = new SSCS_BASIC_CREDENTIAL_UTF8();
|
|
credential.unFlags = unFlag;
|
|
|
|
// alloc some memory
|
|
IntPtr pCredential = Marshal.AllocHGlobal(Marshal.SizeOf(credential));
|
|
Marshal.StructureToPtr(credential, pCredential, false);
|
|
|
|
rcode = miCASAGetCredential(
|
|
ssFlags,
|
|
appSecretID,
|
|
sharedID,
|
|
0,
|
|
pCredential,
|
|
new SSCS_EXT_T()
|
|
);
|
|
|
|
|
|
if (rcode == 0)
|
|
{
|
|
Marshal.PtrToStructure(pCredential, credential);
|
|
string sUsername = GetStringFromUTF8(credential.username, (int)credential.unLen - 1);
|
|
string sPassword = GetStringFromUTF8(credential.password, (int)credential.pwordLen - 1);
|
|
|
|
bc = new BasicCredential(sUsername, sPassword);
|
|
Marshal.FreeHGlobal(pCredential);
|
|
return bc;
|
|
}
|
|
else
|
|
{
|
|
Marshal.FreeHGlobal(pCredential);
|
|
throw new miCasaException(rcode);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public static void SetCredential(
|
|
uint ssFlags,
|
|
string sAppSecretID,
|
|
string sSharedSecretID,
|
|
uint unFlag,
|
|
string sUsername,
|
|
string sPassword)
|
|
{
|
|
|
|
if (sAppSecretID==null || sUsername==null || sPassword==null
|
|
|| sAppSecretID.Length==0 || sUsername.Length==0 || sPassword.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
int rcode;
|
|
|
|
SSCS_SECRET_ID_T appSecretID = new SSCS_SECRET_ID_T();
|
|
appSecretID.id = sAppSecretID;
|
|
appSecretID.len = sAppSecretID.Length;
|
|
|
|
SSCS_SECRET_ID_T sharedID = new SSCS_SECRET_ID_T();
|
|
if (sSharedSecretID != null)
|
|
{
|
|
sharedID.len = sSharedSecretID.Length;
|
|
sharedID.id = sSharedSecretID;
|
|
}
|
|
|
|
SSCS_BASIC_CREDENTIAL_UTF8 credential = new SSCS_BASIC_CREDENTIAL_UTF8();
|
|
credential.unFlags = unFlag;
|
|
|
|
credential.unLen = GetUTF8ByteCount(sUsername);
|
|
credential.username = GetUTF8FromString(sUsername, USERNAME_LEN);
|
|
|
|
credential.pwordLen = GetUTF8ByteCount(sPassword);
|
|
credential.password = GetUTF8FromString(sPassword, PASSWORD_LEN);
|
|
|
|
IntPtr pCredential = Marshal.AllocHGlobal(Marshal.SizeOf(credential));
|
|
|
|
Marshal.StructureToPtr(credential, pCredential, true);
|
|
|
|
rcode = miCASASetCredential
|
|
(ssFlags,
|
|
appSecretID,
|
|
sharedID,
|
|
SSCS_CRED_TYPE_BASIC_F,
|
|
pCredential,
|
|
new SSCS_EXT_T()
|
|
);
|
|
|
|
if (rcode != 0)
|
|
{
|
|
throw new miCasaException(rcode);
|
|
}
|
|
}
|
|
|
|
|
|
public static void RemoveCredential(
|
|
uint ssFlags,
|
|
string sAppSecretID,
|
|
string sSharedSecretID)
|
|
|
|
{
|
|
if (sAppSecretID == null || sAppSecretID.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
int rcode;
|
|
SSCS_SECRET_ID_T appSecretID = new SSCS_SECRET_ID_T();
|
|
appSecretID.id = sAppSecretID;
|
|
appSecretID.len = sAppSecretID.Length;
|
|
|
|
SSCS_SECRET_ID_T sharedID = new SSCS_SECRET_ID_T();
|
|
if (sSharedSecretID != null)
|
|
{
|
|
sharedID.len = sSharedSecretID.Length;
|
|
sharedID.id = sSharedSecretID;
|
|
}
|
|
|
|
rcode = miCASARemoveCredential(ssFlags, appSecretID, sharedID, new SSCS_EXT_T());
|
|
|
|
if (rcode != 0)
|
|
{
|
|
throw new miCasaException(rcode);
|
|
}
|
|
|
|
}
|
|
|
|
internal static int SetMasterPasscode(
|
|
uint ssFlags,
|
|
string passcodeStr)
|
|
{
|
|
|
|
if (passcodeStr==null || passcodeStr.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
int rcode = -1;
|
|
try
|
|
{
|
|
SSCS_PASSCODE_T passcode = new SSCS_PASSCODE_T();
|
|
SSCS_PASSWORD_T passwd = new SSCS_PASSWORD_T();
|
|
|
|
passwd.pwordType = 1;
|
|
/* UTF8 ??
|
|
passwd.pword = GetUTF8FromString(passcodeStr,PASSWORD_LEN);
|
|
passwd.pwordLen = GetUTF8ByteCount(passcodeStr);
|
|
*/
|
|
passwd.pword = passcodeStr;
|
|
passwd.pwordLen = (uint)passcodeStr.Length;
|
|
|
|
|
|
passcode.passcodeType = 1;
|
|
IntPtr temp = Marshal.AllocHGlobal(Marshal.SizeOf(passwd));
|
|
Marshal.StructureToPtr(passwd, temp, false);
|
|
passcode.passcodeHandle = temp;
|
|
|
|
rcode = miCASASetMasterPasscode(ssFlags,
|
|
passcode,
|
|
new SSCS_EXT_T());
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
//Console.WriteLine(e.ToString());
|
|
}
|
|
return rcode;
|
|
}
|
|
public static int SetMasterPassword(
|
|
uint ssFlags,
|
|
string mPasswd)
|
|
{
|
|
|
|
if (mPasswd==null || mPasswd.Length==0)
|
|
return 1;
|
|
|
|
int rcode = -1;
|
|
try
|
|
{
|
|
SSCS_PASSWORD_T passwd = new SSCS_PASSWORD_T();
|
|
|
|
passwd.pwordType = 1;
|
|
passwd.pword = mPasswd;
|
|
passwd.pwordLen = (uint)mPasswd.Length;
|
|
|
|
|
|
rcode = miCASASetMasterPassword(ssFlags,
|
|
passwd,
|
|
null,
|
|
new SSCS_EXT_T());
|
|
}
|
|
catch(Exception)
|
|
{
|
|
//Console.WriteLine(e.ToString());
|
|
}
|
|
return rcode;
|
|
}
|
|
|
|
public static bool IsSecretPersistent(uint ssFlags, string id)
|
|
{
|
|
int rcode = 0;
|
|
if (null != id && "" !=id)
|
|
{
|
|
SSCS_SECRET_ID_T secretID = new SSCS_SECRET_ID_T();
|
|
if(ssFlags == 0)
|
|
{
|
|
secretID.len = id.Length;
|
|
secretID.id = id;
|
|
rcode = miCASAIsSecretPersistent(ssFlags,
|
|
secretID,
|
|
new SSCS_EXT_T());
|
|
}
|
|
else
|
|
{
|
|
rcode = miCASAIsSecretPersistent(ssFlags,
|
|
null,
|
|
new SSCS_EXT_T());
|
|
}
|
|
}
|
|
|
|
if(rcode == 1)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
private static string GetStringFromUTF8(byte[] utf8Bytes, int numBytes)
|
|
{
|
|
if (numBytes > 0)
|
|
{
|
|
Decoder utfDec = System.Text.Encoding.UTF8.GetDecoder();
|
|
int charCount = utfDec.GetCharCount(utf8Bytes, 0, numBytes);
|
|
char[] chars = new char[charCount];
|
|
int len = utfDec.GetChars(utf8Bytes, 0, numBytes, chars, 0);
|
|
|
|
string text = new string(chars);
|
|
text = text.Trim();
|
|
return text;
|
|
}
|
|
else
|
|
return "";
|
|
}
|
|
|
|
private static uint GetUTF8ByteCount(string str)
|
|
{
|
|
uint byteCount = (uint)System.Text.Encoding.UTF8.GetEncoder().GetByteCount(str.ToCharArray(), 0, str.Length, true);
|
|
return byteCount;
|
|
}
|
|
|
|
private static byte[] GetUTF8FromString(string str, int arrayLength)
|
|
{
|
|
// NOTE: Must return a padded array of arrayLength
|
|
Encoder utfEnc = System.Text.Encoding.UTF8.GetEncoder();
|
|
byte[] utf8Bytes = new byte[arrayLength];
|
|
int len = utfEnc.GetBytes(str.ToCharArray(), 0, str.Length, utf8Bytes, 0, true);
|
|
return utf8Bytes;
|
|
}
|
|
internal int RemoveKey(
|
|
string sKeyChainID,
|
|
string secretID,
|
|
string keyID)
|
|
{
|
|
if (sKeyChainID==null || secretID==null || keyID==null
|
|
|| sKeyChainID.Length==0 || secretID.Length==0 || keyID.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
int rcode = 0;
|
|
|
|
if (keyID.Length > 0)
|
|
{
|
|
try
|
|
{
|
|
object o = MiCasaRequestReply.Send(
|
|
MiCasaRequestReply.VERB_REMOVE_KEY,
|
|
sKeyChainID, secretID, keyID, null);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
rcode = -803;
|
|
}
|
|
}
|
|
return rcode;
|
|
}
|
|
|
|
internal ArrayList GetKeyList(
|
|
string sKeyChainID,
|
|
string secretID)
|
|
{
|
|
if (sKeyChainID==null || secretID==null
|
|
|| sKeyChainID.Length==0 || secretID.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
ArrayList keyList = null;
|
|
try
|
|
{
|
|
keyList = (ArrayList) MiCasaRequestReply.Send(
|
|
MiCasaRequestReply.VERB_GET_KEY_LIST,
|
|
sKeyChainID, secretID,null,null);
|
|
return keyList;
|
|
#if false
|
|
|
|
if( null != keyList )
|
|
{
|
|
IEnumerator etor = keyList.GetEnumerator();
|
|
while( etor.MoveNext() )
|
|
{
|
|
Console.WriteLine("Key = " + etor.Current);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Console.WriteLine(e.ToString());
|
|
keyList = null;
|
|
}
|
|
return keyList;
|
|
}
|
|
|
|
|
|
internal string ReadKey(
|
|
string sKeyChainID,
|
|
string secretID,
|
|
string keyID)
|
|
{
|
|
if (sKeyChainID==null || secretID==null || keyID==null
|
|
|| sKeyChainID.Length==0 || secretID.Length==0 || keyID.Length==0)
|
|
throw new miCasaException(miCasaException.NSSCS_E_INVALID_PARAM);
|
|
|
|
int rcode = 0;
|
|
string value = null;
|
|
|
|
if (keyID.Length > 0)
|
|
{
|
|
try
|
|
{
|
|
value = (String)MiCasaRequestReply.Send(
|
|
MiCasaRequestReply.VERB_REMOVE_KEY,
|
|
sKeyChainID, secretID, keyID, null);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// rcode = -803;
|
|
Console.WriteLine(e.ToString());
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private string EscapeReservedChars(string origString)
|
|
{
|
|
if (origString==null)
|
|
return origString;
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
for (int i=0; i<origString.Length; i++)
|
|
{
|
|
switch (origString[i])
|
|
{
|
|
case ':' :
|
|
{
|
|
sb.Append("\\");
|
|
break;
|
|
}
|
|
case '\\' :
|
|
{
|
|
sb.Append("\\");
|
|
break;
|
|
}
|
|
case '=' :
|
|
{
|
|
sb.Append("\\");
|
|
break;
|
|
}
|
|
|
|
}
|
|
sb.Append(origString[i]);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|
|
|
|
|