rippled
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 <ripple/app/misc/ValidatorSite.h>
21 #include <ripple/basics/Slice.h>
22 #include <ripple/basics/base64.h>
23 #include <ripple/basics/strHex.h>
24 #include <ripple/protocol/HashPrefix.h>
25 #include <ripple/protocol/PublicKey.h>
26 #include <ripple/protocol/SecretKey.h>
27 #include <ripple/protocol/Sign.h>
28 #include <ripple/protocol/digest.h>
29 #include <ripple/protocol/jss.h>
30 #include <boost/algorithm/string/join.hpp>
31 #include <boost/algorithm/string/predicate.hpp>
32 #include <boost/asio.hpp>
33 #include <boost/range/adaptor/transformed.hpp>
34 #include <chrono>
35 #include <date/date.h>
36 #include <test/jtx.h>
37 #include <test/jtx/TrustedPublisherServer.h>
38 #include <test/unit_test/FileDirGuard.h>
39 
40 namespace ripple {
41 namespace test {
42 namespace detail {
43 constexpr const char*
44 realValidatorContents()
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 
56 auto constexpr default_expires = std::chrono::seconds{3600};
57 auto constexpr default_effective_overlap = std::chrono::seconds{30};
58 } // namespace detail
59 
60 class ValidatorSite_test : public beast::unit_test::suite
61 {
62 private:
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/", "http://ripple.com/validators",
83  "http://ripple.com:8080/validators",
84  "http://207.261.33.37/validators",
85  "http://207.261.33.37:8080/validators",
86  "https://ripple.com/validators",
87  "https://ripple.com:443/validators",
88  "file:///etc/opt/ripple/validators.txt",
89  "file:///C:/Lib/validators.txt"
90 #if !_MSC_VER
91  ,
92  "file:///"
93 #endif
94  });
95  BEAST_EXPECT(trustedSites->load(cfgSites));
96 
97  // load should reject validator site uris with invalid schemes
98  std::vector<std::string> badSites({"ftp://ripple.com/validators"});
99  BEAST_EXPECT(!trustedSites->load(badSites));
100 
101  badSites[0] = "wss://ripple.com/validators";
102  BEAST_EXPECT(!trustedSites->load(badSites));
103 
104  badSites[0] = "ripple.com/validators";
105  BEAST_EXPECT(!trustedSites->load(badSites));
106 
107  // Host names are not supported for file URLs
108  badSites[0] = "file://ripple.com/vl.txt";
109  BEAST_EXPECT(!trustedSites->load(badSites));
110 
111  // Even local host names are not supported for file URLs
112  badSites[0] = "file://localhost/home/user/vl.txt";
113  BEAST_EXPECT(!trustedSites->load(badSites));
114 
115  // Nor IP addresses
116  badSites[0] = "file://127.0.0.1/home/user/vl.txt";
117  BEAST_EXPECT(!trustedSites->load(badSites));
118 
119  // File URL path can not be empty
120  badSites[0] = "file://";
121  BEAST_EXPECT(!trustedSites->load(badSites));
122 
123 #if _MSC_VER // Windows paths strip off the leading /, leaving the path empty
124  // File URL path can not be a directory
125  // (/ is the only path we can reasonably assume is a directory)
126  badSites[0] = "file:///";
127  BEAST_EXPECT(!trustedSites->load(badSites));
128 #endif
129  }
130 
131  struct FetchListConfig
132  {
133  std::string path;
134  std::string msg;
135  bool ssl;
136  bool failFetch = false;
137  bool failApply = false;
138  int serverVersion = 1;
139  std::chrono::seconds expiresFromNow = detail::default_expires;
140  std::chrono::seconds effectiveOverlap =
141  detail::default_effective_overlap;
142  int expectedRefreshMin = 0;
143  };
144  void
145  testFetchList(
146  detail::DirGuard const& good,
147  std::vector<FetchListConfig> const& paths)
148  {
149  testcase << "Fetch list - "
150  << boost::algorithm::join(
151  paths |
152  boost::adaptors::transformed(
153  [](FetchListConfig const& cfg) {
154  return cfg.path +
155  (cfg.ssl ? " [https] v" : " [http] v") +
156  std::to_string(cfg.serverVersion) +
157  " " + cfg.msg;
158  }),
159  ", ");
160 
161  using namespace jtx;
162  using namespace std::chrono_literals;
163 
164  Env env(*this, [&]() {
165  auto p = test::jtx::envconfig();
166  p->legacy("database_path", good.subdir().string());
167  return p;
168  }());
169  auto& trustedKeys = env.app().validators();
170  env.timeKeeper().set(env.timeKeeper().now() + 30s);
171 
172  test::StreamSink sink;
173  beast::Journal journal{sink};
174 
175  PublicKey emptyLocalKey;
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(
233  trustedKeys.load(emptyLocalKey, emptyCfgKeys, cfgPublishers));
234 
235  // Normally, tests will only need a fraction of this time,
236  // but sometimes DNS resolution takes an inordinate amount
237  // of time, so the test will just wait.
238  auto sites = std::make_unique<ValidatorSite>(env.app(), journal, 12s);
239 
240  std::vector<std::string> uris;
241  for (auto const& u : servers)
242  uris.push_back(u.uri);
243  sites->load(uris);
244  sites->start();
245  sites->join();
246 
247  auto const jv = sites->getJson();
248  for (auto const& u : servers)
249  {
250  for (auto const& val : u.list)
251  {
252  BEAST_EXPECT(
253  trustedKeys.listed(val.masterPublic) != u.cfg.failApply);
254  BEAST_EXPECT(
255  trustedKeys.listed(val.signingPublic) != u.cfg.failApply);
256  }
257 
258  Json::Value myStatus;
259  for (auto const& vs : jv[jss::validator_sites])
260  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
261  myStatus = vs;
262  BEAST_EXPECTS(
263  myStatus[jss::last_refresh_message].asString().empty() !=
264  u.cfg.failFetch,
265  to_string(myStatus) + "\n" + sink.messages().str());
266 
267  if (!u.cfg.msg.empty())
268  {
269  BEAST_EXPECTS(
270  sink.messages().str().find(u.cfg.msg) != std::string::npos,
271  sink.messages().str());
272  }
273 
274  if (u.cfg.expectedRefreshMin)
275  {
276  BEAST_EXPECTS(
277  myStatus[jss::refresh_interval_min].asInt() ==
278  u.cfg.expectedRefreshMin,
279  to_string(myStatus));
280  }
281 
282  if (u.cfg.failFetch)
283  {
284  using namespace std::chrono;
285  std::stringstream nextRefreshStr{
286  myStatus[jss::next_refresh_time].asString()};
287  system_clock::time_point nextRefresh;
288  date::from_stream(nextRefreshStr, "%Y-%b-%d %T", nextRefresh);
289  BEAST_EXPECT(!nextRefreshStr.fail());
290  auto now = system_clock::now();
291  BEAST_EXPECTS(
292  nextRefresh <= now + (u.isRetry ? seconds{30} : minutes{5}),
293  "Now: " + to_string(now) + ", NR: " + nextRefreshStr.str());
294  }
295  }
296  }
297 
298  void
299  testFileList(std::vector<std::pair<std::string, std::string>> const& paths)
300  {
301  testcase << "File list - " << paths[0].first
302  << (paths.size() > 1 ? ", " + paths[1].first : "");
303 
304  using namespace jtx;
305 
306  Env env(*this);
307 
308  test::StreamSink sink;
309  beast::Journal journal{sink};
310 
311  struct publisher
312  {
313  std::string uri;
314  std::string expectMsg;
315  bool shouldFail;
316  };
317  std::vector<publisher> servers;
318 
319  for (auto const& cfg : paths)
320  {
321  servers.push_back({});
322  auto& item = servers.back();
323  item.shouldFail = !cfg.second.empty();
324  item.expectMsg = cfg.second;
325 
326  std::stringstream uri;
327  uri << "file://" << cfg.first;
328  item.uri = uri.str();
329  }
330 
331  auto sites = std::make_unique<ValidatorSite>(env.app(), journal);
332 
333  std::vector<std::string> uris;
334  for (auto const& u : servers)
335  uris.push_back(u.uri);
336  sites->load(uris);
337  sites->start();
338  sites->join();
339 
340  for (auto const& u : servers)
341  {
342  auto const jv = sites->getJson();
343  Json::Value myStatus;
344  for (auto const& vs : jv[jss::validator_sites])
345  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
346  myStatus = vs;
347  BEAST_EXPECTS(
348  myStatus[jss::last_refresh_message].asString().empty() !=
349  u.shouldFail,
350  to_string(myStatus));
351  if (u.shouldFail)
352  {
353  BEAST_EXPECTS(
354  sink.messages().str().find(u.expectMsg) !=
355  std::string::npos,
356  sink.messages().str());
357  }
358  }
359  }
360 
361  void
362  testFileURLs()
363  {
364  auto fullPath = [](detail::FileDirGuard const& guard) {
365  auto absPath = absolute(guard.file()).string();
366  if (absPath.front() != '/')
367  absPath.insert(absPath.begin(), '/');
368  return absPath;
369  };
370  {
371  // Create a file with a real validator list
372  detail::FileDirGuard good(
373  *this, "test_val", "vl.txt", detail::realValidatorContents());
374  // Create a file with arbitrary content
375  detail::FileDirGuard hello(
376  *this, "test_val", "helloworld.txt", "Hello, world!");
377  // Create a file with malformed Json
378  detail::FileDirGuard json(
379  *this,
380  "test_val",
381  "json.txt",
382  R"json({ "version": 2, "extra" : "value" })json");
383  auto const goodPath = fullPath(good);
384  auto const helloPath = fullPath(hello);
385  auto const jsonPath = fullPath(json);
386  auto const missingPath = jsonPath + ".bad";
387  testFileList({
388  {goodPath, ""},
389  {helloPath,
390  "Unable to parse JSON response from file://" + helloPath},
391  {jsonPath,
392  "Missing fields in JSON response from file://" + jsonPath},
393  {missingPath, "Problem retrieving from file://" + missingPath},
394  });
395  }
396  }
397 
398 public:
399  void
400  run() override
401  {
402  testConfigLoad();
403 
404  detail::DirGuard good(*this, "test_fetch");
405  for (auto ssl : {true, false})
406  {
407  // fetch single site
408  testFetchList(good, {{"/validators", "", ssl}});
409  testFetchList(good, {{"/validators2", "", ssl}});
410  // fetch multiple sites
411  testFetchList(
412  good, {{"/validators", "", ssl}, {"/validators", "", ssl}});
413  testFetchList(
414  good, {{"/validators", "", ssl}, {"/validators2", "", ssl}});
415  testFetchList(
416  good, {{"/validators2", "", ssl}, {"/validators", "", ssl}});
417  testFetchList(
418  good, {{"/validators2", "", ssl}, {"/validators2", "", ssl}});
419  // fetch single site with single redirects
420  testFetchList(good, {{"/redirect_once/301", "", ssl}});
421  testFetchList(good, {{"/redirect_once/302", "", ssl}});
422  testFetchList(good, {{"/redirect_once/307", "", ssl}});
423  testFetchList(good, {{"/redirect_once/308", "", ssl}});
424  // one redirect, one not
425  testFetchList(
426  good,
427  {{"/validators", "", ssl}, {"/redirect_once/302", "", ssl}});
428  testFetchList(
429  good,
430  {{"/validators2", "", ssl}, {"/redirect_once/302", "", ssl}});
431  // UNLs with a "gap" between validUntil of one and validFrom of the
432  // next
433  testFetchList(
434  good,
435  {{"/validators2",
436  "",
437  ssl,
438  false,
439  false,
440  1,
441  detail::default_expires,
442  std::chrono::seconds{-90}}});
443  // fetch single site with undending redirect (fails to load)
444  testFetchList(
445  good,
446  {{"/redirect_forever/301",
447  "Exceeded max redirects",
448  ssl,
449  true,
450  true}});
451  // two that redirect forever
452  testFetchList(
453  good,
454  {{"/redirect_forever/307",
455  "Exceeded max redirects",
456  ssl,
457  true,
458  true},
459  {"/redirect_forever/308",
460  "Exceeded max redirects",
461  ssl,
462  true,
463  true}});
464  // one undending redirect, one not
465  testFetchList(
466  good,
467  {{"/validators", "", ssl},
468  {"/redirect_forever/302",
469  "Exceeded max redirects",
470  ssl,
471  true,
472  true}});
473  // one undending redirect, one not
474  testFetchList(
475  good,
476  {{"/validators2", "", ssl},
477  {"/redirect_forever/302",
478  "Exceeded max redirects",
479  ssl,
480  true,
481  true}});
482  // invalid redir Location
483  testFetchList(
484  good,
485  {{"/redirect_to/ftp://invalid-url/302",
486  "Invalid redirect location",
487  ssl,
488  true,
489  true}});
490  testFetchList(
491  good,
492  {{"/redirect_to/file://invalid-url/302",
493  "Invalid redirect location",
494  ssl,
495  true,
496  true}});
497  // invalid json
498  testFetchList(
499  good,
500  {{"/validators/bad",
501  "Unable to parse JSON response",
502  ssl,
503  true,
504  true}});
505  testFetchList(
506  good,
507  {{"/validators2/bad",
508  "Unable to parse JSON response",
509  ssl,
510  true,
511  true}});
512  // error status returned
513  testFetchList(
514  good,
515  {{"/bad-resource", "returned bad status", ssl, true, true}});
516  // location field missing
517  testFetchList(
518  good,
519  {{"/redirect_nolo/308",
520  "returned a redirect with no Location",
521  ssl,
522  true,
523  true}});
524  // json fields missing
525  testFetchList(
526  good,
527  {{"/validators/missing",
528  "Missing fields in JSON response",
529  ssl,
530  true,
531  true}});
532  testFetchList(
533  good,
534  {{"/validators2/missing",
535  "Missing fields in JSON response",
536  ssl,
537  true,
538  true}});
539  // timeout
540  testFetchList(
541  good, {{"/sleep/13", "took too long", ssl, true, true}});
542  // bad manifest format using known versions
543  // * Retrieves a v1 formatted list claiming version 2
544  testFetchList(
545  good, {{"/validators", "Missing fields", ssl, true, true, 2}});
546  // * Retrieves a v2 formatted list claiming version 1
547  testFetchList(
548  good, {{"/validators2", "Missing fields", ssl, true, true, 0}});
549  // bad manifest version
550  // Because versions other than 1 are treated as v2, the v1
551  // list won't have the blobs_v2 fields, and thus will claim to have
552  // missing fields
553  testFetchList(
554  good, {{"/validators", "Missing fields", ssl, true, true, 4}});
555  testFetchList(
556  good,
557  {{"/validators2",
558  "1 unsupported version",
559  ssl,
560  false,
561  true,
562  4}});
563  using namespace std::chrono_literals;
564  // get expired validator list
565  testFetchList(
566  good,
567  {{"/validators",
568  "Applied 1 expired validator list(s)",
569  ssl,
570  false,
571  false,
572  1,
573  0s}});
574  testFetchList(
575  good,
576  {{"/validators2",
577  "Applied 1 expired validator list(s)",
578  ssl,
579  false,
580  false,
581  1,
582  0s,
583  -1s}});
584  // force an out-of-range validUntil value
585  testFetchList(
586  good,
587  {{"/validators",
588  "1 invalid validator list(s)",
589  ssl,
590  false,
591  true,
592  1,
593  std::chrono::seconds{Json::Value::maxInt + 1}}});
594  // force an out-of-range validUntil value on the future list
595  // The first list is accepted. The second fails. The parser
596  // returns the "best" result, so this looks like a success.
597  testFetchList(
598  good,
599  {{"/validators2",
600  "",
601  ssl,
602  false,
603  false,
604  1,
605  std::chrono::seconds{Json::Value::maxInt - 300},
606  299s}});
607  // force an out-of-range validFrom value
608  // The first list is accepted. The second fails. The parser
609  // returns the "best" result, so this looks like a success.
610  testFetchList(
611  good,
612  {{"/validators2",
613  "",
614  ssl,
615  false,
616  false,
617  1,
618  std::chrono::seconds{Json::Value::maxInt - 300},
619  301s}});
620  // force an out-of-range validUntil value on _both_ lists
621  testFetchList(
622  good,
623  {{"/validators2",
624  "2 invalid validator list(s)",
625  ssl,
626  false,
627  true,
628  1,
629  std::chrono::seconds{Json::Value::maxInt + 1},
630  std::chrono::seconds{Json::Value::maxInt - 6000}}});
631  // verify refresh intervals are properly clamped
632  testFetchList(
633  good,
634  {{"/validators/refresh/0",
635  "",
636  ssl,
637  false,
638  false,
639  1,
640  detail::default_expires,
641  detail::default_effective_overlap,
642  1}}); // minimum of 1 minute
643  testFetchList(
644  good,
645  {{"/validators2/refresh/0",
646  "",
647  ssl,
648  false,
649  false,
650  1,
651  detail::default_expires,
652  detail::default_effective_overlap,
653  1}}); // minimum of 1 minute
654  testFetchList(
655  good,
656  {{"/validators/refresh/10",
657  "",
658  ssl,
659  false,
660  false,
661  1,
662  detail::default_expires,
663  detail::default_effective_overlap,
664  10}}); // 10 minutes is fine
665  testFetchList(
666  good,
667  {{"/validators2/refresh/10",
668  "",
669  ssl,
670  false,
671  false,
672  1,
673  detail::default_expires,
674  detail::default_effective_overlap,
675  10}}); // 10 minutes is fine
676  testFetchList(
677  good,
678  {{"/validators/refresh/2000",
679  "",
680  ssl,
681  false,
682  false,
683  1,
684  detail::default_expires,
685  detail::default_effective_overlap,
686  60 * 24}}); // max of 24 hours
687  testFetchList(
688  good,
689  {{"/validators2/refresh/2000",
690  "",
691  ssl,
692  false,
693  false,
694  1,
695  detail::default_expires,
696  detail::default_effective_overlap,
697  60 * 24}}); // max of 24 hours
698  }
699  using namespace boost::filesystem;
700  for (auto const& file : directory_iterator(good.subdir()))
701  {
702  remove_all(file);
703  }
704 
705  testFileURLs();
706  }
707 };
708 
709 BEAST_DEFINE_TESTSUITE_PRIO(ValidatorSite, app, ripple, 2);
710 
711 } // namespace test
712 } // namespace ripple
ripple::test::jtx::json
Inject raw JSON.
Definition: jtx_json.h:31
ripple::test::ValidatorSite_test::testConfigLoad
void testConfigLoad()
Definition: ValidatorSite_test.cpp:66
std::string
STL class.
ripple::test::ValidatorSite_test::FetchListConfig::ssl
bool ssl
Definition: ValidatorSite_test.cpp:135
std::shared_ptr
STL class.
beast::severities::kDisabled
@ kDisabled
Definition: Journal.h:41
ripple::test::ValidatorSite_test::testFetchList
void testFetchList(detail::DirGuard const &good, std::vector< FetchListConfig > const &paths)
Definition: ValidatorSite_test.cpp:145
ripple::test::detail::DirGuard
Create a directory and remove it when it's done.
Definition: FileDirGuard.h:34
ripple::ValidatorSite
Definition: ValidatorSite.h:69
std::pair
std::string::reserve
T reserve(T... args)
std::vector< std::string >
std::chrono::seconds
ripple::test::ValidatorSite_test::testFileURLs
void testFileURLs()
Definition: ValidatorSite_test.cpp:362
std::stringstream
STL class.
ripple::test::jtx::Env::journal
const beast::Journal journal
Definition: Env.h:144
ripple::test::jtx::Env::timeKeeper
ManualTimeKeeper & timeKeeper()
Definition: Env.h:253
ripple::test::jtx::Env::app
Application & app()
Definition: Env.h:241
std::vector::back
T back(T... args)
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:49
ripple::test::ValidatorSite_test::FetchListConfig::expectedRefreshMin
int expectedRefreshMin
Definition: ValidatorSite_test.cpp:142
ripple::test::BEAST_DEFINE_TESTSUITE_PRIO
BEAST_DEFINE_TESTSUITE_PRIO(AccountDelete, app, ripple, 2)
ripple::test::detail::DirGuard::subdir
path const & subdir() const
Definition: FileDirGuard.h:98
ripple::test::detail::default_effective_overlap
constexpr auto default_effective_overlap
Definition: ValidatorSite_test.cpp:57
ripple::test::detail::realValidatorContents
constexpr const char * realValidatorContents()
Definition: ValidatorSite_test.cpp:44
std::vector::push_back
T push_back(T... args)
Json::Value::maxInt
static const Int maxInt
Definition: json_value.h:159
ripple::test::ValidatorSite_test::testFileList
void testFileList(std::vector< std::pair< std::string, std::string >> const &paths)
Definition: ValidatorSite_test.cpp:299
ripple::PublicKey
A public key.
Definition: PublicKey.h:59
std::ofstream
STL class.
chrono
ripple::test::TrustedPublisherServer::Validator
Definition: TrustedPublisherServer.h:112
ripple::test::ValidatorSite_test::FetchListConfig::serverVersion
int serverVersion
Definition: ValidatorSite_test.cpp:138
std::to_string
T to_string(T... args)
ripple::test::ValidatorSite_test::FetchListConfig::path
std::string path
Definition: ValidatorSite_test.cpp:133
ripple::test::jtx::paths
Set Paths, SendMax on a JTx.
Definition: paths.h:32
std::chrono::time_point
beast::Journal
A generic endpoint for log messages.
Definition: Journal.h:58
ripple::test::TrustedPublisherServer::randomValidator
static Validator randomValidator()
Definition: TrustedPublisherServer.h:148
ripple::test::ValidatorSite_test::FetchListConfig::failFetch
bool failFetch
Definition: ValidatorSite_test.cpp:136
ripple::test::detail::default_expires
constexpr auto default_expires
Definition: ValidatorSite_test.cpp:56
ripple::test::ValidatorSite_test::FetchListConfig::effectiveOverlap
std::chrono::seconds effectiveOverlap
Definition: ValidatorSite_test.cpp:140
ripple::Application::validators
virtual ValidatorList & validators()=0
ripple::Application::getIOService
virtual boost::asio::io_service & getIOService()=0
ripple::test::StreamSink
Definition: SuiteJournal.h:114
ripple::test::StreamSink::messages
std::stringstream const & messages() const
Definition: SuiteJournal.h:134
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::test::ValidatorSite_test
Definition: ValidatorSite_test.cpp:60
ripple::test::ValidatorSite_test::FetchListConfig
Definition: ValidatorSite_test.cpp:131
ripple::test::ValidatorSite_test::FetchListConfig::expiresFromNow
std::chrono::seconds expiresFromNow
Definition: ValidatorSite_test.cpp:139
ripple::test::ValidatorSite_test::run
void run() override
Definition: ValidatorSite_test.cpp:400
ripple::test::ValidatorSite_test::FetchListConfig::failApply
bool failApply
Definition: ValidatorSite_test.cpp:137
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
std::stringstream::str
T str(T... args)
ripple::to_string
std::string to_string(Manifest const &m)
Format the specified manifest to a string for debugging purposes.
Definition: app/misc/impl/Manifest.cpp:41
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:30
ripple::test::detail::FileDirGuard
Write a file in a directory and remove when done.
Definition: FileDirGuard.h:107
ripple::test::ManualTimeKeeper::now
time_point now() const override
Returns the estimate of wall time, in network time.
Definition: ManualTimeKeeper.cpp:37
ripple::test::ManualTimeKeeper::set
void set(time_point now)
Definition: ManualTimeKeeper.cpp:81
ripple::test::ValidatorSite_test::FetchListConfig::msg
std::string msg
Definition: ValidatorSite_test.cpp:134
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:116
Json::Value
Represents a JSON value.
Definition: json_value.h:145
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition: json_value.cpp:469
std::chrono
std::chrono::system_clock::now
T now(T... args)
Generated by   doxygen 1.8.17