src/include/ckmc/ckmc-manager.h

   1 /*
   2  *  Copyright (c) 2000 - 2015 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
  48  *          required to use this API since 3.0.
  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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
  92  *          required to use this API since 3.0.
  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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 123  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 161  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer required to use this API since 3.0
 198  *
 199  * @remarks the certificate's binary value will be converted and saved as binary DER encoded
 200  *          certificates.
 201  *
 202  * @param[in] alias  The name of a certificate to be stored
 203  * @param[in] cert   The certificate's binary value to be stored
 204  * @param[in] policy The policy about how to store a certificate securely
 205  *
 206  * @return @c 0 on success,
 207  *         otherwise a negative error value
 208  *
 209  * @retval #CKMC_ERROR_NONE               Successful
 210  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 211  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 212  *                                        in)
 213  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 214  * @retval #CKMC_ERROR_INVALID_FORMAT     The format of raw_cert is not valid
 215  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 216  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 217  *
 218  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 219  *
 220  * @see ckmc_remove_alias()
 221  * @see ckmc_get_cert()
 222  * @see ckmc_get_cert_alias_list()
 223  * @see #ckmc_cert_s
 224  * @see #ckmc_policy_s
 225  */
 226 int ckmc_save_cert(const char *alias, const ckmc_cert_s cert, const ckmc_policy_s policy);
 227
 228 /**
 229  * @deprecated Deprecated since 2.4. [Use ckmc_remove_alias() instead]
 230  * @brief Removes a certificate from key manager.
 231  *
 232  * @since_tizen 2.3
 233  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 234  *          required to use this API since 3.0.
 235  *
 236  * @remarks To remove certificate, client must have remove permission to the specified certificate.
 237  * @remarks The key owner can remove by default.
 238  *
 239  * @param[in] alias The name of a certificate to be removed
 240  *
 241  * @return @c 0 on success,
 242  *         otherwise a negative error value
 243  *
 244  * @retval #CKMC_ERROR_NONE               Successful
 245  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 246  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 247  *                                        in)
 248  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 249  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 250  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 251  *
 252  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 253  *
 254  * @see ckmc_save_cert()
 255  * @see ckmc_get_cert()
 256  * @see ckmc_get_cert_alias_list()
 257  */
 258 int ckmc_remove_cert(const char *alias);
 259
 260 /**
 261  * @brief Gets a certificate from key manager.
 262  *
 263  * @since_tizen 2.3
 264  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 265  *          required to use this API since 3.0.
 266  *
 267  * @remarks A client can access only certificate stored by the client.
 268  * @remarks A DER encoded certificate will be returned as a return value.
 269  * @remarks You must destroy the newly created @a ppcert by calling ckmc_cert_free() if it is no
 270  *          longer needed.
 271  *
 272  * @param[in] alias    The name of a certificate to retrieve
 273  * @param[in] password The password used in decrypting a certificate value \n
 274  *                     If password of policy is provided in ckmc_save_cert(), the same password
 275  *                     should be provided.
 276  * @param[out] ppcert  The pointer to a newly created ckmc_cert_s handle
 277  *
 278  * @return @c 0 on success,
 279  *         otherwise a negative error value
 280  *
 281  * @retval #CKMC_ERROR_NONE               Successful
 282  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 283  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 284  *                                        in)
 285  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 286  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exists
 287  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 288  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 289  *                                        Decryption failed because password is incorrect.
 290  *
 291  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 292  *
 293  * @see ckmc_save_cert()
 294  * @see ckmc_remove_alias()
 295  * @see ckmc_get_cert_alias_list()
 296  */
 297 int ckmc_get_cert(const char *alias, const char *password, ckmc_cert_s **ppcert);
 298
 299 /**
 300  * @brief Gets all alias of certificates which the client can access.
 301  *
 302  * @since_tizen 2.3
 303  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 304  *          required to use this API since 3.0.
 305  *
 306  * @remarks A client can access only data stored by the client.
 307  * @remarks You must destroy the newly created @a ppalias_list by calling ckmc_alias_list_all_free()
 308  *          if it is no longer needed.
 309  *
 310  * @param[out] ppalias_list The pointer to a newly created ckmc_alias_list_s handle containing all
 311  *                          available alias of keys \n
 312  *                          If there is no available key alias, *ppalias_list will be null.
 313  *
 314  * @return @c 0 on success,
 315  *         otherwise a negative error value
 316  *
 317  * @retval #CKMC_ERROR_NONE               Successful
 318  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 319  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 320  *                                        in)
 321  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 322  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 323  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 324  *
 325  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 326  *
 327  * @see ckmc_save_cert()
 328  * @see ckmc_remove_alias()
 329  * @see ckmc_get_cert()
 330  */
 331 int ckmc_get_cert_alias_list(ckmc_alias_list_s** ppalias_list);
 332
 333
 334
 335
 336 /**
 337  * @brief Stores PKCS12's contents inside key manager based on the provided policies.
 338  *        All items from the PKCS12 will use the same alias.
 339  *
 340  * @since_tizen 2.4
 341  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 342  *          required to use this API since 3.0.
 343  *
 344  * @param[in] alias         The name of a data to be stored
 345  * @param[in] pkcs          Pointer to the pkcs12 structure to be saved
 346  * @param[in] key_policy    The policy about how to store pkcs's private key
 347  * @param[in] cert_policy   The policy about how to store pkcs's certificate
 348  *
 349  * @return @c 0 on success,
 350  *         otherwise a negative error value
 351  *
 352  * @retval #CKMC_ERROR_NONE               Successful
 353  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 354  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 355  *                                        in)
 356  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 357  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 358  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 359  *
 360  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 361  *
 362  * @see ckmc_remove_alias()
 363  * @see ckmc_get_pkcs12()
 364  * @see ckmc_get_data_alias_list()
 365  * @see ckmc_pkcs12_load()
 366  * @see #ckmc_pkcs12_s
 367  * @see #ckmc_policy_s
 368  */
 369 int ckmc_save_pkcs12(const char *alias,
 370                      const ckmc_pkcs12_s *pkcs,
 371                      const ckmc_policy_s key_policy,
 372                      const ckmc_policy_s cert_policy);
 373
 374 /**
 375  * @brief Gets a pkcs12 from key manager.
 376  *
 377  * @since_tizen 2.4
 378  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 379  *          required to use this API since 3.0.
 380  *
 381  * @remarks A client can access only data stored by the client.
 382  * @remarks You must destroy the newly created @a pkcs12 by calling ckmc_pkcs12_free() if it is no
 383  *          longer needed.
 384  *
 385  * @param[in]  alias        The name of a data to retrieve
 386  * @param[in]  key_password  Password that was used to encrypt privateKey (may be NULL)
 387  * @param[in]  cert_password Password used to encrypt certificates (may be NULL)
 388  * @param[out] pkcs12       The pointer to a newly created ckmc_pkcs12_s handle
 389  *
 390  * @return @c 0 on success,
 391  *         otherwise a negative error value
 392  *
 393  * @retval #CKMC_ERROR_NONE               Successful
 394  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 395  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 396  *                                        in)
 397  * @retval #CKMC_ERROR_DB_ERROR           Failed due to a database error
 398  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 399  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 400  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 401  *                                        key_password or cert_password does not match with password
 402  *                                        used to encrypt data
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 416  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 449  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 480  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 517  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 555  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 597  *          required to use this API since 3.0.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 639  *          required to use this API since 3.0.
 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  *
 680  * @remarks If password in policy is provided, the key is additionally encrypted with the password
 681  *          in policy.
 682  *
 683  * @param[in] size                The size of key strength to be created \n
 684  *                                @c 128, @c 192 and @c 256 are supported
 685  * @param[in] key_alias           The name of key to be stored
 686  * @param[in] key_policy          The policy about how to store the key securely
 687  *
 688  * @return @c 0 on success,
 689  *         otherwise a negative error value
 690  *
 691  * @retval #CKMC_ERROR_NONE               Successful
 692  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 693  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 694  *                                        in)
 695  * @retval #CKMC_ERROR_DB_ALIAS_EXISTS    Alias already exists
 696  * @retval #CKMC_ERROR_DB_ERROR           Failed due to other DB transaction unexpectedly
 697  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 698  *
 699  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 700  *
 701  * @see ckmc_create_key_pair_rsa()
 702  * @see ckmc_create_key_pair_dsa()
 703  * @see ckmc_create_key_pair_ecdsa()
 704  * @see #ckmc_policy_s
 705  */
 706 int ckmc_create_key_aes(size_t size,
 707                         const char *key_alias,
 708                         ckmc_policy_s key_policy);
 709
 710 /**
 711  * @brief Creates a signature on a given message using a private key and returns the signature.
 712  *
 713  * @since_tizen 2.3
 714  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 715  *          required to use this API since 3.0.
 716  *
 717  * @remarks If password of policy is provided during storing a key, the same password should be
 718  *          provided.
 719  * @remarks You must destroy the newly created @a ppsignature by calling ckmc_buffer_free() if it is
 720  *          no longer needed.
 721  *
 722  * @param[in]  private_key_alias  The name of private key
 723  * @param[in]  password           The password used in decrypting a private key value
 724  * @param[in]  message            The message that is signed with a private key
 725  * @param[in]  hash               The hash algorithm used in creating signature
 726  * @param[in]  padding            The RSA padding algorithm used in creating signature \n
 727  *                                It is used only when the signature algorithm is RSA
 728  * @param[out] ppsignature        The pointer to a newly created signature \n
 729  *                                If an error occurs, @a *ppsignature will be null
 730  *
 731  * @return @c 0 on success,
 732  *         otherwise a negative error value
 733  *
 734  * @retval #CKMC_ERROR_NONE               Successful
 735  * @retval #CKMC_ERROR_INVALID_PARAMETER  Input parameter is invalid
 736  * @retval #CKMC_ERROR_DB_LOCKED          A user key is not loaded in memory (a user is not logged
 737  *                                        in)
 738  * @retval #CKMC_ERROR_DB_ERROR           Failed due to the error with unknown reason
 739  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN   Alias does not exist
 740  * @retval #CKMC_ERROR_PERMISSION_DENIED  Failed to access key manager
 741  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 742  *                                        Decryption failed because password is incorrect
 743  *
 744  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 745  *
 746  * @see ckmc_create_key_pair_rsa()
 747  * @see ckmc_create_key_pair_ecdsa()
 748  * @see ckmc_verify_signature()
 749  * @see ckmc_buffer_free()
 750  * @see #ckmc_hash_algo_e
 751  * @see #ckmc_rsa_padding_algo_e
 752  */
 753 int ckmc_create_signature(const char *private_key_alias,
 754                           const char *password,
 755                           const ckmc_raw_buffer_s message,
 756                           const ckmc_hash_algo_e hash,
 757                           const ckmc_rsa_padding_algo_e padding,
 758                           ckmc_raw_buffer_s **ppsignature);
 759
 760 /**
 761  * @brief Verifies a given signature on a given message using a public key and returns the signature
 762  *        status.
 763  *
 764  * @since_tizen 2.3
 765  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 766  *          required to use this API since 3.0.
 767  *
 768  * @remarks If password of policy is provided during storing a key, the same password should be
 769  *          provided.
 770  *
 771  * @param[in] public_key_alias  The name of public key
 772  * @param[in] password          The password used in decrypting a public key value
 773  * @param[in] message           The input on which the signature is created
 774  * @param[in] signature         The signature that is verified with public key
 775  * @param[in] hash              The hash algorithm used in verifying signature
 776  * @param[in] padding           The RSA padding algorithm used in verifying signature \n
 777  *                              It is used only when the signature algorithm is RSA
 778  *
 779  * @return @c 0 on success and the signature is valid,
 780  *         otherwise a negative error value
 781  *
 782  * @retval #CKMC_ERROR_NONE                 Successful
 783  * @retval #CKMC_ERROR_VERIFICATION_FAILED  The signature is invalid
 784  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 785  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 786  *                                          in)
 787  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 788  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
 789  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 790  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 791  *                                          Decryption failed because password is incorrect
 792  *
 793  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 794  *
 795  * @see ckmc_create_key_pair_rsa()
 796  * @see ckmc_create_key_pair_ecdsa()
 797  * @see ckmc_verify_signature()
 798  * @see #ckmc_hash_algo_e
 799  * @see #ckmc_rsa_padding_algo_e
 800  */
 801 int ckmc_verify_signature(const char *public_key_alias,
 802                           const char *password,
 803                           const ckmc_raw_buffer_s message,
 804                           const ckmc_raw_buffer_s signature,
 805                           const ckmc_hash_algo_e hash,
 806                           const ckmc_rsa_padding_algo_e padding);
 807
 808 /**
 809  * @brief Verifies a certificate chain and returns that chain.
 810  *
 811  * @since_tizen 2.3
 812  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 813  *          required to use this API since 3.0.
 814  *
 815  * @remarks The trusted root certificate of the chain should exist in the system's certificate
 816  *          storage.
 817  * @remarks You must destroy the newly created @a ppcert_chain_list by calling
 818  *          ckmc_cert_list_all_free() if it is no longer needed.
 819  *
 820  * @param[in] cert               The certificate to be verified
 821  * @param[in] untrustedcerts     The untrusted CA certificates to be used in verifying a certificate
 822  *                               chain
 823  * @param[out] ppcert_chain_list The pointer to a newly created certificate chain's handle \n
 824  *                               If an error occurs, @a *ppcert_chain_list will be null
 825  *
 826  * @return @c 0 on success and the signature is valid,
 827  *         otherwise a negative error value
 828  *
 829  * @retval #CKMC_ERROR_NONE                 Successful
 830  * @retval #CKMC_ERROR_VERIFICATION_FAILED  The certificate chain is not valid
 831  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 832  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 833  *                                          in)
 834  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 835  * @retval #CKMC_ERROR_INVALID_FORMAT       The format of certificate is not valid
 836  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 837  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
 838  *                                          Decryption failed because password is incorrect
 839  *
 840  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 841  *
 842  * @see ckmc_cert_list_all_free()
 843  */
 844 int ckmc_get_cert_chain(const ckmc_cert_s *cert,
 845                         const ckmc_cert_list_s *untrustedcerts,
 846                         ckmc_cert_list_s **ppcert_chain_list);
 847
 848 /**
 849  * @deprecated Deprecated since 2.4. [Use ckmc_get_cert_chain() instead]
 850  * @brief Verifies a certificate chain using an alias list of untrusted certificates and return that
 851  *        chain.
 852  *
 853  * @since_tizen 2.3
 854  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 855  *          required to use this API since 3.0.
 856  *
 857  * @remarks The trusted root certificate of the chain should exist in the system's certificate
 858  *          storage.
 859  * @remarks You must destroy the newly created @a ppcert_chain_list by calling
 860  *          ckmc_cert_list_all_free() if it is no longer needed.
 861  * @remarks @a untrustedcerts shouldn't be protected with optional password.
 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  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 900  *          required to use this API since 3.0.
 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_cert_list_all_free()
 932  */
 933 int ckmc_get_cert_chain_with_trustedcert(const ckmc_cert_s *cert,
 934                                          const ckmc_cert_list_s *untrustedcerts,
 935                                          const ckmc_cert_list_s *trustedcerts,
 936                                          const bool use_trustedsystemcerts,
 937                                          ckmc_cert_list_s **ppcert_chain_list);
 938
 939 /**
 940  * @brief Perform OCSP which checks certificate is whether revoked or not.
 941  *
 942  * @since_tizen 2.4
 943  * @privlevel public
 944  * @privilege %http://tizen.org/privilege/internet
 945  *
 946  * @param[in] pcert_chain_list   Valid certificate chain to perform OCSP check
 947  * @param[out] ocsp_status       The pointer to status result of OCSP check
 948  *
 949  * @return @c 0 on success, otherwise a negative error value
 950  *
 951  * @retval #CKMC_ERROR_NONE                 Successful
 952  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 953  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 954  * @retval #CKMC_ERROR_NOT_SUPPORTED        Device needed to run API is not supported
 955  *
 956  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 957  * @pre @a pcert_chain_list is created with ckmc_get_certificate_chain() or
 958  *      ckmc_get_certificate_chain_with_alias().
 959  *
 960  * @see ckmc_get_cert_chain())
 961  * @see ckmc_cert_list_all_free()
 962  */
 963 int ckmc_ocsp_check(const ckmc_cert_list_s *pcert_chain_list, ckmc_ocsp_status_e *ocsp_status);
 964
 965 /**
 966  * @deprecated Deprecated since 2.4. [Use ckmc_set_permission() instead]
 967  * @brief Allows another application to access client's application data.
 968  *
 969  * @since_tizen 2.3
 970  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
 971  *          required to use this API since 3.0.
 972  *
 973  * @remarks Data identified by @a alias should exist.
 974  *
 975  * @param[in] alias       Data alias for which access will be granted
 976  * @param[in] accessor    Package id of the application that will gain access rights
 977  * @param[in] granted     Rights granted for @a accessor application
 978  *
 979  * @return @c 0 on success, otherwise a negative error value
 980  *
 981  * @retval #CKMC_ERROR_NONE                 Successful
 982  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
 983  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
 984  *                                          in)
 985  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
 986  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
 987  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
 988  *
 989  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
 990  *
 991  * @see ckmc_deny_access()
 992  */
 993 int ckmc_allow_access(const char *alias, const char *accessor, ckmc_access_right_e granted);
 994
 995 /**
 996  * @brief Allows another application to access client's application data.
 997  *
 998  * @since_tizen 2.4
 999  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
1000  *          required to use this API since 3.0.
1001  *
1002  * @remarks Data identified by @a alias should exist.
1003  *
1004  * @param[in] alias       Data alias for which access will be granted
1005  * @param[in] accessor    Package id of the application that will gain access rights
1006  * @param[in] permissions Mask of permissions granted for @a accessor application
1007  *                        (@a ckmc_permission_e)
1008  *                        (previous permission mask will be replaced with the new mask value)
1009  *
1010  * @return @c 0 on success, otherwise a negative error value
1011  *
1012  * @retval #CKMC_ERROR_NONE                 Successful
1013  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1014  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1015  *                                          in)
1016  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1017  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
1018  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1019  *
1020  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1021  */
1022 int ckmc_set_permission(const char *alias, const char *accessor, int permissions);
1023
1024 /**
1025  * @deprecated Deprecated since 2.4. [Use ckmc_set_permission() instead]
1026  * @brief Revokes another application's access to client's application data.
1027  *
1028  * @since_tizen 2.3
1029  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
1030  *          required to use this API since 3.0.
1031  *
1032  * @remarks Data identified by @a alias should exist.
1033  * @remarks Only access previously granted with ckmc_allow_access can be revoked.
1034  *
1035  * @param[in] alias       Data alias for which access will be revoked
1036  * @param[in] accessor    Package id of the application that will lose access rights
1037  *
1038  * @return @c 0 on success, otherwise a negative error value
1039  *
1040  * @retval #CKMC_ERROR_NONE                 Successful
1041  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid or the @a accessor doesn't
1042  *                                          have access to @a alias
1043  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1044  *                                          in)
1045  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1046  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Alias does not exist
1047  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1048  *
1049  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1050  *
1051  * @see ckmc_allow_access()
1052  * @see ckmc_set_permission()
1053  */
1054 int ckmc_deny_access(const char *alias, const char *accessor);
1055
1056 /**
1057  * @brief Removes a an entry (no matter of type) from the key manager.
1058  *
1059  * @since_tizen 2.4
1060  * @remarks %http://tizen.org/privilege/keymanager (public level privilege) is no longer
1061  *          required to use this API since 3.0.
1062  *
1063  * @remarks To remove item, client must have remove permission to the specified item.
1064  * @remarks The item owner can remove by default.
1065  *
1066  * @param[in] alias Item alias to be removed
1067  *
1068  * @return @c 0 on success,
1069  *         otherwise a negative error value
1070  *
1071  * @retval #CKMC_ERROR_NONE              Successful
1072  * @retval #CKMC_ERROR_INVALID_PARAMETER Input parameter is invalid
1073  * @retval #CKMC_ERROR_DB_LOCKED         A user key is not loaded in memory (a user is not logged
1074  *                                       in)
1075  * @retval #CKMC_ERROR_DB_ERROR          Failed due to a database error
1076  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN  Alias does not exist
1077  * @retval #CKMC_ERROR_PERMISSION_DENIED Failed to access key manager
1078  *
1079  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1080  *
1081  * @see ckmc_save_key()
1082  * @see ckmc_save_cert()
1083  * @see ckmc_save_data()
1084  * @see ckmc_save_pkcs12()
1085  * @see ckmc_create_key_pair_rsa()
1086  * @see ckmc_create_key_pair_dsa()
1087  * @see ckmc_create_key_pair_ecdsa()
1088  */
1089 int ckmc_remove_alias(const char *alias);
1090
1091 /**
1092  * @brief Encrypts data using selected key and algorithm.
1093  *
1094  * @since_tizen 3.0
1095  *
1096  * @remarks Key identified by @a key_alias should exist.
1097  *
1098  * @param[in] params            Algorithm parameter list handle
1099  * @param[in] key_alias         Alias of the key to be used for encryption
1100  * @param[in] password          The password used in decrypting a key value \n
1101  *                              If password of policy is provided in ckmc_save_key(), the same
1102  *                              password should be provided
1103  * @param[in] decrypted         Data to be encrypted
1104  * @param[out] ppencrypted      Encrypted data (some algorithms may return additional information
1105  *                              embedded in encrypted data. AES GCM is an example) \n
1106  *                              The caller is responsible for freeing @a encrypted with
1107  *                              ckmc_buffer_free()
1108  *
1109  * @return @c 0 on success, otherwise a negative error value
1110  *
1111  * @retval #CKMC_ERROR_NONE                 Successful
1112  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1113  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1114  *                                          in)
1115  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1116  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Key with given alias does not exist
1117  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1118  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
1119  *                                          Key decryption failed because password is incorrect
1120  *
1121  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1122  *
1123  * @see ckmc_buffer_free()
1124  * @see ckmc_param_list_new()
1125  * @see ckmc_param_list_free()
1126  * @see ckmc_param_list_set_integer()
1127  * @see ckmc_param_list_set_buffer()
1128  * @see ckmc_generate_new_params()
1129  * @see #ckmc_param_list_h
1130  * @see #ckmc_param_name_e
1131  */
1132 int ckmc_encrypt_data(ckmc_param_list_h params,
1133                       const char *key_alias,
1134                       const char *password,
1135                       const ckmc_raw_buffer_s decrypted,
1136                       ckmc_raw_buffer_s **ppencrypted);
1137
1138 /**
1139  * @brief Decrypts data using selected key and algorithm.
1140  *
1141  * @since_tizen 3.0
1142  *
1143  * @remarks Key identified by @a key_alias should exist.
1144  *
1145  * @param[in] params            Algorithm parameter list handle
1146  * @param[in] key_alias         Alias of the key to be used for encryption
1147  * @param[in] password          The password used in decrypting a key value \n
1148  *                              If password of policy is provided in ckmc_save_key(), the same
1149  *                              password should be provided
1150  * @param[in] encrypted         Data to be decrypted (some algorithms may require additional
1151  *                              information embedded in encrypted data. AES GCM is an example)
1152  * @param[out] ppdecrypted      Decrypted data \n
1153  *                              The caller is responsible for freeing @a decrypted with
1154  *                              ckmc_buffer_free()
1155  *
1156  * @return @c 0 on success, otherwise a negative error value
1157  *
1158  * @retval #CKMC_ERROR_NONE                 Successful
1159  * @retval #CKMC_ERROR_INVALID_PARAMETER    Input parameter is invalid
1160  * @retval #CKMC_ERROR_DB_LOCKED            A user key is not loaded in memory (a user is not logged
1161  *                                          in)
1162  * @retval #CKMC_ERROR_DB_ERROR             Failed due to the error with unknown reason
1163  * @retval #CKMC_ERROR_DB_ALIAS_UNKNOWN     Key with given alias does not exist
1164  * @retval #CKMC_ERROR_PERMISSION_DENIED    Failed to access key manager
1165  * @retval #CKMC_ERROR_AUTHENTICATION_FAILED
1166  *                                          Key decryption failed because password is incorrect
1167  *
1168  * @pre User is already logged in and the user key is already loaded into memory in plain text form.
1169  *
1170  * @see ckmc_buffer_free()
1171  * @see ckmc_param_list_new()
1172  * @see ckmc_param_list_free()
1173  * @see ckmc_param_list_set_integer()
1174  * @see ckmc_param_list_set_buffer()
1175  * @see ckmc_generate_new_params()
1176  * @see #ckmc_param_list_h
1177  * @see #ckmc_param_name_e
1178  */
1179 int ckmc_decrypt_data(ckmc_param_list_h params,
1180                       const char *key_alias,
1181                       const char *password,
1182                       const ckmc_raw_buffer_s encrypted,
1183                       ckmc_raw_buffer_s **ppdecrypted);
1184
1185 #ifdef __cplusplus
1186 }
1187 #endif
1188
1189 /**
1190  * @}
1191  */
1192
1193
1194 #endif /* __TIZEN_CORE_CKMC_MANAGER_H */