src/include/ckmc/ckmc-manager.h

   1 /*
   2  *  Copyright (c) 2000 - 2014 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  * @file        ckmc-manager.h
  18  * @version     1.0
  19  * @brief       Provides management functions(storing, retrieving, and removing) for keys,
  20  *              certificates and data of a user and additional crypto functions.
  21  */
  22
  23
  24 #ifndef __TIZEN_CORE_CKMC_MANAGER_H
  25 #define __TIZEN_CORE_CKMC_MANAGER_H
  26
  27 #include <stddef.h>
  28 #include <sys/types.h>
  29 #include <tizen.h>
  30 #include <ckmc/ckmc-type.h>
  31 #include <ckmc/ckmc-error.h>
  32
  33 #ifdef __cplusplus
  34 extern "C" {
  35 #endif
  36
  37 /**
  38  * @addtogroup CAPI_KEY_MANAGER_CLIENT_MODULE
  39  * @{
  40  */
  41
  42
  43 /**
  44  * @brief Stores a key inside key manager based on the provided policy.
  45  *
  46  * @since_tizen 2.3
  47  * @privlevel public
  48  * @privilege %http://tizen.org/privilege/keymanager
  49  *
  50  * @remarks Currently API supports seven types of keys. These are RSA public/private key,
  51  *          DSA public/private key, ECDSA public/private key and AES symmetric key.
  52  * @remarks key_type in key may be set to #CKMC_KEY_NONE as an input. key_type is determined inside
  53  *          key manager during storing keys.
  54  * @remarks Some private key files are protected by a password. If raw_key in key read from those
  55  *          encrypted files is encrypted with a password, the password should be provided in the
  56  *          #ckmc_key_s structure.
  57  * @remarks If password in policy is provided, the key is additionally encrypted with the password
  58  *          in policy.
  59  *
  60  * @param[in] alias   The name of a key to be stored
  61  * @param[in] key     The key's binary value to be stored
  62  * @param[in] policy  The policy about how to store a key securely
  63  *
  64  * @return @c 0 on success,
  65  *         otherwise a negative error value
  66  *
  67  * @retval #CKMC_ERROR_NONE              Successful
  68  * @retval #CKMC_ERROR_INVALID_PARAMETER Input parameter is invalid
  69  * @retval #CKMC_ERROR_DB_LOCKED         A user key is not loaded in memory (a user is not logged
  70  *                                       in)
  71  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS   Alias already exists
  72  * @retval #CKMC_ERROR_INVALID_FORMAT    The format of raw_key is not valid
  73  * @retval #CKMC_ERROR_DB_ERROR          Failed due to a database error
  74  * @retval #CKMC_ERROR_PERMISSION_DENIED Failed to access key manager
  75  *
  76  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
  77  *
  78  * @see ckmc_remove_alias()
  79  * @see ckmc_get_key()
  80  * @see ckmc_get_key_alias_list()
  81  * @see #ckmc_key_s
  82  * @see #ckmc_policy_s
  83  */
  84 int ckmc_save_key(const char *alias, const ckmc_key_s key, const ckmc_policy_s policy);
  85
  86 /**
  87  * @deprecated Deprecated since 2.4. [Use ckmc_remove_alias() instead]
  88  * @brief Removes a key from key manager.
  89  *
  90  * @since_tizen 2.3
  91  * @privlevel public
  92  * @privilege %http://tizen.org/privilege/keymanager
  93  *
  94  * @remarks To remove key, client must have remove permission to the specified key.
  95  * @remarks The key owner can remove by default.
  96  *
  97  * @param[in] alias The name of a key to be removed
  98  *
  99  * @return @c 0 on success,
 100  *         otherwise a negative error value
 101  *
 102  * @retval #CKMC_ERROR_NONE              Successful
 103  * @retval #CKMC_ERROR_INVALID_PARAMETER Input parameter is invalid
 104  * @retval #CKMC_ERROR_DB_LOCKED         A user key is not loaded in memory (a user is not logged
 105  *                                       in)
 106  * @retval #CKMC_ERROR_DB_ERROR          Failed due to a database error
 107  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN  Alias does not exist
 108  * @retval #CKMC_ERROR_PERMISSION_DENIED Failed to access key manager
 109  *
 110  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 111  *
 112  * @see ckmc_save_key()
 113  * @see ckmc_get_key()
 114  * @see ckmc_get_key_alias_list()
 115  */
 116 int ckmc_remove_key(const char *alias);
 117
 118 /**
 119  * @brief Gets a key from key manager.
 120  *
 121  * @since_tizen 2.3
 122  * @privlevel public
 123  * @privilege %http://tizen.org/privilege/keymanager
 124  *
 125  * @remarks A client can access only data stored by the client.
 126  * @remarks You must destroy the newly created @a ppkey by calling ckmc_key_free() if it is no
 127  *          longer needed.
 128  *
 129  * @param[in] alias     The name of a key to retrieve
 130  * @param[in] password  The password used in decrypting a key value \n
 131  *                      If password of policy is provided in ckmc_save_key(), the same password
 132  *                      should be provided.
 133  * @param[out] ppkey    The pointer to a newly created ckmc_key_s handle
 134  *
 135  * @return @c 0 on success,
 136  *         otherwise a negative error value
 137  *
 138  * @retval #CKMC_ERROR_NONE              Successful
 139  * @retval #CKMC_ERROR_INVALID_PARAMETER Input parameter is invalid
 140  * @retval #CKMC_ERROR_DB_LOCKED         A user key is not loaded in memory (a user is not logged
 141  *                                       in)
 142  * @retval #CKMC_ERROR_DB_ERROR          Failed due to a database error
 143  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN  Alias does not exist
 144  * @retval #CKMC_ERROR_PERMISSION_DENIED Failed to access key manager
 145  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 146  *                                       Decryption failed because password is incorrect.
 147  *
 148  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 149  *
 150  * @see ckmc_save_key()
 151  * @see ckmc_remove_alias()
 152  * @see ckmc_get_key_alias_list()
 153  */
 154 int ckmc_get_key(const char *alias, const char *password, ckmc_key_s **ppkey);
 155
 156 /**
 157  * @brief Gets all the alias of keys that the client can access.
 158  *
 159  * @since_tizen 2.3
 160  * @privlevel public
 161  * @privilege %http://tizen.org/privilege/keymanager
 162  *
 163  * @remarks A client can access only data stored by the client.
 164  * @remarks You must destroy the newly created @a ppalias_list by calling ckmc_alias_list_all_free()
 165  *          if it is no longer needed.
 166  *
 167  * @param[out] ppalias_list  The pointer to a newly created ckmc_alias_list_s handle containing all
 168  *                           available alias of keys \n
 169  *                           If there is no available key alias, *ppalias_list will be null.
 170  *
 171  * @return @c 0 on success,
 172  *         otherwise a negative error value
 173  *
 174  * @retval #CKMC_ERROR_NONE              Successful
 175  * @retval #CKMC_ERROR_INVALID_PARAMETER Input parameter is invalid
 176  * @retval #CKMC_ERROR_DB_LOCKED         A user key is not loaded in memory (a user is not logged
 177  *                                       in)
 178  * @retval #CKMC_ERROR_DB_ERROR          Failed due to a database error
 179  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN  Alias does not exist
 180  * @retval #CKMC_ERROR_PERMISSION_DENIED Failed to access key manager
 181  *
 182  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 183  *
 184  * @see ckmc_save_key()
 185  * @see ckmc_remove_alias()
 186  * @see ckmc_get_key()
 187  */
 188 int ckmc_get_key_alias_list(ckmc_alias_list_s** ppalias_list);
 189
 190
 191
 192
 193 /**
 194  * @brief Stores a certificate inside key manager based on the provided policy.
 195  *
 196  * @since_tizen 2.3
 197  * @privlevel public
 198  * @privilege %http://tizen.org/privilege/keymanager
 199  *
 200  * @remarks the certificate's binary value will be converted and saved as binary DER encoded
 201  *          certificates.
 202  *
 203  * @param[in] alias  The name of a certificate to be stored
 204  * @param[in] cert   The certificate's binary value to be stored
 205  * @param[in] policy The policy about how to store a certificate securely
 206  *
 207  * @return @c 0 on success,
 208  *         otherwise a negative error value
 209  *
 210  * @retval #CKMC_ERROR_NONE               Successful
 211  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 212  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 213  *                                        in)
 214  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 215  * @retval #CKMC_ERROR_INVALID_FORMAT     The format of raw_cert is not valid
 216  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 217  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 218  *
 219  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 220  *
 221  * @see ckmc_remove_alias()
 222  * @see ckmc_get_cert()
 223  * @see ckmc_get_cert_alias_list()
 224  * @see #ckmc_cert_s
 225  * @see #ckmc_policy_s
 226  */
 227 int ckmc_save_cert(const char *alias, const ckmc_cert_s cert, const ckmc_policy_s policy);
 228
 229 /**
 230  * @deprecated Deprecated since 2.4. [Use ckmc_remove_alias() instead]
 231  * @brief Removes a certificate from key manager.
 232  *
 233  * @since_tizen 2.3
 234  * @privlevel public
 235  * @privilege %http://tizen.org/privilege/keymanager
 236  *
 237  * @remarks To remove certificate, client must have remove permission to the specified certificate.
 238  * @remarks The key owner can remove by default.
 239  *
 240  * @param[in] alias The name of a certificate to be removed
 241  *
 242  * @return @c 0 on success,
 243  *         otherwise a negative error value
 244  *
 245  * @retval #CKMC_ERROR_NONE               Successful
 246  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 247  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 248  *                                        in)
 249  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 250  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 251  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 252  *
 253  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 254  *
 255  * @see ckmc_save_cert()
 256  * @see ckmc_get_cert()
 257  * @see ckmc_get_cert_alias_list()
 258  */
 259 int ckmc_remove_cert(const char *alias);
 260
 261 /**
 262  * @brief Gets a certificate from key manager.
 263  *
 264  * @since_tizen 2.3
 265  * @privlevel public
 266  * @privilege %http://tizen.org/privilege/keymanager
 267  *
 268  * @remarks A client can access only certificate stored by the client.
 269  * @remarks A DER encoded certificate will be returned as a return value.
 270  * @remarks You must destroy the newly created @a ppcert by calling ckmc_cert_free() if it is no
 271  *          longer needed.
 272  *
 273  * @param[in] alias    The name of a certificate to retrieve
 274  * @param[in] password The password used in decrypting a certificate value \n
 275  *                     If password of policy is provided in ckmc_save_cert(), the same password
 276  *                     should be provided.
 277  * @param[out] ppcert  The pointer to a newly created ckmc_cert_s handle
 278  *
 279  * @return @c 0 on success,
 280  *         otherwise a negative error value
 281  *
 282  * @retval #CKMC_ERROR_NONE               Successful
 283  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 284  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 285  *                                        in)
 286  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 287  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exists
 288  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 289  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 290  *                                        Decryption failed because password is incorrect.
 291  *
 292  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 293  *
 294  * @see ckmc_save_cert()
 295  * @see ckmc_remove_alias()
 296  * @see ckmc_get_cert_alias_list()
 297  */
 298 int ckmc_get_cert(const char *alias, const char *password, ckmc_cert_s **ppcert);
 299
 300 /**
 301  * @brief Gets all alias of certificates which the client can access.
 302  *
 303  * @since_tizen 2.3
 304  * @privlevel public
 305  * @privilege %http://tizen.org/privilege/keymanager
 306  *
 307  * @remarks A client can access only data stored by the client.
 308  * @remarks You must destroy the newly created @a ppalias_list by calling ckmc_alias_list_all_free()
 309  *          if it is no longer needed.
 310  *
 311  * @param[out] ppalias_list The pointer to a newly created ckmc_alias_list_s handle containing all
 312  *                          available alias of keys \n
 313  *                          If there is no available key alias, *ppalias_list will be null.
 314  *
 315  * @return @c 0 on success,
 316  *         otherwise a negative error value
 317  *
 318  * @retval #CKMC_ERROR_NONE               Successful
 319  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 320  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 321  *                                        in)
 322  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 323  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 324  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 325  *
 326  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 327  *
 328  * @see ckmc_save_cert()
 329  * @see ckmc_remove_alias()
 330  * @see ckmc_get_cert()
 331  */
 332 int ckmc_get_cert_alias_list(ckmc_alias_list_s** ppalias_list);
 333
 334
 335
 336
 337 /**
 338  * @brief Stores PKCS12's contents inside key manager based on the provided policies.
 339  * All items from the PKCS12 will use the same alias.
 340  *
 341  * @since_tizen 2.4
 342  * @privlevel public
 343  * @privilege %http://tizen.org/privilege/keymanager
 344  *
 345  * @param[in] alias         The name of a data to be stored
 346  * @param[in] pkcs          Pointer to the pkcs12 structure to be saved
 347  * @param[in] key_policy    The policy about how to store pkcs's private key
 348  * @param[in] cert_policy   The policy about how to store pkcs's certificate
 349  *
 350  * @return @c 0 on success,
 351  *         otherwise a negative error value
 352  *
 353  * @retval #CKMC_ERROR_NONE               Successful
 354  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 355  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 356  *                                        in)
 357  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 358  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 359  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 360  *
 361  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 362  *
 363  * @see ckmc_remove_alias()
 364  * @see ckmc_get_pkcs12()
 365  * @see ckmc_get_data_alias_list()
 366  * @see ckmc_pkcs12_load()
 367  * @see #ckmc_pkcs12_s
 368  * @see #ckmc_policy_s
 369  */
 370 int ckmc_save_pkcs12(const char *alias,
 371                      const ckmc_pkcs12_s *pkcs,
 372                      const ckmc_policy_s key_policy,
 373                      const ckmc_policy_s cert_policy);
 374
 375 /**
 376  * @brief Gets a pkcs12 from key manager.
 377  *
 378  * @since_tizen 2.4
 379  * @privlevel public
 380  * @privilege %http://tizen.org/privilege/keymanager
 381  *
 382  * @remarks A client can access only data stored by the client.
 383  * @remarks You must destroy the newly created @a pkcs12 by calling ckmc_pkcs12_free() if it is no
 384  *          longer needed.
 385  *
 386  * @param[in]  alias        The name of a data to retrieve
 387  * @param[in]  key_password  Password that was used to encrypt privateKey (may be NULL)
 388  * @param[in]  cert_password Password used to encrypt certificates (may be NULL)
 389  * @param[out] pkcs12       The pointer to a newly created ckmc_pkcs12_s handle
 390  *
 391  * @return @c 0 on success,
 392  *         otherwise a negative error value
 393  *
 394  * @retval #CKMC_ERROR_NONE               Successful
 395  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 396  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 397  *                                        in)
 398  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 399  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 400  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 401  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 402  *                                        Decryption failed because password is incorrect.
 403  *
 404  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 405  *
 406  * @see ckmc_save_pkcs12()
 407  * @see ckmc_remove_alias()
 408  */
 409 int ckmc_get_pkcs12(const char *alias, const char *key_password, const char *cert_password, ckmc_pkcs12_s **pkcs12);
 410
 411 /**
 412  * @brief Stores a data inside key manager based on the provided policy.
 413  *
 414  * @since_tizen 2.3
 415  * @privlevel public
 416  * @privilege %http://tizen.org/privilege/keymanager
 417  *
 418  * @param[in] alias  The name of a data to be stored
 419  * @param[in] data   The binary value to be stored
 420  * @param[in] policy The policy about how to store a data securely
 421  *
 422  * @return @c 0 on success,
 423  *         otherwise a negative error value
 424  *
 425  * @retval #CKMC_ERROR_NONE               Successful
 426  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 427  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 428  *                                        in)
 429  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 430  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 431  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 432  *
 433  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 434  *
 435  * @see ckmc_remove_alias()
 436  * @see ckmc_get_data()
 437  * @see ckmc_get_data_alias_list()
 438  * @see #ckmc_raw_buffer_s
 439  * @see #ckmc_policy_s
 440  */
 441 int ckmc_save_data(const char *alias, ckmc_raw_buffer_s data, const ckmc_policy_s policy);
 442
 443 /**
 444  * @deprecated Deprecated since 2.4. [Use ckmc_remove_alias() instead]
 445  * @brief Removes a data from key manager.
 446  *
 447  * @since_tizen 2.3
 448  * @privlevel public
 449  * @privilege %http://tizen.org/privilege/keymanager
 450  *
 451  * @remarks To remove data, client must have remove permission to the specified data object.
 452  * @remarks The data owner can remove by default.
 453  *
 454  * @param[in] alias The name of a data to be removed
 455  *
 456  * @return @c 0 on success,
 457  *         otherwise a negative error value
 458  *
 459  * @retval #CKMC_ERROR_NONE               Successful
 460  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 461  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 462  *                                        in)
 463  * @retval #CKMC_ERROR_DB_ERROR           Failed due to the error with unknown reason
 464  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 465  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 466  *
 467  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 468  *
 469  * @see ckmc_save_data()
 470  * @see ckmc_get_data()
 471  * @see ckmc_get_data_alias_list()
 472  */
 473 int ckmc_remove_data(const char *alias);
 474
 475 /**
 476  * @brief Gets a data from key manager.
 477  *
 478  * @since_tizen 2.3
 479  * @privlevel public
 480  * @privilege %http://tizen.org/privilege/keymanager
 481  *
 482  * @remarks A client can access only data stored by the client.
 483  * @remarks You must destroy the newly created @a ppdata by calling ckmc_buffer_free() if it is no
 484  *          longer needed.
 485  *
 486  * @param[in]  alias     The name of a data to retrieve
 487  * @param[in]  password  The password used in decrypting a data value \n
 488  *                       If password of policy is provided in ckmc_save_data(), the same password
 489  *                       should be provided.
 490  * @param[out] ppdata    The pointer to a newly created ckmc_raw_buffer_s handle
 491  *
 492  * @return @c 0 on success,
 493  *         otherwise a negative error value
 494  *
 495  * @retval #CKMC_ERROR_NONE               Successful
 496  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 497  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 498  *                                        in)
 499  * @retval #CKMC_ERROR_DB_ERROR           Failed due to the error with unknown reason
 500  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 501  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 502  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 503  *                                        Decryption failed because password is incorrect.
 504  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 505  *
 506  * @see ckmc_save_data()
 507  * @see ckmc_remove_alias()
 508  * @see ckmc_get_data_alias_list()
 509  */
 510 int ckmc_get_data(const char *alias, const char *password, ckmc_raw_buffer_s **ppdata);
 511
 512 /**
 513  * @brief Gets all alias of data which the client can access.
 514  *
 515  * @since_tizen 2.3
 516  * @privlevel public
 517  * @privilege %http://tizen.org/privilege/keymanager
 518  *
 519  * @remarks A client can access only data stored by the client.
 520  * @remarks You must destroy the newly created @a ppalias_list by calling ckmc_alias_list_all_free()
 521  *          if it is no longer needed.
 522  *
 523  * @param[out] ppalias_list The pointer to a newly created ckmc_alias_list_s handle containing all
 524  *                          available alias of keys \n
 525  *                          If there is no available key alias, *ppalias_list will be null.
 526  *
 527  * @return @c 0 on success,
 528  *         otherwise a negative error value
 529  *
 530  * @retval #CKMC_ERROR_NONE               Successful
 531  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 532  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 533  *                                        in)
 534  * @retval #CKMC_ERROR_DB_ERROR           Failed due to the error with unknown reason
 535  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 536  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 537  *
 538  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 539  *
 540  * @see ckmc_save_data()
 541  * @see ckmc_remove_alias()
 542  * @see ckmc_get_data()
 543  */
 544 int ckmc_get_data_alias_list(ckmc_alias_list_s** ppalias_list);
 545
 546
 547
 548
 549 /**
 550  * @brief Creates RSA private/public key pair and stores them inside key manager based on each
 551  *        policy.
 552  *
 553  * @since_tizen 2.3
 554  * @privlevel public
 555  * @privilege %http://tizen.org/privilege/keymanager
 556  *
 557  * @remarks If password in policy is provided, the key is additionally encrypted with the password
 558  *          in policy.
 559  *
 560  * @param[in] size                The size of key strength to be created \n
 561  *                                @c 1024, @c 2048, and @c 4096 are supported.
 562  * @param[in] private_key_alias   The name of private key to be stored
 563  * @param[in] public_key_alias    The name of public key to be stored
 564  * @param[in] policy_private_key  The policy about how to store a private key securely
 565  * @param[in] policy_public_key   The policy about how to store a public key securely
 566  *
 567  * @return @c 0 on success,
 568  *         otherwise a negative error value
 569  *
 570  * @retval #CKMC_ERROR_NONE               Successful
 571  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 572  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 573  *                                        in)
 574  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 575  * @retval #CKMC_ERROR_DB_ERROR           Failed due to other DB transaction unexpectedly
 576  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 577  *
 578  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 579  *
 580  * @see ckmc_create_key_pair_dsa()
 581  * @see ckmc_create_key_pair_ecdsa()
 582  * @see ckmc_create_signature()
 583  * @see ckmc_verify_signature()
 584  */
 585 int ckmc_create_key_pair_rsa(const size_t size,
 586                              const char *private_key_alias,
 587                              const char *public_key_alias,
 588                              const ckmc_policy_s policy_private_key,
 589                              const ckmc_policy_s policy_public_key);
 590
 591 /**
 592  * @brief Creates DSA private/public key pair and stores them inside key manager based on each
 593  *        policy.
 594  *
 595  * @since_tizen 2.3
 596  * @privlevel public
 597  * @privilege %http://tizen.org/privilege/keymanager
 598  *
 599  * @remarks If password in policy is provided, the key is additionally encrypted with the password
 600  *          in policy.
 601  *
 602  * @param[in] size                The size of key strength to be created \n
 603  *                                @c 1024, @c 2048, @c 3072 and @c 4096 are supported.
 604  * @param[in] private_key_alias   The name of private key to be stored
 605  * @param[in] public_key_alias    The name of public key to be stored
 606  * @param[in] policy_private_key  The policy about how to store a private key securely
 607  * @param[in] policy_public_key   The policy about how to store a public key securely
 608  *
 609  * @return @c 0 on success,
 610  *         otherwise a negative error value
 611  *
 612  * @retval #CKMC_ERROR_NONE               Successful
 613  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 614  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 615  *                                        in)
 616  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 617  * @retval #CKMC_ERROR_DB_ERROR           Failed due to other DB transaction unexpectedly
 618  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 619  *
 620  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 621  *
 622  * @see ckmc_create_key_pair_rsa()
 623  * @see ckmc_create_key_pair_ecdsa()
 624  * @see ckmc_create_signature()
 625  * @see ckmc_verify_signature()
 626  */
 627 int ckmc_create_key_pair_dsa(const size_t size,
 628                              const char *private_key_alias,
 629                              const char *public_key_alias,
 630                              const ckmc_policy_s policy_private_key,
 631                              const ckmc_policy_s policy_public_key);
 632
 633 /**
 634  * @brief Creates ECDSA private/public key pair and stores them inside key manager based on each
 635  *        policy.
 636  *
 637  * @since_tizen 2.3
 638  * @privlevel public
 639  * @privilege %http://tizen.org/privilege/keymanager
 640  *
 641  * @remarks If password in policy is provided, the key is additionally encrypted with the password
 642  *          in policy.
 643  *
 644  * @param[in] type                The type of elliptic curve of ECDSA
 645  * @param[in] private_key_alias   The name of private key to be stored
 646  * @param[in] public_key_alias    The name of public key to be stored
 647  * @param[in] policy_private_key  The policy about how to store a private key securely
 648  * @param[in] policy_public_key   The policy about how to store a public key securely
 649  *
 650  * @return @c 0 on success,
 651  *         otherwise a negative error value
 652  *
 653  * @retval #CKMC_ERROR_NONE               Successful
 654  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 655  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 656  *                                        in)
 657  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 658  * @retval #CKMC_ERROR_DB_ERROR           Failed due to other DB transaction unexpectedly
 659  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 660  *
 661  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 662  *
 663  * @see ckmc_create_key_pair_rsa()
 664  * @see ckmc_create_key_pair_dsa()
 665  * @see ckmc_create_signature()
 666  * @see ckmc_verify_signature()
 667  * @see #ckmc_ec_type_e
 668  */
 669 int ckmc_create_key_pair_ecdsa(const ckmc_ec_type_e type,
 670                                const char *private_key_alias,
 671                                const char *public_key_alias,
 672                                const ckmc_policy_s policy_private_key,
 673                                const ckmc_policy_s policy_public_key);
 674
 675 /**
 676  * @brief Creates AES key and stores it inside key manager based on the policy.
 677  *
 678  * @since_tizen 3.0
 679  * @privlevel public
 680  * @privilege %http://tizen.org/privilege/keymanager
 681  *
 682  * @remarks If password in policy is provided, the key is additionally encrypted with the password
 683  *          in policy.
 684  *
 685  * @param[in] size                The size of key strength to be created. \n
 686  *                                @c 128, @c 192 and @c 256 are supported.
 687  * @param[in] key_alias           The name of key to be stored
 688  * @param[in] key_policy          The policy about how to store the key securely
 689  *
 690  * @return @c 0 on success,
 691  *         otherwise a negative error value
 692  *
 693  * @retval #CKMC_ERROR_NONE               Successful
 694  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 695  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 696  *                                        in)
 697  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 698  * @retval #CKMC_ERROR_DB_ERROR           Failed due to other DB transaction unexpectedly
 699  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 700  *
 701  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 702  *
 703  * @see ckmc_create_key_pair_rsa()
 704  * @see ckmc_create_key_pair_dsa()
 705  * @see ckmc_create_key_pair_ecdsa()
 706  */
 707 int ckmc_create_key_aes(const size_t size,
 708                         const char *key_alias,
 709                         const ckmc_policy_s key_policy);
 710
 711 /**
 712  * @brief Creates a signature on a given message using a private key and returns the signature.
 713  *
 714  * @since_tizen 2.3
 715  * @privlevel public
 716  * @privilege %http://tizen.org/privilege/keymanager
 717  *
 718  * @remarks If password of policy is provided during storing a key, the same password should be
 719  *          provided.
 720  * @remarks You must destroy the newly created @a ppsignature by calling ckmc_buffer_free() if it is
 721  *          no longer needed.
 722  *
 723  * @param[in]  private_key_alias  The name of private key
 724  * @param[in]  password           The password used in decrypting a private key value
 725  * @param[in]  message            The message that is signed with a private key
 726  * @param[in]  hash               The hash algorithm used in creating signature
 727  * @param[in]  padding            The RSA padding algorithm used in creating signature \n
 728  *                                It is used only when the signature algorithm is RSA.
 729  * @param[out] ppsignature        The pointer to a newly created signature \n
 730  *                                If an error occurs, @a *ppsignature will be null.
 731  *
 732  * @return @c 0 on success,
 733  *         otherwise a negative error value
 734  *
 735  * @retval #CKMC_ERROR_NONE               Successful
 736  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 737  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 738  *                                        in)
 739  * @retval #CKMC_ERROR_DB_ERROR           Failed due to the error with unknown reason
 740  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 741  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 742  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 743  *                                        Decryption failed because password is incorrect.
 744  *
 745  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 746  *
 747  * @see ckmc_create_key_pair_rsa()
 748  * @see ckmc_create_key_pair_ecdsa()
 749  * @see ckmc_verify_signature()
 750  * @see ckmc_buffer_free()
 751  * @see #ckmc_hash_algo_e
 752  * @see #ckmc_rsa_padding_algo_e
 753  */
 754 int ckmc_create_signature(const char *private_key_alias,
 755                           const char *password,
 756                           const ckmc_raw_buffer_s message,
 757                           const ckmc_hash_algo_e hash,
 758                           const ckmc_rsa_padding_algo_e padding,
 759                           ckmc_raw_buffer_s **ppsignature);
 760
 761 /**
 762  * @brief Verifies a given signature on a given message using a public key and returns the signature
 763  *        status.
 764  *
 765  * @since_tizen 2.3
 766  * @privlevel public
 767  * @privilege %http://tizen.org/privilege/keymanager
 768  *
 769  * @remarks If password of policy is provided during storing a key, the same password should be
 770  *          provided.
 771  *
 772  * @param[in] public_key_alias  The name of public key
 773  * @param[in] password          The password used in decrypting a public key value
 774  * @param[in] message           The input on which the signature is created
 775  * @param[in] signature         The signature that is verified with public key
 776  * @param[in] hash              The hash algorithm used in verifying signature
 777  * @param[in] padding           The RSA padding algorithm used in verifying signature \n
 778  *                              It is used only when the signature algorithm is RSA.
 779  *
 780  * @return @c 0 on success and the signature is valid,
 781  *         otherwise a negative error value
 782  *
 783  * @retval #CKMC_ERROR_NONE                 Successful
 784  * @retval #CKMC_ERROR_VERIFICATION_FAILED  The signature is invalid
 785  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 786  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 787  *                                          in)
 788  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 789  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
 790  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 791  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 792  *                                          Decryption failed because password is incorrect.
 793  *
 794  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 795  *
 796  * @see ckmc_create_key_pair_rsa()
 797  * @see ckmc_create_key_pair_ecdsa()
 798  * @see ckmc_verify_signature()
 799  * @see #ckmc_hash_algo_e
 800  * @see #ckmc_rsa_padding_algo_e
 801  */
 802 int ckmc_verify_signature(const char *public_key_alias,
 803                           const char *password,
 804                           const ckmc_raw_buffer_s message,
 805                           const ckmc_raw_buffer_s signature,
 806                           const ckmc_hash_algo_e hash,
 807                           const ckmc_rsa_padding_algo_e padding);
 808
 809 /**
 810  * @brief Verifies a certificate chain and returns that chain.
 811  *
 812  * @since_tizen 2.3
 813  * @privlevel public
 814  * @privilege %http://tizen.org/privilege/keymanager
 815  *
 816  * @remarks The trusted root certificate of the chain should exist in the system's certificate
 817  *          storage.
 818  * @remarks You must destroy the newly created @a ppcert_chain_list by calling
 819  *          ckmc_cert_list_all_free() if it is no longer needed.
 820  *
 821  * @param[in] cert               The certificate to be verified
 822  * @param[in] untrustedcerts     The untrusted CA certificates to be used in verifying a certificate
 823  *                               chain
 824  * @param[out] ppcert_chain_list The pointer to a newly created certificate chain's handle \n
 825  *                               If an error occurs, @a *ppcert_chain_list will be null.
 826  *
 827  * @return @c 0 on success and the signature is valid,
 828  *         otherwise a negative error value
 829  *
 830  * @retval #CKMC_ERROR_NONE                 Successful
 831  * @retval #CKMC_ERROR_VERIFICATION_FAILED  The certificate chain is not valid
 832  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 833  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 834  *                                          in)
 835  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 836  * @retval #CKMC_ERROR_INVALID_FORMAT       The format of certificate is not valid
 837  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 838  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 839  *                                          Decryption failed because password is incorrect.
 840  *
 841  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 842  *
 843  * @see ckmc_get_cert_chain_with_alias())
 844  * @see ckmc_cert_list_all_free()
 845  */
 846 int ckmc_get_cert_chain(const ckmc_cert_s *cert,
 847                         const ckmc_cert_list_s *untrustedcerts,
 848                         ckmc_cert_list_s **ppcert_chain_list);
 849
 850 /**
 851  * @brief Verifies a certificate chain using an alias list of untrusted certificates and return that
 852  *        chain.
 853  *
 854  * @since_tizen 2.3
 855  * @privlevel public
 856  * @privilege %http://tizen.org/privilege/keymanager
 857  *
 858  * @remarks The trusted root certificate of the chain should exist in the system's certificate
 859  *          storage.
 860  * @remarks You must destroy the newly created @a ppcert_chain_list by calling
 861  *          ckmc_cert_list_all_free() if it is no longer needed.
 862  *
 863  * @param[in] cert               The certificate to be verified
 864  * @param[in] untrustedcerts     The alias list of untrusted CA certificates stored in key manager
 865  *                               to be used in verifying a certificate chain
 866  * @param[out] ppcert_chain_list The pointer to a newly created certificate chain's handle \n
 867  *                               If an error occurs, @a *ppcert_chain_list will be null.
 868  *
 869  * @return @c 0 on success and the signature is valid,
 870  *         otherwise a negative error value
 871  *
 872  * @retval #CKMC_ERROR_NONE                 Successful
 873  * @retval #CKMC_ERROR_VERIFICATION_FAILED  The certificate chain is not valid
 874  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 875  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 876  *                                          in)
 877  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 878  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
 879  * @retval #CKMC_ERROR_INVALID_FORMAT       The format of certificate is not valid
 880  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 881  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 882  *                                          Some certificates were encrypted with password and could not
 883  *                                          be used.
 884  *
 885  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 886  *
 887  * @see ckmc_get_cert_chain()
 888  * @see ckmc_cert_list_all_free()
 889  */
 890 int ckmc_get_cert_chain_with_alias(const ckmc_cert_s *cert,
 891                                    const ckmc_alias_list_s *untrustedcerts,
 892                                    ckmc_cert_list_s **ppcert_chain_list);
 893
 894 /**
 895  * @brief Verifies a certificate chain and returns that chain using user entered trusted and
 896  *        untrusted CA certificates
 897  *
 898  * @since_tizen 2.4
 899  * @privlevel public
 900  * @privilege %http://tizen.org/privilege/keymanager
 901  *
 902  * @remarks If the trusted root certificates are provided as a user input, these certificates do not
 903  *          need to exist in the system's certificate storage.
 904  * @remarks You must destroy the newly created @a ppcert_chain_list by calling
 905  *          ckmc_cert_list_all_free() if it is no longer needed.
 906  *  *
 907  * @param[in] cert                    The certificate to be verified
 908  * @param[in] untrustedcerts          The untrusted CA certificates to be used in verifying a
 909  *                                    certificate chain
 910  * @param[in] trustedcerts            The trusted CA certificates to be used in verifying a
 911  *                                    certificate chain
 912  * @param[in] use_trustedsystemcerts  The flag indicating the use of the trusted root certificates
 913  *                                    in the system's certificate storage.
 914  * @param[out] ppcert_chain_list The pointer to a newly created certificate chain's handle \n
 915  *                               If an error occurs, @a *ppcert_chain_list will be null.
 916  *
 917  * @return @c 0 on success and the signature is valid,
 918  *         otherwise a negative error value
 919  *
 920  * @retval #CKMC_ERROR_NONE                 Successful
 921  * @retval #CKMC_ERROR_VERIFICATION_FAILED  The certificate chain is not valid
 922  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 923  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 924  *                                          in)
 925  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 926  * @retval #CKMC_ERROR_INVALID_FORMAT       The format of certificate is not valid
 927  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 928  *
 929  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 930  *
 931  * @see ckmc_get_cert_chain_with_trustedcert_alias()
 932  * @see ckmc_cert_list_all_free()
 933  */
 934 int ckmc_get_cert_chain_with_trustedcert(const ckmc_cert_s *cert,
 935                                          const ckmc_cert_list_s *untrustedcerts,
 936                                          const ckmc_cert_list_s *trustedcerts,
 937                                          const bool use_trustedsystemcerts,
 938                                          ckmc_cert_list_s **ppcert_chain_list);
 939
 940 /**
 941  * @brief Verifies a certificate chain and returns that chain using alias lists of untrusted and
 942  *        trusted certificates
 943  *
 944  * @since_tizen 2.4
 945  * @privlevel public
 946  * @privilege %http://tizen.org/privilege/keymanager
 947  *
 948  * @remarks If the alias list of trusted root certificates is provided as a user input, these
 949  *          certificates do not need to exist in the system's certificate storage.
 950  * @remarks You must destroy the newly created @a ppcert_chain_list by calling
 951  *          ckmc_cert_list_all_free() if it is no longer needed.
 952  *
 953  * @param[in] cert                    The certificate to be verified
 954  * @param[in] untrustedcerts          The alias list of untrusted CA certificates stored in key
 955  *                                    manager to be used in verifying a certificate chain
 956  * @param[in] trustedcerts            The alias list of trusted CA certificates stored in key
 957  *                                    manager to be used in verifying a certificate chain
 958  * @param[in] use_trustedsystemcerts  The flag indicating the use of the trusted root certificates
 959  *                                    in the system's certificate storage.
 960  * @param[out] ppcert_chain_list The pointer to a newly created certificate chain's handle \n
 961  *                               If an error occurs, @a *ppcert_chain_list will be null.
 962  *
 963  * @return @c 0 on success and the signature is valid,
 964  *         otherwise a negative error value
 965  *
 966  * @retval #CKMC_ERROR_NONE                 Successful
 967  * @retval #CKMC_ERROR_VERIFICATION_FAILED  The certificate chain is not valid
 968  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 969  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 970  *                                          in)
 971  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 972  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
 973  * @retval #CKMC_ERROR_INVALID_FORMAT       The format of certificate is not valid
 974  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 975  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 976  *                                          Some certificates were encrypted with password and could not
 977  *                                          be used.
 978  *
 979  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 980  *
 981  * @see ckmc_get_cert_chain_with_trustedcert()
 982  * @see ckmc_cert_list_all_free()
 983  */
 984 int ckmc_get_cert_chain_with_trustedcert_alias(const ckmc_cert_s *cert,
 985                                                const ckmc_alias_list_s *untrustedcerts,
 986                                                const ckmc_alias_list_s *trustedcerts,
 987                                                const bool use_trustedsystemcerts,
 988                                                ckmc_cert_list_s **ppcert_chain_list);
 989
 990 /**
 991  * @brief Perform OCSP which checks certificate is whether revoked or not
 992  *
 993  * @since_tizen 2.4
 994  * @privlevel public
 995  * @privilege %http://tizen.org/privilege/keymanager
 996  *
 997  * @param[in] pcert_chain_list   Valid certificate chain to perform OCSP check
 998  * @param[out] ocsp_status       The pointer to status result of OCSP check
 999  *
1000  * @return @c 0 on success, otherwise a negative error value
1001  *
1002  * @retval #CKMC_ERROR_NONE                 Successful
1003  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1004  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1005  *
1006  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1007  * @pre @a pcert_chain_list is created with ckmc_get_certificate_chain() or
1008  *      ckmc_get_certificate_chain_with_alias()
1009  *
1010  * @see ckmc_get_cert_chain())
1011  * @see ckmc_cert_list_all_free()
1012  */
1013 int ckmc_ocsp_check(const ckmc_cert_list_s *pcert_chain_list, ckmc_ocsp_status_e *ocsp_status);
1014
1015 /**
1016  * @deprecated Deprecated since 2.4. [Use ckmc_set_permission() instead]
1017  * @brief Allows another application to access client's application data
1018  *
1019  * @since_tizen 2.3
1020  * @privlevel public
1021  * @privilege %http://tizen.org/privilege/keymanager
1022  *
1023  * @remarks Data identified by @a alias should exist
1024  *
1025  * @param[in] alias       Data alias for which access will be granted
1026  * @param[in] accessor    Package id of the application that will gain access rights
1027  * @param[in] granted     Rights granted for @a accessor application
1028  *
1029  * @return @c 0 on success, otherwise a negative error value
1030  *
1031  * @retval #CKMC_ERROR_NONE                 Successful
1032  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1033  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1034  *                                          in)
1035  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1036  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
1037  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1038  *
1039  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1040  *
1041  * @see ckmc_deny_access()
1042  */
1043 int ckmc_allow_access(const char *alias, const char *accessor, ckmc_access_right_e granted);
1044
1045 /**
1046  * @brief Allows another application to access client's application data
1047  *
1048  * @since_tizen 2.4
1049  * @privlevel public
1050  * @privilege %http://tizen.org/privilege/keymanager
1051  *
1052  * @remarks Data identified by @a alias should exist
1053  *
1054  * @param[in] alias       Data alias for which access will be granted
1055  * @param[in] accessor    Package id of the application that will gain access rights
1056  * @param[in] permissions Mask of permissions granted for @a accessor application
1057  *                        (@a ckmc_permission_e)
1058  *                        (previous permission mask will be replaced with the new mask value)
1059  *
1060  * @return @c 0 on success, otherwise a negative error value
1061  *
1062  * @retval #CKMC_ERROR_NONE                 Successful
1063  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1064  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1065  *                                          in)
1066  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1067  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
1068  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1069  *
1070  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1071  */
1072 int ckmc_set_permission(const char *alias, const char *accessor, int permissions);
1073
1074 /**
1075  * @deprecated Deprecated since 2.4. [Use ckmc_set_permission() instead]
1076  * @brief Revokes another application's access to client's application data
1077  *
1078  * @since_tizen 2.3
1079  * @privlevel public
1080  * @privilege %http://tizen.org/privilege/keymanager
1081  *
1082  * @remarks Data identified by @a alias should exist
1083  * @remarks Only access previously granted with ckmc_allow_access can be revoked.
1084  *
1085  * @param[in] alias       Data alias for which access will be revoked
1086  * @param[in] accessor    Package id of the application that will lose access rights
1087  *
1088  * @return @c 0 on success, otherwise a negative error value
1089  *
1090  * @retval #CKMC_ERROR_NONE                 Successful
1091  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid or the @a accessor doesn't
1092  *                                          have access to @a alias
1093  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1094  *                                          in)
1095  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1096  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
1097  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1098  *
1099  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1100  *
1101  * @see ckmc_allow_access()
1102  * @see ckmc_set_permission()
1103  */
1104 int ckmc_deny_access(const char *alias, const char *accessor);
1105
1106 /**
1107  * @brief Removes a an entry (no matter of type) from the key manager.
1108  *
1109  * @since_tizen 2.4
1110  * @privlevel public
1111  * @privilege %http://tizen.org/privilege/keymanager
1112  *
1113  * @remarks To remove item, client must have remove permission to the specified item.
1114  * @remarks The item owner can remove by default.
1115  *
1116  * @param[in] alias Item alias to be removed
1117  *
1118  * @return @c 0 on success,
1119  *         otherwise a negative error value
1120  *
1121  * @retval #CKMC_ERROR_NONE              Successful
1122  * @retval #CKMC_ERROR_INVALID_PARAMETER Input parameter is invalid
1123  * @retval #CKMC_ERROR_DB_LOCKED         A user key is not loaded in memory (a user is not logged
1124  *                                       in)
1125  * @retval #CKMC_ERROR_DB_ERROR          Failed due to a database error
1126  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN  Alias does not exist
1127  * @retval #CKMC_ERROR_PERMISSION_DENIED Failed to access key manager
1128  *
1129  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1130  *
1131  * @see ckmc_save_key()
1132  * @see ckmc_save_cert
1133  * @see ckmc_save_data
1134  * @see ckmc_save_pkcs12
1135  * @see ckmc_create_key_pair_rsa
1136  * @see ckmc_create_key_pair_dsa
1137  * @see ckmc_create_key_pair_ecdsa
1138  */
1139 int ckmc_remove_alias(const char *alias);
1140
1141 /**
1142  * @brief Encrypts data using selected key and algorithm
1143  *
1144  * @since_tizen 3.0
1145  * @privlevel public
1146  * @privilege %http://tizen.org/privilege/keymanager
1147  *
1148  * @remarks Key identified by @a key_alias should exist
1149  *
1150  * @param[in] params            Algorithm parameters
1151  * @param[in] key_alias         Alias of the key to be used for encryption
1152  * @param[in] password          The password used in decrypting a key value. If password of policy
1153  *                              is provided in ckmc_save_key(), the same password should be provided
1154  * @param[in] decrypted         Data to be encrypted
1155  * @param[out] ppencrypted      Encrypted data (some algorithms may return additional information
1156  *                              embedded in encrypted data. AES GCM is an example). The caller is
1157  *                              responsible for freeing ppencrypted with ckmc_buffer_free().
1158  *
1159  * @return @c 0 on success, otherwise a negative error value
1160  *
1161  * @retval #CKMC_ERROR_NONE                 Successful
1162  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1163  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1164  *                                          in)
1165  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1166  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Key with given alias does not exist
1167  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1168  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
1169  *                                          Key decryption failed because password is incorrect.
1170  *
1171  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1172  */
1173 int ckmc_encrypt_data(const ckmc_param_list_s *params,
1174                       const char *key_alias,
1175                       const char *password,
1176                       const ckmc_raw_buffer_s decrypted,
1177                       ckmc_raw_buffer_s **ppencrypted);
1178
1179 /**
1180  * @brief Decrypts data using selected key and algorithm
1181  *
1182  * @since_tizen 3.0
1183  * @privlevel public
1184  * @privilege %http://tizen.org/privilege/keymanager
1185  *
1186  * @remarks Key identified by @a key_alias should exist
1187  *
1188  * @param[in] params            Algorithm parameters
1189  * @param[in] key_alias         Alias of the key to be used for encryption
1190  * @param[in] password          The password used in decrypting a key value. If password of policy
1191  *                              is provided in ckmc_save_key(), the same password should be provided
1192  * @param[in] encrypted         Data to be decrypted (some algorithms may require additional
1193  *                              information embedded in encrypted data. AES GCM is an example).
1194  * @param[out] ppdecrypted      Decrypted data. The caller is responsible for freeing ppdecrypted
1195  *                              with ckmc_buffer_free().
1196  *
1197  * @return @c 0 on success, otherwise a negative error value
1198  *
1199  * @retval #CKMC_ERROR_NONE                 Successful
1200  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1201  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1202  *                                          in)
1203  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1204  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Key with given alias does not exist
1205  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1206  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
1207  *                                          Key decryption failed because password is incorrect.
1208  *
1209  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1210  */
1211 int ckmc_decrypt_data(const ckmc_param_list_s *params,
1212                       const char *key_alias,
1213                       const char *password,
1214                       const ckmc_raw_buffer_s encrypted,
1215                       ckmc_raw_buffer_s **ppdecrypted);
1216
1217 #ifdef __cplusplus
1218 }
1219 #endif
1220
1221 /**
1222  * @}
1223  */
1224
1225
1226 #endif /* __TIZEN_CORE_CKMC_MANAGER_H */