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 } // namespace detail
57 
58 class ValidatorSite_test : public beast::unit_test::suite
59 {
60 private:
61  using Validator = TrustedPublisherServer::Validator;
62 
63  void
64  testConfigLoad()
65  {
66  testcase("Config Load");
67 
68  using namespace jtx;
69 
70  Env env(*this);
71  auto trustedSites =
72  std::make_unique<ValidatorSite>(env.app(), env.journal);
73 
74  // load should accept empty sites list
75  std::vector<std::string> emptyCfgSites;
76  BEAST_EXPECT(trustedSites->load(emptyCfgSites));
77 
78  // load should accept valid validator site uris
79  std::vector<std::string> cfgSites({
80  "http://ripple.com/", "http://ripple.com/validators",
81  "http://ripple.com:8080/validators",
82  "http://207.261.33.37/validators",
83  "http://207.261.33.37:8080/validators",
84  "https://ripple.com/validators",
85  "https://ripple.com:443/validators",
86  "file:///etc/opt/ripple/validators.txt",
87  "file:///C:/Lib/validators.txt"
88 #if !_MSC_VER
89  ,
90  "file:///"
91 #endif
92  });
93  BEAST_EXPECT(trustedSites->load(cfgSites));
94 
95  // load should reject validator site uris with invalid schemes
96  std::vector<std::string> badSites({"ftp://ripple.com/validators"});
97  BEAST_EXPECT(!trustedSites->load(badSites));
98 
99  badSites[0] = "wss://ripple.com/validators";
100  BEAST_EXPECT(!trustedSites->load(badSites));
101 
102  badSites[0] = "ripple.com/validators";
103  BEAST_EXPECT(!trustedSites->load(badSites));
104 
105  // Host names are not supported for file URLs
106  badSites[0] = "file://ripple.com/vl.txt";
107  BEAST_EXPECT(!trustedSites->load(badSites));
108 
109  // Even local host names are not supported for file URLs
110  badSites[0] = "file://localhost/home/user/vl.txt";
111  BEAST_EXPECT(!trustedSites->load(badSites));
112 
113  // Nor IP addresses
114  badSites[0] = "file://127.0.0.1/home/user/vl.txt";
115  BEAST_EXPECT(!trustedSites->load(badSites));
116 
117  // File URL path can not be empty
118  badSites[0] = "file://";
119  BEAST_EXPECT(!trustedSites->load(badSites));
120 
121 #if _MSC_VER // Windows paths strip off the leading /, leaving the path empty
122  // File URL path can not be a directory
123  // (/ is the only path we can reasonably assume is a directory)
124  badSites[0] = "file:///";
125  BEAST_EXPECT(!trustedSites->load(badSites));
126 #endif
127  }
128 
129  struct FetchListConfig
130  {
131  std::string path;
132  std::string msg;
133  bool ssl;
134  bool failFetch = false;
135  bool failApply = false;
136  int serverVersion = 1;
137  std::chrono::seconds expiresFromNow = detail::default_expires;
138  int expectedRefreshMin = 0;
139  };
140  void
141  testFetchList(std::vector<FetchListConfig> const& paths)
142  {
143  testcase << "Fetch list - "
144  << boost::algorithm::join(
145  paths |
146  boost::adaptors::transformed(
147  [](FetchListConfig const& cfg) {
148  return cfg.path +
149  (cfg.ssl ? " [https]" : " [http]");
150  }),
151  ", ");
152  using namespace jtx;
153 
154  Env env(*this);
155  auto& trustedKeys = env.app().validators();
156 
157  test::StreamSink sink;
158  beast::Journal journal{sink};
159 
160  PublicKey emptyLocalKey;
161  std::vector<std::string> emptyCfgKeys;
162  struct publisher
163  {
164  publisher(FetchListConfig const& c) : cfg{c}
165  {
166  }
167  std::shared_ptr<TrustedPublisherServer> server;
168  std::vector<Validator> list;
169  std::string uri;
170  FetchListConfig const& cfg;
171  bool isRetry;
172  };
173  std::vector<publisher> servers;
174 
175  auto constexpr listSize = 20;
176  std::vector<std::string> cfgPublishers;
177 
178  for (auto const& cfg : paths)
179  {
180  servers.push_back(cfg);
181  auto& item = servers.back();
182  item.isRetry = cfg.path == "/bad-resource";
183  item.list.reserve(listSize);
184  while (item.list.size() < listSize)
185  item.list.push_back(TrustedPublisherServer::randomValidator());
186 
187  item.server = make_TrustedPublisherServer(
188  env.app().getIOService(),
189  item.list,
190  env.timeKeeper().now() + cfg.expiresFromNow,
191  cfg.ssl,
192  cfg.serverVersion);
193  cfgPublishers.push_back(strHex(item.server->publisherPublic()));
194 
195  std::stringstream uri;
196  uri << (cfg.ssl ? "https://" : "http://")
197  << item.server->local_endpoint() << cfg.path;
198  item.uri = uri.str();
199  }
200 
201  BEAST_EXPECT(
202  trustedKeys.load(emptyLocalKey, emptyCfgKeys, cfgPublishers));
203 
204  using namespace std::chrono_literals;
205  // Normally, tests will only need a fraction of this time,
206  // but sometimes DNS resolution takes an inordinate amount
207  // of time, so the test will just wait.
208  auto sites = std::make_unique<ValidatorSite>(env.app(), journal, 12s);
209 
210  std::vector<std::string> uris;
211  for (auto const& u : servers)
212  uris.push_back(u.uri);
213  sites->load(uris);
214  sites->start();
215  sites->join();
216 
217  auto const jv = sites->getJson();
218  for (auto const& u : servers)
219  {
220  for (auto const& val : u.list)
221  {
222  BEAST_EXPECT(
223  trustedKeys.listed(val.masterPublic) != u.cfg.failApply);
224  BEAST_EXPECT(
225  trustedKeys.listed(val.signingPublic) != u.cfg.failApply);
226  }
227 
228  Json::Value myStatus;
229  for (auto const& vs : jv[jss::validator_sites])
230  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
231  myStatus = vs;
232  BEAST_EXPECTS(
233  myStatus[jss::last_refresh_message].asString().empty() !=
234  u.cfg.failFetch,
235  to_string(myStatus) + "\n" + sink.messages().str());
236 
237  if (!u.cfg.msg.empty())
238  {
239  BEAST_EXPECTS(
240  sink.messages().str().find(u.cfg.msg) != std::string::npos,
241  sink.messages().str());
242  }
243 
244  if (u.cfg.expectedRefreshMin)
245  {
246  BEAST_EXPECTS(
247  myStatus[jss::refresh_interval_min].asInt() ==
248  u.cfg.expectedRefreshMin,
249  to_string(myStatus));
250  }
251 
252  if (u.cfg.failFetch)
253  {
254  using namespace std::chrono;
255  log << " -- Msg: "
256  << myStatus[jss::last_refresh_message].asString()
257  << std::endl;
258  std::stringstream nextRefreshStr{
259  myStatus[jss::next_refresh_time].asString()};
260  system_clock::time_point nextRefresh;
261  date::from_stream(nextRefreshStr, "%Y-%b-%d %T", nextRefresh);
262  BEAST_EXPECT(!nextRefreshStr.fail());
263  auto now = system_clock::now();
264  BEAST_EXPECTS(
265  nextRefresh <= now + (u.isRetry ? seconds{30} : minutes{5}),
266  "Now: " + to_string(now) + ", NR: " + nextRefreshStr.str());
267  }
268  }
269  }
270 
271  void
272  testFileList(std::vector<std::pair<std::string, std::string>> const& paths)
273  {
274  testcase << "File list - " << paths[0].first
275  << (paths.size() > 1 ? ", " + paths[1].first : "");
276 
277  using namespace jtx;
278 
279  Env env(*this);
280 
281  test::StreamSink sink;
282  beast::Journal journal{sink};
283 
284  struct publisher
285  {
286  std::string uri;
287  std::string expectMsg;
288  bool shouldFail;
289  };
290  std::vector<publisher> servers;
291 
292  for (auto const& cfg : paths)
293  {
294  servers.push_back({});
295  auto& item = servers.back();
296  item.shouldFail = !cfg.second.empty();
297  item.expectMsg = cfg.second;
298 
299  std::stringstream uri;
300  uri << "file://" << cfg.first;
301  item.uri = uri.str();
302  }
303 
304  auto sites = std::make_unique<ValidatorSite>(env.app(), journal);
305 
306  std::vector<std::string> uris;
307  for (auto const& u : servers)
308  uris.push_back(u.uri);
309  sites->load(uris);
310  sites->start();
311  sites->join();
312 
313  for (auto const& u : servers)
314  {
315  auto const jv = sites->getJson();
316  Json::Value myStatus;
317  for (auto const& vs : jv[jss::validator_sites])
318  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
319  myStatus = vs;
320  BEAST_EXPECTS(
321  myStatus[jss::last_refresh_message].asString().empty() !=
322  u.shouldFail,
323  to_string(myStatus));
324  if (u.shouldFail)
325  {
326  BEAST_EXPECTS(
327  sink.messages().str().find(u.expectMsg) !=
328  std::string::npos,
329  sink.messages().str());
330  log << " -- Msg: "
331  << myStatus[jss::last_refresh_message].asString()
332  << std::endl;
333  }
334  }
335  }
336 
337  void
338  testFileURLs()
339  {
340  auto fullPath = [](detail::FileDirGuard const& guard) {
341  auto absPath = absolute(guard.file()).string();
342  if (absPath.front() != '/')
343  absPath.insert(absPath.begin(), '/');
344  return absPath;
345  };
346  {
347  // Create a file with a real validator list
348  detail::FileDirGuard good(
349  *this, "test_val", "vl.txt", detail::realValidatorContents());
350  // Create a file with arbitrary content
351  detail::FileDirGuard hello(
352  *this, "test_val", "helloworld.txt", "Hello, world!");
353  // Create a file with malformed Json
354  detail::FileDirGuard json(
355  *this,
356  "test_val",
357  "json.txt",
358  R"json({ "version": 2, "extra" : "value" })json");
359  auto const goodPath = fullPath(good);
360  auto const helloPath = fullPath(hello);
361  auto const jsonPath = fullPath(json);
362  auto const missingPath = jsonPath + ".bad";
363  testFileList({
364  {goodPath, ""},
365  {helloPath,
366  "Unable to parse JSON response from file://" + helloPath},
367  {jsonPath,
368  "Missing fields in JSON response from file://" + jsonPath},
369  {missingPath, "Problem retrieving from file://" + missingPath},
370  });
371  }
372  }
373 
374 public:
375  void
376  run() override
377  {
378  testConfigLoad();
379 
380  for (auto ssl : {true, false})
381  {
382  // fetch single site
383  testFetchList({{"/validators", "", ssl}});
384  // fetch multiple sites
385  testFetchList({{"/validators", "", ssl}, {"/validators", "", ssl}});
386  // fetch single site with single redirects
387  testFetchList({{"/redirect_once/301", "", ssl}});
388  testFetchList({{"/redirect_once/302", "", ssl}});
389  testFetchList({{"/redirect_once/307", "", ssl}});
390  testFetchList({{"/redirect_once/308", "", ssl}});
391  // one redirect, one not
392  testFetchList(
393  {{"/validators", "", ssl}, {"/redirect_once/302", "", ssl}});
394  // fetch single site with undending redirect (fails to load)
395  testFetchList(
396  {{"/redirect_forever/301",
397  "Exceeded max redirects",
398  ssl,
399  true,
400  true}});
401  // two that redirect forever
402  testFetchList(
403  {{"/redirect_forever/307",
404  "Exceeded max redirects",
405  ssl,
406  true,
407  true},
408  {"/redirect_forever/308",
409  "Exceeded max redirects",
410  ssl,
411  true,
412  true}});
413  // one undending redirect, one not
414  testFetchList(
415  {{"/validators", "", ssl},
416  {"/redirect_forever/302",
417  "Exceeded max redirects",
418  ssl,
419  true,
420  true}});
421  // invalid redir Location
422  testFetchList(
423  {{"/redirect_to/ftp://invalid-url/302",
424  "Invalid redirect location",
425  ssl,
426  true,
427  true}});
428  testFetchList(
429  {{"/redirect_to/file://invalid-url/302",
430  "Invalid redirect location",
431  ssl,
432  true,
433  true}});
434  // invalid json
435  testFetchList(
436  {{"/validators/bad",
437  "Unable to parse JSON response",
438  ssl,
439  true,
440  true}});
441  // error status returned
442  testFetchList(
443  {{"/bad-resource", "returned bad status", ssl, true, true}});
444  // location field missing
445  testFetchList(
446  {{"/redirect_nolo/308",
447  "returned a redirect with no Location",
448  ssl,
449  true,
450  true}});
451  // json fields missing
452  testFetchList(
453  {{"/validators/missing",
454  "Missing fields in JSON response",
455  ssl,
456  true,
457  true}});
458  // timeout
459  testFetchList({{"/sleep/13", "took too long", ssl, true, true}});
460  // bad manifest version
461  testFetchList(
462  {{"/validators", "Unsupported version", ssl, false, true, 4}});
463  using namespace std::chrono_literals;
464  // get old validator list
465  testFetchList(
466  {{"/validators",
467  "Stale validator list",
468  ssl,
469  false,
470  true,
471  1,
472  0s}});
473  // force an out-of-range expiration value
474  testFetchList(
475  {{"/validators",
476  "Invalid validator list",
477  ssl,
478  false,
479  true,
480  1,
481  std::chrono::seconds{Json::Value::maxInt + 1}}});
482  // verify refresh intervals are properly clamped
483  testFetchList(
484  {{"/validators/refresh/0",
485  "",
486  ssl,
487  false,
488  false,
489  1,
490  detail::default_expires,
491  1}}); // minimum of 1 minute
492  testFetchList(
493  {{"/validators/refresh/10",
494  "",
495  ssl,
496  false,
497  false,
498  1,
499  detail::default_expires,
500  10}}); // 10 minutes is fine
501  testFetchList(
502  {{"/validators/refresh/2000",
503  "",
504  ssl,
505  false,
506  false,
507  1,
508  detail::default_expires,
509  60 * 24}}); // max of 24 hours
510  }
511  testFileURLs();
512  }
513 };
514 
515 BEAST_DEFINE_TESTSUITE(ValidatorSite, app, ripple);
516 
517 } // namespace test
518 } // 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:64
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:133
std::shared_ptr
STL class.
ripple::ValidatorSite
Definition: ValidatorSite.h:67
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:338
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::to_string
std::string to_string(ListDisposition disposition)
Definition: ValidatorList.cpp:42
ripple::test::ValidatorSite_test::FetchListConfig::expectedRefreshMin
int expectedRefreshMin
Definition: ValidatorSite_test.cpp:138
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:141
ripple::test::make_TrustedPublisherServer
std::shared_ptr< TrustedPublisherServer > make_TrustedPublisherServer(boost::asio::io_context &ioc, std::vector< TrustedPublisherServer::Validator > const &validators, NetClock::time_point expiration, bool useSSL=false, int version=1, bool immediateStart=true, int sequence=1)
Definition: TrustedPublisherServer.h:618
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:272
ripple::PublicKey
A public key.
Definition: PublicKey.h:59
chrono
ripple::test::TrustedPublisherServer::Validator
Definition: TrustedPublisherServer.h:95
ripple::test::ValidatorSite_test::FetchListConfig::serverVersion
int serverVersion
Definition: ValidatorSite_test.cpp:136
ripple::test::ValidatorSite_test::FetchListConfig::path
std::string path
Definition: ValidatorSite_test.cpp:131
ripple::test::jtx::paths
Set Paths, SendMax on a JTx.
Definition: paths.h:32
beast::Journal
A generic endpoint for log messages.
Definition: Journal.h:58
ripple::test::TrustedPublisherServer::randomValidator
static Validator randomValidator()
Definition: TrustedPublisherServer.h:131
ripple::test::ValidatorSite_test::FetchListConfig::failFetch
bool failFetch
Definition: ValidatorSite_test.cpp:134
ripple::test::detail::default_expires
constexpr auto default_expires
Definition: ValidatorSite_test.cpp:55
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:58
ripple::test::ValidatorSite_test::FetchListConfig
Definition: ValidatorSite_test.cpp:129
ripple::test::ValidatorSite_test::FetchListConfig::expiresFromNow
std::chrono::seconds expiresFromNow
Definition: ValidatorSite_test.cpp:137
ripple::test::ValidatorSite_test::run
void run() override
Definition: ValidatorSite_test.cpp:376
ripple::test::ValidatorSite_test::FetchListConfig::failApply
bool failApply
Definition: ValidatorSite_test.cpp:135
std::stringstream::str
T str(T... args)
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:67
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::ValidatorSite_test::FetchListConfig::msg
std::string msg
Definition: ValidatorSite_test.cpp:132
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
Generated by   doxygen 1.8.17