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