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