/* * ZeroTier One - Network Virtualization Everywhere * Copyright (C) 2011-2016 ZeroTier, Inc. https://www.zerotier.com/ * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ // Note: unlike the rest of ZT's code base, this requires C++11 due to // the JSON library it uses and other things. #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <string.h> #include "../node/Constants.hpp" #include "../node/Identity.hpp" #include "../version.h" #include "../osdep/OSUtils.hpp" #include "../ext/offbase/json/json.hpp" #ifdef __WINDOWS__ #include <WinSock2.h> #include <windows.h> #include <tchar.h> #include <wchar.h> #else #include <ctype.h> #include <unistd.h> #endif #include <iostream> #include <string> #include <map> #include <vector> #include <tuple> #include <regex> #include <curl/curl.h> using json = nlohmann::json; using namespace ZeroTier; #define ZT_CLI_FLAG_VERBOSE 'v' #define ZT_CLI_FLAG_UNSAFE_SSL 'X' #define REQ_GET 0 #define REQ_POST 1 #define REQ_DEL 2 #define OK_STR "[OK ]: " #define FAIL_STR "[FAIL]: " #define WARN_STR "[WARN]: " #define INVALID_ARGS_STR "Invalid args. Usage: " struct CLIState { std::string atname; std::string command; std::string url; std::map<std::string,std::string> reqHeaders; std::vector<std::string> args; std::map<char,std::string> opts; json settings; }; namespace { static Identity getIdFromArg(char *arg) { Identity id; if ((strlen(arg) > 32)&&(arg[10] == ':')) { // identity is a literal on the command line if (id.fromString(arg)) return id; } else { // identity is to be read from a file std::string idser; if (OSUtils::readFile(arg,idser)) { if (id.fromString(idser)) return id; } } return Identity(); } static std::string trimString(const std::string &s) { unsigned long end = (unsigned long)s.length(); while (end) { char c = s[end - 1]; if ((c == ' ')||(c == '\r')||(c == '\n')||(!c)||(c == '\t')) --end; else break; } unsigned long start = 0; while (start < end) { char c = s[start]; if ((c == ' ')||(c == '\r')||(c == '\n')||(!c)||(c == '\t')) ++start; else break; } return s.substr(start,end - start); } static inline std::string getSettingsFilePath() { #ifdef __WINDOWS__ #else const char *home = getenv("HOME"); if (!home) home = "/"; return (std::string(home) + "/.zerotierCliSettings"); #endif } static bool saveSettingsBackup(CLIState &state) { std::string sfp(getSettingsFilePath().c_str()); if(state.settings.find("generateBackupConfig") != state.settings.end() && state.settings["generateBackupConfig"].get<std::string>() == "true") { std::string backup_file = getSettingsFilePath() + ".bak"; if(!OSUtils::writeFile(sfp.c_str(), state.settings.dump(2))) { OSUtils::lockDownFile(sfp.c_str(),false); std::cout << WARN_STR << "unable to write backup config file" << std::endl; return false; } return true; } return false; } static bool saveSettings(CLIState &state) { std::string sfp(getSettingsFilePath().c_str()); if(OSUtils::writeFile(sfp.c_str(), state.settings.dump(2))) { OSUtils::lockDownFile(sfp.c_str(),false); std::cout << OK_STR << "changes saved." << std::endl; return true; } std::cout << FAIL_STR << "unable to write to " << sfp << std::endl; return false; } static void dumpHelp() { std::cout << "ZeroTier Newer-Spiffier CLI " << ZEROTIER_ONE_VERSION_MAJOR << "." << ZEROTIER_ONE_VERSION_MINOR << "." << ZEROTIER_ONE_VERSION_REVISION << std::endl; std::cout << "(c)2016 ZeroTier, Inc. / Licensed under the GNU GPL v3" << std::endl; std::cout << std::endl; std::cout << "Configuration path: " << getSettingsFilePath() << std::endl; std::cout << std::endl; std::cout << "Usage: zerotier [-option] [@name] <command> [<command options>]" << std::endl; std::cout << std::endl; std::cout << "Options:" << std::endl; std::cout << " -verbose - Verbose JSON output" << std::endl; std::cout << " -X - Do not check SSL certs (CAUTION!)" << std::endl; std::cout << std::endl; std::cout << "CLI Configuration Commands:" << std::endl; std::cout << " cli-set <setting> <value> - Set a CLI option ('cli-set help')" << std::endl; std::cout << " cli-unset <setting> <value> - Un-sets a CLI option ('cli-unset help')" << std::endl; std::cout << " cli-ls - List configured @things" << std::endl; std::cout << " cli-rm @name - Remove a configured @thing" << std::endl; std::cout << " cli-add-zt @name <url> <auth> - Add a ZeroTier service" << std::endl; std::cout << " cli-add-central @name <url> <auth> - Add ZeroTier Central instance" << std::endl; std::cout << std::endl; std::cout << "ZeroTier One Service Commands:" << std::endl; std::cout << " -v / -version - Displays default local instance's version'" << std::endl; std::cout << " ls - List currently joined networks" << std::endl; std::cout << " join <network> [opt=value ...] - Join a network" << std::endl; std::cout << " leave <network> - Leave a network" << std::endl; std::cout << " peers - List ZeroTier VL1 peers" << std::endl; std::cout << " show [<network/peer address>] - Get info about self or object" << std::endl; std::cout << std::endl; std::cout << "Network Controller Commands:" << std::endl; std::cout << " net-create - Create a new network" << std::endl; std::cout << " net-rm <network> - Delete a network (CAUTION!)" << std::endl; std::cout << " net-ls - List administered networks" << std::endl; std::cout << " net-members <network> - List members of a network" << std::endl; std::cout << " net-show <network> [<address>] - Get network or member info" << std::endl; std::cout << " net-auth <network> <address> - Authorize a member" << std::endl; std::cout << " net-unauth <network> <address> - De-authorize a member" << std::endl; std::cout << " net-set <path> <value> - See 'net-set help'" << std::endl; std::cout << std::endl; std::cout << "Identity Commands:" << std::endl; std::cout << " id-generate [<vanity prefix>] - Generate a ZeroTier identity" << std::endl; std::cout << " id-validate <identity> - Locally validate an identity" << std::endl; std::cout << " id-sign <identity> <file> - Sign a file" << std::endl; std::cout << " id-verify <secret> <file> <sig> - Verify a file's signature" << std::endl; std::cout << " id-getpublic <secret> - Get full identity's public portion" << std::endl; std::cout << std::endl; } static size_t _curlStringAppendCallback(void *contents,size_t size,size_t nmemb,void *stdstring) { size_t totalSize = size * nmemb; reinterpret_cast<std::string *>(stdstring)->append((const char *)contents,totalSize); return totalSize; } static std::tuple<int,std::string> REQUEST(int requestType, CLIState &state, const std::map<std::string,std::string> &headers, const std::string &postfield, const std::string &url) { std::string body; char errbuf[CURL_ERROR_SIZE]; char urlbuf[4096]; CURL *curl; curl = curl_easy_init(); if (!curl) { std::cerr << "FATAL: curl_easy_init() failed" << std::endl; exit(-1); } Utils::scopy(urlbuf,sizeof(urlbuf),url.c_str()); curl_easy_setopt(curl,CURLOPT_URL,urlbuf); struct curl_slist *hdrs = (struct curl_slist *)0; for(std::map<std::string,std::string>::const_iterator i(headers.begin());i!=headers.end();++i) { std::string htmp(i->first); htmp.append(": "); htmp.append(i->second); hdrs = curl_slist_append(hdrs,htmp.c_str()); } if (hdrs) curl_easy_setopt(curl,CURLOPT_HTTPHEADER,hdrs); //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); curl_easy_setopt(curl,CURLOPT_WRITEDATA,(void *)&body); curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,_curlStringAppendCallback); if(std::find(state.args.begin(), state.args.end(), "-X") == state.args.end()) curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,(state.opts.count(ZT_CLI_FLAG_UNSAFE_SSL) > 0) ? 0L : 1L); if(requestType == REQ_POST) { curl_easy_setopt(curl, CURLOPT_POST, 1); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfield.c_str()); } if(requestType == REQ_DEL) curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE"); if(requestType == REQ_GET) { curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errbuf); curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,0L); } curl_easy_setopt(curl,CURLOPT_USERAGENT,"ZeroTier-CLI"); CURLcode res = curl_easy_perform(curl); errbuf[CURL_ERROR_SIZE-1] = (char)0; // sanity check if (res != CURLE_OK) return std::make_tuple(-1,std::string(errbuf)); long response_code; int rc = (int)curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE, &response_code); if(response_code == 401) { std::cout << FAIL_STR << response_code << "Unauthorized." << std::endl; exit(0); } else if(response_code == 403) { std::cout << FAIL_STR << response_code << "Forbidden." << std::endl; exit(0); } else if(response_code == 404) { std::cout << FAIL_STR << response_code << "Not found." << std::endl; exit(0); } else if(response_code == 408) { std::cout << FAIL_STR << response_code << "Request timed out." << std::endl; exit(0); } else if(response_code != 200) { std::cout << FAIL_STR << response_code << "Unable to process request." << std::endl; exit(0); } curl_easy_cleanup(curl); if (hdrs) curl_slist_free_all(hdrs); return std::make_tuple(response_code,body); } } // anonymous namespace ////////////////////////////////////////////////////////////////////////////// // Check for user-specified @thing config // Make sure it @thing makes sense // Apply appropriate request headers static void checkForThing(CLIState &state, std::string thingType, bool warnNoThingProvided) { std::string configName; if(state.atname.length()) { configName = state.atname.erase(0,1); // make sure specified @thing makes sense in the context of the command if(thingType == "one" && state.settings["things"][configName]["type"].get<std::string>() != "one") { std::cout << FAIL_STR << "A ZeroTier Central config was specified for a ZeroTier One command." << std::endl; exit(0); } if(thingType == "central" && state.settings["things"][configName]["type"].get<std::string>() != "central") { std::cout << FAIL_STR << "A ZeroTier One config was specified for a ZeroTier Central command." << std::endl; exit(0); } } else { // no @thing specified, check for defaults depending on type if(thingType == "one") { if(state.settings.find("defaultOne") != state.settings.end()) { if(warnNoThingProvided) std::cout << WARN_STR << "No @thing specified, assuming default for ZeroTier One command: " << state.settings["defaultOne"].get<std::string>().c_str() << std::endl; configName = state.settings["defaultOne"].get<std::string>().erase(0,1); // get default } else { std::cout << WARN_STR << "No @thing specified, and no default is known." << std::endl; std::cout << "HELP: To set a default: zerotier cli-set defaultOne @my_default_thing" << std::endl; exit(0); } } if(thingType == "central") { if(state.settings.find("defaultCentral") != state.settings.end()) { if(warnNoThingProvided) std::cout << WARN_STR << "No @thing specified, assuming default for ZeroTier Central command: " << state.settings["defaultCentral"].get<std::string>().c_str() << std::endl; configName = state.settings["defaultCentral"].get<std::string>().erase(0,1); // get default } else { std::cout << WARN_STR << "No @thing specified, and no default is known." << std::endl; std::cout << "HELP: To set a default: zerotier cli-set defaultCentral @my_default_thing" << std::endl; exit(0); } } } // Apply headers if(thingType == "one") { state.reqHeaders["X-ZT1-Auth"] = state.settings["things"][configName]["auth"]; } if(thingType == "central"){ state.reqHeaders["Content-Type"] = "application/json"; state.reqHeaders["Authorization"] = "Bearer " + state.settings["things"][configName]["auth"].get<std::string>(); state.reqHeaders["Accept"] = "application/json"; } state.url = state.settings["things"][configName]["url"]; } static bool checkURL(std::string url) { // TODO return true; } static std::string getLocalVersion(CLIState &state) { json result; std::tuple<int,std::string> res; checkForThing(state,"one",false); res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "/status"); if(std::get<0>(res) == 200) { result = json::parse(std::get<1>(res)); return result["version"].get<std::string>(); } return "---"; } #ifdef __WINDOWS__ int _tmain(int argc, _TCHAR* argv[]) #else int main(int argc,char **argv) #endif { #ifdef __WINDOWS__ { WSADATA wsaData; WSAStartup(MAKEWORD(2,2),&wsaData); } #endif curl_global_init(CURL_GLOBAL_DEFAULT); CLIState state; std::string arg1, arg2, authToken; for(int i=1;i<argc;++i) { if (argv[i][0] == '@') { state.atname = argv[i]; } else if (state.command.length() == 0) { if (argv[i][0] == '-') { if (!argv[i][1]) { dumpHelp(); return -1; } else if (argv[i][2]) { state.opts[argv[i][1]] = argv[i] + 2; } else { state.opts[argv[i][1]] = ""; } } else { state.command = argv[i]; } } else { state.args.push_back(std::string(argv[i])); } } { std::string buf; if (OSUtils::readFile(getSettingsFilePath().c_str(),buf)) state.settings = json::parse(buf); if (state.settings.empty()) { // Default settings state.settings = { { "configVersion", 1 }, { "things", { { "my.zerotier.com", { { "type", "central" }, { "url", "https://my.zerotier.com/" }, { "auth", "" } }}, { "local", { { "type", "one" }, { "url", "" }, { "auth", "" } }} }}, { "defaultController", "@my.zerotier.com" }, { "defaultOne", "@local" } }; std::string oneHome(OSUtils::platformDefaultHomePath()); std::string portStr; bool initSuccess = false; std::string path = oneHome + ZT_PATH_SEPARATOR_S ; if (OSUtils::readFile((oneHome + ZT_PATH_SEPARATOR_S + "authtoken.secret").c_str(),authToken)&&OSUtils::readFile((oneHome + ZT_PATH_SEPARATOR_S + "zerotier-one.port").c_str(),portStr)) { portStr = trimString(portStr); authToken = trimString(authToken); int port = Utils::strToInt(portStr.c_str()); if (((port > 0)&&(port < 65536))&&(authToken.length() > 0)) { state.settings["things"]["local"]["url"] = (std::string("http://127.0.0.1:") + portStr + "/"); state.settings["things"]["local"]["auth"] = authToken; initSuccess = true; } } if (!saveSettings(state)) { std::cerr << "FATAL: unable to write " << getSettingsFilePath() << std::endl; exit(-1); } if (initSuccess) { std::cerr << "INFO: initialized new config at " << getSettingsFilePath() << std::endl; } else { std::cerr << "INFO: initialized new config at " << getSettingsFilePath() << " but could not auto-init local ZeroTier One service config from " << oneHome << " -- you will need to set local service URL and port manually if you want to control a local instance of ZeroTier One. (This happens if you are not root/administrator.)" << std::endl; } } } // PRE-REQUEST SETUP json result; std::tuple<int,std::string> res; std::string url = ""; // META if ((state.command.length() == 0)||(state.command == "help")) { dumpHelp(); return -1; } // zerotier version else if (state.command == "v" || state.command == "version") { std::cout << getLocalVersion(state) << std::endl; return 1; } // zerotier cli-set <setting> <value> else if (state.command == "cli-set") { if(argc != 4) { std::cerr << INVALID_ARGS_STR << "zerotier cli-set <setting> <value>" << std::endl; return 1; } std::string settingName, settingValue; if(state.atname.length()) { // User provided @thing erroneously, we will ignore it and adjust argument indices settingName = argv[3]; settingValue = argv[4]; } else { settingName = argv[2]; settingValue = argv[3]; } saveSettingsBackup(state); state.settings[settingName] = settingValue; // changes saveSettings(state); } // zerotier cli-unset <setting> else if (state.command == "cli-unset") { if(argc != 3) { std::cerr << INVALID_ARGS_STR << "zerotier cli-unset <setting>" << std::endl; return 1; } std::string settingName; if(state.atname.length()) // User provided @thing erroneously, we will ignore it and adjust argument indices settingName = argv[3]; else settingName = argv[2]; saveSettingsBackup(state); state.settings.erase(settingName); // changes saveSettings(state); } // zerotier @thing_to_remove cli-rm --- removes the configuration else if (state.command == "cli-rm") { if(argc != 3) { std::cerr << INVALID_ARGS_STR << "zerotier cli-rm <@thing>" << std::endl; return 1; } if(state.settings["things"].find(state.atname) != state.settings["things"].end()) { if(state.settings["defaultOne"] == state.atname) { std::cout << "WARNING: The config you're trying to remove is currently set as your default. Set a new default first!" << std::endl; std::cout << " | Usage: zerotier set defaultOne @your_other_thing" << std::endl; } else { state.settings["things"].erase(state.atname.c_str()); saveSettings(state); } } } // zerotier cli-add-zt <shortname> <url> <auth> // TODO: Check for malformed urls/auth else if (state.command == "cli-add-zt") { if(argc != 5) { std::cerr << INVALID_ARGS_STR << "zerotier cli-add-zt <shortname> <url> <authToken>" << std::endl; return 1; } std::string thing_name = argv[2], url = argv[3], auth = argv[4]; if(!checkURL(url)) { std::cout << FAIL_STR << "Malformed URL" << std::endl; return 1; } if(state.settings.find(thing_name) != state.settings.end()) { std::cout << "WARNING: A @thing with the shortname " << thing_name.c_str() << " already exists. Choose another name or rename the old @thing" << std::endl; std::cout << " | Usage: To rename a @thing: zerotier cli-rename @old_thing_name @new_thing_name" << std::endl; } else { result = json::parse("{ \"auth\": \"" + auth + "\", \"type\": \"" + "one" + "\", \"url\": \"" + url + "\" }"); saveSettingsBackup(state); // TODO: Handle cases where user may or may not prepend an @ state.settings["things"][thing_name] = result; // changes saveSettings(state); } } // zerotier cli-add-central <shortname> <url> <auth> // TODO: Check for malformed urls/auth else if (state.command == "cli-add-central") { if(argc != 5) { std::cerr << INVALID_ARGS_STR << "zerotier cli-add-central <shortname> <url> <authToken>" << std::endl; return 1; } std::string thing_name = argv[2], url = argv[3], auth = argv[4]; if(!checkURL(url)) { std::cout << FAIL_STR << "Malformed URL" << std::endl; return 1; } if(state.settings.find(thing_name) != state.settings.end()) { std::cout << "WARNING: A @thing with the shortname " << thing_name.c_str() << " already exists. Choose another name or rename the old @thing" << std::endl; std::cout << " | Usage: To rename a @thing: zerotier cli-rename @old_thing_name @new_thing_name" << std::endl; } else { result = json::parse("{ \"auth\": \"" + auth + "\", \"type\": \"" + "central" + "\", \"url\": \"" + url + "\" }"); saveSettingsBackup(state); // TODO: Handle cases where user may or may not prepend an @ state.settings["things"]["@" + thing_name] = result; // changes saveSettings(state); } } // ONE SERVICE // zerotier ls --- display all networks currently joined else if (state.command == "ls" || state.command == "listnetworks") { if(argc != 2) { std::cerr << INVALID_ARGS_STR << "zerotier ls" << std::endl; return 1; } checkForThing(state,"one",true); url = state.url + "network"; res = REQUEST(REQ_GET,state,state.reqHeaders,"",(const std::string)url); if(std::get<0>(res) == 200) { std::cout << "listnetworks <nwid> <name> <mac> <status> <type> <dev> <ZT assigned ips>" << std::endl; auto j = json::parse(std::get<1>(res).c_str()); if (j.type() == json::value_t::array) { for(int i=0;i<j.size();i++){ std::string nwid = j[i]["nwid"].get<std::string>(); std::string name = j[i]["name"].get<std::string>(); std::string mac = j[i]["mac"].get<std::string>(); std::string status = j[i]["status"].get<std::string>(); std::string type = j[i]["type"].get<std::string>(); std::string addrs; for(int m=0; m<j[i]["assignedAddresses"].size(); m++) { addrs += j[i]["assignedAddresses"][m].get<std::string>() + " "; } std::string dev = j[i]["portDeviceName"].get<std::string>(); std::cout << "listnetworks " << nwid << " " << name << " " << mac << " " << status << " " << type << " " << dev << " " << addrs << std::endl; } } } } // zerotier join <nwid> --- joins a network else if (state.command == "join") { if(argc != 3) { std::cerr << INVALID_ARGS_STR << "zerotier join <nwid>" << std::endl; return 1; } checkForThing(state,"one",true); res = REQUEST(REQ_POST,state,state.reqHeaders,"{}",state.url + "/network/" + state.args[0]); if(std::get<0>(res) == 200) { std::cout << OK_STR << "connected to " << state.args[0] << std::endl; } } // zerotier leave <nwid> --- leaves a network else if (state.command == "leave") { if(argc != 3) { std::cerr << INVALID_ARGS_STR << "zerotier leave <nwid>" << std::endl; return 1; } checkForThing(state,"one",true); res = REQUEST(REQ_DEL,state,state.reqHeaders,"{}",state.url + "/network/" + state.args[0]); if(std::get<0>(res) == 200) { std::cout << OK_STR << "disconnected from " << state.args[0] << std::endl; } } // zerotier peers --- display address and role of all peers else if (state.command == "peers") { if(argc != 2) { std::cerr << INVALID_ARGS_STR << "zerotier peers" << std::endl; return 1; } checkForThing(state,"one",true); res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "/peer"); if(std::get<0>(res) == 200) { json result = json::parse(std::get<1>(res)); for(int i=0; i<result.size(); i++) { std::cout << result[i]["address"] << " " << result[i]["role"] << std::endl; } } } // zerotier show --- display status of local instance else if (state.command == "show" || state.command == "status") { if(argc != 2) { std::cerr << INVALID_ARGS_STR << "zerotier show" << std::endl; return 1; } checkForThing(state,"one",true); res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "/status"); if(std::get<0>(res) == 200) { result = json::parse(std::get<1>(res)); std::string status_str = result["online"].get<bool>() ? "ONLINE" : "OFFLINE"; std::cout << "info " << result["address"].get<std::string>() << " " << status_str << " " << result["version"].get<std::string>() << std::endl; } } // REMOTE // zerotier @thing net-create --- creates a new network else if (state.command == "net-create") { if(argc > 3 || (argc == 3 && !state.atname.length())) { std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-create" << std::endl; return 1; } checkForThing(state,"central",true); res = REQUEST(REQ_POST,state,state.reqHeaders,"",state.url + "api/network"); if(std::get<0>(res) == 200) { json result = json::parse(std::get<1>(res)); std::cout << OK_STR << "created network " << result["config"]["nwid"].get<std::string>() << std::endl; } } // zerotier @thing net-rm <nwid> --- deletes a network else if (state.command == "net-rm") { if(argc > 4 || (argc == 4 && !state.atname.length())) { std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-rm <nwid>" << std::endl; return 1; } checkForThing(state,"central",true); if(!state.args.size()) { std::cout << "Argument error: No network specified." << std::endl; std::cout << " | Usage: zerotier net-rm <nwid>" << std::endl; } else { std::string nwid = state.args[0]; res = REQUEST(REQ_DEL,state,state.reqHeaders,"",state.url + "api/network/" + nwid); if(std::get<0>(res) == 200) { std::cout << "deleted network " << nwid << std::endl; } } } // zerotier @thing net-ls --- lists all networks else if (state.command == "net-ls") { if(argc > 3 || (argc == 3 && !state.atname.length())) { std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-ls" << std::endl; return 1; } checkForThing(state,"central",true); res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network"); if(std::get<0>(res) == 200) { json result = json::parse(std::get<1>(res)); for(int m=0;m<result.size(); m++) { std::cout << "network " << result[m]["id"].get<std::string>() << std::endl; } } } // zerotier @thing net-members <nwid> --- show all members of a network else if (state.command == "net-members") { if(argc > 4 || (argc == 4 && !state.atname.length())) { std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-members <nwid>" << std::endl; return 1; } checkForThing(state,"central",true); if(!state.args.size()) { std::cout << FAIL_STR << "Argument error: No network specified." << std::endl; std::cout << " | Usage: zerotier net-members <nwid>" << std::endl; } else { std::string nwid = state.args[0]; res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network/" + nwid + "/member"); json result = json::parse(std::get<1>(res)); std::cout << "Members of " << nwid << ":" << std::endl; for (json::iterator it = result.begin(); it != result.end(); ++it) { std::cout << it.key() << std::endl; } } } // zerotier @thing net-show <nwid> <devID> --- show info about a device on a specific network else if (state.command == "net-show") { if(argc > 5 || (argc == 5 && !state.atname.length())) { std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-show <nwid> <devID>" << std::endl; return 1; } checkForThing(state,"central",true); if(state.args.size() < 2) { std::cout << FAIL_STR << "Argument error: Too few arguments." << std::endl; std::cout << " | Usage: zerotier net-show <nwid> <devID>" << std::endl; } else { std::string nwid = state.args[0]; std::string devid = state.args[1]; res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network/" + nwid + "/member/" + devid); // TODO: More info, what would we like to show exactly? if(std::get<0>(res) == 200) { json result = json::parse(std::get<1>(res)); std::cout << "Assigned IP: " << std::endl; for(int m=0; m<result["config"]["ipAssignments"].size();m++) { std::cout << "\t" << result["config"]["ipAssignments"][m].get<std::string>() << std::endl; } } } } // zerotier @thing net-auth <nwid> <devID> --- authorize a device on a network else if (state.command == "net-auth") { if(argc > 5 || (argc == 5 && !state.atname.length())) { std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-auth <nwid> <devID>" << std::endl; return 1; } checkForThing(state,"central",true); if(state.args.size() != 2) { std::cout << FAIL_STR << "Argument error: Network and/or device ID not specified." << std::endl; std::cout << " | Usage: zerotier net-auth <nwid> <devID>" << std::endl; } std::string nwid = state.args[0]; std::string devid = state.args[1]; url = state.url + "api/network/" + nwid + "/member/" + devid; // Add device to network res = REQUEST(REQ_POST,state,state.reqHeaders,"",(const std::string)url); if(std::get<0>(res) == 200) { result = json::parse(std::get<1>(res)); res = REQUEST(REQ_GET,state,state.reqHeaders,"",(const std::string)url); result = json::parse(std::get<1>(res)); result["config"]["authorized"] = "true"; std::string newconfig = result.dump(); res = REQUEST(REQ_POST,state,state.reqHeaders,newconfig,(const std::string)url); if(std::get<0>(res) == 200) std::cout << OK_STR << devid << " authorized on " << nwid << std::endl; else std::cout << FAIL_STR << "There was a problem authorizing that device." << std::endl; } } // zerotier @thing net-unauth <nwid> <devID> else if (state.command == "net-unauth") { if(argc > 5 || (argc == 5 && !state.atname.length())) { std::cerr << INVALID_ARGS_STR << "zerotier <@thing> net-unauth <nwid> <devID>" << std::endl; return 1; } checkForThing(state,"central",true); if(state.args.size() != 2) { std::cout << FAIL_STR << "Bad argument. No network and/or device ID specified." << std::endl; std::cout << " | Usage: zerotier net-unauth <nwid> <devID>" << std::endl; } std::string nwid = state.args[0]; std::string devid = state.args[1]; // If successful, get member config res = REQUEST(REQ_GET,state,state.reqHeaders,"",state.url + "api/network/" + nwid + "/member/" + devid); result = json::parse(std::get<1>(res)); // modify auth field and re-POST result["config"]["authorized"] = "false"; std::string newconfig = result.dump(); res = REQUEST(REQ_POST,state,state.reqHeaders,newconfig,state.url + "api/network/" + nwid + "/member/" + devid); if(std::get<0>(res) == 200) std::cout << OK_STR << devid << " de-authorized from " << nwid << std::endl; else std::cout << FAIL_STR << "There was a problem de-authorizing that device." << std::endl; } // zerotier @thing net-set else if (state.command == "net-set") { } // ID // zerotier id-generate [<vanity prefix>] else if (state.command == "id-generate") { if(argc != 3) { std::cerr << INVALID_ARGS_STR << "zerotier id-generate [<vanity prefix>]" << std::endl; return 1; } uint64_t vanity = 0; int vanityBits = 0; if (argc >= 5) { vanity = Utils::hexStrToU64(argv[4]) & 0xffffffffffULL; vanityBits = 4 * strlen(argv[4]); if (vanityBits > 40) vanityBits = 40; } ZeroTier::Identity id; for(;;) { id.generate(); if ((id.address().toInt() >> (40 - vanityBits)) == vanity) { if (vanityBits > 0) { fprintf(stderr,"vanity address: found %.10llx !\n",(unsigned long long)id.address().toInt()); } break; } else { fprintf(stderr,"vanity address: tried %.10llx looking for first %d bits of %.10llx\n",(unsigned long long)id.address().toInt(),vanityBits,(unsigned long long)(vanity << (40 - vanityBits))); } } std::string idser = id.toString(true); if (argc >= 3) { if (!OSUtils::writeFile(argv[2],idser)) { std::cerr << "Error writing to " << argv[2] << std::endl; return 1; } else std::cout << argv[2] << " written" << std::endl; if (argc >= 4) { idser = id.toString(false); if (!OSUtils::writeFile(argv[3],idser)) { std::cerr << "Error writing to " << argv[3] << std::endl; return 1; } else std::cout << argv[3] << " written" << std::endl; } } else std::cout << idser << std::endl; } // zerotier id-validate <identity> else if (state.command == "id-validate") { if(argc != 3) { std::cerr << INVALID_ARGS_STR << "zerotier id-validate <identity>" << std::endl; return 1; } Identity id = getIdFromArg(argv[2]); if (!id) { std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl; return 1; } if (!id.locallyValidate()) { std::cerr << argv[2] << " FAILED validation." << std::endl; return 1; } else std::cout << argv[2] << "is a valid identity" << std::endl; } // zerotier id-sign <identity> <file> else if (state.command == "id-sign") { if(argc != 4) { std::cerr << INVALID_ARGS_STR << "zerotier id-sign <identity> <file>" << std::endl; return 1; } Identity id = getIdFromArg(argv[2]); if (!id) { std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl; return 1; } if (!id.hasPrivate()) { std::cerr << argv[2] << " does not contain a private key (must use private to sign)" << std::endl; return 1; } std::string inf; if (!OSUtils::readFile(argv[3],inf)) { std::cerr << argv[3] << " is not readable" << std::endl; return 1; } C25519::Signature signature = id.sign(inf.data(),(unsigned int)inf.length()); std::cout << Utils::hex(signature.data,(unsigned int)signature.size()) << std::endl; } // zerotier id-verify <secret> <file> <sig> else if (state.command == "id-verify") { if(argc != 4) { std::cerr << INVALID_ARGS_STR << "zerotier id-verify <secret> <file> <sig>" << std::endl; return 1; } Identity id = getIdFromArg(argv[2]); if (!id) { std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl; return 1; } std::string inf; if (!OSUtils::readFile(argv[3],inf)) { std::cerr << argv[3] << " is not readable" << std::endl; return 1; } std::string signature(Utils::unhex(argv[4])); if ((signature.length() > ZT_ADDRESS_LENGTH)&&(id.verify(inf.data(),(unsigned int)inf.length(),signature.data(),(unsigned int)signature.length()))) { std::cout << argv[3] << " signature valid" << std::endl; } else { std::cerr << argv[3] << " signature check FAILED" << std::endl; return 1; } } // zerotier id-getpublic <secret> else if (state.command == "id-getpublic") { if(argc != 3) { std::cerr << INVALID_ARGS_STR << "zerotier id-getpublic <secret>" << std::endl; return 1; } Identity id = getIdFromArg(argv[2]); if (!id) { std::cerr << "Identity argument invalid or file unreadable: " << argv[2] << std::endl; return 1; } std::cerr << id.toString(false) << std::endl; } // else { dumpHelp(); return -1; } if(std::find(state.args.begin(), state.args.end(), "-verbose") != state.args.end()) std::cout << "\n\nAPI response = " << std::get<1>(res) << std::endl; curl_global_cleanup(); return 0; }