OpenSSH RemoteForward için dinamik olarak ayrılmış bağlantı noktasını belirleme

Soru (TL; DR)

Uzaktan yönlendirme için bağlantı noktalarını dinamik olarak atarken (diğer bir -Rseçenek olarak), uzak makinedeki bir komut dosyası (örneğin, kaynaklı .bashrc) OpenSSH tarafından hangi bağlantı noktalarının seçildiğini nasıl belirleyebilir?

Arka fon

Birden fazla kullanıcıyla paylaştığım merkezi sunucumuza bağlanmak için OpenSSH (her iki uçta) kullanıyorum. Uzak oturumum için (şimdilik) X, fincanlar ve pulseaudio'ları iletmek istiyorum.

En önemlisi -Xseçeneği kullanarak X iletmektir . Tahsis edilen X adresi çevresel değişkende saklanır DISPLAYve bundan dolayı karşılık gelen TCP bağlantı noktasını çoğu durumda yine de belirleyebilirim. Ama neredeyse hiç ihtiyacım yok, çünkü Xlib onurlandırıyor DISPLAY.

Bardaklar ve pulseaudio için benzer bir mekanizmaya ihtiyacım var. Her iki hizmetin temelleri sırasıyla çevresel değişkenler biçiminde CUPS_SERVERve vardır PULSE_SERVER. Kullanım örnekleri:

ssh -X -R12345:localhost:631 -R54321:localhost:4713 datserver

export CUPS_SERVER=localhost:12345
lowriter #and I can print using my local printer
lpr -P default -o Duplex=DuplexNoTumble minutes.pdf #printing through the tunnel
lpr -H localhost:631 -P default -o Duplex=DuplexNoTumble minutes.pdf #printing remotely

mpg123 mp3s/van_halen/jump.mp3 #annoy co-workers
PULSE_SERVER=localhost:54321 mpg123 mp3s/van_halen/jump.mp3 #listen to music through the tunnel

Sorun ayarlanıyor CUPS_SERVERve PULSE_SERVERdoğru.

Bağlantı noktası iletimlerini çok kullanıyoruz ve bu nedenle dinamik bağlantı noktası ayırmalarına ihtiyacım var. Statik port tahsisi bir seçenek değildir.

OpenSSH, 0uzaktan yönlendirme için bağlantı noktası olarak belirleyerek ( -Risteğe bağlı) uzak sunucuda dinamik bağlantı noktası ayırma mekanizmasına sahiptir . Aşağıdaki komutu kullanarak, OpenSSH dinamik olarak kaplar ve darbe iletme için bağlantı noktaları ayıracaktır.

ssh -X -R0:localhost:631 -R0:localhost:4713 datserver

Bu komutu kullandığımda sshaşağıdakileri yazdırır STDERR:

Allocated port 55710 for remote forward to 127.0.0.1:4713
Allocated port 41273 for remote forward to 127.0.0.1:631

İstediğim bilgiler var! Sonuçta ben oluşturmak istiyorum:

export CUPS_SERVER=localhost:41273
export PULSE_SERVER=localhost:55710

Ancak yerel makinemde "Ayrılan bağlantı noktası ..." iletileri oluşturulur STDERRve uzak makineden erişemediğim adresine gönderilir. Garip bir şekilde OpenSSH'nin port yönlendirmeleri hakkında bilgi almanın bir yolu yok gibi görünüyor.

Bu bilgileri, uygun bir şekilde ayarlamak CUPS_SERVERve PULSE_SERVERuzak ana bilgisayarda bir kabuk betiğine koymak için nasıl getirebilirim ?

Çıkmaz sokaklar

Bulabildiğim tek kolay şey, sshd bu bilgiler günlüklerden kadar . Bu, bilgilerin kök olmayan kullanıcılar tarafından erişilebilir hale getirilmesinden çok daha fazla bilgi ifşa ettiği için geçerli değildir.

