2 // Copyright (c) 2013 Samsung Electronics Co., Ltd.
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
8 // http://www.apache.org/licenses/LICENSE-2.0
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.
18 * @file FSecRsaKeyConverter.h
19 * @brief This is the header file for the %RsaKeyConverter class.
21 * This header file contains the declarations of the %RsaKeyConverter class.
24 #ifndef _FSEC_RSA_KEY_CONVERTER_H_
25 #define _FSEC_RSA_KEY_CONVERTER_H_
27 #include <FSecIPublicKey.h>
28 #include <FSecIPrivateKey.h>
30 namespace Tizen { namespace Security
36 * Defines the types of rsa key format.
42 RSA_KEY_FORMAT_PKCS01_PRIVATE_KEY = 0, /**< The rsa key format is PKCS1 private key */
43 RSA_KEY_FORMAT_PKCS01_PUBLIC_KEY = 1, /**< The rsa key format is PKCS1 public key */
44 RSA_KEY_FORMAT_PKCS08_PRIVATE_KEY = 2, /**< The rsa key format is PKCS8 private key */
45 RSA_KEY_FORMAT_X509_PUBLIC_KEY = 3, /**< The rsa key format is X509 public key */
46 RSA_KEY_FORMAT_UNKNOWN = 0xffffffff /**< The rsa key format is unknown */
50 * @class RsaKeyConverter
51 * @brief This class provides methods for converting the RSA public/private key in multiple key formats and multiple encoding formats.
55 * The %RsaKeyConverter class provides support for converting the RSA public/private key in multiple key formats and multiple encoding formats. @n
56 * The supported RSA key formats are PKCS1/PKCS8/X509. @n
57 * The supported encoding formats are DER/PEM.
60 class _OSP_EXPORT_ RsaKeyConverter
65 * Generates an RSA encoded private key in the passed input RSA key format. @n
66 * If the input private key is in PEM encoded format, then the output RSA private key will be PEM encoded; if it is in DER encoded format,
67 * then the output RSA private key will be DER encoded.
71 * @return A pointer to the encoded Tizen::Base::ByteBuffer instance, @n
72 * else @c null if the method fails to convert the private key in the passed input format
73 * @param[in] format An enum value that contains the RSA private key format @n
74 * The valid values for the supported output RSA private key formats are only
75 * @c RSA_KEY_FORMAT_PKCS01_PRIVATE_KEY and @c RSA_KEY_FORMAT_PKCS08_PRIVATE_KEY.
76 * @param[in] key An instance of IPrivateKey
77 * @exception E_SUCCESS The method is successful.
78 * @exception E_INVALID_ARG A specified input parameter is invalid.
79 * @remarks The specific error code can be accessed using the GetLastResult() method.
81 static Tizen::Base::ByteBuffer* ConvertPrivateKeyFormatN(RsaKeyFormat format, const IPrivateKey& key);
84 * Generates an RSA encoded public key in the passed input RSA key format. @n
85 * If the input public key is in PEM encoded format, then the output RSA public key will be PEM encoded; if it is in DER encoded format,
86 * then the output RSA public key will be DER encoded.
90 * @return A pointer to the encoded Tizen::Base::ByteBuffer instance, @n
91 * else @c null if the method fails to convert the public key in the passed input format
92 * @param[in] format An enum value that contains the RSA public key format @n
93 * The valid values for the supported output RSA public key formats are only
94 * @c RSA_KEY_FORMAT_PKCS01_PUBLIC_KEY and @c RSA_KEY_FORMAT_X509_PUBLIC_KEY.
95 * @param[in] key An instance of IPublicKey
96 * @exception E_SUCCESS The method is successful.
97 * @exception E_INVALID_ARG A specified input parameter is invalid.
98 * @remarks The specific error code can be accessed using the GetLastResult() method.
100 static Tizen::Base::ByteBuffer* ConvertPublicKeyFormatN(RsaKeyFormat format, const IPublicKey& key);
103 * Converts a DER encoded RSA key to the PEM encoded format.
107 * @return A pointer to the PEM encoded Tizen::Base::ByteBuffer instance, @n
108 * else @c null if the method fails to convert the key in the PEM encoded format
109 * @param[in] format An enum value that contains the RSA key format of the input key
110 * @param[in] key An instance of IKey
111 * @exception E_SUCCESS The method is successful.
112 * @exception E_INVALID_ARG A specified input parameter is invalid.
113 * @remarks The specific error code can be accessed using the GetLastResult() method.
115 static Tizen::Base::ByteBuffer* ConvertDerToPemN(RsaKeyFormat format, const IKey& key);
118 * Converts a PEM encoded RSA key to the DER encoded format.
122 * @return A pointer to the DER encoded Tizen::Base::ByteBuffer instance, @n
123 * else @c null if the method fails to convert the key in the DER encoded format
124 * @param[in] format An enum value that contains the RSA key format of the input key
125 * @param[in] key An instance of IKey
126 * @exception E_SUCCESS The method is successful.
127 * @exception E_INVALID_ARG A specified input parameter is invalid.
128 * @remarks The specific error code can be accessed using the GetLastResult() method.
130 static Tizen::Base::ByteBuffer* ConvertPemToDerN(RsaKeyFormat format, const IKey& key);
134 // This default constructor is intentionally declared as private because this class cannot be constructed.
138 RsaKeyConverter(void);
141 // This destructor is intentionally declared as private because this class cannot be constructed.
145 ~RsaKeyConverter(void);
148 // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying of objects.
152 RsaKeyConverter(const RsaKeyConverter& rhs);
155 // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit copying of objects.
159 RsaKeyConverter& operator =(const RsaKeyConverter& rhs);
162 class _RsaKeyConverterImpl* __pRsaKeyConverterImpl;
163 friend class _RsaKeyConverterImpl;
167 } } //Tizen::Security
169 #endif // _FSEC_RSA_KEY_CONVERTER_H_