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