İç yapının güzel bir temsilini basan ek bir kaçış dizisini desteklemek için OpenSSH'yi yamalamayı düşünüyordum permitted_opens, ancak istediğim bu olsa bile, hala istemci tarafından sunucu tarafında kaçış dizilerine erişemiyorum.

Daha iyi bir yol olmalı

Aşağıdaki yaklaşım çok dengesiz görünüyor ve kullanıcı başına böyle bir SSH oturumu ile sınırlı. Ancak, en az iki eşzamanlı oturum ve diğer kullanıcılara daha fazla ihtiyacım var. Ama yorgunum ...

Yıldızlar düzgün bir şekilde hizalandığında, bir veya iki tavuğu feda sshdettikten sonra, kullanıcı olarak başlatılmayan, ancak başarılı bir şekilde giriş yaptıktan sonra bunu yapmak için ayrıcalıklar bırakan gerçeği kötüye kullanabilirim :

• kullanıcıya ait tüm dinleme soketleri için bağlantı noktası numaralarının bir listesini al

  netstat -tlpen | grep ${UID} | sed -e 's/^.*:\([0-9]\+\) .*$/\1/'

• kullanıcımın başlattığı işlemlere ait tüm dinleme soketleri için bağlantı noktası numaralarının bir listesini al

  lsof -u ${UID} 2>/dev/null | grep LISTEN | sed -e 's/.*:\([0-9]\+\) (LISTEN).*$/\1/'

• İlk sette olan tüm bağlantı noktaları, ancak ikinci sette benim iletme portları ve gerçekten setleri verimi çıkarılarak olması için yüksek ihtimalini yok 41273, 55710ve 6010; bardak, nabız ve X.

• 6010kullanılarak X bağlantı noktası olarak tanımlanır DISPLAY.

• 41273bardaklar liman, çünkü lpstat -h localhost:41273 -adöner 0.
• 55710darbe bağlantı noktasıdır, çünkü pactl -s localhost:55710 statgeri döner 0. (Hatta istemcimin ana bilgisayar adını yazdırır!)

