rippled
Loading...
Searching...
No Matches
ValidatorSite_test.cpp
1//------------------------------------------------------------------------------
2/*
3 This file is part of rippled: https://github.com/ripple/rippled
4 Copyright 2016 Ripple Labs Inc.
5
6 Permission to use, copy, modify, and/or distribute this software for any
7 purpose with or without fee is hereby granted, provided that the above
8 copyright notice and this permission notice appear in all copies.
9
10 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17*/
18//==============================================================================
19
20#include <test/jtx.h>
21#include <test/jtx/TrustedPublisherServer.h>
22#include <test/unit_test/FileDirGuard.h>
23#include <xrpld/app/misc/ValidatorSite.h>
24#include <xrpl/basics/Slice.h>
25#include <xrpl/basics/base64.h>
26#include <xrpl/basics/strHex.h>
27#include <xrpl/protocol/HashPrefix.h>
28#include <xrpl/protocol/PublicKey.h>
29#include <xrpl/protocol/SecretKey.h>
30#include <xrpl/protocol/Sign.h>
31#include <xrpl/protocol/digest.h>
32#include <xrpl/protocol/jss.h>
33#include <boost/algorithm/string/join.hpp>
34#include <boost/algorithm/string/predicate.hpp>
35#include <boost/asio.hpp>
36#include <boost/range/adaptor/transformed.hpp>
37#include <chrono>
38#include <date/date.h>
39
40namespace ripple {
41namespace test {
42namespace detail {
43constexpr const char*
44realValidatorContents()
45{
46 return R"vl({
47 "public_key": "ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734",
48 "manifest": "JAAAAAFxIe0md6v/0bM6xvvDBitx8eg5fBUF4cQsZNEa0bKP9z9HNHMh7V0AnEi5D4odY9X2sx+cY8B3OHNjJvMhARRPtTHmWnAhdkDFcg53dAQS1WDMQDLIs2wwwHpScrUnjp1iZwwTXVXXsaRxLztycioto3JgImGdukXubbrjeqCNU02f7Y/+6w0BcBJA3M0EOU+39hmB8vwfgernXZIDQ1+o0dnuXjX73oDLgsacwXzLBVOdBpSAsJwYD+nW8YaSacOHEsWaPlof05EsAg==",
49 "blob" : "{"sequence":37,"expiration":594172800,"validators":[{"validation_public_key":"ED49F8EB8071E26D4E067238D62D67CA6EBFB298B4A72DCFAD536A7EC8925C519B","manifest":"JAAAAAFxIe1J+OuAceJtTgZyONYtZ8puv7KYtKctz61Tan7IklxRm3MhAogMmQTRAFK/+m/XWQfJvXTeMcaiyF6gkhgAssdLOciIdkYwRAIgNxYavJPyHANuxogQY7RNBP9tZogZJxF1wZqzm4a37GgCIBOvbeQ8+P46CCIcy4ZCZA5rZZ+93H0aKJZQ3+IA0OOucBJAASTpQKtEJkeqwHz+jKWNvWl0sHRQZSSJuYiMyyUa7ytpsev6NGoFn1bNpYTgvsaPxoz7vHskDh2Z6gebSDCRCA=="},{"validation_public_key":"ED8108F7D9EE779DC1075EC3CF8EB9004DDF84CD0A0FF5775C9E375CCACDAA3022","manifest":"JAAAAAFxIe2BCPfZ7nedwQdew8+OuQBN34TNCg/1d1yeN1zKzaowInMhAlvPJANQcRUSNUR+NlZuo4kGpYF8l9pHPP1ZROOUcNYRdkYwRAIgRWZZuJLAf3SNMGoFygUlu+eAD51ZoHFMcyoicn0WKucCIGw4n9cVDPOBGC8wlJDy9282x9RdOwo1co2g+NZlc/DNcBJAKJhK/am6L7KE450NVzhpVVoL8OFMo0mFxk8BDG6QO2cSNMN3Oywf40D+Iles9LXxxvvPB6gWSmPlwF7dNR9GAQ=="},{"validation_public_key":"ED7E3BAFF901DE525B00B2C1FE19AF449A080B5F3100C6EC182C867AF61F710FFD","manifest":"JAAAAAFxIe1+O6/5Ad5SWwCywf4Zr0SaCAtfMQDG7Bgshnr2H3EP/XMhA5+GDJh2ApWKCh2N5omx4FAOFEqXMjqy1HJ5E7WA3FrOdkcwRQIhAMRezwjTAL35jpjj15jqoHUvRm7+7iHpU47aKE6HEChZAiBSMIZaMWv6qNJHniYpsYHx4OPPpBoCMMdMVAGfFi9fK3ASQE0TYiIsGv0/ylpqGEBiLkk2XjrA8++Akzpr9vcTtrkHiDDo0cHKO9mRULAXesRrOyFb5QcO0l0VswevD5jlswk="},{"validation_public_key":"ED45E80A04D79CB9DF00AEBD86DCDC1686D6419EA9E5E0E71F1A817E08B5076A55","manifest":"JAAAAAFxIe1F6AoE15y53wCuvYbc3BaG1kGeqeXg5x8agX4ItQdqVXMhAxZo157pcB9de6Smk7hoK3wNCAr4aFZtfAPi7CE4mNJldkcwRQIhALlVjXCfiy/mtXBWsNt77t4jKcNEBpRV8zv+SpU5lCh0AiBa8vo8xxpviYlf4zdG+nQhB2OgfkQZZPMHOt7CaXzXgXASQL8O5p083mg4KKL8uZfMaUqdgzuJ0Gta1lyUWPctTPCxY135XwK+nJAdFsIUFNJ9MPjnpCmSjYVzVa6M5/nAcAI="},{"validation_public_key":"EDD8C88642795CE69C5B780E01702C370F9507D0B64433F17EFE70F2637A40ADB7","manifest":"JAAAAAFxIe3YyIZCeVzmnFt4DgFwLDcPlQfQtkQz8X7+cPJjekCtt3MhAnFfr+r9BXdsXE/cBlJMyd/XsO1A5XEYCctrsvLEX+DmdkcwRQIhANRcRMg9SAXoaOvHDZ2av9RzEaZaVENfQiVgsi+Ox3F0AiB2snSIOm6c4/inbtU0UmWLQTzuwkOdUFPIB8Ax8dmGuHASQMUIfXMj96kcFTSJnMFC/mW/AQ8bKXkFrrk0CUTFFKweEjTq+STrFi6qLL2MT7nveGxsXBCgztjc0qGas9KFWgM="},{"validation_public_key":"EDBDEB901F7C75D0E20C6C42AF03BE0DA40377AF1939A18B3CB3679661DD5F9F74","manifest":"JAAAAAFxIe2965AffHXQ4gxsQq8Dvg2kA3evGTmhizyzZ5Zh3V+fdHMhAg3cyKNPMPqKgR7kIi7c/8GL/YgdBtg4mSAWvwmaevVGdkYwRAIgWzG8GqYg3YpwDs8xXa9XqLHss76KT2uAHRhUXFVUqCQCIG2EvbFKnxezRd9cpPHSt32HXK+P4+aL3p2+vqlCxRR9cBJAboXTmYTayocA3zf9dWEXtyaeOGC1k5WdYURzPleevvalR4xVoXzs38iGPxFr/pA9nL+M4duu0GKCHlVir+fBAg=="},{"validation_public_key":"EDA17871E72B0C570AC4345C60CF02AFBBB740A631B7AD0E1E573216574D9AEA02","manifest":"JAAAAAFxIe2heHHnKwxXCsQ0XGDPAq+7t0CmMbetDh5XMhZXTZrqAnMhAojyuzgtreQkxQj8prHxOsbDcF5fu4XXb0KxEL/Pq5HhdkcwRQIhANfPDLZP47aCWwt5kBnp75BuuCgp9c4BfJPd66SFCw61AiAJvegBvvPIrec+XOSzKRfi5uuXWxtl9Eyr2aPBYXvbRHASQMULYEo7beRfoUCnjk1sTYyY91tLIGLgnnaWXhUm80+zs5IGegk8qijKAtBOMuBC71lAB4KhJc+dB2rpMOFc5gw="},{"validation_public_key":"EDF46EE27AD0E1A714AFECDA816EAB7114614FCB92D0CB4D97B6A88ED43434AFC9","manifest":"JAAAAAFxIe30buJ60OGnFK/s2oFuq3EUYU/LktDLTZe2qI7UNDSvyXMhAw0ATWjVTt4FfeKO7kv6fFgd/go2+d5BSyUcURmRWnTtdkcwRQIhAMwOgDec7QYYNngspg90wEvVbsoh2ux14RPTw+GHaXNlAiALgfEsz+AF4eyX/Y5i44VrFjFFIMWUfOZaQJtsxteM1XASQLOaF0t2ZpqVKd8JESQVY+zU567iAAG2amTPZx95875S9A6Pl+kH5TGHMAeWjgWSqfh3m2HBJX7NIcXb98vy9AA="},{"validation_public_key":"ED6E4C41E59FFBEB51726E54468502FE6437238FA78EA51634E7BF0D09171AEE8F","manifest":"JAAAAAFxIe1uTEHln/vrUXJuVEaFAv5kNyOPp46lFjTnvw0JFxruj3MhAuztGWb/Oi1/V5m5dujWr9HmbKRyK4XYk+kmuFPSgAFrdkYwRAIgfQ+BgXX6QblZy4H05o7GPSIwqS7QQRUW7dqF54IAiiMCIH4XfLw956iEaoxZOk7Kctin2X9hMfaLN7wys9yAUFoZcBJAueEi84XR3Ll1GLJWanW1g1MdUj/0PAxJbw6EEQRuG3zdnuRHNXld6UZAbIkVcP0ztfqulBzjbcsLDOKFEicSBg=="},{"validation_public_key":"EDB6FC8E803EE8EDC2793F1EC917B2EE41D35255618DEB91D3F9B1FC89B75D4539","manifest":"JAAAAAFxIe22/I6APujtwnk/HskXsu5B01JVYY3rkdP5sfyJt11FOXMhA8VdvHFyScByQGTYNGeOvB0+67gWaqefcfvRk5+KwgV1dkYwRAIgZFulO/AiMoczng6i/4BkfzT7j9lxF4PP1ufgrOQaJ8sCIBX/E8Zbpn7tWqgAyNyWpVPkhFmaUMqEry8WoUT1fdGQcBJAv51RqJxgg/VrnrZwiLK2Dc0CKbiLPO5HJ4ZMsjdPT2gRc97rWkAXuV2L6PNFO59xyuoaZmSMlZYvqSGPpfF7Bw=="},{"validation_public_key":"ED691303992FEC64E6BC4BACD36AE6E5AEDC23F2861B6D8EFB9FD77EE3EADE3435","manifest":"JAAAAAFxIe1pEwOZL+xk5rxLrNNq5uWu3CPyhhttjvuf137j6t40NXMhAi2AXJQgo/JuW3r7f/6CcVsGN1YmIj11GiIESHBnQSk8dkcwRQIhANCDEQymrd6veT3ouacF6fhBr5wLw3GmXg1rMCLVvBzZAiA8uWQ+tqd46WmfBexjSBQ2Jd6UAGdrHvjcCQ2ZgSooCnASQFkHl+D7/U3WByYP384+pcFDf2Gi4WIRHVTo58cqdk5CDiwc1T0rDoLhmo41a3f+dsftfwR4aMmwFcPXLnrjrAI="},{"validation_public_key":"EDAD16667F0185DDBB7FA65B22F4B7D310BF5C3E2D9B823FB06A3A41AF8AC83BC1","manifest":"JAAAAAFxIe2tFmZ/AYXdu3+mWyL0t9MQv1w+LZuCP7BqOkGvisg7wXMhAqweE3PIS3E44KhMqKjKtbkBe8H8GbiuoAXAYDRoVRHodkYwRAIgagGkXtowUybdltKojv0lvvflrlQ9IRnPOjekF60iHzgCICg6ZocIMzkUuvO91BEormIWmX4G/MGT2zro6I/PvB8XcBJAcJLXkt/w/kcwEvNiZmi2i2nMn1wiP3LS9NJjBPju8KFLAMg0O9ydQT67U/ALYOeTPTO2/i2Yw9OSlibtqhgzDA=="},{"validation_public_key":"EDC245027A52EE5318095598EC3AB65FF4A3B9F9428E10B2F3C6F39DE15A15C90A","manifest":"JAAAAAFxIe3CRQJ6Uu5TGAlVmOw6tl/0o7n5Qo4QsvPG853hWhXJCnMhA/8/9rKUdA61j/fIEP/cqLpxBlmIhP2rg1d7NaEPyKV+dkcwRQIhAIxE0M/FJ50vfZW6fPpy4yCZumY9n0obrOojUkjm55a0AiBj56O0MpopGoY9HxC/+4wNO36Ho7E9CQeHsnKreDdsAXASQIYUd81jbiVUlET4dGoG2p+cf+2GqEXX5fJMSSyX/qe0XfR4cO+4qlgmjMQdCRDBWABHVvdN/yZyi/rL2c+WrQc="},{"validation_public_key":"ED4246AA3AE9D29863944800CCA91829E4447498A20CD9C3973A6B59346C75AB95","manifest":"JAAAAAFxIe1CRqo66dKYY5RIAMypGCnkRHSYogzZw5c6a1k0bHWrlXMhAkm1lz0c8QXWfJ9b1vB72dLabw8wYId8MtnpsHHBEC8pdkYwRAIgQlb6HJ53hsTAfVid+AOdBVvMF7rahIKNLBHUgn52zBECIGLUqFu8a1AAHRJcVonKYEnmhJwbCXLn+je7na1WD1/ocBJAE4vfvrGSmZC2uAUGmM5dIBtoSgEUey+2VleDYEsce94txYcjR8Z7QLNaliD8w/bD5/hvYQ8meV1Wg1jJFNe0CA=="},{"validation_public_key":"ED2C1468B4A11D281F93EF337C95E4A08DF0000FDEFB6D0EA9BC05FBD5D61A1F5A","manifest":"JAAAAAFxIe0sFGi0oR0oH5PvM3yV5KCN8AAP3vttDqm8BfvV1hofWnMhAkMUmCD2aPmgFDDRmimvSicSIScw6YNr42Dw4RAdwrOAdkcwRQIhAJFOHMg6qTG8v60dhrenYYk6cwOaRXq0RNmLjyyCiz5lAiAdU0YkDUJQhnN8Ry8s+6zTJLiNLbtM8oO/cLnurVpRM3ASQGALarHAsJkSZQtGdM2AaR/joFK/jhDU57+l+RSYjri/ydE20DaKanwkMEoVlBTg7lX4hYjEnmkqo73wIthLOAQ="},{"validation_public_key":"EDA54C85F91219FD259134B6B126AD64AE7204B81DD4052510657E1A5697246AD2","manifest":"JAAAAAJxIe2lTIX5Ehn9JZE0trEmrWSucgS4HdQFJRBlfhpWlyRq0nMhAl8cJerPv+vo1BK611xVTpGxjjr/CuxPTgU8URM4eTZ5dkYwRAIgdK3cQV2Y/viZne/PboKSKewngTuIN2M6c8azwqc20uUCIAc6GoNT+P2YBy49gdau4P7ySwWoQX5nf9dQxiQav5wIcBJAqiCK0d6QRZSpiVHp8O9nlKXCSEhsiSNcWcEFm/fGhJAnAN0Ov9HINId1pxrBn2dKRegLTvYG3Bpbz//HLgEdDA=="},{"validation_public_key":"ED9AE4F5887BA029EB7C0884486D23CF281975F773F44BD213054219882C411CC7","manifest":"JAAAAAFxIe2a5PWIe6Ap63wIhEhtI88oGXX3c/RL0hMFQhmILEEcx3MhAmG2zgv8FBZsZJU8aPapwo9cIqQv4/MSS1oVA5eVMiwLdkYwRAIgF+LOe4eY0gp9ttqh2gnv+z75OqLyOQMpGPALgm+NtOsCICDXBZVPtprmBDkBJkPFSnE55D9eKYRH8z/iY1EtpNplcBJAADEWGVT80Owhd1lh2JsU/oZlmeNF5WN7YvlB8llExaRKEVC+GW9Wg+iNIQ3rmV7P8aNaVuaabG00fOgkgzNhDw=="},{"validation_public_key":"EDA8D29F40CEB28995617641A3BC42692E1DE883214F612FBB62087A148E5F6F9A","manifest":"JAAAAAFxIe2o0p9AzrKJlWF2QaO8QmkuHeiDIU9hL7tiCHoUjl9vmnMhAnYnP7Eg6VgNnEUTRE29d64jQT/iBcWTQtNrUzyD6MJ+dkcwRQIhAOEsV5anTkloSmTZRbimMyBKqHoJYXcBBe8lLiPYC7mUAiAz2aNOpfQ/1LycWloIMvdhxzinq5X7Uas/uOSb9wh8d3ASQLVkfpW/GO6wdT6AuuSJ56TtM343pDNH+iSzxltIfdrPiUxT5rf4k21lQQuPClXm9+SfKrCiUXZK7dj0/GWTYQg="},{"validation_public_key":"ED38B0288EA240B4CDEC18A1A6289EB49007E4EBC0DE944803EB7EF141C5664073","manifest":"JAAAAAFxIe04sCiOokC0zewYoaYonrSQB+TrwN6USAPrfvFBxWZAc3MhAgOKcvIuchalrZw/glTuOxV3IOCcporxMB7JqAVupk1edkcwRQIhAOvRzpe+IYZK1MyInIQZ87JvP2J8SIXCXZMPBCdITBamAiASavJXi9pws8rDDJSxhGMlmE7zI5bSA8ivtRC9Lgq+UXASQDl3eoqLID+ETJNM+zbMuvwvcHEIxeBZkZ9fp5jJv6OCTPwlj4TJSuy1avEWqUYS2riv5Dvl2haFUoCHf4yawAA="},{"validation_public_key":"EDEE10DC36ACD995C8E0E86E3CD2FBF8301A4AC2B8847B61A1935DE4973B407C0E","manifest":"JAAAAAFxIe3uENw2rNmVyODobjzS+/gwGkrCuIR7YaGTXeSXO0B8DnMhAmX0vb7j+lgBjFjbN9RlA86J7AO2Vn6HLquO3aisK4mwdkYwRAIgfxBLn7i4jg/di0U25q6kIbVfTzqbA0SCpQ0I57TOFkcCIFMtJQpENjB2K2EmvBHPvNcwuSPc3vsEeqE2rNJ/cT5DcBJAf68XPFu5RjCeLgpFJM7PKFLgoV8e1nxO5ewjq9Q+TAEGnFyS0IOwf6pOOtIVMdVeXu1v6p4fhXQkdihHt1x6Ag=="},{"validation_public_key":"ED583ECD06C3B7369980E65C78C440A529300F557ED81256283F7DD5AA3513A334","manifest":"JAAAAAFxIe1YPs0Gw7c2mYDmXHjEQKUpMA9VftgSVig/fdWqNROjNHMhAyuUnzZZ1n2/GaTmE1m7H/v9YlZyDEwHY3gSHUA3ICL9dkYwRAIgHx2PHvidoN+5yG9WeAS2k7nwIM8ajxQW6wjvt8kBenACIDNxQPQkDyDJH9seS5C62mAarQmgiN89YS3jhNtnvEIqcBJAj7Jh0Kac+aJdpoepu/+eJKnnFQ7YByZB8eMZ+SS1zLhE+lip/49qqVNcpAxEqfaGtxJzoDDD1/QbuU7NOSPkCg=="},{"validation_public_key":"ED95C5172B2AD7D39434EEBC436B65B3BB7E58D5C1CEFC820B6972ACAD776E286A","manifest":"JAAAAAFxIe2VxRcrKtfTlDTuvENrZbO7fljVwc78ggtpcqytd24oanMhAiqcRde3MQZ075fa4ZNNyRaYJGMdBNkBnn3bQrKseBDQdkYwRAIgU+LfcE71DPVrO+KtUBjQ9D2u0k/Pr7lukO1nPRj6hSACIDNLYC/JFgobCsIa0BGw+6bUnOw9meU3FdXgR7Q7SoqJcBJAXQakOoQnPp3pcLL7zdKCPUX4b+/FC9Unhqp+O9xQFnRaCWVGmk5MJOIMs4WOQdpM1j3OgSsABmRuCXYvwo/nDw=="},{"validation_public_key":"ED90163D2BF0B7788904C4A4118D7D968920E847D88B79178390837DE3CA261562","manifest":"JAAAAAFxIe2QFj0r8Ld4iQTEpBGNfZaJIOhH2It5F4OQg33jyiYVYnMhA72VTRiGhkJBtqgGHDzHj7YbC6+NsEKrFHNuE/LO3Tn5dkYwRAIgf8s+fYt0llrKQ2qiWPnGmb6qJPoe8OnCM3VS29XKbYYCIHGnlJ4OTs2dXugO6Bto63NpDvvqJ+WIwdYKqZ6BiBfzcBJAGvNtkog4pfE5dZRwmic87ZBeeunOh4YpL0SERdxWj43Cs9815zFJuZysSaUX2R/vdE2VKqvSgqqtDEnrMo2oAw=="}]}",
50 "signature" : "9FF30EDC4DED7ABCD0D36389B7C716EED4B5E4F043902853534EBAC7BE966BB3813D5CF25E4DADA5E657CCF019FFD11847FD3CC44B5559A6FCEEE4C3DCFF8D0E",
51 "version": 1
52}
53)vl";
54}
55
56auto constexpr default_expires = std::chrono::seconds{3600};
57auto constexpr default_effective_overlap = std::chrono::seconds{30};
58} // namespace detail
59
60class ValidatorSite_test : public beast::unit_test::suite
61{
62private:
63 using Validator = TrustedPublisherServer::Validator;
64
65 void
66 testConfigLoad()
67 {
68 testcase("Config Load");
69
70 using namespace jtx;
71
72 Env env(*this, envconfig(), nullptr, beast::severities::kDisabled);
73 auto trustedSites =
74 std::make_unique<ValidatorSite>(env.app(), env.journal);
75
76 // load should accept empty sites list
77 std::vector<std::string> emptyCfgSites;
78 BEAST_EXPECT(trustedSites->load(emptyCfgSites));
79
80 // load should accept valid validator site uris
81 std::vector<std::string> cfgSites(
82 {"http://ripple.com/",
83 "http://ripple.com/validators",
84 "http://ripple.com:8080/validators",
85 "http://207.261.33.37/validators",
86 "http://207.261.33.37:8080/validators",
87 "https://ripple.com/validators",
88 "https://ripple.com:443/validators",
89 "file:///etc/opt/ripple/validators.txt",
90 "file:///C:/Lib/validators.txt"
91#if !_MSC_VER
92 ,
93 "file:///"
94#endif
95 });
96 BEAST_EXPECT(trustedSites->load(cfgSites));
97
98 // load should reject validator site uris with invalid schemes
99 std::vector<std::string> badSites({"ftp://ripple.com/validators"});
100 BEAST_EXPECT(!trustedSites->load(badSites));
101
102 badSites[0] = "wss://ripple.com/validators";
103 BEAST_EXPECT(!trustedSites->load(badSites));
104
105 badSites[0] = "ripple.com/validators";
106 BEAST_EXPECT(!trustedSites->load(badSites));
107
108 // Host names are not supported for file URLs
109 badSites[0] = "file://ripple.com/vl.txt";
110 BEAST_EXPECT(!trustedSites->load(badSites));
111
112 // Even local host names are not supported for file URLs
113 badSites[0] = "file://localhost/home/user/vl.txt";
114 BEAST_EXPECT(!trustedSites->load(badSites));
115
116 // Nor IP addresses
117 badSites[0] = "file://127.0.0.1/home/user/vl.txt";
118 BEAST_EXPECT(!trustedSites->load(badSites));
119
120 // File URL path can not be empty
121 badSites[0] = "file://";
122 BEAST_EXPECT(!trustedSites->load(badSites));
123
124#if _MSC_VER // Windows paths strip off the leading /, leaving the path empty
125 // File URL path can not be a directory
126 // (/ is the only path we can reasonably assume is a directory)
127 badSites[0] = "file:///";
128 BEAST_EXPECT(!trustedSites->load(badSites));
129#endif
130 }
131
132 struct FetchListConfig
133 {
134 std::string path;
135 std::string msg;
136 bool ssl;
137 bool failFetch = false;
138 bool failApply = false;
139 int serverVersion = 1;
140 std::chrono::seconds expiresFromNow = detail::default_expires;
141 std::chrono::seconds effectiveOverlap =
142 detail::default_effective_overlap;
143 int expectedRefreshMin = 0;
144 };
145 void
146 testFetchList(
147 detail::DirGuard const& good,
148 std::vector<FetchListConfig> const& paths)
149 {
150 testcase << "Fetch list - "
151 << boost::algorithm::join(
152 paths |
153 boost::adaptors::transformed(
154 [](FetchListConfig const& cfg) {
155 return cfg.path +
156 (cfg.ssl ? " [https] v" : " [http] v") +
157 std::to_string(cfg.serverVersion) +
158 " " + cfg.msg;
159 }),
160 ", ");
161
162 using namespace jtx;
163 using namespace std::chrono_literals;
164
165 Env env(*this, [&]() {
166 auto p = test::jtx::envconfig();
167 p->legacy("database_path", good.subdir().string());
168 return p;
169 }());
170 auto& trustedKeys = env.app().validators();
171 env.timeKeeper().set(env.timeKeeper().now() + 30s);
172
173 test::StreamSink sink;
174 beast::Journal journal{sink};
175
176 std::vector<std::string> emptyCfgKeys;
177 struct publisher
178 {
179 publisher(FetchListConfig const& c) : cfg{c}
180 {
181 }
182 std::shared_ptr<TrustedPublisherServer> server;
183 std::vector<Validator> list;
184 std::string uri;
185 FetchListConfig const& cfg;
186 bool isRetry;
187 };
188 std::vector<publisher> servers;
189
190 auto constexpr listSize = 20;
191 std::vector<std::string> cfgPublishers;
192
193 for (auto const& cfg : paths)
194 {
195 servers.push_back(cfg);
196 auto& item = servers.back();
197 item.isRetry = cfg.path == "/bad-resource";
198 item.list.reserve(listSize);
199 while (item.list.size() < listSize)
200 item.list.push_back(TrustedPublisherServer::randomValidator());
201
202 NetClock::time_point const expires =
203 env.timeKeeper().now() + cfg.expiresFromNow;
204 NetClock::time_point const effective2 =
205 expires - cfg.effectiveOverlap;
206 NetClock::time_point const expires2 =
207 effective2 + cfg.expiresFromNow;
208 item.server = make_TrustedPublisherServer(
209 env.app().getIOService(),
210 item.list,
211 expires,
212 {{effective2, expires2}},
213 cfg.ssl,
214 cfg.serverVersion);
215 std::string pubHex = strHex(item.server->publisherPublic());
216 cfgPublishers.push_back(pubHex);
217
218 if (item.cfg.failFetch)
219 {
220 // Create a cache file
221 auto const name = good.subdir() / ("cache." + pubHex);
222 std::ofstream o(name.string());
223 o << "{}";
224 }
225
226 std::stringstream uri;
227 uri << (cfg.ssl ? "https://" : "http://")
228 << item.server->local_endpoint() << cfg.path;
229 item.uri = uri.str();
230 }
231
232 BEAST_EXPECT(trustedKeys.load({}, emptyCfgKeys, cfgPublishers));
233
234 // Normally, tests will only need a fraction of this time,
235 // but sometimes DNS resolution takes an inordinate amount
236 // of time, so the test will just wait.
237 auto sites = std::make_unique<ValidatorSite>(env.app(), journal, 12s);
238
239 std::vector<std::string> uris;
240 for (auto const& u : servers)
241 {
242 log << "Testing " << u.uri << std::endl;
243 uris.push_back(u.uri);
244 }
245 sites->load(uris);
246 sites->start();
247 sites->join();
248
249 auto const jv = sites->getJson();
250 for (auto const& u : servers)
251 {
252 for (auto const& val : u.list)
253 {
254 BEAST_EXPECT(
255 trustedKeys.listed(val.masterPublic) != u.cfg.failApply);
256 BEAST_EXPECT(
257 trustedKeys.listed(val.signingPublic) != u.cfg.failApply);
258 }
259
260 Json::Value myStatus;
261 for (auto const& vs : jv[jss::validator_sites])
262 if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
263 myStatus = vs;
264 BEAST_EXPECTS(
265 myStatus[jss::last_refresh_message].asString().empty() !=
266 u.cfg.failFetch,
267 to_string(myStatus) + "\n" + sink.messages().str());
268
269 if (!u.cfg.msg.empty())
270 {
271 BEAST_EXPECTS(
272 sink.messages().str().find(u.cfg.msg) != std::string::npos,
273 sink.messages().str());
274 }
275
276 if (u.cfg.expectedRefreshMin)
277 {
278 BEAST_EXPECTS(
279 myStatus[jss::refresh_interval_min].asInt() ==
280 u.cfg.expectedRefreshMin,
281 to_string(myStatus));
282 }
283
284 if (u.cfg.failFetch)
285 {
286 using namespace std::chrono;
287 std::stringstream nextRefreshStr{
288 myStatus[jss::next_refresh_time].asString()};
289 system_clock::time_point nextRefresh;
290 date::from_stream(nextRefreshStr, "%Y-%b-%d %T", nextRefresh);
291 BEAST_EXPECT(!nextRefreshStr.fail());
292 auto now = system_clock::now();
293 BEAST_EXPECTS(
294 nextRefresh <= now + (u.isRetry ? seconds{30} : minutes{5}),
295 "Now: " + to_string(now) + ", NR: " + nextRefreshStr.str());
296 }
297 }
298 }
299
300 void
301 testFileList(std::vector<std::pair<std::string, std::string>> const& paths)
302 {
303 testcase << "File list - " << paths[0].first
304 << (paths.size() > 1 ? ", " + paths[1].first : "");
305
306 using namespace jtx;
307
308 Env env(*this);
309
310 test::StreamSink sink;
311 beast::Journal journal{sink};
312
313 struct publisher
314 {
315 std::string uri;
316 std::string expectMsg;
317 bool shouldFail;
318 };
319 std::vector<publisher> servers;
320
321 for (auto const& cfg : paths)
322 {
323 servers.push_back({});
324 auto& item = servers.back();
325 item.shouldFail = !cfg.second.empty();
326 item.expectMsg = cfg.second;
327
328 std::stringstream uri;
329 uri << "file://" << cfg.first;
330 item.uri = uri.str();
331 }
332
333 auto sites = std::make_unique<ValidatorSite>(env.app(), journal);
334
335 std::vector<std::string> uris;
336 for (auto const& u : servers)
337 uris.push_back(u.uri);
338 sites->load(uris);
339 sites->start();
340 sites->join();
341
342 for (auto const& u : servers)
343 {
344 auto const jv = sites->getJson();
345 Json::Value myStatus;
346 for (auto const& vs : jv[jss::validator_sites])
347 if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
348 myStatus = vs;
349 BEAST_EXPECTS(
350 myStatus[jss::last_refresh_message].asString().empty() !=
351 u.shouldFail,
352 to_string(myStatus));
353 if (u.shouldFail)
354 {
355 BEAST_EXPECTS(
356 sink.messages().str().find(u.expectMsg) !=
357 std::string::npos,
358 sink.messages().str());
359 }
360 }
361 }
362
363 void
364 testFileURLs()
365 {
366 auto fullPath = [](detail::FileDirGuard const& guard) {
367 auto absPath = absolute(guard.file()).string();
368 if (absPath.front() != '/')
369 absPath.insert(absPath.begin(), '/');
370 return absPath;
371 };
372 {
373 // Create a file with a real validator list
374 detail::FileDirGuard good(
375 *this, "test_val", "vl.txt", detail::realValidatorContents());
376 // Create a file with arbitrary content
377 detail::FileDirGuard hello(
378 *this, "test_val", "helloworld.txt", "Hello, world!");
379 // Create a file with malformed Json
380 detail::FileDirGuard json(
381 *this,
382 "test_val",
383 "json.txt",
384 R"json({ "version": 2, "extra" : "value" })json");
385 auto const goodPath = fullPath(good);
386 auto const helloPath = fullPath(hello);
387 auto const jsonPath = fullPath(json);
388 auto const missingPath = jsonPath + ".bad";
389 testFileList({
390 {goodPath, ""},
391 {helloPath,
392 "Unable to parse JSON response from file://" + helloPath},
393 {jsonPath,
394 "Missing fields in JSON response from file://" + jsonPath},
395 {missingPath, "Problem retrieving from file://" + missingPath},
396 });
397 }
398 }
399
400public:
401 void
402 run() override
403 {
404 testConfigLoad();
405
406 detail::DirGuard good(*this, "test_fetch");
407 for (auto ssl : {true, false})
408 {
409 // fetch single site
410 testFetchList(good, {{"/validators", "", ssl}});
411 testFetchList(good, {{"/validators2", "", ssl}});
412 // fetch multiple sites
413 testFetchList(
414 good, {{"/validators", "", ssl}, {"/validators", "", ssl}});
415 testFetchList(
416 good, {{"/validators", "", ssl}, {"/validators2", "", ssl}});
417 testFetchList(
418 good, {{"/validators2", "", ssl}, {"/validators", "", ssl}});
419 testFetchList(
420 good, {{"/validators2", "", ssl}, {"/validators2", "", ssl}});
421 // fetch single site with single redirects
422 testFetchList(good, {{"/redirect_once/301", "", ssl}});
423 testFetchList(good, {{"/redirect_once/302", "", ssl}});
424 testFetchList(good, {{"/redirect_once/307", "", ssl}});
425 testFetchList(good, {{"/redirect_once/308", "", ssl}});
426 // one redirect, one not
427 testFetchList(
428 good,
429 {{"/validators", "", ssl}, {"/redirect_once/302", "", ssl}});
430 testFetchList(
431 good,
432 {{"/validators2", "", ssl}, {"/redirect_once/302", "", ssl}});
433 // UNLs with a "gap" between validUntil of one and validFrom of the
434 // next
435 testFetchList(
436 good,
437 {{"/validators2",
438 "",
439 ssl,
440 false,
441 false,
442 1,
443 detail::default_expires,
444 std::chrono::seconds{-90}}});
445 // fetch single site with undending redirect (fails to load)
446 testFetchList(
447 good,
448 {{"/redirect_forever/301",
449 "Exceeded max redirects",
450 ssl,
451 true,
452 true}});
453 // two that redirect forever
454 testFetchList(
455 good,
456 {{"/redirect_forever/307",
457 "Exceeded max redirects",
458 ssl,
459 true,
460 true},
461 {"/redirect_forever/308",
462 "Exceeded max redirects",
463 ssl,
464 true,
465 true}});
466 // one undending redirect, one not
467 testFetchList(
468 good,
469 {{"/validators", "", ssl},
470 {"/redirect_forever/302",
471 "Exceeded max redirects",
472 ssl,
473 true,
474 true}});
475 // one undending redirect, one not
476 testFetchList(
477 good,
478 {{"/validators2", "", ssl},
479 {"/redirect_forever/302",
480 "Exceeded max redirects",
481 ssl,
482 true,
483 true}});
484 // invalid redir Location
485 testFetchList(
486 good,
487 {{"/redirect_to/ftp://invalid-url/302",
488 "Invalid redirect location",
489 ssl,
490 true,
491 true}});
492 testFetchList(
493 good,
494 {{"/redirect_to/file://invalid-url/302",
495 "Invalid redirect location",
496 ssl,
497 true,
498 true}});
499 // invalid json
500 testFetchList(
501 good,
502 {{"/validators/bad",
503 "Unable to parse JSON response",
504 ssl,
505 true,
506 true}});
507 testFetchList(
508 good,
509 {{"/validators2/bad",
510 "Unable to parse JSON response",
511 ssl,
512 true,
513 true}});
514 // error status returned
515 testFetchList(
516 good,
517 {{"/bad-resource", "returned bad status", ssl, true, true}});
518 // location field missing
519 testFetchList(
520 good,
521 {{"/redirect_nolo/308",
522 "returned a redirect with no Location",
523 ssl,
524 true,
525 true}});
526 // json fields missing
527 testFetchList(
528 good,
529 {{"/validators/missing",
530 "Missing fields in JSON response",
531 ssl,
532 true,
533 true}});
534 testFetchList(
535 good,
536 {{"/validators2/missing",
537 "Missing fields in JSON response",
538 ssl,
539 true,
540 true}});
541 // timeout
542 testFetchList(
543 good, {{"/sleep/13", "took too long", ssl, true, true}});
544 // bad manifest format using known versions
545 // * Retrieves a v1 formatted list claiming version 2
546 testFetchList(
547 good, {{"/validators", "Missing fields", ssl, true, true, 2}});
548 // * Retrieves a v2 formatted list claiming version 1
549 testFetchList(
550 good, {{"/validators2", "Missing fields", ssl, true, true, 0}});
551 // bad manifest version
552 // Because versions other than 1 are treated as v2, the v1
553 // list won't have the blobs_v2 fields, and thus will claim to have
554 // missing fields
555 testFetchList(
556 good, {{"/validators", "Missing fields", ssl, true, true, 4}});
557 testFetchList(
558 good,
559 {{"/validators2",
560 "1 unsupported version",
561 ssl,
562 false,
563 true,
564 4}});
565 using namespace std::chrono_literals;
566 // get expired validator list
567 testFetchList(
568 good,
569 {{"/validators",
570 "Applied 1 expired validator list(s)",
571 ssl,
572 false,
573 false,
574 1,
575 0s}});
576 testFetchList(
577 good,
578 {{"/validators2",
579 "Applied 1 expired validator list(s)",
580 ssl,
581 false,
582 false,
583 1,
584 0s,
585 -1s}});
586 // force an out-of-range validUntil value
587 testFetchList(
588 good,
589 {{"/validators",
590 "1 invalid validator list(s)",
591 ssl,
592 false,
593 true,
594 1,
595 std::chrono::seconds{Json::Value::maxInt + 1}}});
596 // force an out-of-range validUntil value on the future list
597 // The first list is accepted. The second fails. The parser
598 // returns the "best" result, so this looks like a success.
599 testFetchList(
600 good,
601 {{"/validators2",
602 "",
603 ssl,
604 false,
605 false,
606 1,
607 std::chrono::seconds{Json::Value::maxInt - 300},
608 299s}});
609 // force an out-of-range validFrom value
610 // The first list is accepted. The second fails. The parser
611 // returns the "best" result, so this looks like a success.
612 testFetchList(
613 good,
614 {{"/validators2",
615 "",
616 ssl,
617 false,
618 false,
619 1,
620 std::chrono::seconds{Json::Value::maxInt - 300},
621 301s}});
622 // force an out-of-range validUntil value on _both_ lists
623 testFetchList(
624 good,
625 {{"/validators2",
626 "2 invalid validator list(s)",
627 ssl,
628 false,
629 true,
630 1,
631 std::chrono::seconds{Json::Value::maxInt + 1},
632 std::chrono::seconds{Json::Value::maxInt - 6000}}});
633 // verify refresh intervals are properly clamped
634 testFetchList(
635 good,
636 {{"/validators/refresh/0",
637 "",
638 ssl,
639 false,
640 false,
641 1,
642 detail::default_expires,
643 detail::default_effective_overlap,
644 1}}); // minimum of 1 minute
645 testFetchList(
646 good,
647 {{"/validators2/refresh/0",
648 "",
649 ssl,
650 false,
651 false,
652 1,
653 detail::default_expires,
654 detail::default_effective_overlap,
655 1}}); // minimum of 1 minute
656 testFetchList(
657 good,
658 {{"/validators/refresh/10",
659 "",
660 ssl,
661 false,
662 false,
663 1,
664 detail::default_expires,
665 detail::default_effective_overlap,
666 10}}); // 10 minutes is fine
667 testFetchList(
668 good,
669 {{"/validators2/refresh/10",
670 "",
671 ssl,
672 false,
673 false,
674 1,
675 detail::default_expires,
676 detail::default_effective_overlap,
677 10}}); // 10 minutes is fine
678 testFetchList(
679 good,
680 {{"/validators/refresh/2000",
681 "",
682 ssl,
683 false,
684 false,
685 1,
686 detail::default_expires,
687 detail::default_effective_overlap,
688 60 * 24}}); // max of 24 hours
689 testFetchList(
690 good,
691 {{"/validators2/refresh/2000",
692 "",
693 ssl,
694 false,
695 false,
696 1,
697 detail::default_expires,
698 detail::default_effective_overlap,
699 60 * 24}}); // max of 24 hours
700 }
701 using namespace boost::filesystem;
702 for (auto const& file : directory_iterator(good.subdir()))
703 {
704 remove_all(file);
705 }
706
707 testFileURLs();
708 }
709};
710
711BEAST_DEFINE_TESTSUITE_PRIO(ValidatorSite, app, ripple, 2);
712
713} // namespace test
714} // namespace ripple
std::vector::back
T back(T... args)
Json::Value
Represents a JSON value.
Definition: json_value.h:147
Json::Value::maxInt
static const Int maxInt
Definition: json_value.h:160
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition: json_value.cpp:469
beast::Journal
A generic endpoint for log messages.
Definition: Journal.h:59
beast::unit_test::suite
A testsuite class.
Definition: suite.h:53
beast::unit_test::suite::log
log_os< char > log
Logging output stream.
Definition: suite.h:150
beast::unit_test::suite::testcase
testcase_t testcase
Memberspace for declaring test cases.
Definition: suite.h:153
ripple::Application::validators
virtual ValidatorList & validators()=0
ripple::Application::getIOService
virtual boost::asio::io_service & getIOService()=0
ripple::test::ManualTimeKeeper::now
time_point now() const override
Returns the current time.
Definition: ManualTimeKeeper.h:38
ripple::test::StreamSink::messages
std::stringstream const & messages() const
Definition: SuiteJournal.h:153
ripple::test::ValidatorSite_test
Definition: ValidatorSite_test.cpp:61
ripple::test::ValidatorSite_test::testFetchList
void testFetchList(detail::DirGuard const &good, std::vector< FetchListConfig > const &paths)
Definition: ValidatorSite_test.cpp:146
ripple::test::ValidatorSite_test::testFileURLs
void testFileURLs()
Definition: ValidatorSite_test.cpp:364
ripple::test::ValidatorSite_test::run
void run() override
Runs the suite.
Definition: ValidatorSite_test.cpp:402
ripple::test::ValidatorSite_test::testFileList
void testFileList(std::vector< std::pair< std::string, std::string > > const &paths)
Definition: ValidatorSite_test.cpp:301
ripple::test::ValidatorSite_test::testConfigLoad
void testConfigLoad()
Definition: ValidatorSite_test.cpp:66
ripple::test::detail::DirGuard
Create a directory and remove it when it's done.
Definition: FileDirGuard.h:35
ripple::test::detail::DirGuard::subdir
path const & subdir() const
Definition: FileDirGuard.h:98
ripple::test::detail::FileDirGuard
Write a file in a directory and remove when done.
Definition: FileDirGuard.h:108
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:117
ripple::test::jtx::Env::app
Application & app()
Definition: Env.h:255
ripple::test::jtx::Env::journal
beast::Journal const journal
Definition: Env.h:158
ripple::test::jtx::Env::timeKeeper
ManualTimeKeeper & timeKeeper()
Definition: Env.h:267
ripple::test::jtx::json
Inject raw JSON.
Definition: jtx_json.h:32
ripple::test::jtx::paths
Set Paths, SendMax on a JTx.
Definition: paths.h:33
std::endl
T endl(T... args)
ripple::test::detail::default_expires
auto constexpr default_expires
Definition: ValidatorSite_test.cpp:56
ripple::test::detail::default_effective_overlap
auto constexpr default_effective_overlap
Definition: ValidatorSite_test.cpp:57
ripple::test::detail::realValidatorContents
constexpr const char * realValidatorContents()
Definition: ValidatorSite_test.cpp:44
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:54
ripple::test::make_TrustedPublisherServer
std::shared_ptr< TrustedPublisherServer > make_TrustedPublisherServer(boost::asio::io_context &ioc, std::vector< TrustedPublisherServer::Validator > const &validators, NetClock::time_point validUntil, std::vector< std::pair< NetClock::time_point, NetClock::time_point > > const &futures, bool useSSL=false, int version=1, bool immediateStart=true, int sequence=1)
Definition: TrustedPublisherServer.h:714
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: algorithm.h:26
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:30
ripple::to_string
std::string to_string(base_uint< Bits, Tag > const &a)
Definition: base_uint.h:629
std::vector::push_back
T push_back(T... args)
std::string::reserve
T reserve(T... args)
std::stringstream::str
T str(T... args)
ripple::test::ValidatorSite_test::FetchListConfig
Definition: ValidatorSite_test.cpp:133
ripple::test::ValidatorSite_test::FetchListConfig::expectedRefreshMin
int expectedRefreshMin
Definition: ValidatorSite_test.cpp:143
ripple::test::ValidatorSite_test::FetchListConfig::effectiveOverlap
std::chrono::seconds effectiveOverlap
Definition: ValidatorSite_test.cpp:141
ripple::test::ValidatorSite_test::FetchListConfig::ssl
bool ssl
Definition: ValidatorSite_test.cpp:136
ripple::test::ValidatorSite_test::FetchListConfig::expiresFromNow
std::chrono::seconds expiresFromNow
Definition: ValidatorSite_test.cpp:140
ripple::test::ValidatorSite_test::FetchListConfig::path
std::string path
Definition: ValidatorSite_test.cpp:134
ripple::test::ValidatorSite_test::FetchListConfig::msg
std::string msg
Definition: ValidatorSite_test.cpp:135
ripple::test::ValidatorSite_test::FetchListConfig::failApply
bool failApply
Definition: ValidatorSite_test.cpp:138
ripple::test::ValidatorSite_test::FetchListConfig::serverVersion
int serverVersion
Definition: ValidatorSite_test.cpp:139
ripple::test::ValidatorSite_test::FetchListConfig::failFetch
bool failFetch
Definition: ValidatorSite_test.cpp:137
std::to_string
T to_string(T... args)
Generated by doxygen 1.9.5