Remove duplicated prefix(Ckmc) in Interop

Change-Id: I72d17c6fc0dff47695d287513426bbd175aa4238
Signed-off-by: Kyungwook Tak <k.tak@samsung.com>

diff --git a/Tizen.Security/Interop/Interop.CkmcManager.cs b/Tizen.Security/Interop/Interop.CkmcManager.cs
index 9fb04d2..7bbf709 100644 (file)
--- a/Tizen.Security/Interop/Interop.CkmcManager.cs
+++ b/Tizen.Security/Interop/Interop.CkmcManager.cs
@@ -21,120 +21,120 @@ internal static partial class Interop
 {
     internal static partial class CkmcManager
     {
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_save_key", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcSaveKey(string alias, CkmcKey key, CkmcPolicy policy);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_key", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int SaveKey(string alias, CkmcKey key, CkmcPolicy policy);
         // int ckmc_save_key(const char *alias, const ckmc_key_s key, const ckmc_policy_s policy);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_key", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetKey(string alias, string password, out IntPtr key);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_key", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetKey(string alias, string password, out IntPtr key);
         // int ckmc_get_key(const char *alias, const char *password, ckmc_key_s **ppkey);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_key_alias_list", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetKeyAliasList(out IntPtr aliases);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_key_alias_list", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetKeyAliasList(out IntPtr aliases);
         // int ckmc_get_key_alias_list(ckmc_alias_list_s **ppalias_list);
 
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_save_cert", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcSaveCert(string alias, CkmcCert cert, CkmcPolicy policy);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_cert", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int SaveCert(string alias, CkmcCert cert, CkmcPolicy policy);
         // int ckmc_save_cert(const char *alias, const ckmc_cert_s cert, const ckmc_policy_s policy);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_cert", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetCert(string alias, string password, out IntPtr data);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetCert(string alias, string password, out IntPtr data);
         // int ckmc_get_cert(const char *alias, const char *password, ckmc_cert_s** ppcert);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_cert_alias_list", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetCertAliasList(out IntPtr aliases);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert_alias_list", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetCertAliasList(out IntPtr aliases);
         // int ckmc_get_cert_alias_list(ckmc_alias_list_s **ppalias_list);
 
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_save_data", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcSaveData(string alias, CkmcRawBuffer data, CkmcPolicy policy);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_data", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int SaveData(string alias, CkmcRawBuffer data, CkmcPolicy policy);
         // int ckmc_save_data(const char *alias, ckmc_raw_buffer_s data, const ckmc_policy_s policy);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_data", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetData(string alias, string password, out IntPtr data);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_data", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetData(string alias, string password, out IntPtr data);
         // int ckmc_get_data(const char* alias, const char* password, ckmc_raw_buffer_s **ppdata);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_data_alias_list", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetDataAliasList(out IntPtr aliases);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_data_alias_list", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetDataAliasList(out IntPtr aliases);
         // int ckmc_get_data_alias_list(ckmc_alias_list_s **ppalias_list);
 
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_remove_alias", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcRemoveAlias(string alias);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_remove_alias", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int RemoveAlias(string alias);
         // int ckmc_remove_alias(const char *alias);
 
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_save_pkcs12", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcSavePkcs12(string alias, IntPtr p12, CkmcPolicy keyPolicy, CkmcPolicy certPolicy);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_pkcs12", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int SavePkcs12(string alias, IntPtr p12, CkmcPolicy keyPolicy, CkmcPolicy certPolicy);
         // int ckmc_save_pkcs12(const char *alias, const ckmc_pkcs12_s* pkcs, const ckmc_policy_s key_policy, const ckmc_policy_s cert_policy);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_pkcs12", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetPkcs12(string alias, string keyPassword, string certPassword, out IntPtr pkcs12);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_pkcs12", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetPkcs12(string alias, string keyPassword, string certPassword, out IntPtr pkcs12);
         // int ckmc_get_pkcs12(const char *alias, const char *key_password, const char* cert_password, ckmc_pkcs12_s **pkcs12);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_set_permission", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcSetPermission(string alias, string accessor, int permissions);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_set_permission", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int SetPermission(string alias, string accessor, int permissions);
         // int ckmc_set_permission(const char *alias, const char *accessor, int permissions);
 
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_create_key_pair_rsa", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCreateKeyPairRsa(int size, string privateKeyAlias, string publicKeyAlias,
-                                                        CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_pair_rsa", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CreateKeyPairRsa(int size, string privateKeyAlias, string publicKeyAlias,
+                                                  CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
         // int ckmc_create_key_pair_rsa(const size_t size, const char* private_key_alias, const char* public_key_alias,
         //                              const ckmc_policy_s policy_private_key, const ckmc_policy_s policy_public_key);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_create_key_pair_dsa", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCreateKeyPairDsa(int size, string privateKeyAlias, string publicKeyAlias,
-                                                        CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_pair_dsa", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CreateKeyPairDsa(int size, string privateKeyAlias, string publicKeyAlias,
+                                                  CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
         // int ckmc_create_key_pair_dsa(const size_t size, const char* private_key_alias, const char* public_key_alias,
         //                              const ckmc_policy_s policy_private_key, const ckmc_policy_s policy_public_key);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_create_key_pair_ecdsa", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCreateKeyPairEcdsa(int ecType, string privateKeyAlias, string publicKeyAlias,
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_pair_ecdsa", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CreateKeyPairEcdsa(int ecType, string privateKeyAlias, string publicKeyAlias,
                                                         CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
         // int ckmc_create_key_pair_ecdsa(const size_t size, const char* private_key_alias, const char* public_key_alias,
-        //                              const ckmc_policy_s policy_private_key, const ckmc_policy_s policy_public_key);
+        //                                const ckmc_policy_s policy_private_key, const ckmc_policy_s policy_public_key);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_create_key_aes", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCreateKeyAes(int size, string ceyAlias, CkmcPolicy keyPolicy);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_aes", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CreateKeyAes(int size, string ceyAlias, CkmcPolicy keyPolicy);
         // int ckmc_create_key_aes(size_t size, const char* key_alias, ckmc_policy_s key_policy);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_create_signature", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCreateSignature(string privateKeyAlias, string password, CkmcRawBuffer message,
-                                                       int hashAlgorithm, int paddingAlgorithm, out IntPtr signature);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_signature", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CreateSignature(string privateKeyAlias, string password, CkmcRawBuffer message,
+                                                 int hashAlgorithm, int paddingAlgorithm, out IntPtr signature);
         // int ckmc_create_signature(const char *private_key_alias, const char* password, const ckmc_raw_buffer_s message,
