src/Tizen.Security.SecureRepository/Interop/Interop.CkmcManager.cs

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  */
  16
  17 using System;
  18 using System.Runtime.InteropServices;
  19
  20 internal static partial class Interop
  21 {
  22     internal static partial class CkmcManager
  23     {
  24         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_key", CallingConvention = CallingConvention.Cdecl)]
  25         public static extern int SaveKey(string alias, CkmcKey key, CkmcPolicy policy);
  26         // int ckmc_save_key(const char *alias, const ckmc_key_s key, const ckmc_policy_s policy);
  27
  28         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_key", CallingConvention = CallingConvention.Cdecl)]
  29         public static extern int GetKey(string alias, string password, out IntPtr key);
  30         // int ckmc_get_key(const char *alias, const char *password, ckmc_key_s **ppkey);
  31
  32         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_key_alias_list", CallingConvention = CallingConvention.Cdecl)]
  33         public static extern int GetKeyAliasList(out IntPtr aliases);
  34         // int ckmc_get_key_alias_list(ckmc_alias_list_s **ppalias_list);
  35
  36
  37         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_cert", CallingConvention = CallingConvention.Cdecl)]
  38         public static extern int SaveCert(string alias, CkmcCert cert, CkmcPolicy policy);
  39         // int ckmc_save_cert(const char *alias, const ckmc_cert_s cert, const ckmc_policy_s policy);
  40
  41         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert", CallingConvention = CallingConvention.Cdecl)]
  42         public static extern int GetCert(string alias, string password, out IntPtr data);
  43         // int ckmc_get_cert(const char *alias, const char *password, ckmc_cert_s** ppcert);
  44
  45         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert_alias_list", CallingConvention = CallingConvention.Cdecl)]
  46         public static extern int GetCertAliasList(out IntPtr aliases);
  47         // int ckmc_get_cert_alias_list(ckmc_alias_list_s **ppalias_list);
  48
  49
  50         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_data", CallingConvention = CallingConvention.Cdecl)]
  51         public static extern int SaveData(string alias, CkmcRawBuffer data, CkmcPolicy policy);
  52         // int ckmc_save_data(const char *alias, ckmc_raw_buffer_s data, const ckmc_policy_s policy);
  53
  54         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_data", CallingConvention = CallingConvention.Cdecl)]
  55         public static extern int GetData(string alias, string password, out IntPtr data);
  56         // int ckmc_get_data(const char* alias, const char* password, ckmc_raw_buffer_s **ppdata);
  57
  58         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_data_alias_list", CallingConvention = CallingConvention.Cdecl)]
  59         public static extern int GetDataAliasList(out IntPtr aliases);
  60         // int ckmc_get_data_alias_list(ckmc_alias_list_s **ppalias_list);
  61
  62
  63         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_remove_alias", CallingConvention = CallingConvention.Cdecl)]
  64         public static extern int RemoveAlias(string alias);
  65         // int ckmc_remove_alias(const char *alias);
  66
  67
  68         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_save_pkcs12", CallingConvention = CallingConvention.Cdecl)]
  69         public static extern int SavePkcs12(string alias, IntPtr p12, CkmcPolicy keyPolicy, CkmcPolicy certPolicy);
  70         // int ckmc_save_pkcs12(const char *alias, const ckmc_pkcs12_s* pkcs, const ckmc_policy_s key_policy, const ckmc_policy_s cert_policy);
  71
  72         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_pkcs12", CallingConvention = CallingConvention.Cdecl)]
  73         public static extern int GetPkcs12(string alias, string keyPassword, string certPassword, out IntPtr pkcs12);
  74         // int ckmc_get_pkcs12(const char *alias, const char *key_password, const char* cert_password, ckmc_pkcs12_s **pkcs12);
  75
  76         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_set_permission", CallingConvention = CallingConvention.Cdecl)]
  77         public static extern int SetPermission(string alias, string accessor, int permissions);
  78         // int ckmc_set_permission(const char *alias, const char *accessor, int permissions);
  79
  80
  81         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_pair_rsa", CallingConvention = CallingConvention.Cdecl)]
  82         public static extern int CreateKeyPairRsa(UIntPtr size, string privateKeyAlias, string publicKeyAlias,
  83                                                   CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
  84         // int ckmc_create_key_pair_rsa(const size_t size, const char* private_key_alias, const char* public_key_alias,
  85         //                              const ckmc_policy_s policy_private_key, const ckmc_policy_s policy_public_key);
  86
  87         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_pair_dsa", CallingConvention = CallingConvention.Cdecl)]
  88         public static extern int CreateKeyPairDsa(UIntPtr size, string privateKeyAlias, string publicKeyAlias,
  89                                                   CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
  90         // int ckmc_create_key_pair_dsa(const size_t size, const char* private_key_alias, const char* public_key_alias,
  91         //                              const ckmc_policy_s policy_private_key, const ckmc_policy_s policy_public_key);
  92
  93         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_pair_ecdsa", CallingConvention = CallingConvention.Cdecl)]
  94         public static extern int CreateKeyPairEcdsa(int ecType, string privateKeyAlias, string publicKeyAlias,
  95                                                         CkmcPolicy privateKeyPolicy, CkmcPolicy publicKeyPolicy);
  96         // int ckmc_create_key_pair_ecdsa(const ckmc_ec_type_e type, const char* private_key_alias, const char* public_key_alias,
  97         //                                const ckmc_policy_s policy_private_key, const ckmc_policy_s policy_public_key);
  98
  99         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_key_aes", CallingConvention = CallingConvention.Cdecl)]
 100         public static extern int CreateKeyAes(UIntPtr size, string ceyAlias, CkmcPolicy keyPolicy);
 101         // int ckmc_create_key_aes(size_t size, const char* key_alias, ckmc_policy_s key_policy);
 102
 103         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_create_signature", CallingConvention = CallingConvention.Cdecl)]
 104         public static extern int CreateSignature(string privateKeyAlias, string password, CkmcRawBuffer message,
 105                                                  int hashAlgorithm, int paddingAlgorithm, out IntPtr signature);
 106         // int ckmc_create_signature(const char *private_key_alias, const char* password, const ckmc_raw_buffer_s message,
 107         //                           const ckmc_hash_algo_e hash, const ckmc_rsa_padding_algo_e padding, ckmc_raw_buffer_s **ppsignature);
 108
 109         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_verify_signature", CallingConvention = CallingConvention.Cdecl)]
 110         public static extern int VerifySignature(string publicKeyAlias, string password, CkmcRawBuffer message,
 111                                                  CkmcRawBuffer signature, int hashAlgorithm, int paddingAlgorithm);
 112         // int ckmc_verify_signature(const char *public_key_alias, const char* password, const ckmc_raw_buffer_s message,
 113         //           const ckmc_raw_buffer_s signature, const ckmc_hash_algo_e hash, const ckmc_rsa_padding_algo_e padding);
 114
 115         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_encrypt_data", CallingConvention = CallingConvention.Cdecl)]
 116         public static extern int EncryptData(IntPtr parameters, string keyAlias, string password, CkmcRawBuffer plainText, out IntPtr cipherText);
 117         // int ckmc_encrypt_data(ckmc_param_list_h params, const char* key_alias, const char* password,
 118         //                       const ckmc_raw_buffer_s decrypted, ckmc_raw_buffer_s **ppencrypted);
 119
 120         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_decrypt_data", CallingConvention = CallingConvention.Cdecl)]
 121         public static extern int DecryptData(IntPtr parameters, string keyAlias, string password, CkmcRawBuffer cipherText, out IntPtr plainText);
 122         // int ckmc_decrypt_data(ckmc_param_list_h params, const char* key_alias, const char* password,
 123         //                       const ckmc_raw_buffer_s encrypted, ckmc_raw_buffer_s **ppdecrypted);
 124
 125
 126         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert_chain", CallingConvention = CallingConvention.Cdecl)]
 127         public static extern int GetCertChain(IntPtr cert, IntPtr untrustedCerts, out IntPtr certChain);
 128         // int ckmc_get_cert_chain(const ckmc_cert_s *cert, const ckmc_cert_list_s* untrustedcerts, ckmc_cert_list_s **ppcert_chain_list);
 129
 130         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_get_cert_chain_with_trustedcert", CallingConvention = CallingConvention.Cdecl)]
 131         public static extern int GetCertChainWithTrustedCerts(IntPtr cert, IntPtr untrustedCerts, IntPtr trustedCerts,
 132                                                               bool useTrustedSystemCerts, out IntPtr certChain);
 133         // int ckmc_get_cert_chain_with_trustedcert(const ckmc_cert_s *cert, const ckmc_cert_list_s* untrustedcerts,
 134         //       const ckmc_cert_list_s* trustedcerts, const bool use_trustedsystemcerts, ckmc_cert_list_s **ppcert_chain_list);
 135
 136         [DllImport(Libraries.KeyManager, EntryPoint = "ckmc_ocsp_check", CallingConvention = CallingConvention.Cdecl)]
 137         public static extern int OcspCheck(IntPtr certChain, ref int ocspStatus);
 138         // int ckmc_ocsp_check(const ckmc_cert_list_s *pcert_chain_list, ckmc_ocsp_status_e* ocsp_status);
 139     }
 140 }