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);
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(std::vector<FetchListConfig> const& paths)
146  {
147  testcase << "Fetch list - "
148  << boost::algorithm::join(
149  paths |
150  boost::adaptors::transformed(
151  [](FetchListConfig const& cfg) {
152  return cfg.path +
153  (cfg.ssl ? " [https] v" : " [http] v") +
154  std::to_string(cfg.serverVersion) +
155  " " + cfg.msg;
156  }),
157  ", ");
158  using namespace jtx;
159  using namespace std::chrono_literals;
160 
161  Env env(*this);
162  auto& trustedKeys = env.app().validators();
163  env.timeKeeper().set(env.timeKeeper().now() + 30s);
164 
165  test::StreamSink sink;
166  beast::Journal journal{sink};
167 
168  PublicKey emptyLocalKey;
169  std::vector<std::string> emptyCfgKeys;
170  struct publisher
171  {
172  publisher(FetchListConfig const& c) : cfg{c}
173  {
174  }
175  std::shared_ptr<TrustedPublisherServer> server;
176  std::vector<Validator> list;
177  std::string uri;
178  FetchListConfig const& cfg;
179  bool isRetry;
180  };
181  std::vector<publisher> servers;
182 
183  auto constexpr listSize = 20;
184  std::vector<std::string> cfgPublishers;
185 
186  for (auto const& cfg : paths)
187  {
188  servers.push_back(cfg);
189  auto& item = servers.back();
190  item.isRetry = cfg.path == "/bad-resource";
191  item.list.reserve(listSize);
192  while (item.list.size() < listSize)
193  item.list.push_back(TrustedPublisherServer::randomValidator());
194 
195  NetClock::time_point const expires =
196  env.timeKeeper().now() + cfg.expiresFromNow;
197  NetClock::time_point const effective2 =
198  expires - cfg.effectiveOverlap;
199  NetClock::time_point const expires2 =
200  effective2 + cfg.expiresFromNow;
201  item.server = make_TrustedPublisherServer(
202  env.app().getIOService(),
203  item.list,
204  expires,
205  {{effective2, expires2}},
206  cfg.ssl,
207  cfg.serverVersion);
208  cfgPublishers.push_back(strHex(item.server->publisherPublic()));
209 
210  std::stringstream uri;
211  uri << (cfg.ssl ? "https://" : "http://")
212  << item.server->local_endpoint() << cfg.path;
213  item.uri = uri.str();
214  }
215 
216  BEAST_EXPECT(
217  trustedKeys.load(emptyLocalKey, emptyCfgKeys, cfgPublishers));
218 
219  // Normally, tests will only need a fraction of this time,
220  // but sometimes DNS resolution takes an inordinate amount
221  // of time, so the test will just wait.
222  auto sites = std::make_unique<ValidatorSite>(env.app(), journal, 12s);
223 
224  std::vector<std::string> uris;
225  for (auto const& u : servers)
226  uris.push_back(u.uri);
227  sites->load(uris);
228  sites->start();
229  sites->join();
230 
231  auto const jv = sites->getJson();
232  for (auto const& u : servers)
233  {
234  for (auto const& val : u.list)
235  {
236  BEAST_EXPECT(
237  trustedKeys.listed(val.masterPublic) != u.cfg.failApply);
238  BEAST_EXPECT(
239  trustedKeys.listed(val.signingPublic) != u.cfg.failApply);
240  }
241 
242  Json::Value myStatus;
243  for (auto const& vs : jv[jss::validator_sites])
244  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
245  myStatus = vs;
246  BEAST_EXPECTS(
247  myStatus[jss::last_refresh_message].asString().empty() !=
248  u.cfg.failFetch,
249  to_string(myStatus) + "\n" + sink.messages().str());
250 
251  if (!u.cfg.msg.empty())
252  {
253  BEAST_EXPECTS(
254  sink.messages().str().find(u.cfg.msg) != std::string::npos,
255  sink.messages().str());
256  }
257 
258  if (u.cfg.expectedRefreshMin)
259  {
260  BEAST_EXPECTS(
261  myStatus[jss::refresh_interval_min].asInt() ==
262  u.cfg.expectedRefreshMin,
263  to_string(myStatus));
264  }
265 
266  if (u.cfg.failFetch)
267  {
268  using namespace std::chrono;
269  log << " -- Msg: "
270  << myStatus[jss::last_refresh_message].asString()
271  << std::endl;
272  std::stringstream nextRefreshStr{
273  myStatus[jss::next_refresh_time].asString()};
274  system_clock::time_point nextRefresh;
275  date::from_stream(nextRefreshStr, "%Y-%b-%d %T", nextRefresh);
276  BEAST_EXPECT(!nextRefreshStr.fail());
277  auto now = system_clock::now();
278  BEAST_EXPECTS(
279  nextRefresh <= now + (u.isRetry ? seconds{30} : minutes{5}),
280  "Now: " + to_string(now) + ", NR: " + nextRefreshStr.str());
281  }
282  }
283  }
284 
285  void
286  testFileList(std::vector<std::pair<std::string, std::string>> const& paths)
287  {
288  testcase << "File list - " << paths[0].first
289  << (paths.size() > 1 ? ", " + paths[1].first : "");
290 
291  using namespace jtx;
292 
293  Env env(*this);
294 
295  test::StreamSink sink;
296  beast::Journal journal{sink};
297 
298  struct publisher
299  {
300  std::string uri;
301  std::string expectMsg;
302  bool shouldFail;
303  };
304  std::vector<publisher> servers;
305 
306  for (auto const& cfg : paths)
307  {
308  servers.push_back({});
309  auto& item = servers.back();
310  item.shouldFail = !cfg.second.empty();
311  item.expectMsg = cfg.second;
312 
313  std::stringstream uri;
314  uri << "file://" << cfg.first;
315  item.uri = uri.str();
316  }
317 
318  auto sites = std::make_unique<ValidatorSite>(env.app(), journal);
319 
320  std::vector<std::string> uris;
321  for (auto const& u : servers)
322  uris.push_back(u.uri);
323  sites->load(uris);
324  sites->start();
325  sites->join();
326 
327  for (auto const& u : servers)
328  {
329  auto const jv = sites->getJson();
330  Json::Value myStatus;
331  for (auto const& vs : jv[jss::validator_sites])
332  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
333  myStatus = vs;
334  BEAST_EXPECTS(
335  myStatus[jss::last_refresh_message].asString().empty() !=
336  u.shouldFail,
337  to_string(myStatus));
338  if (u.shouldFail)
339  {
340  BEAST_EXPECTS(
341  sink.messages().str().find(u.expectMsg) !=
342  std::string::npos,
343  sink.messages().str());
344  log << " -- Msg: "
345  << myStatus[jss::last_refresh_message].asString()
346  << std::endl;
347  }
348  }
349  }
350 
351  void
352  testFileURLs()
353  {
354  auto fullPath = [](detail::FileDirGuard const& guard) {
355  auto absPath = absolute(guard.file()).string();
356  if (absPath.front() != '/')
357  absPath.insert(absPath.begin(), '/');
358  return absPath;
359  };
360  {
361  // Create a file with a real validator list
362  detail::FileDirGuard good(
363  *this, "test_val", "vl.txt", detail::realValidatorContents());
364  // Create a file with arbitrary content
365  detail::FileDirGuard hello(
366  *this, "test_val", "helloworld.txt", "Hello, world!");
367  // Create a file with malformed Json
368  detail::FileDirGuard json(
369  *this,
370  "test_val",
371  "json.txt",
372  R"json({ "version": 2, "extra" : "value" })json");
373  auto const goodPath = fullPath(good);
374  auto const helloPath = fullPath(hello);
375  auto const jsonPath = fullPath(json);
376  auto const missingPath = jsonPath + ".bad";
377  testFileList({
378  {goodPath, ""},
379  {helloPath,
380  "Unable to parse JSON response from file://" + helloPath},
381  {jsonPath,
382  "Missing fields in JSON response from file://" + jsonPath},
383  {missingPath, "Problem retrieving from file://" + missingPath},
384  });
385  }
386  }
387 
388 public:
389  void
390  run() override
391  {
392  testConfigLoad();
393 
394  for (auto ssl : {true, false})
395  {
396  // fetch single site
397  testFetchList({{"/validators", "", ssl}});
398  testFetchList({{"/validators2", "", ssl}});
399  // fetch multiple sites
400  testFetchList({{"/validators", "", ssl}, {"/validators", "", ssl}});
401  testFetchList(
402  {{"/validators", "", ssl}, {"/validators2", "", ssl}});
403  testFetchList(
404  {{"/validators2", "", ssl}, {"/validators", "", ssl}});
405  testFetchList(
406  {{"/validators2", "", ssl}, {"/validators2", "", ssl}});
407  // fetch single site with single redirects
408  testFetchList({{"/redirect_once/301", "", ssl}});
409  testFetchList({{"/redirect_once/302", "", ssl}});
410  testFetchList({{"/redirect_once/307", "", ssl}});
411  testFetchList({{"/redirect_once/308", "", ssl}});
412  // one redirect, one not
413  testFetchList(
414  {{"/validators", "", ssl}, {"/redirect_once/302", "", ssl}});
415  testFetchList(
416  {{"/validators2", "", ssl}, {"/redirect_once/302", "", ssl}});
417  // UNLs with a "gap" between validUntil of one and validFrom of the
418  // next
419  testFetchList(
420  {{"/validators2",
421  "",
422  ssl,
423  false,
424  false,
425  1,
426  detail::default_expires,
427  std::chrono::seconds{-90}}});
428  // fetch single site with undending redirect (fails to load)
429  testFetchList(
430  {{"/redirect_forever/301",
431  "Exceeded max redirects",
432  ssl,
433  true,
434  true}});
435  // two that redirect forever
436  testFetchList(
437  {{"/redirect_forever/307",
438  "Exceeded max redirects",
439  ssl,
440  true,
441  true},
442  {"/redirect_forever/308",
443  "Exceeded max redirects",
444  ssl,
445  true,
446  true}});
447  // one undending redirect, one not
448  testFetchList(
449  {{"/validators", "", ssl},
450  {"/redirect_forever/302",
451  "Exceeded max redirects",
452  ssl,
453  true,
454  true}});
455  // one undending redirect, one not
456  testFetchList(
457  {{"/validators2", "", ssl},
458  {"/redirect_forever/302",
459  "Exceeded max redirects",
460  ssl,
461  true,
462  true}});
463  // invalid redir Location
464  testFetchList(
465  {{"/redirect_to/ftp://invalid-url/302",
466  "Invalid redirect location",
467  ssl,
468  true,
469  true}});
470  testFetchList(
471  {{"/redirect_to/file://invalid-url/302",
472  "Invalid redirect location",
473  ssl,
474  true,
475  true}});
476  // invalid json
477  testFetchList(
478  {{"/validators/bad",
479  "Unable to parse JSON response",
480  ssl,
481  true,
482  true}});
483  testFetchList(
484  {{"/validators2/bad",
485  "Unable to parse JSON response",
486  ssl,
487  true,
488  true}});
489  // error status returned
490  testFetchList(
491  {{"/bad-resource", "returned bad status", ssl, true, true}});
492  // location field missing
493  testFetchList(
494  {{"/redirect_nolo/308",
495  "returned a redirect with no Location",
496  ssl,
497  true,
498  true}});
499  // json fields missing
500  testFetchList(
501  {{"/validators/missing",
502  "Missing fields in JSON response",
503  ssl,
504  true,
505  true}});
506  testFetchList(
507  {{"/validators2/missing",
508  "Missing fields in JSON response",
509  ssl,
510  true,
511  true}});
512  // timeout
513  testFetchList({{"/sleep/13", "took too long", ssl, true, true}});
514  // bad manifest format using known versions
515  // * Retrieves a v1 formatted list claiming version 2
516  testFetchList(
517  {{"/validators", "Missing fields", ssl, true, true, 2}});
518  // * Retrieves a v2 formatted list claiming version 1
519  testFetchList(
520  {{"/validators2", "Missing fields", ssl, true, true, 0}});
521  // bad manifest version
522  // Because versions other than 1 are treated as v2, the v1
523  // list won't have the blobs_v2 fields, and thus will claim to have
524  // missing fields
525  testFetchList(
526  {{"/validators", "Missing fields", ssl, true, true, 4}});
527  testFetchList(
528  {{"/validators2",
529  "1 unsupported version",
530  ssl,
531  false,
532  true,
533  4}});
534  using namespace std::chrono_literals;
535  // get expired validator list
536  testFetchList(
537  {{"/validators",
538  "Applied 1 expired validator list(s)",
539  ssl,
540  false,
541  false,
542  1,
543  0s}});
544  testFetchList(
545  {{"/validators2",
546  "Applied 1 expired validator list(s)",
547  ssl,
548  false,
549  false,
550  1,
551  0s,
552  -1s}});
553  // force an out-of-range validUntil value
554  testFetchList(
555  {{"/validators",
556  "1 invalid validator list(s)",
557  ssl,
558  false,
559  true,
560  1,
561  std::chrono::seconds{Json::Value::maxInt + 1}}});
562  // force an out-of-range validUntil value on the future list
563  // The first list is accepted. The second fails. The parser
564  // returns the "best" result, so this looks like a success.
565  testFetchList(
566  {{"/validators2",
567  "",
568  ssl,
569  false,
570  false,
571  1,
572  std::chrono::seconds{Json::Value::maxInt - 300},
573  299s}});
574  // force an out-of-range validFrom value
575  // The first list is accepted. The second fails. The parser
576  // returns the "best" result, so this looks like a success.
577  testFetchList(
578  {{"/validators2",
579  "",
580  ssl,
581  false,
582  false,
583  1,
584  std::chrono::seconds{Json::Value::maxInt - 300},
585  301s}});
586  // force an out-of-range validUntil value on _both_ lists
587  testFetchList(
588  {{"/validators2",
589  "2 invalid validator list(s)",
590  ssl,
591  false,
592  true,
593  1,
594  std::chrono::seconds{Json::Value::maxInt + 1},
595  std::chrono::seconds{Json::Value::maxInt - 6000}}});
596  // verify refresh intervals are properly clamped
597  testFetchList(
598  {{"/validators/refresh/0",
599  "",
600  ssl,
601  false,
602  false,
603  1,
604  detail::default_expires,
605  detail::default_effective_overlap,
606  1}}); // minimum of 1 minute
607  testFetchList(
608  {{"/validators2/refresh/0",
609  "",
610  ssl,
611  false,
612  false,
613  1,
614  detail::default_expires,
615  detail::default_effective_overlap,
616  1}}); // minimum of 1 minute
617  testFetchList(
618  {{"/validators/refresh/10",
619  "",
620  ssl,
621  false,
622  false,
623  1,
624  detail::default_expires,
625  detail::default_effective_overlap,
626  10}}); // 10 minutes is fine
627  testFetchList(
628  {{"/validators2/refresh/10",
629  "",
630  ssl,
631  false,
632  false,
633  1,
634  detail::default_expires,
635  detail::default_effective_overlap,
636  10}}); // 10 minutes is fine
637  testFetchList(
638  {{"/validators/refresh/2000",
639  "",
640  ssl,
641  false,
642  false,
643  1,
644  detail::default_expires,
645  detail::default_effective_overlap,
646  60 * 24}}); // max of 24 hours
647  testFetchList(
648  {{"/validators2/refresh/2000",
649  "",
650  ssl,
651  false,
652  false,
653  1,
654  detail::default_expires,
655  detail::default_effective_overlap,
656  60 * 24}}); // max of 24 hours
657  }
658  testFileURLs();
659  }
660 };
661 
662 BEAST_DEFINE_TESTSUITE(ValidatorSite, app, ripple);
663 
664 } // namespace test
665 } // 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
ripple::test::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AccountDelete, app, ripple)
std::string
STL class.
ripple::test::ValidatorSite_test::FetchListConfig::ssl
bool ssl
Definition: ValidatorSite_test.cpp:135
std::shared_ptr
STL class.
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:352
std::stringstream
STL class.
ripple::test::jtx::Env::journal
const beast::Journal journal
Definition: Env.h:143
ripple::test::jtx::Env::timeKeeper
ManualTimeKeeper & timeKeeper()
Definition: Env.h:252
ripple::test::jtx::Env::app
Application & app()
Definition: Env.h:240
std::vector::back
T back(T... args)
ripple::test::ValidatorSite_test::FetchListConfig::expectedRefreshMin
int expectedRefreshMin
Definition: ValidatorSite_test.cpp:142
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)
ripple::test::ValidatorSite_test::testFetchList
void testFetchList(std::vector< FetchListConfig > const &paths)
Definition: ValidatorSite_test.cpp:145
Json::Value::maxInt
static const Int maxInt
Definition: json_value.h:159
std::log
T log(T... args)
ripple::test::ValidatorSite_test::testFileList
void testFileList(std::vector< std::pair< std::string, std::string >> const &paths)
Definition: ValidatorSite_test.cpp:286
ripple::PublicKey
A public key.
Definition: PublicKey.h:59
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
std::endl
T endl(T... args)
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:390
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:712
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:40
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:45
ripple::test::detail::FileDirGuard
Write a file in a directory and remove when done.
Definition: FileDirGuard.h:110
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:115
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