1
=== modified file 'src/cookie/authority.cpp'
2
--- src/cookie/authority.cpp	2016-01-29 08:18:22 +0000
3
+++ src/cookie/authority.cpp	2016-02-26 07:35:45 +0000
4
@@ -41,9 +41,6 @@
5
41
41
6
42
namespace
42
namespace
7
43
{
43
{
8
44
std::string const random_device_path{"/dev/random"};
9
45
std::string const urandom_device_path{"/dev/urandom"};
10
46
uint32_t const wait_seconds{30};
11
47
uint32_t const mac_byte_size{20};
44
uint32_t const mac_byte_size{20};
12
48
45
13
49
size_t cookie_size_from_format(mir::cookie::Format const& format)
46
size_t cookie_size_from_format(mir::cookie::Format const& format)
14
@@ -62,55 +59,19 @@
15
62
59
16
63
static mir::cookie::Secret get_random_data(unsigned size)
60
static mir::cookie::Secret get_random_data(unsigned size)
17
64
{
61
{
18
62
    int fd = open("/dev/urandom", O_RDONLY);
19
63
    if (fd < 0)
20
64
        BOOST_THROW_EXCEPTION(std::system_error(errno, std::system_category(),
21
65
                                                "open failed on urandom"));
22
66
23
65
    mir::cookie::Secret buffer(size);
67
    mir::cookie::Secret buffer(size);
72
66
    int random_fd;
68
    auto got = read(fd, buffer.data(), size);
73
67
    int retval;
69
    int error = errno;
74
68
    fd_set rfds;
70
    close(fd);
75
69
71
    
76
70
    struct timeval tv;
72
    if (got != size)
77
71
    tv.tv_sec  = wait_seconds;
73
        BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
78
72
    tv.tv_usec = 0;
74
                                                "read failed on urandom"));
31
73
32
74
    if ((random_fd = open(random_device_path.c_str(), O_RDONLY)) == -1)
33
75
    {
34
76
        int error = errno;
35
77
        BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
36
78
                                                "open failed on device " + random_device_path));
37
79
    }
38
80
39
81
    FD_ZERO(&rfds);
40
82
    FD_SET(random_fd, &rfds);
41
83
42
84
    /* We want to block until *some* entropy exists on boot, then use urandom once we have some */
43
85
    retval = select(random_fd + 1, &rfds, NULL, NULL, &tv);
44
86
45
87
    /* We are done with /dev/random at this point, and it is either an error or ready to be read */
46
88
    if (close(random_fd) == -1)
47
89
    {
48
90
        int error = errno;
49
91
        BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
50
92
                                                "close failed on device " + random_device_path));
51
93
    }
52
94
53
95
    if (retval == -1)
54
96
    {
55
97
        int error = errno;
56
98
        BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
57
99
                                                "select failed on file descriptor " + std::to_string(random_fd) +
58
100
                                                " from device " + random_device_path));
59
101
    }
60
102
    else if (retval && FD_ISSET(random_fd, &rfds))
61
103
    {
62
104
        std::uniform_int_distribution<uint8_t> dist;
63
105
        std::random_device rand_dev(urandom_device_path);
64
106
65
107
        std::generate(std::begin(buffer), std::end(buffer), [&]() { return dist(rand_dev); });
66
108
    }
67
109
    else
68
110
    {
69
111
        BOOST_THROW_EXCEPTION(std::runtime_error("Failed to read from device: " + random_device_path +
70
112
                                                 " after: " + std::to_string(wait_seconds) + " seconds"));
71
113
    }
79
114
75
80
115
    return buffer;
76
    return buffer;
81
116
}
77
}
82
117
78
83
=== modified file 'tests/acceptance-tests/test_server_startup.cpp'
84
--- tests/acceptance-tests/test_server_startup.cpp	2016-02-26 03:37:46 +0000
85
+++ tests/acceptance-tests/test_server_startup.cpp	2016-02-26 07:35:45 +0000
86
@@ -68,7 +68,7 @@
87
68
        });
68
        });
88
69
}
69
}
89
70
70
91
71
TEST(ServerStartupReliability, DISABLED_can_start_with_low_entropy)
71
TEST(ServerStartupReliability, can_start_with_low_entropy)
92
72
{   // Regression test for LP: #1536662 and LP: #1541188
72
{   // Regression test for LP: #1536662 and LP: #1541188
93
73
    using namespace ::testing;
73
    using namespace ::testing;
94
74
74
95
75
75
96
=== modified file 'tests/unit-tests/test_mir_cookie.cpp'
97
--- tests/unit-tests/test_mir_cookie.cpp	2016-02-26 03:37:46 +0000
98
+++ tests/unit-tests/test_mir_cookie.cpp	2016-02-26 07:35:45 +0000
99
@@ -119,7 +119,7 @@
100
119
        Ge(mir::cookie::Authority::minimum_secret_size));
119
        Ge(mir::cookie::Authority::minimum_secret_size));
