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::unique_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 = std::make_unique<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  auto sites = std::make_unique<ValidatorSite>(env.app(), journal, 2s);
206 
207  std::vector<std::string> uris;
208  for (auto const& u : servers)
209  uris.push_back(u.uri);
210  sites->load(uris);
211  sites->start();
212  sites->join();
213 
214  auto const jv = sites->getJson();
215  for (auto const& u : servers)
216  {
217  for (auto const& val : u.list)
218  {
219  BEAST_EXPECT(
220  trustedKeys.listed(val.masterPublic) != u.cfg.failApply);
221  BEAST_EXPECT(
222  trustedKeys.listed(val.signingPublic) != u.cfg.failApply);
223  }
224 
225  Json::Value myStatus;
226  for (auto const& vs : jv[jss::validator_sites])
227  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
228  myStatus = vs;
229  BEAST_EXPECTS(
230  myStatus[jss::last_refresh_message].asString().empty() !=
231  u.cfg.failFetch,
232  to_string(myStatus) + "\n" + sink.messages().str());
233 
234  if (!u.cfg.msg.empty())
235  {
236  BEAST_EXPECTS(
237  sink.messages().str().find(u.cfg.msg) != std::string::npos,
238  sink.messages().str());
239  }
240 
241  if (u.cfg.expectedRefreshMin)
242  {
243  BEAST_EXPECTS(
244  myStatus[jss::refresh_interval_min].asInt() ==
245  u.cfg.expectedRefreshMin,
246  to_string(myStatus));
247  }
248 
249  if (u.cfg.failFetch)
250  {
251  using namespace std::chrono;
252  log << " -- Msg: "
253  << myStatus[jss::last_refresh_message].asString()
254  << std::endl;
255  std::stringstream nextRefreshStr{
256  myStatus[jss::next_refresh_time].asString()};
257  system_clock::time_point nextRefresh;
258  date::from_stream(nextRefreshStr, "%Y-%b-%d %T", nextRefresh);
259  BEAST_EXPECT(!nextRefreshStr.fail());
260  auto now = system_clock::now();
261  BEAST_EXPECTS(
262  nextRefresh <= now + (u.isRetry ? seconds{30} : minutes{5}),
263  "Now: " + to_string(now) + ", NR: " + nextRefreshStr.str());
264  }
265  }
266  }
267 
268  void
269  testFileList(std::vector<std::pair<std::string, std::string>> const& paths)
270  {
271  testcase << "File list - " << paths[0].first
272  << (paths.size() > 1 ? ", " + paths[1].first : "");
273 
274  using namespace jtx;
275 
276  Env env(*this);
277 
278  test::StreamSink sink;
279  beast::Journal journal{sink};
280 
281  struct publisher
282  {
283  std::string uri;
284  std::string expectMsg;
285  bool shouldFail;
286  };
287  std::vector<publisher> servers;
288 
289  for (auto const& cfg : paths)
290  {
291  servers.push_back({});
292  auto& item = servers.back();
293  item.shouldFail = !cfg.second.empty();
294  item.expectMsg = cfg.second;
295 
296  std::stringstream uri;
297  uri << "file://" << cfg.first;
298  item.uri = uri.str();
299  }
300 
301  auto sites = std::make_unique<ValidatorSite>(env.app(), journal);
302 
303  std::vector<std::string> uris;
304  for (auto const& u : servers)
305  uris.push_back(u.uri);
306  sites->load(uris);
307  sites->start();
308  sites->join();
309 
310  for (auto const& u : servers)
311  {
312  auto const jv = sites->getJson();
313  Json::Value myStatus;
314  for (auto const& vs : jv[jss::validator_sites])
315  if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
316  myStatus = vs;
317  BEAST_EXPECTS(
318  myStatus[jss::last_refresh_message].asString().empty() !=
319  u.shouldFail,
320  to_string(myStatus));
321  if (u.shouldFail)
322  {
323  BEAST_EXPECTS(
324  sink.messages().str().find(u.expectMsg) !=
325  std::string::npos,
326  sink.messages().str());
327  log << " -- Msg: "
328  << myStatus[jss::last_refresh_message].asString()
329  << std::endl;
330  }
331  }
332  }
333 
334  void
335  testFileURLs()
336  {
337  auto fullPath = [](detail::FileDirGuard const& guard) {
338  auto absPath = absolute(guard.file()).string();
339  if (absPath.front() != '/')
340  absPath.insert(absPath.begin(), '/');
341  return absPath;
342  };
343  {
344  // Create a file with a real validator list
345  detail::FileDirGuard good(
346  *this, "test_val", "vl.txt", detail::realValidatorContents());
347  // Create a file with arbitrary content
348  detail::FileDirGuard hello(
349  *this, "test_val", "helloworld.txt", "Hello, world!");
350  // Create a file with malformed Json
351  detail::FileDirGuard json(
352  *this,
353  "test_val",
354  "json.txt",
355  R"json({ "version": 2, "extra" : "value" })json");
356  auto const goodPath = fullPath(good);
357  auto const helloPath = fullPath(hello);
358  auto const jsonPath = fullPath(json);
359  auto const missingPath = jsonPath + ".bad";
360  testFileList({
361  {goodPath, ""},
362  {helloPath,
363  "Unable to parse JSON response from file://" + helloPath},
364  {jsonPath,
365  "Missing fields in JSON response from file://" + jsonPath},
366  {missingPath, "Problem retrieving from file://" + missingPath},
367  });
368  }
369  }
370 
371 public:
372  void
373  run() override
374  {
375  testConfigLoad();
376 
377  for (auto ssl : {true, false})
378  {
379  // fetch single site
380  testFetchList({{"/validators", "", ssl}});
381  // fetch multiple sites
382  testFetchList({{"/validators", "", ssl}, {"/validators", "", ssl}});
383  // fetch single site with single redirects
384  testFetchList({{"/redirect_once/301", "", ssl}});
385  testFetchList({{"/redirect_once/302", "", ssl}});
386  testFetchList({{"/redirect_once/307", "", ssl}});
387  testFetchList({{"/redirect_once/308", "", ssl}});
388  // one redirect, one not
389  testFetchList(
390  {{"/validators", "", ssl}, {"/redirect_once/302", "", ssl}});
391  // fetch single site with undending redirect (fails to load)
392  testFetchList(
393  {{"/redirect_forever/301",
394  "Exceeded max redirects",
395  ssl,
396  true,
397  true}});
398  // two that redirect forever
399  testFetchList(
400  {{"/redirect_forever/307",
401  "Exceeded max redirects",
402  ssl,
403  true,
404  true},
405  {"/redirect_forever/308",
406  "Exceeded max redirects",
407  ssl,
408  true,
409  true}});
410  // one undending redirect, one not
411  testFetchList(
412  {{"/validators", "", ssl},
413  {"/redirect_forever/302",
414  "Exceeded max redirects",
415  ssl,
416  true,
417  true}});
418  // invalid redir Location
419  testFetchList(
420  {{"/redirect_to/ftp://invalid-url/302",
421  "Invalid redirect location",
422  ssl,
423  true,
424  true}});
425  testFetchList(
426  {{"/redirect_to/file://invalid-url/302",
427  "Invalid redirect location",
428  ssl,
429  true,
430  true}});
431  // invalid json
432  testFetchList(
433  {{"/validators/bad",
434  "Unable to parse JSON response",
435  ssl,
436  true,
437  true}});
438  // error status returned
439  testFetchList(
440  {{"/bad-resource", "returned bad status", ssl, true, true}});
441  // location field missing
442  testFetchList(
443  {{"/redirect_nolo/308",
444  "returned a redirect with no Location",
445  ssl,
446  true,
447  true}});
448  // json fields missing
449  testFetchList(
450  {{"/validators/missing",
451  "Missing fields in JSON response",
452  ssl,
453  true,
454  true}});
455  // timeout
456  testFetchList({{"/sleep/3", "took too long", ssl, true, true}});
457  // bad manifest version
458  testFetchList(
459  {{"/validators", "Unsupported version", ssl, false, true, 4}});
460  using namespace std::chrono_literals;
461  // get old validator list
462  testFetchList(
463  {{"/validators",
464  "Stale validator list",
465  ssl,
466  false,
467  true,
468  1,
469  0s}});
470  // force an out-of-range expiration value
471  testFetchList(
472  {{"/validators",
473  "Invalid validator list",
474  ssl,
475  false,
476  true,
477  1,
478  std::chrono::seconds{Json::Value::maxInt + 1}}});
479  // verify refresh intervals are properly clamped
480  testFetchList(
481  {{"/validators/refresh/0",
482  "",
483  ssl,
484  false,
485  false,
486  1,
487  detail::default_expires,
488  1}}); // minimum of 1 minute
489  testFetchList(
490  {{"/validators/refresh/10",
491  "",
492  ssl,
493  false,
494  false,
495  1,
496  detail::default_expires,
497  10}}); // 10 minutes is fine
498  testFetchList(
499  {{"/validators/refresh/2000",
500  "",
501  ssl,
502  false,
503  false,
504  1,
505  detail::default_expires,
506  60 * 24}}); // max of 24 hours
507  }
508  testFileURLs();
509  }
510 };
511 
512 BEAST_DEFINE_TESTSUITE(ValidatorSite, app, ripple);
513 
514 } // namespace test
515 } // 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
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:335
std::stringstream
STL class.
ripple::test::jtx::Env::journal
const beast::Journal journal
Definition: Env.h:141
ripple::test::jtx::Env::timeKeeper
ManualTimeKeeper & timeKeeper()
Definition: Env.h:250
ripple::test::jtx::Env::app
Application & app()
Definition: Env.h:238
std::vector::back
T back(T... args)
ripple::to_string
std::string to_string(ListDisposition disposition)
Definition: ValidatorList.cpp:41
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
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:269
ripple::PublicKey
A public key.
Definition: PublicKey.h:59
chrono
ripple::test::TrustedPublisherServer::Validator
Definition: TrustedPublisherServer.h:92
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:128
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:110
ripple::test::StreamSink::messages
std::stringstream const & messages() const
Definition: SuiteJournal.h:130
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:373
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
std::unique_ptr
STL class.
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:114
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