Merge pull request #4 from djw8605/add-scitoken-get

Adding function scitoken_get_claim_string implementation

Author: bbockelm

src/scitokens.cpp

@@ -67,10 +67,18 @@ int scitoken_set_claim_string(SciToken token, const char *key, const char *value
 }
 
 int scitoken_get_claim_string(const SciToken token, const char *key, char **value, char **err_msg) {
-    if (err_msg) {
-        *err_msg = strdup("This function is not implemented");
+    scitokens::SciToken *real_token = reinterpret_cast<scitokens::SciToken*>(token);
+    std::string claim_str;
+    try {
+        claim_str = real_token->get_claim_string(key);
+    } catch (std::exception &exc) {
+        if (err_msg) {
+            *err_msg = strdup(exc.what());
+        }
+        return -1;
     }
-    return -1;
+    *value = strdup(claim_str.c_str());
+    return 0;
 }
 
 

src/scitokens_internal.cpp

@@ -316,6 +316,9 @@ SciToken::deserialize(const std::string &data, const std::vector<std::string> al
     val.add_allowed_issuers(allowed_issuers);
     val.set_validate_all_claims_scitokens_1(false);
     val.verify(*m_decoded);
+
+    // Set all the claims
+    m_claims = m_decoded->get_payload_claims();
 }
 
 

src/scitokens_internal.h

@@ -1,6 +1,7 @@
 
 #include <memory>
 #include <sstream>
+#include <unordered_map>
 
 #include <jwt-cpp/jwt.h>
 #include <uuid/uuid.h>
@@ -111,39 +112,57 @@ friend class scitokens::Validator;
 
 public:
     SciToken(SciTokenKey &signing_algorithm)
-        : m_builder(jwt::create()),
-          m_key(signing_algorithm)
+        : m_key(signing_algorithm)
     {}
 
     void
     set_claim(const std::string &key, const jwt::claim &value) {
-        m_builder.set_payload_claim(key, value);
+        m_claims[key] = value;
         if (key == "iss") {m_issuer_set = true;}
     }
 
+    const jwt::claim
+    get_claim(const std::string &key) {
+        return m_claims[key];
+    }
+
+    // Return a claim as a string
+    // If the claim is not a string, it can throw
+    // a std::bad_cast() exception.
+    const std::string
+    get_claim_string(const std::string &key) {
+        return m_claims[key].as_string();
+    }
+
     void
     set_lifetime(int lifetime) {
         m_lifetime = lifetime;
     }
 
     std::string
     serialize() {
+        jwt::builder builder(jwt::create());
+
         if (!m_issuer_set) {
             throw MissingIssuerException();
         }
         auto time = std::chrono::system_clock::now();
-        m_builder.set_issued_at(time);
-        m_builder.set_not_before(time);
-        m_builder.set_expires_at(time + std::chrono::seconds(m_lifetime));
+        builder.set_issued_at(time);
+        builder.set_not_before(time);
+        builder.set_expires_at(time + std::chrono::seconds(m_lifetime));
 
         uuid_t uuid;
         uuid_generate(uuid);
         char uuid_str[37];
         uuid_unparse_lower(uuid, uuid_str);
-        m_builder.set_payload_claim("jti", std::string(uuid_str));
+        m_claims["jti"] = std::string(uuid_str);
+
+        // Set all the payload claims
+        for (auto it : m_claims) {
+            builder.set_payload_claim(it.first, it.second);
+        }
 
-        // TODO: handle JTI
-        return m_key.serialize(m_builder);
+        return m_key.serialize(builder);
     }
 
     void
@@ -152,7 +171,7 @@ friend class scitokens::Validator;
 private:
     bool m_issuer_set{false};
     int m_lifetime{600};
-    jwt::builder m_builder;
+    std::unordered_map<std::string, jwt::claim> m_claims;
     std::unique_ptr<jwt::decoded_jwt> m_decoded;
     SciTokenKey &m_key;
 };

src/test.cpp

@@ -1,5 +1,6 @@
 #include <iostream>
 #include <fstream>
+#include <stdio.h>
 
 #include <jwt-cpp/jwt.h>
 
@@ -16,13 +17,17 @@ int main(int argc, const char** argv) {
     for (auto& e : decoded.get_payload_claims())
         std::cout << e.first << " = " << e.second.to_json() << std::endl;
 
-    std::ifstream ifs("test.pem");
-    std::string contents( (std::istreambuf_iterator<char>(ifs)),
+    std::ifstream priv_ifs("test.pem");
+    std::string private_contents( (std::istreambuf_iterator<char>(priv_ifs)),
+                          (std::istreambuf_iterator<char>())
+                        );
+    std::ifstream pub_ifs("test.pem.pub");
+    std::string public_contents( (std::istreambuf_iterator<char>(pub_ifs)),
                           (std::istreambuf_iterator<char>())
                         );
 
     char *err_msg;
-    SciTokenKey key = scitoken_key_create("key-es356", "RS256", contents.c_str(), contents.c_str(), &err_msg);
+    SciTokenKey key = scitoken_key_create("key-es356", "RS256", public_contents.c_str(), private_contents.c_str(), &err_msg); 
     if (!key) {
         std::cout << "Failed to generate a key: " << err_msg << std::endl;
         return 1;
@@ -31,9 +36,18 @@ int main(int argc, const char** argv) {
     if (scitoken_set_claim_string(scitoken, "iss", "https://demo.scitokens.org", &err_msg)) {
         std::cout << "Failed to set a claim: " << err_msg << std::endl;
     }
+
+    // Test setting and getting a claim
     char *value;
+    if (scitoken_get_claim_string(scitoken, "iss", &value, &err_msg)) {
+        std::cout << "Failed to get a claim: " << err_msg << std::endl;
+    }
+    if (strcmp(value, "https://demo.scitokens.org") != 0) {
+        std::cout << "Failed to get same claim a claim: " << err_msg << std::endl;
+    }
+
     if (scitoken_serialize(scitoken, &value, &err_msg)) {
-        std::cout << "Failed to generate a key: " << err_msg << std::endl;
+        std::cout << "Failed to generate a token: " << err_msg << std::endl;
         return 1;
     }
     std::cout << "SciToken: " << value << std::endl;