milkcocoa0902/CocoaTweet
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

access tokenが取得できるように

Browse Source
This commit is contained in:
keita
2022-04-23 04:55:43 +09:00
parent d43e04506b
commit 560fe707a6
75 changed files with 591 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/cocoatweet/oauth/authorize.cc
View File
src/cocoatweet/oauth/authorize.h
+22
View File
@@ -0,0 +1,22 @@
#ifndef COCOATWEET_OAUTH_AUTHORIZE_H_
#define COCOATWEET_OAUTH_AUTHORIZE_H_
#include "cocoatweet/api/interface/groupInterface.h"
#include <vector>
#include <utility>
namespace CocoaTweet::Authentication{
class Auth: public groupInterface {
public:
enum AuthType { OAuth, Bearer };
Auth();
Auth(Key _key);
authorize(const bool app_only);
private:
Key key_;
}
}
#endif
src/cocoatweet/oauth/key.cc
-32
View File
@@ -1,32 +0,0 @@
#include "cocoatweet/oauth/key.h"
#include "nlohmann/json.hpp"
#include <fstream>
#include <string>
#include <typeinfo>
namespace CocoaTweet::OAuth {
Key Key::fromJsonFile(const std::string _jsonFile) {
std::ifstream ifs(_jsonFile);
std::string str((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
auto j = nlohmann::json::parse(str);
Key key;
if (j.contains("consumer_key")) {
key.consumerKey(j["consumer_key"].get<std::string>());
}
if (j.contains("consumer_secret")) {
key.consumerSecret(j["consumer_secret"].get<std::string>());
}
if (j.contains("access_token")) {
key.accessToken(j["access_token"].get<std::string>());
}
if (j.contains("access_token_secret")) {
key.accessTokenSecret(j["access_token_secret"].get<std::string>());
}
return key;
}
} // namespace CocoaTweet::OAuth
src/cocoatweet/oauth/key.h
-75
View File
@@ -1,75 +0,0 @@
#ifndef COCOATWEET_OAUTH_KEY_H_
#define COCOATWEET_OAUTH_KEY_H_
#include <string>
#include <map>
namespace CocoaTweet::OAuth {
class Key {
std::string consumerKey_;
std::string consumerSecret_;
std::string accessToken_;
std::string accessTokenSecret_;
std::string bearerToken_;
public:
Key() : consumerKey_(""), consumerSecret_(""), accessToken_(""), accessTokenSecret_("") {}
Key(const std::string& _consumerKey, const std::string& _consumerSecret,
const std::string& _accessToken, const std::string& _accessTokenSecret)
: consumerKey_(_consumerKey),
consumerSecret_(_consumerSecret),
accessToken_(_accessToken),
accessTokenSecret_(_accessTokenSecret) {}
Key(const std::string& _consumerKey, const std::string& _consumerSecret)
: consumerKey_(_consumerKey), consumerSecret_(_consumerSecret) {}
void consumerKey(const std::string& _consumerKey) {
consumerKey_ = _consumerKey;
}
void consumerSecret(const std::string& _consumerSecret) {
consumerSecret_ = _consumerSecret;
}
void accessToken(const std::string& _accessToken) {
accessToken_ = _accessToken;
}
void accessTokenSecret(const std::string& _accessTokenSecret) {
accessTokenSecret_ = _accessTokenSecret;
}
void bearerToken(const std::string& _bearer) {
bearerToken_ = _bearer;
}
const std::string& consumerKey() const {
return consumerKey_;
}
const std::string& consumerSecret() const {
return consumerSecret_;
}
const std::string& accessToken() const {
return accessToken_;
}
const std::string& accessTokenSecret() const {
return accessTokenSecret_;
}
const std::string& bearerToken() const {
return bearerToken_;
}
std::map<std::string, std::string> noSecret() const {
return std::map<std::string, std::string>{{"oauth_consumer_key", consumerKey_},
{"oauth_token", accessToken_}};
}
const std::map<std::string, std::string> secret() const {
return std::map<std::string, std::string>{{"oauth_consumer_key", consumerSecret_},
{"oauth_token", accessTokenSecret_}};
}
static Key fromJsonFile(const std::string _jsonFile);
};
} // namespace CocoaTweet::OAuth
#endif
src/cocoatweet/oauth/oauth.cc
-238
View File
@@ -1,238 +0,0 @@
#include "oauth.h"
#include "cocoatweet/util/util.h"
#include <random>
#include <ctime>
#include <bitset>
#include <sstream>
#include <string>
#include <cstring>
#include <iterator>
#include <nlohmann/json.hpp>
#include <cocoatweet/exception/invalidParameterException.h>
extern "C" {
#include <openssl/hmac.h>
#include <openssl/sha.h>
#include <openssl/buffer.h>
#include <curl/curl.h>
}
#ifndef NDEBUG
#include <iostream>
#endif
namespace CocoaTweet::OAuth {
OAuth1::OAuth1() : authType_(AuthType::OAuth) {}
OAuth1::OAuth1(const Key _key) : key_(_key), authType_(AuthType::OAuth) {}
std::map<std::string, std::string> OAuth1::signature(
const std::map<std::string, std::string>& _param, const std::string& _method,
const std::string& _url) {
std::vector<std::string> tmp;
for (const auto& [key, value] : _param) {
tmp.push_back(key + "=" + value);
}
std::string query = CocoaTweet::Util::join(tmp, "&");
auto significateKey = key().consumerSecret() + "&" + key().accessTokenSecret();
auto significateBase = _method + "&" + CocoaTweet::Util::urlEncode(_url) + "&" +
CocoaTweet::Util::urlEncode(query);
auto k64Sha1 = hmacSha1(significateKey, significateBase);
auto ret = std::map<std::string, std::string>{{"oauth_signature", k64Sha1}};
return ret;
}
const std::string OAuth1::calculateAuthHeader(std::map<std::string, std::string> _bodyParam,
const std::string& _method,
const std::string& _url) {
if (authType_ == AuthType::Bearer) {
return "Authorization: Bearer " + key_.bearerToken();
}
auto authParam = oauthParam();
auto sigingParam = authParam;
if (!_bodyParam.empty()) {
for (const auto [k, v] : _bodyParam) {
sigingParam.insert_or_assign(k, v);
}
}
auto sign = signature(sigingParam, _method, _url);
authParam.merge(sign);
// ヘッダの構築
std::string oauthHeader = "authorization: OAuth ";
{
std::vector<std::string> tmp;
for (const auto& [key, value] : authParam) {
tmp.push_back(key + "=" + CocoaTweet::Util::urlEncode(value));
}
oauthHeader += CocoaTweet::Util::join(tmp, ",");
}
return oauthHeader;
}
const std::string& OAuth1::generateBearerToken() {
auto signature = key_.consumerKey() + ":" + key_.consumerSecret();
auto k64Signature = base64(signature);
auto authHeader = std::string("Authorization: Basic ") + k64Signature;
auto contentType =
std::string("Content-Type: application/x-www-form-urlencoded;charset=UTF-8");
auto url = std::string("https://api.twitter.com/oauth2/token");
auto requestBody = std::string("grant_type=client_credentials");
// do post
CURL* curl;
CURLcode res;
std::string rcv;
long responseCode;
curl = curl_easy_init();
if (curl) {
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, requestBody.c_str());
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, requestBody.length());
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlCallback_);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (std::string*)&rcv);
#ifndef NDEBUG
std::cout << "requestBody : " << requestBody << std::endl;
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
#endif
// Headerを保持するcurl_slist*を初期化
struct curl_slist* headers = NULL;
// Authorizationをヘッダに追加
headers = curl_slist_append(headers, authHeader.c_str());
headers = curl_slist_append(headers, contentType.c_str());
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
curl_easy_cleanup(curl);
}
if (res != CURLE_OK) {
throw std::runtime_error(std::string("INTERNAL ERROR : curl(") + std::to_string(res) + ")");
exit(1);
}
auto j = nlohmann::json::parse(rcv);
if ((responseCode / 100) == 4) {
auto error = j["errors"][0]["code"];
auto message = j["errors"][0]["message"];
if (j.count("error") != 0) {
// この形式はエラーコードを持たないのでエラー種別が特定できない
throw new CocoaTweet::Exception::Exception(j["error"]);
}
if (error.get<int>() == 44) {
throw CocoaTweet::Exception::InvalidParameterException(
message.get<std::string>().c_str());
}
}
key_.bearerToken(j["access_token"]);
authType_ = AuthType::Bearer;
return key_.bearerToken();
}
const std::string OAuth1::nonce() const {
std::random_device engine;
std::string nonceTable = "abcdefghijklmnopqrstuvwxyz0123456789";
std::uniform_int_distribution<std::size_t> dist(0, nonceTable.length() - 1);
std::string nonce;
for (auto i = 0; i < 32; ++i) {
nonce += nonceTable[dist(engine)];
}
return nonce;
}
const std::string OAuth1::timestamp() const {
return std::to_string(time(nullptr));
}
const std::string OAuth1::method() const {
return SIGNATURE_METHOD_;
}
const std::string OAuth1::version() const {
return OAUTH_VERSION_;
}
const Key OAuth1::key() const {
return key_;
}
std::map<std::string, std::string> OAuth1::oauthParam() const {
auto tmp = std::map<std::string, std::string>{{"oauth_nonce", nonce()},
{"oauth_signature_method", method()},
{"oauth_timestamp", timestamp()},
{"oauth_version", version()}};
tmp.merge(key().noSecret());
return tmp;
}
const std::string OAuth1::base64(const std::string& _raw) {
auto base64Table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
std::stringstream ss;
for (auto r : _raw) {
ss << std::bitset<8>(r);
}
if (_raw.length() % 3 == 1) {
ss << "0000";
} else if (_raw.length() % 3 == 2) {
ss << "00";
}
auto bin = ss.str();
std::string base64 = "";
for (auto i = 0; i < bin.length() / 6; i++) {
base64 += base64Table[std::stoi(bin.substr(i * 6, 6), nullptr, 2)];
}
if (base64.length() % 4 == 3) {
base64 += "=";
} else if (base64.length() % 4 == 2) {
base64 += "==";
} else if (base64.length() % 4 == 1) {
base64 += "===";
}
return base64;
}
std::string OAuth1::hmacSha1(std::string _key, std::string _data) {
unsigned char result[255];
unsigned int length = 255;
HMAC(EVP_sha1(), reinterpret_cast<const unsigned char*>(_key.c_str()), _key.length(),
reinterpret_cast<const unsigned char*>(_data.c_str()), _data.length(), result, &length);
auto sha1 = std::string(reinterpret_cast<char*>(result), length);
// base64 encodeもやっちゃえ日産
BIO* encoder = BIO_new(BIO_f_base64());
BIO* bmem = BIO_new(BIO_s_mem());
encoder = BIO_push(encoder, bmem);
BIO_write(encoder, sha1.c_str(), sha1.length());
BIO_flush(encoder);
BUF_MEM* bptr;
BIO_get_mem_ptr(encoder, &bptr);
char* k64 = (char*)std::malloc(bptr->length);
std::memcpy(k64, bptr->data, bptr->length - 1);
k64[bptr->length - 1] = 0;
BIO_free_all(encoder);
return static_cast<std::string>(k64);
}
} // namespace CocoaTweet::OAuth
src/cocoatweet/oauth/oauth.h
-46
View File
@@ -1,46 +0,0 @@
#ifndef COCOATWEET_OAUTH_OAUTH_H_
#define COCOATWEET_OAUTH_OAUTH_H_
#include <string>
#include <map>
#include <memory>
#include "key.h"
namespace CocoaTweet::OAuth {
class OAuth1 {
public:
enum AuthType { OAuth, Bearer };
OAuth1();
OAuth1(const Key _key);
std::map<std::string, std::string> signature(const std::map<std::string, std::string>& _param,
const std::string& _method,
const std::string& _url);
const std::string& generateBearerToken();
const std::string calculateAuthHeader(std::map<std::string, std::string> _bodyParam,
const std::string& _method, const std::string& _url);
const std::string nonce() const;
const std::string timestamp() const;
const std::string method() const;
const std::string version() const;
const Key key() const;
std::map<std::string, std::string> oauthParam() const;
std::string hmacSha1(std::string _key, std::string _data);
const std::string base64(const std::string& _raw);
private:
AuthType authType_;
Key key_;
const std::string SIGNATURE_METHOD_ = "HMAC-SHA1";
const std::string OAUTH_VERSION_ = "1.0";
static size_t curlCallback_(char* _ptr, size_t _size, size_t _nmemb, std::string* _stream) {
int realsize = _size * _nmemb;
_stream->append(_ptr, realsize);
return realsize;
}
};
} // namespace CocoaTweet::OAuth
#endif
src/cocoatweet/oauth/oauth2/invalidateToken.cc
View File
src/cocoatweet/oauth/oauth2/invalidateToken.h
View File
src/cocoatweet/oauth/oauth2/token.cc
View File
src/cocoatweet/oauth/oauth2/token.h
View File