← Back to branch summary

~ubuntu-branches/ubuntu/vivid/sslh/vivid-proposed

« back to all changes in this revision

Viewing changes to .pc/disable_ip_freebind_test.diff/t

  • Committer: Package Import Robot
  • Author(s): Guillaume Delacour
  • Date: 2014-08-07 00:06:06 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20140807000606-y1tg7j8i5t7d4drr
Tags: 1.16-1
http://bugs.debian.org/740560
* New upstream release: fix some startup problem when interfaces are not
  ready at boot time (IP_FREEBIND support when available) and can use libcap
  for transparent mode
* Enable libcap and libwrap support at build time
* Enable dpkg-buildflags: Drop hardening-wrapper Build-Depends and use
  DEB_BUILD_HARDENING instead of DEB_BUILD_MAINT_OPTIONS
* Remove old .gitignore as upstream has one too
* debian/sslh.tmpfile: Create /run/sslh for systemd as root because sslh
  write its pid before dropping privileges (Closes: #740560)
* debian/patches/disable_ip_freebind_test.diff: Remove "Can't bind address"
  upstream test because IP_FREEBIND is now enabled upstream
* debian/docs: upstream README is now README.md
* debian/rules:
  + use DESTDIR in addition of PREFIX as upstream change Makefile
* Refresh debian/patches/disable_valgrind_launch.diff due to upstream
  changes
* Stop service in case of purge (to be able to remove the user too)
* Use DEB_BUILD_OPTIONS to speed the build
* debian/patches/fixed_version.diff: Fix the version of binaries based on
  debian/changelog (instead of relying on git)
* Update Description as sslh is not only a ssl/ssh multiplexer but a
  protocol multiplexer

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/disable_ip_freebind_test.diff/t
 
1
#! /usr/bin/perl -w
 
2
 
 
3
# Test script for sslh
 
4
 
 
5
use strict;
 
6
use IO::Socket::INET6;
 
7
use Test::More qw/no_plan/;
 
8
 
 
9
# We use ports 9000, 9001 and 9002 -- hope that won't clash
 
10
# with anything...
 
11
my $ssh_address = "::1:9000";
 
12
my $ssl_address = "::1:9001";
 
13
my $sslh_port = 9002;
 
14
my $no_listen = 9003;  # Port on which no-one listens
 
15
my $pidfile = "/tmp/sslh_test.pid";
 
16
 
 
17
# Which tests do we run
 
18
my $SSL_CNX =           1;
 
19
my $SSH_SHY_CNX =       1;
 
20
my $SSH_BOLD_CNX =      1;
 
21
my $SSH_PROBE_AGAIN =   1;
 
22
my $SSL_MIX_SSH =       1;
 
23
my $SSH_MIX_SSL =       1;
 
24
my $BIG_MSG =           0; # This test is unreliable
 
25
my $STALL_CNX =         0; # This test needs fixing
 
26
 
 
27
# Robustness tests. These are mostly to achieve full test
 
28
# coverage, but do not necessarily result in an actual test
 
29
# (e.g. some tests need to be run with valgrind to check all
 
30
# memory management code).
 
31
my $RB_CNX_NOSERVER =           1;
 
32
my $RB_PARAM_NOHOST =           1;
 
33
my $RB_WRONG_USERNAME =         1;
 
34
my $RB_OPEN_PID_FILE =          1;
 
35
my $RB_BIND_ADDRESS =           1;
 
36
my $RB_RESOLVE_ADDRESS =        1;
 
37
 
 
38
`lcov --directory . --zerocounters`;
 
39
 
 
40
 
 
41
my ($ssh_pid, $ssl_pid);
 
42
 
 
43
if (!($ssh_pid = fork)) {
 
44
    exec "./echosrv --listen $ssh_address --prefix 'ssh: '";
 
45
}
 
46
 
 
47
if (!($ssl_pid = fork)) {
 
48
    exec "./echosrv --listen $ssl_address --prefix 'ssl: '";
 
49
}
 
50
 
 
51
my @binaries = ('sslh-select', 'sslh-fork');
 
52
for my $binary (@binaries) {
 
53
    warn "Testing $binary\n";
 
54
 
 
55
# Start sslh with the right plumbing
 
56
    my $sslh_pid;
 
57
    if (!($sslh_pid = fork)) {
 
58
        my $user = (getpwuid $<)[0]; # Run under current username
 
59
        my $cmd = "./$binary -v -f -u $user --listen localhost:$sslh_port --ssh $ssh_address --ssl $ssl_address -P $pidfile";
 
60
        warn "$cmd\n";
 
61
        exec $cmd;
 
62
        exit 0;
 
63
    }
 
64
    warn "spawned $sslh_pid\n";
 
65
    sleep 5;  # valgrind can be heavy -- wait 5 seconds
 
66
 
 
67
 
 
68
    my $test_data = "hello world\n";
 
69
#    my $ssl_test_data = (pack 'n', ((length $test_data) + 2)) .  $test_data;
 
70
    my $ssl_test_data = "\x16\x03\x03$test_data\n";
 
71
 
 
72
# Test: SSL connection
 
73
    if ($SSL_CNX) {
 
74
        print "***Test: SSL connection\n";
 
75
        my $cnx_l = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
76
        warn "$!\n" unless $cnx_l;
 
77
        if (defined $cnx_l) {
 
78
            print $cnx_l $ssl_test_data;
 
79
            my $data;
 
80
            my $n = sysread $cnx_l, $data, 1024;
 
81
            is($data, "ssl: $ssl_test_data", "SSL connection");
 
82
        }
 
83
    }
 
84
 
 
85
# Test: Shy SSH connection
 
86
    if ($SSH_SHY_CNX) {
 
87
        print "***Test: Shy SSH connection\n";
 
88
        my $cnx_h = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
89
        warn "$!\n" unless $cnx_h;
 
90
        if (defined $cnx_h) {
 
91
            sleep 3;
 
92
            print $cnx_h $test_data;
 
93
            my $data = <$cnx_h>;
 
94
            is($data, "ssh: $test_data", "Shy SSH connection");
 
95
        }
 
96
    }
 
97
 
 
98
# Test: Bold SSH connection
 
99
    if ($SSH_BOLD_CNX) {
 
100
        print "***Test: Bold SSH connection\n";
 
101
        my $cnx_h = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
102
        warn "$!\n" unless $cnx_h;
 
103
        if (defined $cnx_h) {
 
104
            my $td = "SSH-2.0 testsuite\t$test_data";
 
105
            print $cnx_h $td;
 
106
            my $data = <$cnx_h>;
 
107
            is($data, "ssh: $td", "Bold SSH connection");
 
108
        }
 
109
    }
 
110
 
 
111
# Test: PROBE_AGAIN, incomplete first frame
 
112
    if ($SSH_PROBE_AGAIN) {
 
113
        print "***Test: incomplete SSH first frame\n";
 
114
        my $cnx_h = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
115
        warn "$!\n" unless $cnx_h;
 
116
        if (defined $cnx_h) {
 
117
            my $td = "SSH-2.0 testsuite\t$test_data";
 
118
            print $cnx_h substr $td, 0, 2;
 
119
            sleep 1;
 
120
            print $cnx_h substr $td, 2;
 
121
            my $data = <$cnx_h>;
 
122
            is($data, "ssh: $td", "Incomplete first SSH frame");
 
123
        }
 
124
    }
 
125
 
 
126
 
 
127
# Test: One SSL half-started then one SSH
 
128
    if ($SSL_MIX_SSH) {
 
129
        print "***Test: One SSL half-started then one SSH\n";
 
130
        my $cnx_l = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
131
        warn "$!\n" unless $cnx_l;
 
132
        if (defined $cnx_l) {
 
133
            print $cnx_l $ssl_test_data;
 
134
            my $cnx_h= new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
135
            warn "$!\n" unless $cnx_h;
 
136
            if (defined $cnx_h) {
 
137
                sleep 3;
 
138
                print $cnx_h $test_data;
 
139
                my $data_h = <$cnx_h>;
 
140
                is($data_h, "ssh: $test_data", "SSH during SSL being established");
 
141
            }
 
142
            my $data;
 
143
            my $n = sysread $cnx_l, $data, 1024;
 
144
            is($data, "ssl: $ssl_test_data", "SSL connection interrupted by SSH");
 
145
        }
 
146
    }
 
147
 
 
148
# Test: One SSH half-started then one SSL
 
149
    if ($SSH_MIX_SSL) {
 
150
        print "***Test: One SSH half-started then one SSL\n";
 
151
        my $cnx_h = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
152
        warn "$!\n" unless $cnx_h;
 
153
        if (defined $cnx_h) {
 
154
            sleep 3;
 
155
            my $cnx_l = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
156
            warn "$!\n" unless $cnx_l;
 
157
            if (defined $cnx_l) {
 
158
                print $cnx_l $ssl_test_data;
 
159
                my $data;
 
160
                my $n = sysread $cnx_l, $data, 1024;
 
161
                is($data, "ssl: $ssl_test_data", "SSL during SSH being established");
 
162
            }
 
163
            print $cnx_h $test_data;
 
164
            my $data = <$cnx_h>;
 
165
            is($data, "ssh: $test_data", "SSH connection interrupted by SSL");
 
166
        }
 
167
    }
 
168
 
 
169
 
 
170
# Test: Big messages (careful: don't go over echosrv's buffer limit (1M))
 
171
    if ($BIG_MSG) {
 
172
        print "***Test: big message\n";
 
173
        my $cnx_l = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
174
        warn "$!\n" unless $cnx_l;
 
175
        my $rept = 1000;
 
176
        my $test_data2 = $ssl_test_data . ("helloworld"x$rept);
 
177
        if (defined $cnx_l) {
 
178
            my $n = syswrite $cnx_l, $test_data2;
 
179
            my ($data);
 
180
            $n = sysread $cnx_l, $data, 1 << 20;
 
181
            is($data, "ssl: ". $test_data2, "Big message");
 
182
        }
 
183
    }
 
184
 
 
185
# Test: Stalled connection
 
186
# Create two connections, stall one, check the other one
 
187
# works, unstall first and check it works fine
 
188
# This test needs fixing.
 
189
# Now that echosrv no longer works on "lines" (finishing
 
190
# with '\n'), it may cut blocks randomly with prefixes.
 
191
# The whole thing needs to be re-thought as it'll only
 
192
# work by chance.
 
193
    if ($STALL_CNX) {
 
194
        print "***Test: Stalled connection\n";
 
195
        my $cnx_1 = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
196
        warn "$!\n" unless defined $cnx_1;
 
197
        my $cnx_2 = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
198
        warn "$!\n" unless defined $cnx_2;
 
199
        my $test_data2 = "helloworld";
 
200
        sleep 4;
 
201
        my $rept = 1000;
 
202
        if (defined $cnx_1 and defined $cnx_2) {
 
203
            print $cnx_1 ($test_data2 x $rept);
 
204
            print $cnx_1 "\n";
 
205
            print $cnx_2 ($test_data2 x $rept);
 
206
            print $cnx_2 "\n";
 
207
            my $data = <$cnx_2>;
 
208
            is($data, "ssh: " . ($test_data2 x $rept) . "\n", "Stalled connection (1)");
 
209
            print $cnx_2 ($test_data2 x $rept);
 
210
            print $cnx_2 "\n";
 
211
            $data = <$cnx_2>;
 
212
            is($data, "ssh: " . ($test_data2 x $rept) . "\n", "Stalled connection (2)");
 
213
            $data = <$cnx_1>;
 
214
            is($data, "ssh: " . ($test_data2 x $rept) . "\n", "Stalled connection (3)");
 
215
 
 
216
        }
 
217
    }
 
218
 
 
219
    my $pid = `cat $pidfile`;
 
220
    warn "killing $pid\n";
 
221
    kill TERM => $pid or warn "kill process: $!\n";
 
222
    sleep 1;
 
223
}
 
224
 
 
225
# Robustness: Connecting to non-existant server
 
226
if ($RB_CNX_NOSERVER) {
 
227
    print "***Test: Connecting to non-existant server\n";
 
228
    my $sslh_pid;
 
229
    if (!($sslh_pid = fork)) {
 
230
        my $user = (getpwuid $<)[0]; # Run under current username
 
231
        exec "./sslh-select -v -f -u $user --listen localhost:$sslh_port --ssh localhost:$no_listen --ssl localhost:$no_listen -P $pidfile";
 
232
    }
 
233
    warn "spawned $sslh_pid\n";
 
234
 
 
235
    sleep 1;
 
236
 
 
237
    my $cnx_h = new IO::Socket::INET(PeerHost => "localhost:$sslh_port");
 
238
    warn "$!\n" unless $cnx_h;
 
239
    if (defined $cnx_h) {
 
240
        sleep 1;
 
241
        my $test_data = "hello";
 
242
        print $cnx_h $test_data;
 
243
    }
 
244
    # Ideally we should check a log is emitted.
 
245
 
 
246
    kill TERM => `cat $pidfile` or warn "kill: $!\n";
 
247
    sleep 1;
 
248
}
 
249
 
 
250
 
 
251
# Robustness: No hostname in address
 
252
if ($RB_PARAM_NOHOST) {
 
253
    print "***Test: No hostname in address\n";
 
254
    my $sslh_pid;
 
255
    if (!($sslh_pid = fork)) {
 
256
        my $user = (getpwuid $<)[0]; # Run under current username
 
257
        exec "./sslh-select -v -f -u $user --listen $sslh_port --ssh $ssh_address --ssl $ssl_address -P $pidfile";
 
258
    }
 
259
    warn "spawned $sslh_pid\n";
 
260
    waitpid $sslh_pid, 0;
 
261
    my $code = $? >> 8;
 
262
    warn "exited with $code\n";
 
263
    is($code, 1, "Exit status on illegal option");
 
264
}
 
265
 
 
266
# Robustness: User does not exist
 
267
if ($RB_WRONG_USERNAME) {
 
268
    print "***Test: Changing to non-existant username\n";
 
269
    my $sslh_pid;
 
270
    if (!($sslh_pid = fork)) {
 
271
        my $user = (getpwuid $<)[0]; # Run under current username
 
272
        exec "./sslh-select -v -f -u ${user}_doesnt_exist --listen localhost:$sslh_port --ssh $ssh_address --ssl $ssl_address -P $pidfile";
 
273
    }
 
274
    warn "spawned $sslh_pid\n";
 
275
    waitpid $sslh_pid, 0;
 
276
    my $code = $? >> 8;
 
277
    warn "exited with $code\n";
 
278
    is($code, 2, "Exit status on non-existant username");
 
279
}
 
280
 
 
281
# Robustness: Can't open PID file
 
282
if ($RB_OPEN_PID_FILE) {
 
283
    print "***Test: Can't open PID file\n";
 
284
    my $sslh_pid;
 
285
    if (!($sslh_pid = fork)) {
 
286
        my $user = (getpwuid $<)[0]; # Run under current username
 
287
        exec "./sslh-select -v -f -u $user --listen localhost:$sslh_port --ssh $ssh_address --ssl $ssl_address -P /dont_exist/$pidfile";
 
288
        # You don't have a /dont_exist/ directory, do you?!
 
289
    }
 
290
    warn "spawned $sslh_pid\n";
 
291
    waitpid $sslh_pid, 0;
 
292
    my $code = $? >> 8;
 
293
    warn "exited with $code\n";
 
294
    is($code, 3, "Exit status if can't open PID file");
 
295
}
 
296
 
 
297
# Robustness: Can't bind address
 
298
if ($RB_BIND_ADDRESS) {
 
299
    print "***Test: Can't bind address\n";
 
300
    my $sslh_pid;
 
301
    if (!($sslh_pid = fork)) {
 
302
        my $user = (getpwuid $<)[0]; # Run under current username
 
303
        exec "./sslh-select -v -f -u $user --listen 74.125.39.106:9000 --ssh $ssh_address --ssl $ssl_address -P $pidfile";
 
304
    }
 
305
    warn "spawned $sslh_pid\n";
 
306
    waitpid $sslh_pid, 0;
 
307
    my $code = $? >> 8;
 
308
    warn "exited with $code\n";
 
309
    is($code, 1, "Exit status if can't bind address");
 
310
}
 
311
 
 
312
# Robustness: Can't resolve address
 
313
if ($RB_RESOLVE_ADDRESS) {
 
314
    print "***Test: Can't resolve address\n";
 
315
    my $sslh_pid;
 
316
    if (!($sslh_pid = fork)) {
 
317
        my $user = (getpwuid $<)[0]; # Run under current username
 
318
        exec "./sslh-select -v -f -u $user --listen blahblah.dontexist:9000 --ssh $ssh_address --ssl $ssl_address -P $pidfile";
 
319
    }
 
320
    warn "spawned $sslh_pid\n";
 
321
    waitpid $sslh_pid, 0;
 
322
    my $code = $? >> 8;
 
323
    warn "exited with $code\n";
 
324
    is($code, 4, "Exit status if can't resolve address");
 
325
}
 
326
 
 
327
`lcov --directory . --capture --output-file sslh_cov.info`;
 
328
`genhtml sslh_cov.info`;
 
329
 
 
330
`killall echosrv`;
 
331