[KeyManager] getCertificate and saveCertificate

[Verification]
var cert = new tizen.Certificate("cert3", null, true);
cert.save("MIIDGDC...DVC8w==",
    function() {
        console.log('ok');
        var c = tizen.keymanager.getCertificate("cert3");
        console.log(c.name);
        console.log(c.password);
        console.log(c.extractable);
        console.log(c.rawCert);
    },
    function(e) {
        console.log(e.code);
        console.log(e.message);
    }
);

Change-Id: I44ff150d6e83a9715d86e0bc1ca659047bc40a9c
Signed-off-by: Przemyslaw Ciezkowski <p.ciezkowski@samsung.com>

diff --git a/src/keymanager/keymanager_instance.cc b/src/keymanager/keymanager_instance.cc
index bcd665fd8a59c6c447183c312e82ab0abaa0eb56..b20c9b79053aa15a993593dc8ed7649566080f4a 100644 (file)
--- a/src/keymanager/keymanager_instance.cc
+++ b/src/keymanager/keymanager_instance.cc
@@ -39,6 +39,10 @@ KeyManagerInstance::KeyManagerInstance() {
       std::bind(&KeyManagerInstance::RemoveKey, this, _1, _2));
   RegisterSyncHandler("KeyManager_generateKeyPair",
       std::bind(&KeyManagerInstance::GenerateKeyPair, this, _1, _2));
+  RegisterSyncHandler("KeyManager_getCertificate",
+      std::bind(&KeyManagerInstance::GetCertificate, this, _1, _2));
+  RegisterSyncHandler("KeyManager_saveCertificate",
+      std::bind(&KeyManagerInstance::SaveCertificate, this, _1, _2));
 }
 
 KeyManagerInstance::~KeyManagerInstance() {
@@ -213,6 +217,16 @@ void KeyManagerInstance::OnCreateKeyPair(double callbackId,
   PostMessage(res.serialize().c_str());
 }
 
+std::string RawBufferToBase64(const CKM::RawBuffer &buf) {
+  std::string result;
+  if (!buf.empty()) {
+    gchar* base64 = g_base64_encode(&buf[0], buf.size());
+    result = base64;
+    g_free(base64);
+  }
+  return result;
+}
+
 void KeyManagerInstance::GetKey(const picojson::value& args, picojson::object& out) {
   LoggerD("Enter");
   using CKM::KeyType;
@@ -266,21 +280,93 @@ void KeyManagerInstance::GetKey(const picojson::value& args, picojson::object& o
         dict["keyType"] = picojson::value("KEY_AES");
         break;
     }
-    CKM::RawBuffer buf = key->getDER();
-    if (!buf.empty()) {
-      gchar* base64 = g_base64_encode(&buf[0], buf.size());
-      dict["rawKey"] = picojson::value(std::string(base64));
-      g_free(base64);
+    dict["rawKey"] = picojson::value(RawBufferToBase64(key->getDER()));
+    //if key was retrieved it is extractable from db
+    dict["extractable"] = picojson::value(true);
+
+    picojson::value res(dict);
+    ReportSuccess(res, out);
+  }
+}
+
+void KeyManagerInstance::GetCertificate(const picojson::value& args,
+    picojson::object& out) {
+  LoggerD("Enter");
+
+  CKM::Password pass;
+  if (args.get("password").is<std::string>()) {
+    pass = args.get("password").get<std::string>().c_str();
+  }
+  const std::string& alias = args.get("name").get<std::string>();
+  CKM::CertificateShPtr cert;
+  int ret = CKM::Manager::create()->getCertificate(alias, pass, cert);
+  if (ret != CKM_API_SUCCESS) {
+    LoggerE("Failed to get cert: %d", ret);
+    if (ret == CKM_API_ERROR_DB_ALIAS_UNKNOWN) {
+      ReportError(common::PlatformResult(common::ErrorCode::NOT_FOUND_ERR,
+        "Cert alias not found"), &out);
     } else {
-      dict["rawKey"] = picojson::value(std::string());
+      ReportError(common::PlatformResult(common::ErrorCode::UNKNOWN_ERR,
+        "Failed to get cert"), &out);
     }
-    //if key was retrieved it is extractable from db
+  } else {
+    picojson::object dict;
+    dict["name"] = args.get("name");
+    if (args.get("password").is<std::string>()) {
+      dict["password"] = args.get("password");
+    }
+    //if cert was retrieved it is extractable from db
     dict["extractable"] = picojson::value(true);
+    dict["rawCert"] = picojson::value(RawBufferToBase64(cert->getDER()));
 
     picojson::value res(dict);
     ReportSuccess(res, out);
   }
 }
 
+void KeyManagerInstance::SaveCertificate(const picojson::value& args,
+    picojson::object& out) {
+  LoggerD("Enter");
+
+  const picojson::value& crt = args.get("certificate");
+  const std::string& alias = crt.get("name").get<std::string>();
+  std::string password;
+  if (crt.get("password").is<std::string>()) {
+    password = crt.get("password").get<std::string>();
+  }
+  std::string base64 = args.get("rawCert").get<std::string>();
+  pcrecpp::RE_Options opt;
+  opt.set_multiline(true);
+  //remove first line and last line
+  pcrecpp::RE("-----[^-]*-----", opt).GlobalReplace("", &base64);
+  gsize len = 0;
+  guchar* rawData = g_base64_decode(base64.c_str(), &len);
+  CKM::RawBuffer rawBuffer;
+  rawBuffer.assign(rawData, rawData + len);
+  g_free(rawData);
+  CKM::Password pass(password.c_str());
+  CKM::CertificateShPtr cert = CKM::Certificate::create(rawBuffer,
+      CKM::DataFormat::FORM_DER);
+  CKM::Policy policy(pass, crt.get("extractable").get<bool>());
+  CKM::ManagerAsync::ObserverPtr observer(new SaveCertObserver(this,
+    args.get("callbackId").get<double>()));
+  m_manager.saveCertificate(observer, alias, cert, policy);
+
+  ReportSuccess(out);
+}
+
+void KeyManagerInstance::OnSaveCert(double callbackId,
+    const common::PlatformResult& result) {
+  LoggerD("Enter");
+  picojson::value::object dict;
+  dict["callbackId"] = picojson::value(callbackId);
+  if (result.IsError()) {
+    LoggerE("There was an error");
+    ReportError(result, &dict);
+  }
+  picojson::value res(dict);
+  PostMessage(res.serialize().c_str());
+}
+
 } // namespace keymanager
 } // namespace extension

