# syslog-ng remote logging

## vitriol

I am having a hard time finding any references to this, hopefully someone else can give me a clue:

I have as a router OpenBSD 3.5 with pf. Pflogd (pf's logging daemon) sends logs to /var/log/pflog.txt and I have it set up to log to a remote server as well. So my logs should be coming to my gentoo box inside my network, but they're not showing up anywhere.

*As far as I know* what I need to do is change syslog-ng's config file to accept remote logs from the router. Anyone know how to do this? Surely its possible..

Thanks!

----------

## spudicus

It is possible as I have the same setup working here.

Are you allowing connections to port 514 to your server through iptables?

Do you have similar entries to the following in your syslog-ng.conf

```
source remote { tcp(ip("<LogserverAddress>") port(514) keep-alive(yes)); };

destination hosts { file("/var/log/HOSTS/$HOST/$FACILITY" owner(root) group(root) perm(0600) dir_perm(0700) create_dirs(yes)); };

log { source(remote); destination(hosts); };
```

I don't have access to my config at the moment, but the above was taken from:

http://venus.ece.ndsu.nodak.edu/~jezerr/linux/secure-remote-logging.html

This should also help:

http://sial.org/howto/logging/syslog-ng/

----------

## vitriol

I switched to sysklogd because it was much easier to configure for remote logging. 

However, all the logfiles are being sent to /var/log/messages . Its a huge mess  :Sad:  There doesn't seem to be a 'facility' in syslog covering pflog, either.

----------

## spudicus

 *vitriol wrote:*   

> I switched to sysklogd because it was much easier to configure for remote logging. 
> 
> However, all the logfiles are being sent to /var/log/messages . Its a huge mess  There doesn't seem to be a 'facility' in syslog covering pflog, either.

 

I don't have any experience with sysklogd, so I can't help there. Are you using sysklogd on the OpenBSD box or as the server?

My syslog.conf has the following two entries, which log locally for pflog and also send everything to the remote server

```
local0.info           /var/log/pflog.txt

*.*                @loghost
```

There isn't a specific facility for pflog (just like there isn't one for iptables) that's why you use the local0.info facility. I assume you've followed the OpenBSD pf guide correctly to get pflogging properly on the OpenBSD box.

In, syslog-ng, I have a filter that searches for the string "pfilter" and sends it to the appropriate file. The string "pfilter" is the tag defined in my pflogging script with the -t switch i.e.

```
tcpdump -n -e -ttt -r $i | logger -t pfilter -p local0.info
```

I'm still not in a position to access my syslog-ng server config but can organise it later if you choose to switch back to syslog-ng.

----------

## spudicus

The following is my syslog-ng.conf for my logserver

```
options {

        use_fqdn(yes);

        keep_hostname(yes);

        create_dirs(yes);

        dir_owner(root);

        dir_group(root);

        dir_perm(0755);

        perm(0644);

        log_fifo_size(1024);

        long_hostnames(off);

        sync(1);

        bad_hostname("gconfd");

};

#

# This is the default behavior of sysklogd package

# Logs may come from unix stream, but not from another machine.

#

source src { unix-stream("/dev/log"); internal(); file("/proc/kmsg" log_prefix("kernel: ")); udp(); };

#Standard logfiles

destination authlog { file("/var/log/$FULLHOST/auth.log" owner("root") group("adm") perm(0640)); };

destination syslog { file("/var/log/$FULLHOST/syslog" owner("root") group("adm") perm(0640)); };

destination cron { file("/var/log/$FULLHOST/cron.log" owner("root") group("adm") perm(0640)); };

destination daemon { file("/var/log/$FULLHOST/daemon.log" owner("root") group("adm") perm(0640)); };

destination kern { file("/var/log/$FULLHOST/kern.log" owner("root") group("adm") perm(0640)); };

destination lpr { file("/var/log/$FULLHOST/lpr.log" owner("root") group("adm") perm(0640)); };

destination mail { file("/var/log/$FULLHOST/mail.log" owner("root") group("adm") perm(0640)); };

destination user { file("/var/log/$FULLHOST/user.log" owner("root") group("adm") perm(0640)); };

destination uucp { file("/var/log/$FULLHOST/uucp.log" owner("root") group("adm") perm(0640)); };

#mail subsystem.

destination mailinfo { file("/var/log/$FULLHOST/mail.info" owner("root") group("adm") perm(0640)); };

destination mailwarn { file("/var/log/$FULLHOST/mail.warn" owner("root") group("adm") perm(0640)); };

destination mailerr { file("/var/log/$FULLHOST/mail.err" owner("root") group("adm") perm(0640)); };

#INN news system

destination newscrit { file("/var/log/$FULLHOST/news/news.crit" owner("news") group("adm") perm(0640)); };

destination newserr { file("/var/log/$FULLHOST/news/news.err" owner("news") group("adm") perm(0640)); };

destination newsnotice { file("/var/log/$FULLHOST/news/news.notice" owner("news") group("adm") perm(0640)); };

#`catch-all' logfiles.