(Ayarlama çıkarma I'yi yapmak ve sort -uyukarıdaki komut satırlarından çıkışı saklamak commve çıkarma yapmak için kullanın .)

Pulseaudio istemciyi tanımlamama izin veriyor ve tüm niyetler ve amaçlar için bu, ayrılması gereken SSH oturumlarını ayırmak için bir çapa görevi görebilir. Ancak, ben bağlamak için bir yol bulmuş değil 41273, 55710ve 6010aynı için sshdsüreç. netstatbu bilgileri kök olmayan kullanıcılara açıklamaz. Yalnızca bir olsun -içinde PID/Program nameben okumak istiyorum kolonunun 2339/54(bu özel durumda). Çok yakın ...

İki tane alın ( scp'yi sunucu tarafından yapan ve biraz daha basit olan bir sürümün geçmişine bakın ), bunu yapmalıdır. Bunun özü şudur:

1. bir ortam değişkenini istemciden sunucuya geçirerek sunucuya bağlantı noktası bilgilerinin ne zaman kullanılabilir olduğunu nasıl algılayabileceğini ve sonra alıp kullanabileceğini söyler.
2. bağlantı noktası bilgileri kullanılabilir olduğunda, istemciden sunucuya kopyalayın ve sunucunun (yukarıdaki 1. bölümün yardımıyla) almasına izin verin ve kullanın

İlk olarak, uzak taraftaki kurulum, sshd yapılandırmasında bir env değişkeni göndermeyi etkinleştirmeniz gerekir :

sudo yourfavouriteeditor /etc/ssh/sshd_config

İle satırı bulun AcceptEnvve ekleyin MY_PORT_FILE(veya Hosthenüz yoksa sağ bölümün altındaki satırı ekleyin ). Benim için çizgi şu oldu:

AcceptEnv LANG LC_* MY_PORT_FILE

Ayrıca sshd'yi yeniden başlatmayı da unutmayınBunun etkili olması için .

Ayrıca, aşağıdaki komut dosyalarının çalışması mkdir ~/portfilesiçin uzak tarafta yapın!

Sonra yerel tarafta, bir komut dosyası snippet'i

1. stderr yönlendirmesi için geçici dosya adı oluştur
2. dosyanın içeriğe sahip olmasını beklemek için bir arka plan işi bırak
3. ssh'yi yeniden yönlendirirken dosya adını env değişkeni olarak sunucuya geçirin stderr dosyasını dosyaya
4. arka plan işi ayrı scp kullanarak stderr temp dosyasını sunucu tarafına kopyalamaya devam eder
5. arka plan işi ayrıca stderr dosyasının hazır olduğunu belirtmek için bir bayrak dosyasını sunucuya kopyalar

Komut dosyası snippet'i:

REMOTE=$USER@datserver

PORTFILE=`mktemp /tmp/sshdataserverports-$(hostname)-XXXXX`
test -e $PORTFILE && rm -v $PORTFILE

# EMPTYFLAG servers both as empty flag file for remote side,
# and safeguard for background job termination on this side
EMPTYFLAG=$PORTFILE-empty
cp /dev/null $EMPTYFLAG

# this variable has the file name sent over ssh connection
export MY_PORT_FILE=$(basename $PORTFILE)

# background job loop to wait for the temp file to have data
( while [ -f $EMPTYFLAG -a \! -s $PORTFILE ] ; do
     sleep 1 # check once per sec
  done
  sleep 1 # make sure temp file gets the port data

  # first copy temp file, ...
  scp  $PORTFILE $REMOTE:portfiles/$MY_PORT_FILE

  # ...then copy flag file telling temp file contents are up to date
  scp  $EMPTYFLAG $REMOTE:portfiles/$MY_PORT_FILE.flag
) &

# actual ssh terminal connection    
ssh -X -o "SendEnv MY_PORT_FILE" -R0:localhost:631 -R0:localhost:4713 $REMOTE 2> $PORTFILE

# remove files after connection is over
rm -v $PORTFILE $EMPTYFLAG

Sonra uzak taraf için bir snippet, .bashrc için uygun :

# only do this if subdir has been created and env variable set
if [ -d ~/portfiles -a "$MY_PORT_FILE" ] ; then

       PORTFILE=~/portfiles/$(basename "$MY_PORT_FILE")
       FLAGFILE=$PORTFILE.flag
       # wait for FLAGFILE to get copied,
       # after which PORTFILE should be complete
       while [ \! -f "$FLAGFILE" ] ; do 
           echo "Waiting for $FLAGFILE..."
           sleep 1
       done

       # use quite exact regexps and head to make this robust
       export CUPS_SERVER=localhost:$(grep '^Allocated port [0-9]\+ .* localhost:631[[:space:]]*$' "$PORTFILE" | head -1 | cut -d" " -f3)
       export PULSE_SERVER=localhost:$(grep '^Allocated port [0-9]\+ .* localhost:4713[[:space:]]*$' "$PORTFILE" | head -1 | cut -d" " -f3)
       echo "Set CUPS_SERVER and PULSE_SERVER"

       # copied files served their purpose, and can be removed right away
       rm -v -- "$PORTFILE" "$FLAGFILE"
fi

Not : Yukarıdaki kod elbette çok kapsamlı bir şekilde test edilmemiştir ve her türlü hata, kopyala-yapıştır hataları vb. İçerebilir. Daha iyi kullanan herkes de anlar, kendi sorumluluğunuzdadır! Sadece localhost bağlantısı kullanarak test ettim ve benim için çalıştı, benim test env. YMMV.

Yerel taraf için bir snippet, .bashrc için uygun:

#!/bin/bash

user=$1
host=$2

sshr() {
# 1. connect, get dynamic port, disconnect  
port=`echo "exit" | ssh -R '*:0:127.0.0.1:52698' -t $1 2>&1 | grep 'Allocated port' | awk '/port/ {print $3;}'`
# 2. reconnect with this port and set remote variable
cmds="ssh -R $port:127.0.0.1:52698 -t $1 bash -c \"export RMATE_PORT=$port; bash\""
($cmds)
}

sshr $user@$host

Aynı şeyi yerel istemcide bir boru oluşturarak, daha sonra stderr'i ssh girişine yönlendirilen boruya yönlendirerek de başardım. Başarısız olabilen bilinen bir bağlantı noktasını varsaymak için birden fazla ssh bağlantısı gerektirmez. Bu şekilde oturum açma başlığı ve "Ayrılan bağlantı noktası ### ..." metni uzak ana bilgisayara yeniden yönlendirilir.

getsshport.shYeniden yönlendirilen girişi okur ve bağlantı noktasını ayrıştırır uzak ana bilgisayarda çalıştırılan ana bilgisayarda basit bir komut dosyası var . Bu komut dosyası bitmediği sürece, ssh uzaktan kumandası açık kalır.

yerel taraf

mkfifo pipe
ssh -R "*:0:localhost:22" user@remotehost "~/getsshport.sh" 3>&1 1>&2 2>&3 < pipe | cat > pipe

3>&1 1>&2 2>&3 stderr ve stdout'u değiştirmek için küçük bir hiledir, böylece stderr kediye bağlanır ve ssh'den tüm normal çıktılar stderr'de gösterilir.

uzak taraf ~ / getsshport.sh

#!/bin/sh
echo "Connection from $SSH_CLIENT"
while read line
do
    echo "$line" # echos everything sent back to the client
    echo "$line" | sed -n "s/Allocated port \([0-9]*\) for remote forward to \(.*\)\:\([0-9]*\).*/client port \3 is on local port \1/p" >> /tmp/allocatedports
done

grepYerel taraftaki "tahsis edilen bağlantı noktası" mesajını ssh ile göndermeden önce denedim , ancak ssh borunun stdin'de açılmasını beklemeyi engelleyecek gibi görünüyor. grep, bir şey alana kadar yazmak için pipo açmaz, bu yüzden temelde çıkmazlar. catancak aynı davranışa sahip gibi görünmüyor ve hemen yazmak için pipoyu açarak ssh'ın bağlantıyı açmasına izin veriyor.

bu uzak tarafta aynı sorun ve neden readstdin'den sadece grep yerine satır satır - aksi takdirde ssh tüneli kapatılıncaya kadar tüm amacı yenen `` / tmp / tahsis edilen sporlar '' yazılmıyor

~/getsshport.shKomut, başlık metni veya borudaki başka herhangi bir şey belirtmeden uzak kabukta yürütüldüğünden, ssh stderr komutunu benzer bir komuta borulamak tercih edilir.

Bu zor bir, satır boyunca ekstra sunucu tarafı işleme SSH_CONNECTIONveya DISPLAYharika olurdu, ancak eklemek kolay değil: sorunun bir kısmı sadece sshistemci yerel hedef biliyor, istek paketi (sunucuya) içerir yalnızca uzak adres ve bağlantı noktası.

Buradaki diğer yanıtlar, bu istemci tarafını yakalamak ve sunucuya göndermek için çeşitli hoş olmayan çözümlere sahiptir. İşte dürüst olmaktan çok daha güzel olmayan alternatif bir yaklaşım, ama en azından bu çirkin parti müşteri tarafında tutulur ;-)

• istemci tarafında, SendEnvbazı ortam değişkenlerini ssh üzerinden yerel olarak gönderebilmemiz için ekleme / değiştirme (muhtemelen varsayılan değil)
• sunucu tarafında, AcceptEnvaynı kabul etmek için ekle / değiştir (muhtemelen varsayılan olarak etkin değildir)
• izlemek sshssh istemci ortamı dinamik yüklü kütüphane ile müşteri stderr çıkış ve güncelleme kurmak bağlantı sırasında
• profil / oturum açma komut dosyasında ortam değişkenleri sunucu tarafını al

Uzaktan çalışır, ortam değiştirilmeden önce ayarlanır ve kaydedilir (ile onaylayın ssh -vv ...). Dinamik olarak yüklenen kitaplığın write()libc işlevini yakalaması gerekir ( ssh_confirm_remote_forward()→ logit()→ do_log()→ write()). ELF ikili dosyasında (yeniden derlemeden) yeniden yönlendirme veya sarma işlevleri, dinamik kitaplıktaki bir işlev için aynısını yapmaktan daha karmaşık büyüklük sıralarıdır.

İstemcide .ssh/config(veya komut satırında -o SendEnv ...)

Host somehost
  user whatever
  SendEnv SSH_RFWD_*

Sunucuda sshd_config(kök / yönetici değişikliği gerekir)

AcceptEnv LC_* SSH_RFWD_*

Bu yaklaşım Linux istemcileri için çalışır ve sunucuda özel bir şey gerektirmez, bazı küçük değişiklikler ile diğer * nix için çalışmalıdır. En az OpenSSH 5.8p1 ile 7.5p1 arasında çalışır.

Aşağıdakilerle derleyin gcc -Wall -shared -ldl -Wl,-soname,rfwd -o rfwd.so rfwd.c :

LD_PRELOAD=./rfwd.so ssh -R0:127.0.0.1:4713 -R0:localhost:631 somehost

Kod:

#define _GNU_SOURCE
#include <stdio.h>
#include <dlfcn.h>
#include <string.h>
#include <stdlib.h>

// gcc -Wall -shared  -ldl -Wl,-soname,rfwd -o rfwd.so rfwd.c

#define DEBUG 0
#define dfprintf(fmt, ...) \
    do { if (DEBUG) fprintf(stderr, "[%14s#%04d:%8s()] " fmt, \
          __FILE__, __LINE__, __func__,##__VA_ARGS__); } while (0)

typedef ssize_t write_fp(int fd, const void *buf, size_t count);
static write_fp *real_write;

void myinit(void) __attribute__((constructor));
void myinit(void)
{
    void *dl;
    dfprintf("It's alive!\n");
    if ((dl=dlopen(NULL,RTLD_NOW))) {
        real_write=dlsym(RTLD_NEXT,"write");
        if (!real_write) dfprintf("error: %s\n",dlerror());
        dfprintf("found %p write()\n", (void *)real_write);
    } else {
        dfprintf(stderr,"dlopen() failed\n");
    }
}

ssize_t write(int fd, const void *buf, size_t count)
{
     static int nenv=0;

     // debug1: Remote connections from 192.168.0.1:0 forwarded to local address 127.0.0.1:1000
     //  Allocated port 44284 for remote forward to 127.0.0.1:1000
     // debug1: All remote forwarding requests processed
     if ( (fd==2) && (!strncmp(buf,"Allocated port ",15)) ) {
         char envbuf1[256],envbuf2[256];
         unsigned int rport;
         char lspec[256];
         int rc;

         rc=sscanf(buf,"Allocated port %u for remote forward to %256s",
          &rport,lspec);

         if ( (rc==2) && (nenv<32) ) {
             snprintf(envbuf1,sizeof(envbuf1),"SSH_RFWD_%i",nenv++);
             snprintf(envbuf2,sizeof(envbuf2),"%u %s",rport,lspec);
             setenv(envbuf1,envbuf2,1);
             dfprintf("setenv(%s,%s,1)\n",envbuf1,envbuf2);
         }
     }
     return real_write(fd,buf,count);
}

(Bu yaklaşımla sembol sürümlemeyle ilgili bazı glibc ayı tuzakları vardır, ancak write()bu sorun yoktur.)

Cesur hissediyorsanız, setenv()ilgili kodu alıp ssh.c ssh_confirm_remote_forward()geri arama işlevine ekleyebilirsiniz.

Bu SSH_RFWD_nnn, adlandırılan ortam değişkenlerini ayarlar , bunları profilinizde inceleyin, örneğinbash

for fwd in ${!SSH_RFWD_*}; do
    IFS=" :" read lport rip rport <<< ${!fwd}
    [[ $rport -eq "631" ]] && export CUPS_SERVER=localhost:$lport
    # ...
done

Uyarılar:

• kodda çok fazla hata kontrolü yok
• ortamı değiştirmek iş parçacığı ile ilgili sorunlara neden olabilir , PAM iş parçacıkları kullanır, sorun beklemiyorum ama bunu test etmedim
• sshşu anda tam olarak * yerel: bağlantı noktası: uzak: bağlantı noktası * formunun tam olarak yönlendirilmesini günlüğe kaydetmez (gerekirse debug1iletilerin daha fazla ayrıştırılması ssh -vgerekir), ancak kullanım durumunuz için buna ihtiyacınız yoktur

Garip bir şekilde OpenSSH'nin port yönlendirmeleri hakkında bilgi almanın bir yolu yok gibi görünüyor.

Bunu (kısmen) kaçışla etkileşimli olarak yapabilirsiniz ~#, garip bir şekilde uygulama dinleyen kanallar üzerinden atlar, sadece açık (yani TCP KURULU) olanları listeler ve her durumda yararlı alanları yazdırmaz. Görmekchannels.c channel_open_message()

SSH_CHANNEL_PORT_LISTENERYuvaların ayrıntılarını yazdırmak için bu işlevi yamalayabilirsiniz, ancak bu yalnızca yerel yönlendirmeleri alır ( kanallar gerçek iletilerle aynı şey değildir ). Veya, iki yönlendirme tablosunu genel optionsyapıdan dökmek için yama yapabilirsiniz :

#include "readconf.h"
Options options;  /* extern */
[...]
snprintf(buf, sizeof buf, "Local forwards:\r\n");
buffer_append(&buffer, buf, strlen(buf));
for (i = 0; i < options.num_local_forwards; i++) {
     snprintf(buf, sizeof buf, "  #%d listen %s:%d connect %s:%d\r\n",i,
       options.local_forwards[i].listen_host,
       options.local_forwards[i].listen_port,
       options.local_forwards[i].connect_host,
       options.local_forwards[i].connect_port);
     buffer_append(&buffer, buf, strlen(buf));
}
snprintf(buf, sizeof buf, "Remote forwards:\r\n");
buffer_append(&buffer, buf, strlen(buf));
for (i = 0; i < options.num_remote_forwards; i++) {
     snprintf(buf, sizeof buf, "  #%d listen %s:%d connect %s:%d\r\n",i,
       options.remote_forwards[i].listen_host,
       options.remote_forwards[i].listen_port,
       options.remote_forwards[i].connect_host,
       options.remote_forwards[i].connect_port);
     buffer_append(&buffer, buf, strlen(buf));
}

Bu, "programlı" bir çözüm olmasa da, istemci kodunun (henüz kaynağında XXX olarak işaretlenmiş) uyarıları anında eklediğinizde / kaldırdığınızda ( ~C)

Sunucu (lar) Linux ise, bir seçeneğiniz daha vardır, ancak uzaktan kullanmak yerine yerel yönlendirme için genel olarak kullandığım budur. loLinux'ta 127/8 içindeki herhangi bir adrese şeffaf bir şekilde bağlanabilirsiniz , böylece benzersiz 127.xyz adresleri kullanıyorsanız sabit bağlantı noktalarını kullanabilirsiniz, örneğin:

mr@local:~$ ssh -R127.53.50.55:44284:127.0.0.1:44284 remote
[...]
mr@remote:~$ ss -atnp src 127.53.50.55
State      Recv-Q Send-Q        Local Address:Port          Peer Address:Port 
LISTEN     0      128            127.53.50.55:44284                    *:*    

Bu, 1024'ten küçük bağlayıcı ayrıcalıklı bağlantı noktalarına tabidir, OpenSSH Linux yeteneklerini desteklemez ve çoğu platformda sabit kodlanmış bir UID kontrolü vardır.

Akıllıca seçilmiş sekizliler (benim durumumda ASCII ordinal anımsatıcılar), günün sonunda karışıklığın çözülmesine yardımcı olur.