src/security/cert/FSecCert_Certificate.h

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   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 /**
  18  * @file        FSecCert_Certificate.h
  19  * @brief       This header file contains the declarations of parsing class.
  20  *
  21  * This header file contains the declarations of parsing class.
  22  */
  23
  24 #ifndef _FSEC_CERT_INTERNAL_CERTIFICATE_H_
  25 #define _FSEC_CERT_INTERNAL_CERTIFICATE_H_
  26
  27 #include <unique_ptr.h>
  28 #include <FBaseDateTime.h>
  29 #include "FSecCert_CertExtension.h"
  30 #include "FSecCert_CertSignature.h"
  31 #include "FSecCert_CertTime.h"
  32 #include "FSecCert_Asn1Parser.h"
  33 #include "FSecCert_CertTypes.h"
  34
  35
  36 namespace Tizen { namespace Security { namespace Cert
  37 {
  38
  39 class _OSP_EXPORT_ _X509CertValidity
  40 {
  41 public:
  42         _X509CertValidity(void);
  43
  44         _X509CertValidity(byte* pNotBefore, byte* pNotAfter);
  45
  46         virtual ~_X509CertValidity(void);
  47
  48         result GetValidity(Tizen::Base::DateTime& drmTime);
  49
  50         result SetTimes(byte* pNotBefore, byte* pNotAfter);
  51
  52         result GetBeforeTimes(Tizen::Base::DateTime& notBefore);
  53
  54         result GetAfterTimes(Tizen::Base::DateTime& notAfter);
  55
  56 private:
  57         _X509CertValidity(const _X509CertValidity& rhs);
  58
  59         _X509CertValidity& operator =(const _X509CertValidity& rhs);
  60
  61 private:
  62         _CertTime __notBefore;
  63         _CertTime __notAfter;
  64
  65 }; //_X509CertValidity
  66
  67 class _OSP_EXPORT_ _X509CertSubPublicKeyInfo
  68 {
  69 public:
  70         _X509CertSubPublicKeyInfo(void);
  71
  72         _X509CertSubPublicKeyInfo(const char* pAlg, int keyLen, byte* pPubKey);
  73
  74         virtual ~_X509CertSubPublicKeyInfo(void);
  75
  76         result GetPubKeyN(int& keyLen, byte** ppPubKey);
  77
  78         result SetPubKey(int keyLen, byte* pPubKey);
  79
  80         char* GetPubKeyAlgoId(void);
  81
  82         result SetPubKeyAlgoId(const char* pPubKeyAlgoId);
  83
  84 private:
  85         _X509CertSubPublicKeyInfo(const _X509CertSubPublicKeyInfo& rhs);
  86
  87         _X509CertSubPublicKeyInfo& operator =(const _X509CertSubPublicKeyInfo& rhs);
  88
  89 private:
  90         std::unique_ptr< char[] > __pPubKeyAlg;
  91         std::unique_ptr< byte[] > __publicKey;
  92         int __publicKeySize;
  93
  94 }; //_X509CertSubPublicKeyInfo
  95
  96 class _OSP_EXPORT_ _X509TbsCert
  97 {
  98 public:
  99         _X509TbsCert(void);
 100
 101         virtual ~_X509TbsCert(void);
 102
 103         void SetVersion(byte* pVersion, int len);
 104
 105         void SetVersion(int version);
 106
 107         int GetVersion(void);
 108
 109         void SetSerialNumber(byte* pSerial, int len);
 110
 111         result GetSerialNumber(byte*& pSerial, int& len);
 112
 113         result SetSignatureAlgoId(const char* pAlgoId);
 114
 115         char* GetSignatureAlgoId(void);
 116
 117         result SetIssuerName(byte* pName);
 118
 119         byte* GetIssuerName(void);
 120
 121         result SetValidity(byte* pNotBefore, byte* pNotAfter);
 122
 123         result GetValidity(void);
 124
 125         result GetBeforeTimes(Tizen::Base::DateTime& notBefore);
 126
 127         result GetAfterTimes(Tizen::Base::DateTime& notAfter);
 128
 129         result SetSubjectName(byte* pName);
 130
 131         byte* GetSubjectName(void);
 132
 133         result SetPublicKeyInfo(int keyLen, byte* pPubKey);
 134
 135         result GetPublicKeyInfoN(int& keyLen, byte** ppPubKey);
 136
 137         char* GetPublicKeyAlgoIdInfo(void);
 138
 139         result SetPublicKeyAlgoIdInfo(const char* pPubKeyAlgoId);
 140
 141         result AddExtension(byte* pOid, bool critical, byte* pValue, int len);
 142
 143         _CertExtension* GetCertExtension(void);
 144
 145 private:
 146         _X509TbsCert(const _X509TbsCert& rhs);
 147
 148         _X509TbsCert& operator =(const _X509TbsCert& rhs);
 149
 150 private:
 151         int __version;
 152         int __serialNumberLen;
 153         byte __serialNumber[_MAX_SERIAL_NUMBER_SIZE];
 154         std::unique_ptr< byte[] > __pIssuer;
 155         std::unique_ptr< byte[] > __pSubject;
 156         std::unique_ptr< char[] > __pSignatureAlgoId;
 157         _CertExtension __extension;
 158         _X509CertSubPublicKeyInfo __subPubKeyInfo;
 159         _X509CertValidity __validity;
 160
 161 }; //_X509TbsCert
 162
 163 class _OSP_EXPORT_ _Certificate
 164         : public _Asn1Parser
 165 {
 166 public:
 167         _Certificate(void);
 168
 169         virtual ~_Certificate(void);
 170
 171         result ParseObject(void);
 172
 173         virtual result GetKeyIdN(byte** ppKeyid);
 174
 175         virtual bool IsSelfSigned(void);
 176
 177         _Certificate* GetNextEntry(void);
 178
 179         void SetCertFormat(_CertFormat certFormat);
 180
 181         _CertFormat GetCertFormat(void);
 182
 183 private:
 184         _Certificate(const _Certificate& rhs);
 185
 186         _Certificate& operator =(const _Certificate& rhs);
 187
 188 private:
 189         _CertFormat __certFormat;
 190
 191 }; //_Certificate
 192
 193 class _OSP_EXPORT_ _X509Certificate
 194         : public _Certificate
 195 {
 196 public:
 197         _X509Certificate(void);
 198
 199         virtual ~_X509Certificate(void);
 200
 201         result ParseObject(void);
 202
 203         _X509TbsCert* GetTbsCertInstance(void);
 204
 205         _CertSignature* GetSignInstance(void);
 206
 207         result GetKeyIdN(byte** ppKeyid);
 208
 209         bool IsSelfSigned(void);
 210
 211         bool IsContextCertificate(void);
 212
 213         void SetContextCertificate(bool contextCert);
 214
 215         result GetCertBuffer(byte*& pBuf, int& bufSize);
 216
 217         result GetIssuerBuffer(byte*& pBuf, int& bufSize);
 218
 219         result GetSubjectNameBuffer(byte*& pBuf, int& bufSize);
 220
 221         result VerifySignature(byte* pPublicKey, int keySize);
 222
 223         bool IsCaCertificate();
 224
 225         _X509Certificate* GetNextEntry(void);
 226
 227         bool IsIssuer(_X509Certificate* pCertIssuer);
 228
 229         void* GetX509CertObject();
 230
 231 private:
 232         _X509Certificate(const _X509Certificate& rhs);
 233
 234         _X509Certificate& operator =(const _X509Certificate& rhs);
 235
 236         result ParseRun(void);
 237
 238         result ParseTbsCertHeader(void);
 239
 240         result ParseVersion(void);
 241
 242         result ParseSerialNumber(void);
 243
 244         result ParseAlgorithmIdentifier(void);
 245
 246         result ParseIssuerName(void);
 247
 248         result ParseValidity(void);
 249
 250         result ParseSubjectName(void);
 251
 252         result ParseSubjectPublicKeyInfo(void);
 253
 254         result ParseExtensions(void);
 255
 256         result ParseSignature(void);
 257
 258 private:
 259         bool __contextCert;
 260         bool __isCaCert;
 261         bool __x509IsSelfSign;
 262         void* __pX509Certificate;
 263         _X509TbsCert __tbsCert;
 264         _CertSignature __signautreInfo;
 265
 266 }; //_X509Certificate
 267
 268 } } } //Tizen::Security::Cert
 269
 270 #endif // _FSEC_CERT_INTERNAL_CERTIFICATE_H_