-        //           const ckmc_hash_algo_e hash, const ckmc_rsa_padding_algo_e padding, ckmc_raw_buffer_s **ppsignature);
+        //                           const ckmc_hash_algo_e hash, const ckmc_rsa_padding_algo_e padding, ckmc_raw_buffer_s **ppsignature);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_verify_signature", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcVerifySignature(string publicKeyAlias, string password, CkmcRawBuffer message,
-                                                       CkmcRawBuffer signature, int hashAlgorithm, int paddingAlgorithm);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_verify_signature", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int VerifySignature(string publicKeyAlias, string password, CkmcRawBuffer message,
+                                                 CkmcRawBuffer signature, int hashAlgorithm, int paddingAlgorithm);
         // int ckmc_verify_signature(const char *public_key_alias, const char* password, const ckmc_raw_buffer_s message,
         //           const ckmc_raw_buffer_s signature, const ckmc_hash_algo_e hash, const ckmc_rsa_padding_algo_e padding);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_encrypt_data", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcEncryptData(IntPtr parameters, string keyAlias, string password, CkmcRawBuffer plainText, out IntPtr cipherText);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_encrypt_data", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int EncryptData(IntPtr parameters, string keyAlias, string password, CkmcRawBuffer plainText, out IntPtr cipherText);
         // int ckmc_encrypt_data(ckmc_param_list_h params, const char* key_alias, const char* password,
         //                       const ckmc_raw_buffer_s decrypted, ckmc_raw_buffer_s **ppencrypted);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_decrypt_data", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcDecryptData(IntPtr parameters, string keyAlias, string password, CkmcRawBuffer cipherText, out IntPtr plainText);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_decrypt_data", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int DecryptData(IntPtr parameters, string keyAlias, string password, CkmcRawBuffer cipherText, out IntPtr plainText);
         // int ckmc_decrypt_data(ckmc_param_list_h params, const char* key_alias, const char* password,
         //                       const ckmc_raw_buffer_s encrypted, ckmc_raw_buffer_s **ppdecrypted);
 
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_cert_chain", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetCertChain(IntPtr cert, IntPtr untrustedCerts, out IntPtr certChain);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert_chain", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetCertChain(IntPtr cert, IntPtr untrustedCerts, out IntPtr certChain);
         // int ckmc_get_cert_chain(const ckmc_cert_s *cert, const ckmc_cert_list_s* untrustedcerts, ckmc_cert_list_s **ppcert_chain_list);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_get_cert_chain_with_trustedcert", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGetCertChainWithTrustedCerts(IntPtr cert, IntPtr untrustedCerts, IntPtr trustedCerts,
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert_chain_with_trustedcert", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetCertChainWithTrustedCerts(IntPtr cert, IntPtr untrustedCerts, IntPtr trustedCerts,
                                                                     bool useTrustedSystemCerts, out IntPtr certChain);
         // int ckmc_get_cert_chain_with_trustedcert(const ckmc_cert_s *cert, const ckmc_cert_list_s* untrustedcerts,
         //       const ckmc_cert_list_s* trustedcerts, const bool use_trustedsystemcerts, ckmc_cert_list_s **ppcert_chain_list);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_ocsp_check", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcOcspCheck(IntPtr certChain, ref int ocspStatus);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_ocsp_check", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int OcspCheck(IntPtr certChain, ref int ocspStatus);
         // int ckmc_ocsp_check(const ckmc_cert_list_s *pcert_chain_list, ckmc_ocsp_status_e* ocsp_status);
     }
 }