101
120
}
120
}
102
121
121
104
122
TEST(MirCookieAuthority, DISABLED_given_low_entropy_does_not_hang_or_crash)
122
TEST(MirCookieAuthority, given_low_entropy_does_not_hang_or_crash)
105
123
{   // Regression test for LP: #1536662 and LP: #1541188
123
{   // Regression test for LP: #1536662 and LP: #1541188
106
124
    using namespace testing;
124
    using namespace testing;
107
125
125
Reviewer	Review Type	Date Requested	Status
Chris Halse Rogers			Disapprove on 2016-02-29
Brandon Schaefer (community)			Disapprove on 2016-02-26
Alan Griffiths			Disapprove on 2016-02-26
Alexandros Frantzis (community)		2016-02-26	Approve on 2016-02-26
Mir CI Bot	continuous-integration		Needs Fixing on 2016-02-26
Review via email: mp+287266@code.launchpad.net
1	=== modified file 'src/cookie/authority.cpp'
2	--- src/cookie/authority.cpp 2016-01-29 08:18:22 +0000
3	+++ src/cookie/authority.cpp 2016-02-26 07:35:45 +0000
4	@@ -41,9 +41,6 @@
5	41		41
6	42	namespace	42	namespace
7	43	{	43	{
8	44	std::string const random_device_path{"/dev/random"};
9	45	std::string const urandom_device_path{"/dev/urandom"};
10	46	uint32_t const wait_seconds{30};
11	47	uint32_t const mac_byte_size{20};	44	uint32_t const mac_byte_size{20};
12	48		45
13	49	size_t cookie_size_from_format(mir::cookie::Format const& format)	46	size_t cookie_size_from_format(mir::cookie::Format const& format)
14	@@ -62,55 +59,19 @@
15	62		59
16	63	static mir::cookie::Secret get_random_data(unsigned size)	60	static mir::cookie::Secret get_random_data(unsigned size)
17	64	{	61	{
18			62	int fd = open("/dev/urandom", O_RDONLY);
19			63	if (fd < 0)
20			64	BOOST_THROW_EXCEPTION(std::system_error(errno, std::system_category(),
21			65	"open failed on urandom"));
22			66
23	65	mir::cookie::Secret buffer(size);	67	mir::cookie::Secret buffer(size);
72	66	int random_fd;	68	auto got = read(fd, buffer.data(), size);
73	67	int retval;	69	int error = errno;
74	68	fd_set rfds;	70	close(fd);
75	69		71
76	70	struct timeval tv;	72	if (got != size)
77	71	tv.tv_sec = wait_seconds;	73	BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
78	72	tv.tv_usec = 0;	74	"read failed on urandom"));
31	73
32	74	if ((random_fd = open(random_device_path.c_str(), O_RDONLY)) == -1)
33	75	{
34	76	int error = errno;
35	77	BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
36	78	"open failed on device " + random_device_path));
37	79	}
38	80
39	81	FD_ZERO(&rfds);
40	82	FD_SET(random_fd, &rfds);
41	83
42	84	/* We want to block until some entropy exists on boot, then use urandom once we have some */
43	85	retval = select(random_fd + 1, &rfds, NULL, NULL, &tv);
44	86
45	87	/* We are done with /dev/random at this point, and it is either an error or ready to be read */
46	88	if (close(random_fd) == -1)
47	89	{
48	90	int error = errno;
49	91	BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
50	92	"close failed on device " + random_device_path));
51	93	}
52	94
53	95	if (retval == -1)
54	96	{
55	97	int error = errno;
56	98	BOOST_THROW_EXCEPTION(std::system_error(error, std::system_category(),
57	99	"select failed on file descriptor " + std::to_string(random_fd) +
58	100	" from device " + random_device_path));
59	101	}
60	102	else if (retval && FD_ISSET(random_fd, &rfds))
61	103	{
62	104	std::uniform_int_distribution<uint8_t> dist;
63	105	std::random_device rand_dev(urandom_device_path);
64	106
65	107	std::generate(std::begin(buffer), std::end(buffer), [&]() { return dist(rand_dev); });
66	108	}
67	109	else
68	110	{
69	111	BOOST_THROW_EXCEPTION(std::runtime_error("Failed to read from device: " + random_device_path +
70	112	" after: " + std::to_string(wait_seconds) + " seconds"));
71	113	}
79	114		75
80	115	return buffer;	76	return buffer;
81	116	}	77	}
82	117		78
83	=== modified file 'tests/acceptance-tests/test_server_startup.cpp'
84	--- tests/acceptance-tests/test_server_startup.cpp 2016-02-26 03:37:46 +0000
85	+++ tests/acceptance-tests/test_server_startup.cpp 2016-02-26 07:35:45 +0000
86	@@ -68,7 +68,7 @@
87	68	});	68	});
88	69	}	69	}
89	70		70
91	71	TEST(ServerStartupReliability, DISABLED_can_start_with_low_entropy)	71	TEST(ServerStartupReliability, can_start_with_low_entropy)
92	72	{ // Regression test for LP: #1536662 and LP: #1541188	72	{ // Regression test for LP: #1536662 and LP: #1541188
93	73	using namespace ::testing;	73	using namespace ::testing;
94	74		74
95	75		75
96	=== modified file 'tests/unit-tests/test_mir_cookie.cpp'
97	--- tests/unit-tests/test_mir_cookie.cpp 2016-02-26 03:37:46 +0000
98	+++ tests/unit-tests/test_mir_cookie.cpp 2016-02-26 07:35:45 +0000
99	@@ -119,7 +119,7 @@
100	119	Ge(mir::cookie::Authority::minimum_secret_size));	119	Ge(mir::cookie::Authority::minimum_secret_size));
101	120	}	120	}
102	121		121
104	122	TEST(MirCookieAuthority, DISABLED_given_low_entropy_does_not_hang_or_crash)	122	TEST(MirCookieAuthority, given_low_entropy_does_not_hang_or_crash)
105	123	{ // Regression test for LP: #1536662 and LP: #1541188	123	{ // Regression test for LP: #1536662 and LP: #1541188
106	124	using namespace testing;	124	using namespace testing;
107	125		125