destination debug { file("/var/log/$FULLHOST/debug" owner("root") group("adm") perm(0640)); };

destination messages { file("/var/log/$FULLHOST/messages" owner("root") group("adm") perm(0640)); };

#root's console.

destination console { usertty("root"); };

# Virtual console.

#

destination console_all { file("/dev/tty8"); };

#user-defined

destination d_fwall { file("/var/log/$FULLHOST/firewall.log"); };

destination d_distcc { file("/var/log/$FULLHOST/distcc.log"); };

destination d_acpi { file("/var/log/$FULLHOST/acpi.log"); };

destination d_ntp { file("/var/log/$FULLHOST/ntp.log"); };

destination d_rsync { file("/var/log/$FULLHOST/rsync.log"); };

destination d_snort { file("/var/log/$FULLHOST/snort.log"); };

destination d_dhcp { file("/var/log/$FULLHOST/dhcp.log"); };                                                                                        

                                                                                                                                                    

#destination gate  { file("/var/log/$FULLHOST/log" owner(root) group(root) perm(0600) dir_perm(0700) create_dirs(yes)); };                          

                                                                                                                                                    

#user-defined filters                                                                                                                               

filter f_rsync{                                                                                                                                     

        match("(rsync|rsyncd)");                                                                                                                    

};                                                                                                                                                  

                                                                                                                                                    

filter f_snort{                                                                                                                                     

        match("(snort)");                                                                                                                           

};                                                                                                                                                  

                                                                                                                                                    

filter f_ntp{                                                                                                                                       

        match("(NTP|ntp)");                                                                                                                         

};                                                                                                                                                  

                                                                                                                                                    

filter f_acpi{                                                                                                                                      

        match("(ACPI|acpi)");                                                                                                                       

};                                                                                                                                                  

                                                                                                                                                    

filter f_distcc{                                                                                                                                    

        match("(distccd)");                                                                                                                         

};                                                                                                                                                  

                                                                                                                                                    

filter f_fwall {                                                                                                                                    

        match("(iptables|Iptables|pfilter)");                                                                                                       

};                                                                                                                                                  

                                                                                                                                                    

filter f_ssh_login_attempt {                                                                                                                        

        program("sshd.*")                                                                                                                           

        and match("(Failed|Accepted)")                                                                                                              

        and not match("Accepted (hostbased|publickey) for (spud) from (192.168.2.107)");                                                            

};                                                                                                                                                  

                                                                                                                                                    

#standard filters                                                                                                                                   

filter f_authpriv { facility(auth, authpriv); };                                                                                                    

filter f_syslog { not facility(auth, authpriv); };                                                                                                  

                                                                                                                                                    

filter f_cron {                                                                                                                                     

        facility(cron)                                                                                                                              

        or match("(CRON|cron)");                                                                                                                    

};                                                                                                                                                  

                                                                                                                                                    

filter f_daemon { facility(daemon); };                                                                                                              

filter f_kern { facility(kern); };                                                                                                                  

filter f_lpr { facility(lpr); };                                                                                                                    

filter f_mail { facility(mail); };                                                                                                                  

filter f_user { facility(user); };                                                                                                                  

filter f_uucp { facility(uucp); };                                                                                                                  

                                                                                                                                                    

filter f_news { facility(news); };                                                                                                                  

                                                                                                                                                    

filter f_debug { not facility(auth, authpriv, news, mail); };                                                                                       

filter f_messages { level(info .. warn)                                                                                                             

        and not facility(auth, authpriv, cron, daemon, mail, news); };                                                                              

filter f_emergency { level(emerg); };                                                                                                               

#Catch-all filters                                                                                                                                  

filter f_debug { level(debug); };                                                                                                                   

filter f_info { level(info); };                                                                                                                     

filter f_notice { level(notice); };                                                                                                                 

filter f_warn { level(warn); };                                                                                                                     

filter f_err { level(err); };                                                                                                                       

filter f_crit { level(crit); };                                                                                                                     

filter f_alert { level(alert); };                                                                                                                   

filter f_emerg { level(emerg); };                                                                                                                   

                                                                                                                                                    

filter f_cnews { level(notice, err, crit) and facility(news); };                                                                                    

filter f_cother { level(debug, info, notice, warn) or facility(daemon, mail); };                                                                    

                                                                                                                                                    

log { source(src); filter(f_authpriv); destination(authlog); };                                                                                     

log { source(src); filter(f_syslog); destination(syslog); };                                                                                        

log { source(src); filter(f_daemon); destination(daemon); };                                                                                        

log { source(src); filter(f_kern); destination(kern); };                                                                                            

log { source(src); filter(f_lpr); destination(lpr); };                                                                                              

log { source(src); filter(f_mail); destination(mail); };                                                                                            

log { source(src); filter(f_user); destination(user); };                                                                                            

log { source(src); filter(f_uucp); destination(uucp); };                                                                                            

                                                                                                                                                    

log { source(src); filter(f_mail); filter(f_debug); destination(mailinfo); };                                                                       

log { source(src); filter(f_mail); filter(f_info); destination(mailinfo); };                                                                        