diff --git a/Tizen.Security/Interop/Interop.CkmcTypes.cs b/Tizen.Security/Interop/Interop.CkmcTypes.cs
index 42900aa..bcc0f99 100644 (file)
--- a/Tizen.Security/Interop/Interop.CkmcTypes.cs
+++ b/Tizen.Security/Interop/Interop.CkmcTypes.cs
@@ -110,104 +110,104 @@ internal static partial class Interop
 
     internal static partial class CkmcTypes
     {
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_key_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcKeyFree(IntPtr buffer);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_key_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void KeyFree(IntPtr buffer);
         // void ckmc_key_free(ckmc_key_s *key);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_buffer_new", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcBufferNew(byte[] data, uint size, out IntPtr buffer);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_buffer_new", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int BufferNew(byte[] data, uint size, out IntPtr buffer);
         // int ckmc_buffer_new(unsigned char *data, size_t size, ckmc_raw_buffer_s** ppbuffer);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_buffer_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcBufferFree(IntPtr buffer);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_buffer_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void BufferFree(IntPtr buffer);
         // void ckmc_buffer_free(ckmc_raw_buffer_s* buffer);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_cert_new", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCertNew(byte[] rawCert, uint size, int dataFormat, out IntPtr cert);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_cert_new", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CertNew(byte[] rawCert, uint size, int dataFormat, out IntPtr cert);
         // int ckmc_cert_new(unsigned char *raw_cert, size_t cert_size, ckmc_data_format_e data_format, ckmc_cert_s** ppcert);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_cert_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcCertFree(IntPtr buffer);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_cert_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void CertFree(IntPtr buffer);
         // void ckmc_cert_free(ckmc_cert_s *cert);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_load_cert_from_file", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcLoadCertFromFile(string filePath, out IntPtr cert);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_load_cert_from_file", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int LoadCertFromFile(string filePath, out IntPtr cert);
         // int ckmc_load_cert_from_file(const char *file_path, ckmc_cert_s **cert);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_pkcs12_new", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcPkcs12New(string filePath, out IntPtr cert);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_pkcs12_new", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int Pkcs12New(string filePath, out IntPtr cert);
         // int ckmc_pkcs12_new(ckmc_key_s *private_key, ckmc_cert_s* cert, ckmc_cert_list_s *ca_cert_list, ckmc_pkcs12_s** pkcs12_bundle);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_load_from_pkcs12_file", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcLoadFromPkcs12File(string filePath, string password, out IntPtr privateKey, out IntPtr cert, out IntPtr caCertList);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_load_from_pkcs12_file", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int LoadFromPkcs12File(string filePath, string password, out IntPtr privateKey, out IntPtr cert, out IntPtr caCertList);
         // int ckmc_load_from_pkcs12_file(const char *file_path, const char* passphrase, ckmc_key_s **private_key, ckmc_cert_s** cert, ckmc_cert_list_s **ca_cert_list);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_pkcs12_load", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcPkcs12Load(string filePath, string password, out IntPtr pkcs12);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_pkcs12_load", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int Pkcs12Load(string filePath, string password, out IntPtr pkcs12);
         // int ckmc_pkcs12_load(const char *file_path, const char* passphrase, ckmc_pkcs12_s **pkcs12_bundle);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_pkcs12_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcPkcs12Free(IntPtr pkcs12);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_pkcs12_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void Pkcs12Free(IntPtr pkcs12);
         // void ckmc_pkcs12_free(ckmc_pkcs12_s *pkcs12);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_alias_list_new", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcAliasListNew(string alias, out IntPtr aliasList);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_alias_list_new", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int AliasListNew(string alias, out IntPtr aliasList);
         // int ckmc_alias_list_new(char *alias, ckmc_alias_list_s **ppalias_list);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_alias_list_add", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcAliasListAdd(IntPtr previous, string alias, out IntPtr aliasList);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_alias_list_add", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int AliasListAdd(IntPtr previous, string alias, out IntPtr aliasList);
         // int ckmc_alias_list_add(ckmc_alias_list_s *previous, char* alias, ckmc_alias_list_s **pplast);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_alias_list_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcAliasListFree(IntPtr first);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_alias_list_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void AliasListFree(IntPtr first);
         // void ckmc_alias_list_free(ckmc_alias_list_s* first);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_alias_list_all_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcAliasListAllFree(IntPtr first);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_alias_list_all_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void AliasListAllFree(IntPtr first);
         // void ckmc_alias_list_all_free(ckmc_alias_list_s* first);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_cert_list_new", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCertListNew(IntPtr cert, out IntPtr certList);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_cert_list_new", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CertListNew(IntPtr cert, out IntPtr certList);
         // int ckmc_cert_list_new(ckmc_cert_s *cert, ckmc_cert_list_s **ppcert_list);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_cert_list_add", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcCertListAdd(IntPtr previous, IntPtr cert, out IntPtr certList);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_cert_list_add", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int CertListAdd(IntPtr previous, IntPtr cert, out IntPtr certList);
         // int ckmc_cert_list_add(ckmc_cert_list_s *previous, ckmc_cert_s *cert, ckmc_cert_list_s** pplast);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_cert_list_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcCertListFree(IntPtr first);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_cert_list_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void CertListFree(IntPtr first);
         // void ckmc_cert_list_free(ckmc_cert_list_s *first);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_cert_list_all_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcCertListAllFree(IntPtr first);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_cert_list_all_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void CertListAllFree(IntPtr first);
         // void ckmc_cert_list_all_free(ckmc_cert_list_s *first);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_param_list_new", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcParamListNew(out IntPtr paramList);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_param_list_new", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ParamListNew(out IntPtr paramList);
         // int ckmc_param_list_new(ckmc_param_list_h *pparams);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_param_list_set_integer", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcParamListSetInteger(IntPtr paramList, int name, long value);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_param_list_set_integer", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ParamListSetInteger(IntPtr paramList, int name, long value);
         // int ckmc_param_list_set_integer(ckmc_param_list_h params, ckmc_param_name_e name, uint64_t value);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_param_list_set_buffer", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcParamListSetBuffer(IntPtr paramList, int name, IntPtr buffer);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_param_list_set_buffer", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ParamListSetBuffer(IntPtr paramList, int name, IntPtr buffer);
         // int ckmc_param_list_set_buffer(ckmc_param_list_h params, ckmc_param_name_e name, const ckmc_raw_buffer_s* buffer);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_param_list_get_integer", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcParamListGetInteger(IntPtr paramList, int name, out long value);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_param_list_get_integer", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ParamListGetInteger(IntPtr paramList, int name, out long value);
         // int ckmc_param_list_get_integer(ckmc_param_list_h params, ckmc_param_name_e name, uint64_t *pvalue);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_param_list_get_buffer", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcParamListGetBuffer(IntPtr paramList, int name, out IntPtr buffer);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_param_list_get_buffer", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int ParamListGetBuffer(IntPtr paramList, int name, out IntPtr buffer);
         // int ckmc_param_list_get_buffer(ckmc_param_list_h params, ckmc_param_name_e name, ckmc_raw_buffer_s **ppbuffer);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_param_list_free", CallingConvention = CallingConvention.Cdecl)]
-        public static extern void CkmcParamListFree(IntPtr first);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_param_list_free", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ParamListFree(IntPtr first);
         // void ckmc_param_list_free(ckmc_param_list_h params);
 
-        [DllImport(Libraries.KeyManagerClient, EntryPoint = "ckmc_generate_new_params", CallingConvention = CallingConvention.Cdecl)]
-        public static extern int CkmcGenerateNewParam(int algoType, out IntPtr paramList);
+        [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_generate_new_params", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GenerateNewParam(int algoType, out IntPtr paramList);
         // int ckmc_generate_new_params(ckmc_algo_type_e type, ckmc_param_list_h *pparams);
     }
 }

