rippled
STValidation_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2012, 2013 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/basics/Log.h>
21 #include <ripple/basics/random.h>
22 #include <ripple/beast/unit_test.h>
23 #include <ripple/beast/xor_shift_engine.h>
24 #include <ripple/json/json_reader.h>
25 #include <ripple/json/to_string.h>
26 #include <ripple/protocol/SecretKey.h>
27 #include <ripple/protocol/jss.h>
28 #include <ripple/protocol/st.h>
29 #include <test/jtx.h>
30 
31 #include <memory>
32 #include <type_traits>
33 
34 namespace ripple {
35 
36 class STValidation_test : public beast::unit_test::suite
37 {
38  // No public key:
39  static constexpr std::uint8_t payload1[] = {
40  0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26,
41  0x47, 0x31, 0x1A, 0x3A, 0x4E, 0x69, 0x6B, 0x2B, 0x54, 0x69, 0x66, 0x66,
42  0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E,
43  0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8,
44  0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97, 0x50, 0x17, 0x21,
45  0x0B, 0xAB, 0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED, 0x1E, 0x07, 0xB4,
46  0xFB, 0xC5, 0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43, 0x35, 0x28, 0xEB,
47  0xD9, 0x06, 0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x76, 0x47, 0x30, 0x45, 0x02,
48  0x21, 0x00, 0xAF, 0x1D, 0x17, 0xA2, 0x12, 0x7B, 0xA4, 0x6B, 0x40, 0xBD,
49  0x58, 0x76, 0x39, 0x3F, 0xF4, 0x49, 0x6B, 0x25, 0xA1, 0xAD, 0xB7, 0x36,
50  0xFB, 0x64, 0x4C, 0x05, 0x21, 0x0C, 0x43, 0x02, 0xE5, 0xEE, 0x02, 0x20,
51  0x26, 0x01, 0x7C, 0x5F, 0x69, 0xDA, 0xD1, 0xC3, 0x28, 0xED, 0x80, 0x05,
52  0x36, 0x86, 0x8B, 0x1B, 0x22, 0xE4, 0x8E, 0x09, 0x11, 0x52, 0x28, 0x5A,
53  0x48, 0x8F, 0x98, 0x7A, 0x5A, 0x10, 0x74, 0xCC};
54 
55  // Short public key:
56  static constexpr std::uint8_t payload2[] = {
57  0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26,
58  0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69,
59  0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40,
60  0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97,
61  0x50, 0x17, 0x21, 0x0B, 0xAB, 0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED,
62  0x1E, 0x07, 0xB4, 0xFB, 0xC5, 0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43,
63  0x35, 0x28, 0xEB, 0xD9, 0x06, 0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x73, 0x20,
64  0x02, 0x9D, 0x19, 0xFB, 0x09, 0x40, 0xE5, 0xC0, 0xD8, 0x58, 0x73, 0xFA,
65  0x71, 0x19, 0x99, 0x94, 0x4A, 0x68, 0x7D, 0x12, 0x9D, 0xA5, 0xC3, 0x3E,
66  0x92, 0x8C, 0x27, 0x51, 0xFC, 0x1B, 0x31, 0xEB, 0x76, 0x46, 0x30, 0x44,
67  0x02, 0x20, 0x34, 0x89, 0xA3, 0xBF, 0xA9, 0x97, 0x13, 0xBC, 0x87, 0x61,
68  0xC5, 0x2B, 0x7F, 0xAA, 0xE9, 0x31, 0x4C, 0xCD, 0x6F, 0x57, 0x68, 0x70,
69  0xC8, 0xDC, 0x58, 0x76, 0x91, 0x2F, 0x70, 0x2F, 0xD0, 0x78, 0x02, 0x20,
70  0x7E, 0x57, 0x9D, 0xCA, 0x11, 0xF1, 0x3B, 0xA0, 0x39, 0x38, 0x37, 0x40,
71  0xC5, 0xC8, 0xFE, 0xC1, 0xFC, 0xE9, 0xE7, 0x84, 0x6C, 0x2D, 0x47, 0x6E,
72  0xD7, 0xFF, 0x83, 0x9D, 0xEF, 0x7D, 0xF7, 0x6A};
73 
74  // Long public key:
75  static constexpr std::uint8_t payload3[] = {
76  0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26,
77  0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69,
78  0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40,
79  0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97,
80  0x50, 0x17, 0x21, 0x0B, 0xAB, 0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED,
81  0x1E, 0x07, 0xB4, 0xFB, 0xC5, 0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43,
82  0x35, 0x28, 0xEB, 0xD9, 0x06, 0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x73, 0x22,
83  0x02, 0x9D, 0x19, 0xFB, 0x09, 0x40, 0xE5, 0xC0, 0xD8, 0x58, 0x73, 0xFA,
84  0x71, 0x19, 0x99, 0x94, 0x4A, 0x68, 0x7D, 0x12, 0x9D, 0xA5, 0xC3, 0x3E,
85  0x92, 0x8C, 0x27, 0x51, 0xFC, 0x1B, 0x31, 0xEB, 0x32, 0x78, 0x76, 0x46,
86  0x30, 0x44, 0x02, 0x20, 0x3C, 0xAB, 0xEE, 0x36, 0xD8, 0xF3, 0x74, 0x5F,
87  0x50, 0x28, 0x66, 0x17, 0x57, 0x26, 0x6A, 0xBD, 0x9A, 0x19, 0x08, 0xAA,
88  0x65, 0x94, 0x0B, 0xDF, 0x24, 0x20, 0x44, 0x99, 0x05, 0x8C, 0xB7, 0x3D,
89  0x02, 0x20, 0x79, 0x66, 0xE6, 0xCC, 0xA2, 0x5E, 0x15, 0xFE, 0x18, 0x4B,
90  0xB2, 0xA8, 0x01, 0x3A, 0xD6, 0x63, 0x54, 0x08, 0x1B, 0xDA, 0xD0, 0x04,
91  0xEF, 0x4C, 0x73, 0xB3, 0xFF, 0xFE, 0xA9, 0x8E, 0x92, 0xE8};
92 
93  // Ed25519 public key:
94  static constexpr std::uint8_t payload4[] = {
95  0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26,
96  0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69,
97  0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40,
98  0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97,
99  0x50, 0x17, 0x21, 0x0B, 0xAB, 0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED,
100  0x1E, 0x07, 0xB4, 0xFB, 0xC5, 0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43,
101  0x35, 0x28, 0xEB, 0xD9, 0x06, 0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x73, 0x21,
102  0xED, 0x04, 0x8B, 0x9A, 0x31, 0x5E, 0xC7, 0x33, 0xC0, 0x15, 0x3B, 0x67,
103  0x04, 0x73, 0x7A, 0x91, 0x3D, 0xEF, 0x57, 0x1D, 0xAD, 0xEC, 0x57, 0xE5,
104  0x91, 0x5D, 0x55, 0xD9, 0x32, 0x9D, 0x45, 0x12, 0x85, 0x76, 0x40, 0x52,
105  0x07, 0xF9, 0x0D, 0x18, 0x2B, 0xB7, 0xAF, 0x5D, 0x43, 0xF8, 0xF9, 0xC5,
106  0xAD, 0xF9, 0xBA, 0x33, 0x23, 0xC0, 0x2F, 0x95, 0xFF, 0x36, 0x94, 0xD8,
107  0x99, 0x99, 0xE0, 0x66, 0xF8, 0xB6, 0x27, 0x22, 0xFD, 0x29, 0x39, 0x30,
108  0x39, 0xAB, 0x93, 0xDB, 0x9D, 0x2C, 0xE5, 0xF0, 0x4C, 0xB7, 0x30, 0xFD,
109  0xC7, 0xD3, 0x21, 0xC9, 0x4E, 0x0D, 0x8A, 0x1B, 0xB2, 0x89, 0x97, 0x10,
110  0x7E, 0x84, 0x09};
111 
112  // No ledger sequence:
113  static constexpr std::uint8_t payload5[] = {
114  0x22, 0x80, 0x00, 0x00, 0x01, 0x29, 0x26, 0x47, 0x31, 0x1A, 0x51, 0x53,
115  0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C,
116  0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39,
117  0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97, 0x50, 0x17, 0x21, 0x0B, 0xAB,
118  0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED, 0x1E, 0x07, 0xB4, 0xFB, 0xC5,
119  0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43, 0x35, 0x28, 0xEB, 0xD9, 0x06,
120  0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x73, 0x21, 0x02, 0x9D, 0x19, 0xFB, 0x09,
121  0x40, 0xE5, 0xC0, 0xD8, 0x58, 0x73, 0xFA, 0x71, 0x19, 0x99, 0x94, 0x4A,
122  0x68, 0x7D, 0x12, 0x9D, 0xA5, 0xC3, 0x3E, 0x92, 0x8C, 0x27, 0x51, 0xFC,
123  0x1B, 0x31, 0xEB, 0x32, 0x76, 0x47, 0x30, 0x45, 0x02, 0x21, 0x00, 0x83,
124  0xB3, 0x1B, 0xE9, 0x03, 0x8F, 0x4A, 0x92, 0x8B, 0x9B, 0x51, 0xEF, 0x79,
125  0xED, 0xA1, 0x4A, 0x58, 0x9B, 0x20, 0xCF, 0x89, 0xC4, 0x75, 0x99, 0x5F,
126  0x6D, 0x79, 0x51, 0x79, 0x07, 0xF9, 0x93, 0x02, 0x20, 0x39, 0xA6, 0x0C,
127  0x77, 0x68, 0x84, 0x50, 0xDB, 0xDA, 0x64, 0x32, 0x74, 0xEC, 0x63, 0x48,
128  0x48, 0x96, 0xB5, 0x94, 0x57, 0x55, 0x8D, 0x7D, 0xD8, 0x25, 0x78, 0xD1,
129  0xEA, 0x5F, 0xD9, 0xC7, 0xAA};
130 
131  // No sign time:
132  static constexpr std::uint8_t payload6[] = {
133  0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x51, 0x53,
134  0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69, 0x16, 0xF8, 0x3E, 0xEA, 0x5C,
135  0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40, 0x8C, 0xDE, 0xB8, 0x79, 0x39,
136  0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97, 0x50, 0x17, 0x21, 0x0B, 0xAB,
137  0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED, 0x1E, 0x07, 0xB4, 0xFB, 0xC5,
138  0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43, 0x35, 0x28, 0xEB, 0xD9, 0x06,
139  0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x73, 0x21, 0x02, 0x9D, 0x19, 0xFB, 0x09,
140  0x40, 0xE5, 0xC0, 0xD8, 0x58, 0x73, 0xFA, 0x71, 0x19, 0x99, 0x94, 0x4A,
141  0x68, 0x7D, 0x12, 0x9D, 0xA5, 0xC3, 0x3E, 0x92, 0x8C, 0x27, 0x51, 0xFC,
142  0x1B, 0x31, 0xEB, 0x32, 0x76, 0x47, 0x30, 0x45, 0x02, 0x21, 0x00, 0xDD,
143  0xB0, 0x59, 0x9A, 0x02, 0x3E, 0xF2, 0x44, 0xCE, 0x1D, 0xA8, 0x99, 0x06,
144  0xF3, 0x8A, 0x4B, 0xEB, 0x95, 0x42, 0x63, 0x6A, 0x6C, 0x04, 0x30, 0x7F,
145  0x62, 0x78, 0x3A, 0x89, 0xB0, 0x3F, 0x22, 0x02, 0x20, 0x4E, 0x6A, 0x55,
146  0x63, 0x8A, 0x19, 0xED, 0xFE, 0x70, 0x34, 0xD1, 0x30, 0xED, 0x7C, 0xAF,
147  0xB2, 0x78, 0xBB, 0x15, 0x6C, 0x42, 0x3E, 0x19, 0x5D, 0xEA, 0xC5, 0x5E,
148  0x23, 0xE2, 0x14, 0x80, 0x54};
149 
150  // No signature field:
151  static constexpr std::uint8_t payload7[] = {
152  0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26,
153  0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69,
154  0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40,
155  0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97,
156  0x50, 0x17, 0x21, 0x0B, 0xAB, 0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED,
157  0x1E, 0x07, 0xB4, 0xFB, 0xC5, 0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43,
158  0x35, 0x28, 0xEB, 0xD9, 0x06, 0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x73, 0x21,
159  0x02, 0x9D, 0x19, 0xFB, 0x09, 0x40, 0xE5, 0xC0, 0xD8, 0x58, 0x73, 0xFA,
160  0x71, 0x19, 0x99, 0x94, 0x4A, 0x68, 0x7D, 0x12, 0x9D, 0xA5, 0xC3, 0x3E,
161  0x92, 0x8C, 0x27, 0x51, 0xFC, 0x1B, 0x31, 0xEB, 0x32};
162 
163  // Good:
164  static constexpr std::uint8_t payload8[] = {
165  0x22, 0x80, 0x00, 0x00, 0x01, 0x26, 0x03, 0x4B, 0xEA, 0x97, 0x29, 0x26,
166  0x47, 0x31, 0x1A, 0x51, 0x53, 0x1F, 0x1A, 0x4E, 0xBB, 0x43, 0x19, 0x69,
167  0x16, 0xF8, 0x3E, 0xEA, 0x5C, 0x77, 0x94, 0x08, 0x19, 0x0B, 0x4B, 0x40,
168  0x8C, 0xDE, 0xB8, 0x79, 0x39, 0xF3, 0x9D, 0x66, 0x7B, 0x12, 0xCA, 0x97,
169  0x50, 0x17, 0x21, 0x0B, 0xAB, 0xBC, 0x8C, 0xB7, 0xFB, 0x45, 0x49, 0xED,
170  0x1E, 0x07, 0xB4, 0xFB, 0xC5, 0xF2, 0xFB, 0x67, 0x2D, 0x18, 0xA6, 0x43,
171  0x35, 0x28, 0xEB, 0xD9, 0x06, 0x3E, 0xB3, 0x8B, 0xC2, 0xE0, 0x73, 0x21,
172  0x02, 0x9D, 0x19, 0xFB, 0x09, 0x40, 0xE5, 0xC0, 0xD8, 0x58, 0x73, 0xFA,
173  0x71, 0x19, 0x99, 0x94, 0x4A, 0x68, 0x7D, 0x12, 0x9D, 0xA5, 0xC3, 0x3E,
174  0x92, 0x8C, 0x27, 0x51, 0xFC, 0x1B, 0x31, 0xEB, 0x32, 0x76, 0x47, 0x30,
175  0x45, 0x02, 0x21, 0x00, 0xDD, 0x29, 0xDC, 0xAC, 0x82, 0x5E, 0xF9, 0xE2,
176  0x2D, 0x26, 0x03, 0x95, 0xC2, 0x11, 0x3A, 0x2A, 0x83, 0xEE, 0xA0, 0x2B,
177  0x9F, 0x2A, 0x51, 0xBD, 0x6B, 0xF7, 0x83, 0xCE, 0x4A, 0x7C, 0x52, 0x29,
178  0x02, 0x20, 0x52, 0x45, 0xB9, 0x07, 0x57, 0xEF, 0xB2, 0x6C, 0x69, 0xC5,
179  0x47, 0xCA, 0xE2, 0x76, 0x00, 0xFC, 0x35, 0x46, 0x5D, 0x19, 0x64, 0xCE,
180  0xCA, 0x88, 0xA1, 0x2A, 0x20, 0xCF, 0x3C, 0xF9, 0xCE, 0xCF};
181 
182 public:
183  void
184  testDeserialization()
185  {
186  testcase("Deserialization");
187 
188  try
189  {
190  SerialIter sit{payload8};
191 
192  auto val = std::make_shared<STValidation>(
193  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, true);
194 
195  BEAST_EXPECT(val);
196  BEAST_EXPECT(val->isFieldPresent(sfLedgerSequence));
197  BEAST_EXPECT(val->isFieldPresent(sfSigningPubKey));
198  BEAST_EXPECT(val->isFieldPresent(sfSigningTime));
199  BEAST_EXPECT(val->isFieldPresent(sfFlags));
200  BEAST_EXPECT(val->isFieldPresent(sfLedgerHash));
201  BEAST_EXPECT(val->isFieldPresent(sfSignature));
202  }
203  catch (std::exception const& ex)
204  {
205  fail(std::string("Unexpected exception thrown: ") + ex.what());
206  }
207 
208  testcase("Deserialization: Public Key Tests");
209 
210  try
211  {
212  SerialIter sit{payload1};
213  auto val = std::make_shared<ripple::STValidation>(
214  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false);
215  fail("An exception should have been thrown");
216  }
217  catch (std::exception const& ex)
218  {
219  BEAST_EXPECT(
220  strcmp(
221  ex.what(),
222  "Field 'SigningPubKey' is required but missing.") == 0);
223  }
224 
225  try
226  {
227  SerialIter sit{payload2};
228  auto val = std::make_shared<ripple::STValidation>(
229  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false);
230  fail("An exception should have been thrown");
231  }
232  catch (std::exception const& ex)
233  {
234  BEAST_EXPECT(
235  strcmp(ex.what(), "Invalid public key in validation") == 0);
236  }
237 
238  try
239  {
240  SerialIter sit{payload3};
241  auto val = std::make_shared<ripple::STValidation>(
242  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false);
243  fail("An exception should have been thrown");
244  }
245  catch (std::exception const& ex)
246  {
247  BEAST_EXPECT(
248  strcmp(ex.what(), "Invalid public key in validation") == 0);
249  }
250 
251  try
252  {
253  SerialIter sit{payload4};
254  auto val = std::make_shared<ripple::STValidation>(
255  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false);
256  fail("An exception should have been thrown");
257  }
258  catch (std::exception const& ex)
259  {
260  BEAST_EXPECT(
261  strcmp(ex.what(), "Invalid public key in validation") == 0);
262  }
263 
264  testcase("Deserialization: Missing Fields");
265 
266  try
267  {
268  SerialIter sit{payload5};
269  auto val = std::make_shared<STValidation>(
270  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false);
271  fail("Expected exception not thrown from validation");
272  }
273  catch (std::exception const& ex)
274  {
275  BEAST_EXPECT(
276  strcmp(
277  ex.what(),
278  "Field 'LedgerSequence' is required but missing.") == 0);
279  }
280 
281  try
282  {
283  SerialIter sit{payload6};
284  auto val = std::make_shared<STValidation>(
285  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false);
286  fail("Expected exception not thrown from validation");
287  }
288  catch (std::exception const& ex)
289  {
290  BEAST_EXPECT(
291  strcmp(
292  ex.what(),
293  "Field 'SigningTime' is required but missing.") == 0);
294  }
295 
296  try
297  {
298  SerialIter sit{payload7};
299 
300  auto val = std::make_shared<STValidation>(
301  sit, [](PublicKey const& pk) { return calcNodeID(pk); }, false);
302 
303  fail("Expected exception not thrown from validation");
304  }
305  catch (std::exception const& ex)
306  {
307  BEAST_EXPECT(
308  strcmp(
309  ex.what(), "Field 'Signature' is required but missing.") ==
310  0);
311  }
312 
313  testcase("Deserialization: Corrupted Data / Fuzzing");
314 
315  // Mutate a known-good validation and expect it to fail:
316  std::vector<std::uint8_t> v;
317  for (auto c : payload8)
318  v.push_back(c);
319 
320  beast::xor_shift_engine g(148979842);
321 
322  for (std::size_t i = 0; i != v.size(); ++i)
323  {
324  auto v2 = v;
325 
326  while (v2[i] == v[i])
327  v2[i] = rand_byte<std::uint8_t>(g);
328 
329  try
330  {
331  SerialIter sit{makeSlice(v2)};
332 
333  auto val = std::make_shared<STValidation>(
334  sit,
335  [](PublicKey const& pk) { return calcNodeID(pk); },
336  true);
337 
338  fail(
339  "Mutated validation signature checked out: offset=" +
340  std::to_string(i));
341  }
342  catch (std::exception const&)
343  {
344  pass();
345  }
346  }
347  }
348 
349  void
350  run() override
351  {
352  testDeserialization();
353  }
354 };
355 
356 BEAST_DEFINE_TESTSUITE(STValidation, protocol, ripple);
357 
358 } // namespace ripple
ripple::makeSlice
std::enable_if_t< std::is_same< T, char >::value||std::is_same< T, unsigned char >::value, Slice > makeSlice(std::array< T, N > const &a)
Definition: Slice.h:241
ripple::STValidation_test::payload8
static constexpr std::uint8_t payload8[]
Definition: STValidation_test.cpp:164
ripple::STValidation_test::testDeserialization
void testDeserialization()
Definition: STValidation_test.cpp:184
std::string
STL class.
ripple::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, ripple)
std::exception
STL class.
ripple::calcNodeID
NodeID calcNodeID(PublicKey const &pk)
Calculate the 160-bit node ID from a node public key.
Definition: PublicKey.cpp:303
ripple::sfLedgerSequence
const SF_UINT32 sfLedgerSequence
ripple::STValidation_test::payload4
static constexpr std::uint8_t payload4[]
Definition: STValidation_test.cpp:94
std::vector
STL class.
std::vector::size
T size(T... args)
ripple::sfSigningPubKey
const SF_VL sfSigningPubKey
ripple::STValidation_test
Definition: STValidation_test.cpp:36
ripple::STValidation_test::payload7
static constexpr std::uint8_t payload7[]
Definition: STValidation_test.cpp:151
std::vector::push_back
T push_back(T... args)
ripple::PublicKey
A public key.
Definition: PublicKey.h:59
ripple::sfLedgerHash
const SF_UINT256 sfLedgerHash
std::to_string
T to_string(T... args)
ripple::SerialIter
Definition: Serializer.h:310
std::uint8_t
ripple::STValidation_test::payload2
static constexpr std::uint8_t payload2[]
Definition: STValidation_test.cpp:56
memory
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
protocol
Definition: ValidatorList.h:38
ripple::STValidation_test::payload3
static constexpr std::uint8_t payload3[]
Definition: STValidation_test.cpp:75
ripple::STValidation_test::payload6
static constexpr std::uint8_t payload6[]
Definition: STValidation_test.cpp:132
ripple::sfFlags
const SF_UINT32 sfFlags
ripple::sfSignature
const SF_VL sfSignature
ripple::STValidation_test::run
void run() override
Definition: STValidation_test.cpp:350
std::size_t
beast::detail::xor_shift_engine
Definition: xor_shift_engine.h:32
ripple::STValidation_test::payload5
static constexpr std::uint8_t payload5[]
Definition: STValidation_test.cpp:113
ripple::STValidation_test::payload1
static constexpr std::uint8_t payload1[]
Definition: STValidation_test.cpp:39
ripple::sfSigningTime
const SF_UINT32 sfSigningTime
type_traits
std::exception::what
T what(T... args)
Generated by   doxygen 1.8.17