diff --git a/src/keymanager/keymanager_instance.h b/src/keymanager/keymanager_instance.h
index a842b0b93dcc5036547bd5ee6bf915d505bdfc14..2421c58e7e087217b4e49c94b742e073c4a99cce 100644 (file)
--- a/src/keymanager/keymanager_instance.h
+++ b/src/keymanager/keymanager_instance.h
@@ -21,6 +21,7 @@ class KeyManagerInstance :
   virtual ~KeyManagerInstance();
   void OnSaveKey(double callbackId, const common::PlatformResult& result);
   void OnCreateKeyPair(double callbackId, const common::PlatformResult& result);
+  void OnSaveCert(double callbackId, const common::PlatformResult& result);
  private:
   void GetAliasList(std::function<int(CKM::AliasVector&)> coreFunc,
       picojson::object& out);
@@ -32,6 +33,8 @@ class KeyManagerInstance :
   void SaveKey(const picojson::value& args, picojson::object& out);
   void RemoveKey(const picojson::value& args, picojson::object& out);
   void GenerateKeyPair(const picojson::value& args, picojson::object& out);
+  void GetCertificate(const picojson::value& args, picojson::object& out);
+  void SaveCertificate(const picojson::value& args, picojson::object& out);
 
   CKM::ManagerAsync m_manager;
 };

diff --git a/src/keymanager/keymanager_observers.cc b/src/keymanager/keymanager_observers.cc
index b3e06459154414300e4382cb4b90cf4244b322e3..763d5240d3d3f724935d28137fe3b1d4b0775983 100644 (file)
--- a/src/keymanager/keymanager_observers.cc
+++ b/src/keymanager/keymanager_observers.cc
@@ -91,5 +91,27 @@ void CreateKeyObserver::ReceivedError(int error) {
     PlatformResult(code, message)));
 }
 
+SaveCertObserver::SaveCertObserver(KeyManagerListener* listener, double callbackId):
+    CommonObserver(listener, callbackId) {
+}
+
+void SaveCertObserver::ReceivedError(int error) {
+  LoggerD("Enter, error: %d", error);
+  ErrorCode code = ErrorCode::UNKNOWN_ERR;
+  if (error == CKM_API_ERROR_INPUT_PARAM) {
+    code = ErrorCode::INVALID_VALUES_ERR;
+  }
+  common::TaskQueue::GetInstance().Async(std::bind(
+    &KeyManagerListener::OnSaveCert, listener, callbackId,
+    PlatformResult(code, "Failed to save certificate")));
+}
+
+void SaveCertObserver::ReceivedSaveCertificate() {
+  LoggerD("Enter");
+  common::TaskQueue::GetInstance().Async(std::bind(
+    &KeyManagerListener::OnSaveCert, listener, callbackId,
+    PlatformResult(ErrorCode::NO_ERROR)));
+}
+
 } // namespace keymanager
 } // namespace extension

diff --git a/src/keymanager/keymanager_observers.h b/src/keymanager/keymanager_observers.h
index 68f98e31180c0eaa84b2d3d9e4497fc723dbf1e6..4c9f51ccd6571324485c9c90bc502bae9891b5c5 100644 (file)
--- a/src/keymanager/keymanager_observers.h
+++ b/src/keymanager/keymanager_observers.h
@@ -15,6 +15,7 @@ class KeyManagerListener {
 public:
   virtual void OnSaveKey(double callbackId, const common::PlatformResult& result) = 0;
   virtual void OnCreateKeyPair(double callbackId, const common::PlatformResult& result) = 0;
+  virtual void OnSaveCert(double callbackId, const common::PlatformResult& result) = 0;
   virtual ~KeyManagerListener() {}
 };
 
@@ -44,6 +45,12 @@ private:
 
 };
 
+struct SaveCertObserver: public CommonObserver {
+  SaveCertObserver(KeyManagerListener* listener, double callbackId);
+  void ReceivedError(int error);
+  void ReceivedSaveCertificate();
+};
+
 } // namespace keymanager
 } // namespace extension