diff --git a/Tizen.Security/Interop/Interop.Libraries.cs b/Tizen.Security/Interop/Interop.Libraries.cs
index 0405bb8..ce5d263 100644 (file)
--- a/Tizen.Security/Interop/Interop.Libraries.cs
+++ b/Tizen.Security/Interop/Interop.Libraries.cs
@@ -19,6 +19,6 @@ internal static partial class Interop
     internal static partial class Libraries
     {
         public const string Privilege = "libprivilege-info.so.1";
-        public const string KeyManagerClient = "libkey-manager-client.so.1";
+        public const string KeyManager = "libkey-manager-client.so.1";
     }
 }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Certificate.cs b/Tizen.Security/Tizen.Security.SecureRepository/Certificate.cs
index 40a4e4a..a3b9929 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Certificate.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Certificate.cs
@@ -84,7 +84,7 @@ namespace Tizen.Security.SecureRepository
         {
             if (IsInvalid) // do not release
                 return true;
-            Interop.CkmcTypes.CkmcCertFree(handle);
+            Interop.CkmcTypes.CertFree(handle);
             this.SetHandle(IntPtr.Zero);
             return true;
         }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/CertificateManager.cs b/Tizen.Security/Tizen.Security.SecureRepository/CertificateManager.cs
index 6b19f00..15cf517 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/CertificateManager.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/CertificateManager.cs
@@ -36,7 +36,7 @@ namespace Tizen.Security.SecureRepository
         {
             IntPtr ptr = new IntPtr();
 
-            int ret = Interop.CkmcManager.CkmcGetCert(alias, password, out ptr);
+            int ret = Interop.CkmcManager.GetCert(alias, password, out ptr);
             Interop.CheckNThrowException(ret, "Failed to get certificate. alias=" + alias);
 
             return new Certificate(ptr);
@@ -49,7 +49,7 @@ namespace Tizen.Security.SecureRepository
         static public IEnumerable<string> GetCertificateAliases()
         {
             IntPtr ptr = new IntPtr();
-            int ret = Interop.CkmcManager.CkmcGetCertAliasList(out ptr);
+            int ret = Interop.CkmcManager.GetCertAliasList(out ptr);
             Interop.CheckNThrowException(ret, "Failed to get certificate aliases.");
 
             return new SafeAliasListHandle(ptr).Aliases;
@@ -63,7 +63,7 @@ namespace Tizen.Security.SecureRepository
         /// <param name="policy">The policy about how to store a certificate securely.</param>
         static public void SaveCertificate(string alias, Certificate cert, Policy policy)
         {
-            int ret = Interop.CkmcManager.CkmcSaveCert(alias, cert.ToCkmcCert(), policy.ToCkmcPolicy());
+            int ret = Interop.CkmcManager.SaveCert(alias, cert.ToCkmcCert(), policy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to save certificate. alias=" + alias);
         }
 
@@ -81,7 +81,7 @@ namespace Tizen.Security.SecureRepository
 
             SafeCertificateListHandle untrustedCerts = new SafeCertificateListHandle(untrustedCertificates);
 
-            int ret = Interop.CkmcManager.CkmcGetCertChain(new PinnedObject(certificate.ToCkmcCert()),
+            int ret = Interop.CkmcManager.GetCertChain(new PinnedObject(certificate.ToCkmcCert()),
                                                         untrustedCerts.ToCkmcCertificateListPtr(), out ptrCertChain);
             Interop.CheckNThrowException(ret, "Failed to get certificate chain");
 
@@ -106,7 +106,7 @@ namespace Tizen.Security.SecureRepository
             SafeCertificateListHandle untrustedCerts = new SafeCertificateListHandle(untrustedCertificates);
             SafeCertificateListHandle trustedCerts = new SafeCertificateListHandle(trustedCertificates);
 
-            int ret = Interop.CkmcManager.CkmcGetCertChainWithTrustedCerts(new PinnedObject(certificate.ToCkmcCert()),
+            int ret = Interop.CkmcManager.GetCertChainWithTrustedCerts(new PinnedObject(certificate.ToCkmcCert()),
                             untrustedCerts.ToCkmcCertificateListPtr(), trustedCerts.ToCkmcCertificateListPtr(), useTrustedSystemCertificates,
                             out ptrCertChain);
             Interop.CheckNThrowException(ret, "Failed to get certificate chain with trusted certificates");
@@ -125,7 +125,7 @@ namespace Tizen.Security.SecureRepository
         {
             int ocspStatus = (int)OcspStatus.Good;
             SafeCertificateListHandle certChain = new SafeCertificateListHandle(certificateChain);
-            int ret = Interop.CkmcManager.CkmcOcspCheck(certChain.ToCkmcCertificateListPtr(), ref ocspStatus);
+            int ret = Interop.CkmcManager.OcspCheck(certChain.ToCkmcCertificateListPtr(), ref ocspStatus);
             Interop.CheckNThrowException(ret, "Failed to get certificate chain with trusted certificates");
             return (OcspStatus)ocspStatus;
         }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Cipher.cs b/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Cipher.cs
index b92e0ff..0fd3014 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Cipher.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Cipher.cs
@@ -57,7 +57,7 @@ namespace Tizen.Security.SecureRepository.Crypto
             IntPtr ptrPlainText = new IntPtr();
             Interop.CkmcRawBuffer cipherTextBuff = new Interop.CkmcRawBuffer(new PinnedObject(cipherText), cipherText.Length);
 
-            int ret = Interop.CkmcManager.CkmcDecryptData(Parameters.PtrCkmcParamList, keyAlias, password, cipherTextBuff, out ptrPlainText);
+            int ret = Interop.CkmcManager.DecryptData(Parameters.PtrCkmcParamList, keyAlias, password, cipherTextBuff, out ptrPlainText);
             Interop.CheckNThrowException(ret, "Failed to decrypt data");
 
             return new SafeRawBufferHandle(ptrPlainText).Data;
@@ -79,7 +79,7 @@ namespace Tizen.Security.SecureRepository.Crypto
             IntPtr ptrCipherText = new IntPtr();
             Interop.CkmcRawBuffer plainTextBuff = new Interop.CkmcRawBuffer(new PinnedObject(plainText), plainText.Length);
 
-            int ret = Interop.CkmcManager.CkmcEncryptData(Parameters.PtrCkmcParamList, keyAlias, password, plainTextBuff, out ptrCipherText);
+            int ret = Interop.CkmcManager.EncryptData(Parameters.PtrCkmcParamList, keyAlias, password, plainTextBuff, out ptrCipherText);
             Interop.CheckNThrowException(ret, "Failed to encrypt data");
 
             return new SafeRawBufferHandle(ptrCipherText).Data;

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Crypto/CipherParameters.cs b/Tizen.Security/Tizen.Security.SecureRepository/Crypto/CipherParameters.cs
index 61a3362..bcb8da9 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Crypto/CipherParameters.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Crypto/CipherParameters.cs
@@ -31,7 +31,7 @@ namespace Tizen.Security.SecureRepository.Crypto
         public CipherParameters(CipherAlgorithmType algorithm) : base(IntPtr.Zero, true)
         {
             IntPtr ptrParams;
-            Interop.CkmcTypes.CkmcGenerateNewParam((int)algorithm, out ptrParams);
+            Interop.CkmcTypes.GenerateNewParam((int)algorithm, out ptrParams);
             this.SetHandle(ptrParams);
         }
 
@@ -42,7 +42,7 @@ namespace Tizen.Security.SecureRepository.Crypto
         /// <param name="value">Parameter value.</param>
         protected void Add(CipherParameterName name, long value)
         {
-            int ret = Interop.CkmcTypes.CkmcParamListSetInteger(PtrCkmcParamList, (int)name, value);
+            int ret = Interop.CkmcTypes.ParamListSetInteger(PtrCkmcParamList, (int)name, value);
             Interop.CheckNThrowException(ret, "Failed to add parameter.");
         }
 
@@ -54,7 +54,7 @@ namespace Tizen.Security.SecureRepository.Crypto
         protected void Add(CipherParameterName name, byte[] value)
         {
             Interop.CkmcRawBuffer rawBuff = new Interop.CkmcRawBuffer(new PinnedObject(value), value.Length);
-            int ret = Interop.CkmcTypes.CkmcParamListSetBuffer(PtrCkmcParamList, (int)name, new PinnedObject(rawBuff));
+            int ret = Interop.CkmcTypes.ParamListSetBuffer(PtrCkmcParamList, (int)name, new PinnedObject(rawBuff));
             Interop.CheckNThrowException(ret, "Failed to add parameter.");
         }
 
@@ -65,7 +65,7 @@ namespace Tizen.Security.SecureRepository.Crypto
         protected long GetInteger(CipherParameterName name)
         {
             long value = 0;
-            int ret = Interop.CkmcTypes.CkmcParamListGetInteger(PtrCkmcParamList, (int)name, out value);
+            int ret = Interop.CkmcTypes.ParamListGetInteger(PtrCkmcParamList, (int)name, out value);
             Interop.CheckNThrowException(ret, "Failed to get parameter.");
             return value;
         }
@@ -78,7 +78,7 @@ namespace Tizen.Security.SecureRepository.Crypto
         {
             IntPtr ptr = new IntPtr();
 
-            int ret = Interop.CkmcTypes.CkmcParamListGetBuffer(PtrCkmcParamList, (int)name, out ptr);
+            int ret = Interop.CkmcTypes.ParamListGetBuffer(PtrCkmcParamList, (int)name, out ptr);
             Interop.CheckNThrowException(ret, "Failed to get parameter.");
 
             return new SafeRawBufferHandle(ptr).Data;
@@ -113,7 +113,7 @@ namespace Tizen.Security.SecureRepository.Crypto
         {
             if (IsInvalid) // do not release
                 return true;
-            Interop.CkmcTypes.CkmcParamListFree(handle);
+            Interop.CkmcTypes.ParamListFree(handle);
             this.SetHandle(IntPtr.Zero);
             return true;
         }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Signature.cs b/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Signature.cs
index cdb295b..be5c95b 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Signature.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Crypto/Signature.cs
@@ -70,7 +70,7 @@ namespace Tizen.Security.SecureRepository.Crypto
             IntPtr ptrSignature = new IntPtr();
             Interop.CkmcRawBuffer messageBuff = new Interop.CkmcRawBuffer(new PinnedObject(message), message.Length);
 
-            int ret = Interop.CkmcManager.CkmcCreateSignature(privateKeyAlias, password, messageBuff,
+            int ret = Interop.CkmcManager.CreateSignature(privateKeyAlias, password, messageBuff,
                                                             hash, rsaPadding, out ptrSignature);
             Interop.CheckNThrowException(ret, "Failed to generate signature");
 
@@ -106,7 +106,7 @@ namespace Tizen.Security.SecureRepository.Crypto
             Interop.CkmcRawBuffer messageBuff = new Interop.CkmcRawBuffer(new PinnedObject(message), message.Length);
             Interop.CkmcRawBuffer signatureBuff = new Interop.CkmcRawBuffer(new PinnedObject(signature), signature.Length);
 
-            int ret = Interop.CkmcManager.CkmcVerifySignature(publicKeyAlias, password, messageBuff,
+            int ret = Interop.CkmcManager.VerifySignature(publicKeyAlias, password, messageBuff,
                                                         signatureBuff, hash, rsaPadding);
             if (ret == (int)Interop.KeyManagerError.VerificationFailed)
                 return false;

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/DataManager.cs b/Tizen.Security/Tizen.Security.SecureRepository/DataManager.cs
index 5e317f6..1a7aa46 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/DataManager.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/DataManager.cs
@@ -36,7 +36,7 @@ namespace Tizen.Security.SecureRepository
         {
             IntPtr ptr = new IntPtr();
 
-            int ret = Interop.CkmcManager.CkmcGetData(alias, password, out ptr);
+            int ret = Interop.CkmcManager.GetData(alias, password, out ptr);
             Interop.CheckNThrowException(ret, "Failed to get certificate. alias=" + alias);
 
             return new SafeRawBufferHandle(ptr).Data;
@@ -49,7 +49,7 @@ namespace Tizen.Security.SecureRepository
         static public IEnumerable<string> GetDataAliases()
         {
             IntPtr ptr = new IntPtr();
-            int ret = Interop.CkmcManager.CkmcGetDataAliasList(out ptr);
+            int ret = Interop.CkmcManager.GetDataAliasList(out ptr);
             Interop.CheckNThrowException(ret, "Failed to get data aliases");
 
             return new SafeAliasListHandle(ptr).Aliases;
@@ -65,7 +65,7 @@ namespace Tizen.Security.SecureRepository
         {
             Interop.CkmcRawBuffer rawBuff = new Interop.CkmcRawBuffer(new PinnedObject(data), data.Length);
 
-            int ret = Interop.CkmcManager.CkmcSaveData(alias, rawBuff, policy.ToCkmcPolicy());
+            int ret = Interop.CkmcManager.SaveData(alias, rawBuff, policy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to save data. alias=" + alias);
         }
     }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Key.cs b/Tizen.Security/Tizen.Security.SecureRepository/Key.cs
index 8be0d49..00ae581 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Key.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Key.cs
@@ -77,9 +77,9 @@ namespace Tizen.Security.SecureRepository
         internal CkmcKey ToCkmcKey()
         {
             return new Interop.CkmcKey(new PinnedObject(Binary),
-                                            Binary.Length,
-                                            (int)Type,
-                                            new PinnedObject(BinaryPassword));
+                                       Binary.Length,
+                                       (int)Type,
+                                       new PinnedObject(BinaryPassword));
         }
 
         /// <summary>
@@ -99,7 +99,7 @@ namespace Tizen.Security.SecureRepository
             if (IsInvalid) // do not release
                 return true;
 
-            Interop.CkmcTypes.CkmcKeyFree(handle);
+            Interop.CkmcTypes.KeyFree(handle);
             this.SetHandle(IntPtr.Zero);
             return true;
         }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/KeyManager.cs b/Tizen.Security/Tizen.Security.SecureRepository/KeyManager.cs
index ede1173..c63f3b7 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/KeyManager.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/KeyManager.cs
@@ -36,7 +36,7 @@ namespace Tizen.Security.SecureRepository
         {
             IntPtr ptr = new IntPtr();
 
-            int ret = Interop.CkmcManager.CkmcGetKey(alias, password, out ptr);
+            int ret = Interop.CkmcManager.GetKey(alias, password, out ptr);
             Interop.CheckNThrowException(ret, "Failed to get key. alias=" + alias);
 
             return new Key(ptr);
@@ -49,7 +49,7 @@ namespace Tizen.Security.SecureRepository
         static public IEnumerable<string> GetKeyAliases()
         {
             IntPtr ptr = new IntPtr();
-            int ret = Interop.CkmcManager.CkmcGetKeyAliasList(out ptr);
+            int ret = Interop.CkmcManager.GetKeyAliasList(out ptr);
             Interop.CheckNThrowException(ret, "Failed to get key aliases.");
 
             return new SafeAliasListHandle(ptr).Aliases;
@@ -65,7 +65,7 @@ namespace Tizen.Security.SecureRepository
         /// <remarks>If password in policy is provided, the key is additionally encrypted with the password in policy.</remarks>
         static public void SaveKey(string alias, Key key, Policy policy)
         {
-            int ret = Interop.CkmcManager.CkmcSaveKey(alias, key.ToCkmcKey(), policy.ToCkmcPolicy());
+            int ret = Interop.CkmcManager.SaveKey(alias, key.ToCkmcKey(), policy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to save Key. alias=" + alias);
         }
 
@@ -81,7 +81,7 @@ namespace Tizen.Security.SecureRepository
         static public void CreateKeyPairRsa(int size, string privateKeyAlias, string publicKeyAlias,
                                             Policy privateKeyPolicy, Policy publicKeyPolicy)
         {
-            int ret = Interop.CkmcManager.CkmcCreateKeyPairRsa(size, privateKeyAlias, publicKeyAlias,
+            int ret = Interop.CkmcManager.CreateKeyPairRsa(size, privateKeyAlias, publicKeyAlias,
                                         privateKeyPolicy.ToCkmcPolicy(), publicKeyPolicy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to Create RSA Key Pair");
         }
@@ -98,7 +98,7 @@ namespace Tizen.Security.SecureRepository
         static public void CreateKeyPairDsa(int size, string privateKeyAlias, string publicKeyAlias,
                                             Policy privateKeyPolicy, Policy publicKeyPolicy)
         {
-            int ret = Interop.CkmcManager.CkmcCreateKeyPairDsa(size, privateKeyAlias, publicKeyAlias,
+            int ret = Interop.CkmcManager.CreateKeyPairDsa(size, privateKeyAlias, publicKeyAlias,
                                         privateKeyPolicy.ToCkmcPolicy(), publicKeyPolicy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to Create DSA Key Pair");
         }
@@ -115,7 +115,7 @@ namespace Tizen.Security.SecureRepository
         static public void CreateKeyPairEcdsa(EllipticCurveType type, string privateKeyAlias, string publicKeyAlias,
                                     Policy privateKeyPolicy, Policy publicKeyPolicy)
         {
-            int ret = Interop.CkmcManager.CkmcCreateKeyPairEcdsa((int)type, privateKeyAlias, publicKeyAlias,
+            int ret = Interop.CkmcManager.CreateKeyPairEcdsa((int)type, privateKeyAlias, publicKeyAlias,
                                         privateKeyPolicy.ToCkmcPolicy(), publicKeyPolicy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to Create ECDSA Key Pair");
         }
@@ -129,7 +129,7 @@ namespace Tizen.Security.SecureRepository
         /// <remarks>If password in policy is provided, the key is additionally encrypted with the password in policy.</remarks>
         static public void CreateKeyAes(int size, string keyAlias, Policy policy)
         {
-            int ret = Interop.CkmcManager.CkmcCreateKeyAes(size, keyAlias, policy.ToCkmcPolicy());
+            int ret = Interop.CkmcManager.CreateKeyAes(size, keyAlias, policy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to AES Key");
         }
     }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Manager.cs b/Tizen.Security/Tizen.Security.SecureRepository/Manager.cs
index 1a4bb3f..20524ae 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Manager.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Manager.cs
@@ -53,7 +53,7 @@ namespace Tizen.Security.SecureRepository
         /// <remarks>The item owner can remove by default.</remarks>
         static public void RemoveAlias(string alias)
         {
-            int ret = Interop.CkmcManager.CkmcRemoveAlias(alias);
+            int ret = Interop.CkmcManager.RemoveAlias(alias);
             Interop.CheckNThrowException(ret, "Failed to remove alias. alias=" + alias);
         }
 
@@ -67,7 +67,7 @@ namespace Tizen.Security.SecureRepository
         /// <remarks>The item owner can set permissions.</remarks>
         static public void SetPermission(string alias, string otherPackageId, int permissions)
         {
-            int ret = Interop.CkmcManager.CkmcSetPermission(alias, otherPackageId, permissions);
+            int ret = Interop.CkmcManager.SetPermission(alias, otherPackageId, permissions);
             Interop.CheckNThrowException(ret, "Failed to set permission. alias=" + alias);
         }
     }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12.cs b/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12.cs
index 43036e4..d693749 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12.cs
@@ -37,7 +37,7 @@ namespace Tizen.Security.SecureRepository
         {
             IntPtr ptr = new IntPtr();
 
-            int ret = Interop.CkmcTypes.CkmcPkcs12Load(filePath, filePassword, out ptr);
+            int ret = Interop.CkmcTypes.Pkcs12Load(filePath, filePassword, out ptr);
             Interop.CheckNThrowException(ret, "Failed to load PKCS12. file=" + filePath);
 
             return new Pkcs12(ptr);
@@ -154,7 +154,7 @@ namespace Tizen.Security.SecureRepository
             if (IsInvalid) // do not release
                 return true;
 
-            Interop.CkmcTypes.CkmcPkcs12Free(handle);
+            Interop.CkmcTypes.Pkcs12Free(handle);
             this.SetHandle(IntPtr.Zero);
             return true;
         }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12Manager.cs b/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12Manager.cs
index f18585f..d52db23 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12Manager.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/Pkcs12Manager.cs
@@ -38,7 +38,7 @@ namespace Tizen.Security.SecureRepository
         {
             IntPtr ptr = new IntPtr();
 
-            int ret = Interop.CkmcManager.CkmcGetPkcs12(alias, keyPassword, cerificatePassword, out ptr);
+            int ret = Interop.CkmcManager.GetPkcs12(alias, keyPassword, cerificatePassword, out ptr);
             Interop.CheckNThrowException(ret, "Failed to get PKCS12. alias=" + alias);
 
             return new Pkcs12(ptr);
@@ -54,10 +54,10 @@ namespace Tizen.Security.SecureRepository
         /// <param name="certificatePolicy">The policy about how to store pkcs's certificate.</param>
         static public void SavePkcs12(string alias, Pkcs12 pkcs12, Policy keyPolicy, Policy certificatePolicy)
         {
-            int ret = Interop.CkmcManager.CkmcSavePkcs12(alias,
-                                                    new PinnedObject(pkcs12.ToCkmcPkcs12()),
-                                                    keyPolicy.ToCkmcPolicy(),
-                                                    certificatePolicy.ToCkmcPolicy());
+            int ret = Interop.CkmcManager.SavePkcs12(alias,
+                                                     new PinnedObject(pkcs12.ToCkmcPkcs12()),
+                                                     keyPolicy.ToCkmcPolicy(),
+                                                     certificatePolicy.ToCkmcPolicy());
             Interop.CheckNThrowException(ret, "Failed to save PKCS12. alias=" + alias);
         }
     }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/SafeAliasListHandle.cs b/Tizen.Security/Tizen.Security.SecureRepository/SafeAliasListHandle.cs
index 981ad26..fb57c56 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/SafeAliasListHandle.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/SafeAliasListHandle.cs
@@ -60,7 +60,7 @@ namespace Tizen.Security.SecureRepository
             if (IsInvalid) // do not release
                 return true;
 
-            Interop.CkmcTypes.CkmcAliasListAllFree(handle);
+            Interop.CkmcTypes.AliasListAllFree(handle);
             this.SetHandle(IntPtr.Zero);
             return true;
         }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/SafeCertificateListHandle.cs b/Tizen.Security/Tizen.Security.SecureRepository/SafeCertificateListHandle.cs
index 2676759..b0be5e9 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/SafeCertificateListHandle.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/SafeCertificateListHandle.cs
@@ -67,20 +67,20 @@ namespace Tizen.Security.SecureRepository
             foreach (Certificate cert in _certificates)
             {
                 IntPtr certPtr;
-                ret = Interop.CkmcTypes.CkmcCertNew(cert.Binary, (uint)cert.Binary.Length, (int)cert.Format, out certPtr);
+                ret = Interop.CkmcTypes.CertNew(cert.Binary, (uint)cert.Binary.Length, (int)cert.Format, out certPtr);
                 Interop.CheckNThrowException(ret, "Failed to create new Certificate.");
 
                 IntPtr outCertList;
                 if (previous == IntPtr.Zero)
                 {
-                    ret = Interop.CkmcTypes.CkmcCertListNew(certPtr, out outCertList);
+                    ret = Interop.CkmcTypes.CertListNew(certPtr, out outCertList);
                     Interop.CheckNThrowException(ret, "Failed to create new CertificateList.");
                     first = outCertList;
                     previous = outCertList;
                 }
                 else
                 {
-                    ret = Interop.CkmcTypes.CkmcCertListAdd(previous, certPtr, out outCertList);
+                    ret = Interop.CkmcTypes.CertListAdd(previous, certPtr, out outCertList);
                     Interop.CheckNThrowException(ret, "Failed to add Certificate to CertificateList.");
                     previous = outCertList;
                 }
@@ -107,7 +107,7 @@ namespace Tizen.Security.SecureRepository
             if (handle == IntPtr.Zero) // do not release
                 return true;
 
-            Interop.CkmcTypes.CkmcCertListAllFree(handle);
+            Interop.CkmcTypes.CertListAllFree(handle);
             this.SetHandle(IntPtr.Zero);
             return true;
         }

diff --git a/Tizen.Security/Tizen.Security.SecureRepository/SafeRawBufferHandle.cs b/Tizen.Security/Tizen.Security.SecureRepository/SafeRawBufferHandle.cs
index d2fed99..4e4ba5a 100644 (file)
--- a/Tizen.Security/Tizen.Security.SecureRepository/SafeRawBufferHandle.cs
+++ b/Tizen.Security/Tizen.Security.SecureRepository/SafeRawBufferHandle.cs
@@ -58,7 +58,7 @@ namespace Tizen.Security.SecureRepository
             if (IsInvalid) // do not release
                 return true;
 
-            Interop.CkmcTypes.CkmcBufferFree(handle);
+            Interop.CkmcTypes.BufferFree(handle);
             this.SetHandle(IntPtr.Zero);
             return true;
         }