log { source(src); filter(f_mail); filter(f_notice); destination(mailinfo); };                                                                      

log { source(src); filter(f_mail); filter(f_warn); destination(mailwarn); };                                                                        

log { source(src); filter(f_mail); filter(f_err); destination(mailerr); };                                                                          

log { source(src); filter(f_mail); filter(f_crit); destination(mailerr); };                                                                         

log { source(src); filter(f_mail); filter(f_alert); destination(mailerr); };                                                                        

log { source(src); filter(f_mail); filter(f_emerg); destination(mailerr); };                                                                        

                                                                                                                                                    

log { source(src); filter(f_news); filter(f_emerg); destination(newscrit); };                                                                       

log { source(src); filter(f_news); filter(f_alert); destination(newscrit); };                                                                       

log { source(src); filter(f_news); filter(f_crit); destination(newscrit); };                                                                        

log { source(src); filter(f_news); filter(f_err); destination(newserr); };                                                                          

log { source(src); filter(f_news); filter(f_warn); destination(newsnotice); };                                                                      

log { source(src); filter(f_news); filter(f_notice); destination(newsnotice); };                                                                    

log { source(src); filter(f_news); filter(f_info); destination(newsnotice); };                                                                      

log { source(src); filter(f_news); filter(f_debug); destination(newsnotice); };                                                                     

                                                                                                                                                    

log { source(src); filter(f_debug); destination(debug); };                                                                                          

log { source(src); filter(f_messages); destination(messages); };                                                                                    

log { source(src); filter(f_emergency); destination(console); };                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                    

#user-defined logs                                                                                                                                  

log { source(src); filter(f_fwall); destination(d_fwall); };                                                                                        

log { source(src); filter(f_distcc); destination(d_distcc); };                                                                                      

log { source(src); filter(f_acpi); destination(d_acpi); };                                                                                          

log { source(src); filter(f_ntp); destination(d_ntp); };                                                                                            

log { source(src); filter(f_rsync); destination(d_rsync); };                                                                                        

log { source(src); filter(f_snort); destination(d_snort); };                                                                                                     
```

Basically, I've set my log source to get logs from /dev/kmem and UDP port 514, and then I send the relevant info to a directory named after the hostname.

Edit: For some reason it's adding blank lines between some of the later entries  :Evil or Very Mad: 

----------

## vitriol

I was going to just set up a cron job to grep through /var/log/messages every few minutes for new pf log entries, but I didn't have any decent examples of how to get syslog-ng working. I'll try using your rules as an example and give syslog-ng another shot.

----------

## Janne Pikkarainen

grepping through your logs every couple of minutes isn't very effective solution, unless your log files tend to be very small. Better approach would be to track them in real time with Prelude, wasabi, bofhlog or some similar utility.

----------

## vitriol

I tried taking your syslog-ng.conf, spudicus, and applying it to my situation. It isn't working like it should. I'm getting a 'syntax error: line 39' when I boot, and this causes syslog-ng to fail to start as well as the cron daemon.

Could someone take a look at my syslog-ng.conf and give me a hint as to what I've b0rked?

Here it is:

```

options {

        use_fqdn(yes);

        keep_hostname(yes);

        create_dirs(yes);

        dir_owner(root);

        dir_group(root);

        dir_perm(0755);

        perm(0644);

        log_fifo_size(1024);

        long_hostnames(off);

        sync(1);

        # The default action of syslog-ng 1.6.0 is to log a STATS line

        # to the file every 10 minutes.  That's pretty ugly after a while.

        # Change it to every 12 hours so you get a nice daily update of

        # how many messages syslog-ng missed (0).

        stats(43200);

};

source src { unix-stream("/dev/log"); internal(); pipe("/proc/kmsg"); };

destination messages { file("/var/log/messages"); };

# By default messages are logged to tty12...

destination console_all { file("/dev/tty12"); };

# ...if you intend to use /dev/console for programs like xconsole

# you can comment out the destination line above that references /dev/tty12

# and uncomment the line below.

#destination console_all { file("/dev/console"); };

log { source(src); destination(messages); };

log { source(src); destination(console_all); };

#user-defined

destination d_fwall (file("/var/log/$FULLHOST/firewall.log"); };

#user-defined filters

filter f_fwall {

        match("(pf)");

};

#user-defined logs

log { source(src); filter(f_fwall); destination(d_fwall); };

```

This configuration file scares me. If you throw in a few more {}()'s, it would look like lisp! Ahhhhhh!!

----------

## spudicus

Try changing

```
match("(pf)");
```

to

```
match("pf");
```

Generally, you only need the inside brackets if you ORing a list of expressions (although, for some reason I added them like yours).

You also need to add the fact that you want to listen for network requests as well

```
source src { unix-stream("/dev/log"); internal(); pipe("/proc/kmsg"); udp(); };
```

----------

## vitriol

Thanks. That works great! And if I ever want to set up some more advanced logging, all I have to do is check back here at the syslog-ng.conf that you posted as an example.  :Very Happy: 

----------

