Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
| 2 | /** |
Zhiyi Zhang | 74c6114 | 2020-10-07 21:00:49 -0700 | [diff] [blame] | 3 | * Copyright (c) 2017-2020, Regents of the University of California. |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 4 | * |
| 5 | * This file is part of ndncert, a certificate management system based on NDN. |
| 6 | * |
| 7 | * ndncert is free software: you can redistribute it and/or modify it under the terms |
| 8 | * of the GNU General Public License as published by the Free Software Foundation, either |
| 9 | * version 3 of the License, or (at your option) any later version. |
| 10 | * |
| 11 | * ndncert is distributed in the hope that it will be useful, but WITHOUT ANY |
| 12 | * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A |
| 13 | * PARTICULAR PURPOSE. See the GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received copies of the GNU General Public License along with |
| 16 | * ndncert, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>. |
| 17 | * |
| 18 | * See AUTHORS.md for complete list of ndncert authors and contributors. |
| 19 | */ |
| 20 | |
| 21 | #include "challenge-email.hpp" |
Zhiyi Zhang | 523f0c2 | 2020-09-29 14:19:20 -0700 | [diff] [blame] | 22 | #include <regex> |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 23 | |
| 24 | namespace ndn { |
| 25 | namespace ndncert { |
| 26 | |
Zhiyi Zhang | d61b4a8 | 2020-10-10 15:18:43 -0700 | [diff] [blame] | 27 | NDN_LOG_INIT(ndncert.challenge.email); |
Zhiyi Zhang | 3670683 | 2019-07-04 21:33:03 -0700 | [diff] [blame] | 28 | NDNCERT_REGISTER_CHALLENGE(ChallengeEmail, "email"); |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 29 | |
| 30 | const std::string ChallengeEmail::NEED_CODE = "need-code"; |
| 31 | const std::string ChallengeEmail::WRONG_CODE = "wrong-code"; |
Zhiyi Zhang | ead9f00 | 2020-10-03 15:42:52 -0700 | [diff] [blame] | 32 | const std::string ChallengeEmail::INVALID_EMAIL = "invalid-email"; |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 33 | const std::string ChallengeEmail::PARAMETER_KEY_EMAIL = "email"; |
| 34 | const std::string ChallengeEmail::PARAMETER_KEY_CODE = "code"; |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 35 | |
| 36 | ChallengeEmail::ChallengeEmail(const std::string& scriptPath, |
| 37 | const size_t& maxAttemptTimes, |
| 38 | const time::seconds secretLifetime) |
Zhiyi Zhang | ead9f00 | 2020-10-03 15:42:52 -0700 | [diff] [blame] | 39 | : ChallengeModule("email", maxAttemptTimes, secretLifetime) |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 40 | , m_sendEmailScript(scriptPath) |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 41 | { |
| 42 | } |
| 43 | |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 44 | // For CA |
Zhiyi Zhang | aafc55e | 2020-09-28 17:54:48 -0700 | [diff] [blame] | 45 | std::tuple<ErrorCode, std::string> |
Zhiyi Zhang | 32d4b4e | 2020-10-28 22:10:49 -0700 | [diff] [blame] | 46 | ChallengeEmail::handleChallengeRequest(const Block& params, ca::RequestState& request) |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 47 | { |
Suyong Won | 44d0cce | 2020-05-10 04:07:43 -0700 | [diff] [blame] | 48 | params.parse(); |
Zhiyi Zhang | 8da54d6 | 2019-11-21 00:03:05 -0800 | [diff] [blame] | 49 | auto currentTime = time::system_clock::now(); |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 50 | if (request.m_status == Status::BEFORE_CHALLENGE) { |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 51 | // for the first time, init the challenge |
tylerliu | 50d679e | 2020-10-14 14:08:39 -0700 | [diff] [blame] | 52 | std::string emailAddress = readString(params.get(tlv::ParameterValue)); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 53 | if (!isValidEmailAddress(emailAddress)) { |
Zhiyi Zhang | ead9f00 | 2020-10-03 15:42:52 -0700 | [diff] [blame] | 54 | return returnWithNewChallengeStatus(request, INVALID_EMAIL, JsonSection(), m_maxAttemptTimes - 1, m_secretLifetime); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 55 | } |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 56 | auto lastComponentRequested = readString(request.m_cert.getIdentity().get(-1)); |
| 57 | if (lastComponentRequested != emailAddress) { |
tylerliu | 6563f93 | 2020-10-30 11:13:38 -0700 | [diff] [blame^] | 58 | NDN_LOG_TRACE("Email and requested name do not match. Email " << emailAddress << "requested last component " |
| 59 | << lastComponentRequested); |
Zhiyi Zhang | 5f749a2 | 2019-06-12 17:02:33 -0700 | [diff] [blame] | 60 | } |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 61 | std::string emailCode = generateSecretCode(); |
| 62 | JsonSection secretJson; |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 63 | secretJson.add(PARAMETER_KEY_CODE, emailCode); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 64 | // send out the email |
| 65 | sendEmail(emailAddress, emailCode, request); |
Zhiyi Zhang | 8fdb36b | 2020-10-18 11:58:51 -0700 | [diff] [blame] | 66 | NDN_LOG_TRACE("Secret for request " << toHex(request.m_requestId.data(), request.m_requestId.size()) << " : " << emailCode); |
Zhiyi Zhang | a749f44 | 2020-09-29 17:19:51 -0700 | [diff] [blame] | 67 | return returnWithNewChallengeStatus(request, NEED_CODE, std::move(secretJson), m_maxAttemptTimes, m_secretLifetime); |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 68 | } |
Zhiyi Zhang | a749f44 | 2020-09-29 17:19:51 -0700 | [diff] [blame] | 69 | if (request.m_challengeState) { |
| 70 | if (request.m_challengeState->m_challengeStatus == NEED_CODE || |
| 71 | request.m_challengeState->m_challengeStatus == WRONG_CODE) { |
Zhiyi Zhang | d61b4a8 | 2020-10-10 15:18:43 -0700 | [diff] [blame] | 72 | NDN_LOG_TRACE("Challenge Interest arrives. Challenge Status: " << request.m_challengeState->m_challengeStatus); |
Zhiyi Zhang | a749f44 | 2020-09-29 17:19:51 -0700 | [diff] [blame] | 73 | // the incoming interest should bring the pin code |
tylerliu | 50d679e | 2020-10-14 14:08:39 -0700 | [diff] [blame] | 74 | std::string givenCode = readString(params.get(tlv::ParameterValue)); |
Zhiyi Zhang | a749f44 | 2020-09-29 17:19:51 -0700 | [diff] [blame] | 75 | auto secret = request.m_challengeState->m_secrets; |
| 76 | // check if run out of time |
| 77 | if (currentTime - request.m_challengeState->m_timestamp >= m_secretLifetime) { |
| 78 | return returnWithError(request, ErrorCode::OUT_OF_TIME, "Secret expired."); |
| 79 | } |
| 80 | // check if provided secret is correct |
| 81 | if (givenCode == secret.get<std::string>(PARAMETER_KEY_CODE)) { |
| 82 | // the code is correct |
Zhiyi Zhang | d61b4a8 | 2020-10-10 15:18:43 -0700 | [diff] [blame] | 83 | NDN_LOG_TRACE("Correct secret code. Challenge succeeded."); |
Zhiyi Zhang | a749f44 | 2020-09-29 17:19:51 -0700 | [diff] [blame] | 84 | return returnWithSuccess(request); |
| 85 | } |
| 86 | // otherwise, check remaining attempt times |
| 87 | if (request.m_challengeState->m_remainingTries > 1) { |
| 88 | auto remainTime = m_secretLifetime - (currentTime - request.m_challengeState->m_timestamp); |
Zhiyi Zhang | d61b4a8 | 2020-10-10 15:18:43 -0700 | [diff] [blame] | 89 | NDN_LOG_TRACE("Wrong secret code provided. Remaining Tries - 1."); |
Zhiyi Zhang | a749f44 | 2020-09-29 17:19:51 -0700 | [diff] [blame] | 90 | return returnWithNewChallengeStatus(request, WRONG_CODE, std::move(secret), |
| 91 | request.m_challengeState->m_remainingTries - 1, |
| 92 | time::duration_cast<time::seconds>(remainTime)); |
| 93 | } |
| 94 | else { |
| 95 | // run out times |
Zhiyi Zhang | d61b4a8 | 2020-10-10 15:18:43 -0700 | [diff] [blame] | 96 | NDN_LOG_TRACE("Wrong secret code provided. Ran out tires. Challenge failed."); |
Zhiyi Zhang | a749f44 | 2020-09-29 17:19:51 -0700 | [diff] [blame] | 97 | return returnWithError(request, ErrorCode::OUT_OF_TRIES, "Ran out tires."); |
| 98 | } |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 99 | } |
| 100 | } |
Zhiyi Zhang | aafc55e | 2020-09-28 17:54:48 -0700 | [diff] [blame] | 101 | return returnWithError(request, ErrorCode::INVALID_PARAMETER, "Unexpected status or challenge status"); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | // For Client |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 105 | std::vector<std::tuple<std::string, std::string>> |
| 106 | ChallengeEmail::getRequestedParameterList(Status status, const std::string& challengeStatus) |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 107 | { |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 108 | std::vector<std::tuple<std::string, std::string>> result; |
Zhiyi Zhang | 48f2378 | 2020-09-28 12:11:24 -0700 | [diff] [blame] | 109 | if (status == Status::BEFORE_CHALLENGE && challengeStatus == "") { |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 110 | result.push_back(std::make_tuple(PARAMETER_KEY_EMAIL, "Please input your email address")); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 111 | } |
Zhiyi Zhang | 48f2378 | 2020-09-28 12:11:24 -0700 | [diff] [blame] | 112 | else if (status == Status::CHALLENGE && challengeStatus == NEED_CODE) { |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 113 | result.push_back(std::make_tuple(PARAMETER_KEY_CODE, "Please input your verification code")); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 114 | } |
Zhiyi Zhang | 48f2378 | 2020-09-28 12:11:24 -0700 | [diff] [blame] | 115 | else if (status == Status::CHALLENGE && challengeStatus == WRONG_CODE) { |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 116 | result.push_back(std::make_tuple(PARAMETER_KEY_CODE, "Incorrect code, please try again")); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 117 | } |
| 118 | else { |
tylerliu | 41c1153 | 2020-10-10 16:14:45 -0700 | [diff] [blame] | 119 | NDN_THROW(std::runtime_error("Unexpected status or challenge status.")); |
Zhiyi Zhang | af7c290 | 2019-03-14 22:13:21 -0700 | [diff] [blame] | 120 | } |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 121 | return result; |
| 122 | } |
| 123 | |
Suyong Won | 19fba4d | 2020-05-09 13:39:46 -0700 | [diff] [blame] | 124 | Block |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 125 | ChallengeEmail::genChallengeRequestTLV(Status status, const std::string& challengeStatus, std::vector<std::tuple<std::string, std::string>>&& params) |
Suyong Won | 19fba4d | 2020-05-09 13:39:46 -0700 | [diff] [blame] | 126 | { |
tylerliu | 50d679e | 2020-10-14 14:08:39 -0700 | [diff] [blame] | 127 | Block request = makeEmptyBlock(tlv::EncryptedPayload); |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 128 | if (status == Status::BEFORE_CHALLENGE) { |
| 129 | if (params.size() != 1 || std::get<0>(params[0]) != PARAMETER_KEY_EMAIL) { |
tylerliu | 41c1153 | 2020-10-10 16:14:45 -0700 | [diff] [blame] | 130 | NDN_THROW(std::runtime_error("Wrong parameter provided.")); |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 131 | } |
tylerliu | 50d679e | 2020-10-14 14:08:39 -0700 | [diff] [blame] | 132 | request.push_back(makeStringBlock(tlv::SelectedChallenge, CHALLENGE_TYPE)); |
| 133 | request.push_back(makeStringBlock(tlv::ParameterKey, PARAMETER_KEY_EMAIL)); |
| 134 | request.push_back(makeStringBlock(tlv::ParameterValue, std::get<1>(params[0]))); |
Suyong Won | 19fba4d | 2020-05-09 13:39:46 -0700 | [diff] [blame] | 135 | } |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 136 | else if (status == Status::CHALLENGE && (challengeStatus == NEED_CODE || challengeStatus == WRONG_CODE)) { |
| 137 | if (params.size() != 1 || std::get<0>(params[0]) != PARAMETER_KEY_CODE) { |
tylerliu | 41c1153 | 2020-10-10 16:14:45 -0700 | [diff] [blame] | 138 | NDN_THROW(std::runtime_error("Wrong parameter provided.")); |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 139 | } |
tylerliu | 50d679e | 2020-10-14 14:08:39 -0700 | [diff] [blame] | 140 | request.push_back(makeStringBlock(tlv::SelectedChallenge, CHALLENGE_TYPE)); |
| 141 | request.push_back(makeStringBlock(tlv::ParameterKey, PARAMETER_KEY_CODE)); |
| 142 | request.push_back(makeStringBlock(tlv::ParameterValue, std::get<1>(params[0]))); |
Suyong Won | 19fba4d | 2020-05-09 13:39:46 -0700 | [diff] [blame] | 143 | } |
| 144 | else { |
tylerliu | 41c1153 | 2020-10-10 16:14:45 -0700 | [diff] [blame] | 145 | NDN_THROW(std::runtime_error("Unexpected status or challenge status.")); |
Suyong Won | 19fba4d | 2020-05-09 13:39:46 -0700 | [diff] [blame] | 146 | } |
Suyong Won | 44d0cce | 2020-05-10 04:07:43 -0700 | [diff] [blame] | 147 | request.encode(); |
Suyong Won | 19fba4d | 2020-05-09 13:39:46 -0700 | [diff] [blame] | 148 | return request; |
| 149 | } |
| 150 | |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 151 | bool |
| 152 | ChallengeEmail::isValidEmailAddress(const std::string& emailAddress) |
| 153 | { |
Zhiyi Zhang | 8ce677b | 2018-07-13 14:44:06 -0700 | [diff] [blame] | 154 | const std::string pattern = R"_REGEX_((^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+.[a-zA-Z0-9\-\.]+$))_REGEX_"; |
| 155 | static const std::regex emailPattern(pattern); |
| 156 | return std::regex_match(emailAddress, emailPattern); |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | void |
Zhiyi Zhang | 576aad1 | 2017-10-03 15:41:53 -0700 | [diff] [blame] | 160 | ChallengeEmail::sendEmail(const std::string& emailAddress, const std::string& secret, |
Zhiyi Zhang | 32d4b4e | 2020-10-28 22:10:49 -0700 | [diff] [blame] | 161 | const ca::RequestState& request) const |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 162 | { |
Zhiyi Zhang | 576aad1 | 2017-10-03 15:41:53 -0700 | [diff] [blame] | 163 | std::string command = m_sendEmailScript; |
Zhiyi Zhang | 4604983 | 2020-09-28 17:08:12 -0700 | [diff] [blame] | 164 | command += " \"" + emailAddress + "\" \"" + secret + "\" \"" + request.m_caPrefix.toUri() + "\" \"" + request.m_cert.getName().toUri() + "\""; |
Zhiyi Zhang | 576aad1 | 2017-10-03 15:41:53 -0700 | [diff] [blame] | 165 | int result = system(command.c_str()); |
| 166 | if (result == -1) { |
Zhiyi Zhang | d61b4a8 | 2020-10-10 15:18:43 -0700 | [diff] [blame] | 167 | NDN_LOG_TRACE("EmailSending Script " + m_sendEmailScript + " fails."); |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 168 | } |
Zhiyi Zhang | d61b4a8 | 2020-10-10 15:18:43 -0700 | [diff] [blame] | 169 | NDN_LOG_TRACE("EmailSending Script " + m_sendEmailScript + |
Zhiyi Zhang | 576aad1 | 2017-10-03 15:41:53 -0700 | [diff] [blame] | 170 | " was executed successfully with return value" + std::to_string(result) + "."); |
Zhiyi Zhang | defa959 | 2017-02-21 10:56:22 -0800 | [diff] [blame] | 171 | return; |
| 172 | } |
| 173 | |
Zhiyi Zhang | e4891b7 | 2020-10-10 15:11:57 -0700 | [diff] [blame] | 174 | } // namespace ndncert |
| 175 | } // namespace ndn |