Mostrando entradas con la etiqueta openssl. Mostrar todas las entradas
Mostrando entradas con la etiqueta openssl. Mostrar todas las entradas

martes, 26 de agosto de 2025

DBeaver. Obtención de las contraseñas de las conexiones a las BD

 Desde el vídeo de Codewis explican como extraer las contraseñas de las conexxiones a las BBDD.

1. File - Export -DBeaver- Project -Next


2. Elegimos "General y le indicamos fichero y carpeta


3. Abrimos elfichero "General-20250826.dbp" con un editor de fichero comprimidos y extraemos el fichero "credentials-confog.json"

4. Abrimos una ventana de comando y nos vamos a la carpeta donde hemos dejado el fichero  "credentials-config.json" y ejecutamos:

openssl aes-128-cbc -d -K babb4a9f774ab853c96c2d653dfe544a -iv 00000000000000000000000000000000 -in "credentials-config.json" >credenciales.txt

Con ello desencriptamos el contenido en un fichero dentro de otro fichero "credenciales.txt" pero que hay que tener cuidado al abrirlo pues tiene algunos caracteresd extraños que algunos programas de trataiento de texto no pueden leer. 

A una mala , se puede obviar la parte que final de la sentincia que lo vuelca a un fichero:

openssl aes-128-cbc -d -K babb4a9f774ab853c96c2d653dfe544a -iv 00000000000000000000000000000000 -in "credentials-config.json" 

y se puede ver por pantalla. 




domingo, 8 de diciembre de 2024

Python (XVI) exportar certificados de los navegadores

1. Localización de los ficheros de certificados

En Linux-Mozilla los certificados se guardan en la carpeta hija de:

~/.mozilla/firefox

que contiene entre otros el fichero "cert9.db"

Por tanto hay que buscar las carpetas contenedoras de dicho fichero (puede haber varias)

En Linux-Chrome se guardan en la carpeta:

~/.pki/nssdb


2. Como se hace en Linux bash?

Para manejar los certificados contenidos en cada carpeta hay que instalar algunas librerías del paquete NSS (Network Security Services).

sudo apt install libnss3-tools

Para listar los certificados contenidos en una carpeta de las mencionadas arriba, por ejemplo para mozilla, donde XXXX es la carpeta que contiene el fichero "cert9.db":

certutil -L -d sql:$HOME/.mozilla/firefox/XXXX

Ojo hay que tener cuiidado de no incluir "cer9.db" en la ruta

Y para Chrome

certutil -L -d sql:$HOME/.pki/nsb

Y nos mostará algo parecido a:

Certificate Nickname                              Trust Attributes
                                                   SSL,S/MIME,JAR/XPI
Mi nick                                            u,u,u
ACME Root CA                                       CT,C,C

Ahora podemos extraer los certificados a partir de la carpeta y el Nickname. En el lisado anterior vemos un nickname llamado "Mi nick". Para obtener este ceerificamos SIN CLAVE PRIVADA hacemos:

certutil -L -n "Mi nick" -d sql:$HOME/.pki/nsb -a > cert.pem

Pero hay que tener cuidado pues no incluye la clave privada. Si queremos que incluya la clave pivada, hay que guardar una contraseña en un fichero y ejecutar el comando. En este ejmplo hacemos las dos cosas

# Guardamos la conraseña en un fichero
echo "mypasword" > temp_pass_file_path

#Guardamos el certificado con la clave privada, protegidos por la contraseña "mypassword" 
pk12util -o, cert.pem -d sql:$HOME/.pki/nsb -n "My nick" -k $HOME/.pki/nsb/key4.db -w temp_pass_file_path

Ahora supongamos que queremos leer el fichero pem generado "cert.pem" y queremos guardarlo con otro nombre y con otra contraseña:

#Cambiamos el nombre y nos pedirá la nueva contraseña
openssl rsa -in cert.pem -out nuevo_certificado.pem -aes256

#Comprobamos que podemos leer el fichero con la nueva contraseña
openssl rsa -in nuevo_certificado.pem

3. Como se hace en Windows powershell?

Ejecutamos este programa de powershell para extrar todos los certificados a formato pfx y los protegemos con la contraseña "password_pfx"

# Ruta donde se guardarán los archivos PFX
$outputFolder = "C:\ruta\certificados"

# Crear la carpeta si no existe
if (-not (Test-Path -Path $outputFolder)) {
    New-Item -ItemType Directory -Path $outputFolder
}

# Iterar sobre todos los certificados que se listan con "Get-ChildItem Cert:\CurrentUser\My"
$certificates = Get-ChildItem Cert:\CurrentUser\My
foreach ($cert in $certificates) {
    $filePath = Join-Path -Path $outputFolder -ChildPath ("cert_" + $cert.Thumbprint + ".pfx")
    $password = ConvertTo-SecureString -String "password_pfx" -Force -AsPlainText

    Export-PfxCertificate -Cert $cert -FilePath $filePath -Password $password
    Write-Host "Exportado: $filePath"
}

Y para convertir de pfx a pem utilizamos el power shell, manteniendo la misma contraseña:

# Ruta donde están los archivos PFX
$pfxFolder = "C:\ruta\certificados"
# Ruta donde se guardarán los archivos PEM
$pemFolder = "C:\ruta\certificados_pem"

# Crear la carpeta para los PEM si no existe
if (-not (Test-Path -Path $pemFolder)) {
    New-Item -ItemType Directory -Path $pemFolder
}

# Convertir cada PFX a PEM
$pfxFiles = Get-ChildItem -Path $pfxFolder -Filter "*.pfx"
foreach ($pfx in $pfxFiles) {
    $pemFilePath = Join-Path -Path $pemFolder -ChildPath ($pfx.BaseName + ".pem")

    # Ejecutar OpenSSL para la conversión
    & "openssl" pkcs12 -in $pfx.FullName -out $pemFilePath -nodes -password pass:password_pfx
    Write-Host "Convertido a PEM: $pemFilePath"
}


4. En Python

Solo se ha comprobado en Linux.

Veamos el código python

import os
import platform
import subprocess
from cryptography.hazmat.primitives.serialization import Encoding, pkcs12, NoEncryption
from cryptography.x509 import load_der_x509_certificate, load_pem_x509_certificate
from cryptography import x509
from Crypto.IO import PEM
from Crypto.PublicKey import RSA
from OpenSSL.crypto import PKCS12, FILETYPE_PEM, dump_certificate, dump_privatekey
import base64
import ssl
import tempfile

# ------Imprescindible para poder importar de otras carpetas (de basicutils)
import sys
from pathlib import Path
for i in range(2):sys.path.append(str(Path(__file__).parents[i]))
try: # if in the same folder then needs a try and import directly
	from basicutils import xmfiles
except Exception as error:
	import xmfiles	
# ------Fin imprescindible


#def save_certificate_to_file(cert, filename):
#    """Save a certificate to a file in PEM format."""
#    try:
#        with open(filename, "wb") as f:
#            f.write(cert.public_bytes(Encoding.PEM))
#        print(f"Certificate saved to {filename}")
#    except Exception as e:
#        print(f"Error saving certificate to file: {e}")

def change_password(input_pem, input_password, output_pem, output_password):
    '''
    Cambia la contraseña de un archivo PEM'''
    try:
        # Leer contenido del archivo PEM
        with open(input_pem, "rb") as file:
            pem_data = file.read()

        # Desencriptar la clave privada usando la contraseña existente
        key, _ = PEM.decode(pem_data, passphrase=input_password.encode("utf-8"))

        # Cargar la clave como objeto RSA
        rsa_key = RSA.import_key(key)

        # Re-encriptar la clave privada con la nueva contraseña
        encrypted_key = rsa_key.export_key(format="PEM", passphrase=output_password, pkcs=8)

        # Escribir el nuevo archivo PEM con la nueva contraseña
        with open(output_pem, "wb") as file:
            file.write(encrypted_key)

        print(f"Archivo PEM guardado como '{output_pem}' con la nueva contraseña.")
    except Exception as e:
        print(f"Error: {e}")

        
def parse_certificate(browser:str, cert_data)->dict:
    """Parse a certificate into a dict and print details of an X.509 certificate."""
    try:
        cert = load_der_x509_certificate(cert_data)
    except ValueError:
        try:
            cert = load_pem_x509_certificate(cert_data)
        except Exception as e:
            print(f"Failed to parse certificate: {e}")
            return None

    try:
        #print("\nCertificate Details:"); #print(f"  Subject: {cert.subject}")
        # Obtener el CN
        subject = cert.subject
        cn = cert.subject.get_attributes_for_oid(x509.NameOID.COMMON_NAME)[0].value
        print(f"  CN: {cn}")
        browseCN=browser+"-"+cn
        
        #print(f"  Issuer: {cert.issuer}") ; #print(f"  Serial Number: {cert.serial_number}")
        #print(f"  Valid From: {cert.not_valid_before}");  #print(f"  Valid To: {cert.not_valid_after}")
        #print(f"  Signature Algorithm: {cert.signature_algorithm_oid}")
    except Exception as e: 
        print(f"Failed to print certificate details: {e}")    
    return {browseCN:cert} if cn else {'No CN':cert}

def export_certificate_and_key_linux(nssDir:str, output_path:str, nickname:str, pkcs12_password:str,exportKey:bool=False):
    ''' 
        Exports the certificate and key in a file "pem" and also into 
        2 diferent files, one for the cert (.crt) and another for te key (.key)
        if exportKey is False, the files ".crt" and ".key" are not created 
        Parameters:
            nssDir (str): The path to the NSS database.
            output_path (str): The path where the files will be saved.
            nickname (str): The nickname of the certificate.
            pkcs12_password (str): The password for the PKCS#12 file.
            exportKey (bool): Whether to create crt and key files.
    '''
    try:
        # Step 1: Define paths
        #nss_dir = os.path.expanduser("~/.pki/nssdb")
        if not os.path.exists(nssDir):
            raise FileNotFoundError(f"NSS database not found in {nssDir}. Ensure Chrome has certificates stored there.")

        # Step 2: Write password to a temporary file
        with tempfile.NamedTemporaryFile(delete=False, mode="w", prefix="pkcs12_", suffix=".pass") as temp_pass_file:
            temp_pass_file.write(pkcs12_password)
            temp_pass_file_path = temp_pass_file.name

        # Step 3: Export the certificate and key as a PKCS#12 file
        pkcs12_file = os.path.join(output_path, f"{nickname}.p12")
        pk12util_cmd = [
            "pk12util",
            "-o", pkcs12_file,
            "-d", f"sql:{nssDir}",
            "-n", nickname,
            "-k", f"{nssDir}/key4.db",
            "-w", temp_pass_file_path
        ]

        print("Exporting PKCS#12 file...")
        subprocess.run(pk12util_cmd, check=True)
        print(f"PKCS#12 file exported to: {pkcs12_file}")

        if exportKey:
            # Step 4: Convert PKCS#12 to separate certificate and private key
            cert_file = os.path.join(output_path, f"{nickname}.crt")
            key_file = os.path.join(output_path, f"{nickname}.key")
            openssl_cmd = [
                "openssl", "pkcs12",
                "-in", pkcs12_file,
                "-clcerts",
                "-nokeys", "-out", cert_file,
                "-nodes",
                "-password", f"pass:{pkcs12_password}"
            ]
            print("Extracting certificate...")
            subprocess.run(openssl_cmd, check=True)
            print(f"Certificate exported to: {cert_file}")

            openssl_key_cmd = [
                "openssl", "pkcs12",
                "-in", pkcs12_file,
                "-nocerts",
                "-out", key_file,
                "-nodes",
                "-password", f"pass:{pkcs12_password}"
            ]
            print("Extracting private key...")
            subprocess.run(openssl_key_cmd, check=True)
            print(f"Private key exported to: {key_file}")

    except subprocess.CalledProcessError as e:
        print(f"Error executing command: {e}")
    except FileNotFoundError as e:
        print(e)
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

def export_user_certs_windows(output_path, password="my-password", export_format="pem"):
    """
    Busca un certificado por nombre en el almacén de Windows, extrae su clave privada y lo guarda como PEM o PFX.
    
    Args:
        name (str): Nombre del certificado a buscar.
        output_path (str): Ruta donde se guardará el archivo exportado.
        password (str, optional): Contraseña para proteger el archivo PFX.
        export_format (str): Formato del archivo de salida ('pem' o 'pfx').
    """
    import wincertstore
    try:
        with wincertstore.CertSystemStore("MY") as store:
            for cert in store.itercerts(usage=wincertstore.CERT_FIND_ANY):

                # Extraer el certificado y la clave privada
                private_key = cert.get_key()
                certificate = cert.get_cert()

                # Verificar si la clave privada está disponible
                if not private_key:
                    print("Advertencia: Clave privada no disponible o no exportable.")
                    return

                if export_format == "pem":
                    # Exportar como PEM
                    cert_pem = dump_certificate(FILETYPE_PEM, certificate)
                    key_pem = dump_privatekey(FILETYPE_PEM, private_key)
                    with open(output_path, "wb") as f:
                        f.write(key_pem)
                        f.write(cert_pem)
                    print(f"Certificado exportado como PEM: {output_path}")
                elif export_format == "pfx":
                    # Exportar como PFX
                    pfx = PKCS12()
                    pfx.set_privatekey(private_key)
                    pfx.set_certificate(certificate)
                    pfx_data = pfx.export(password.encode() if password else None)
                    with open(output_path, "wb") as f:
                        f.write(pfx_data)
                    print(f"Certificado exportado como PFX: {output_path}")
                else:
                    print("Formato no soportado. Usa 'pem' o 'pfx'.")
    except Exception as e:
        print(f"Error: {e}")  

def list_user_certificates_linux():
    """List user-installed certificates on Linux and display their details."""
    certs = []
    certificates=[]
    allCertsDict={}
    home_dir = os.path.expanduser("~")

    # Firefox Certificates
    firefox_path = os.path.join(home_dir, ".mozilla/firefox")
    if os.path.exists(firefox_path):
        #profiles = [d for d in os.listdir(firefox_path) if d.endswith(".default")]
        #for profile in profiles:
        #    cert_db = os.path.join(firefox_path, profile, "cert9.db")
        #    if os.path.exists(cert_db):
        #        certs.append(("Firefox", cert_db))
        certDBs=xmfiles.findFileInFolderRecursive('cert9.db', firefox_path)
        for i, certDB in enumerate(certDBs):
            certs.append(("Mz-"+str(i), certDB[1]))

    # Chrome Certificates
    chrome_path = os.path.join(home_dir, ".pki/nssdb")
    if os.path.exists(chrome_path):
        certs.append(("Ch", chrome_path))

    # Display certificate details using `certutil`
    for browser, cert_db in certs:
        print(f"\n{browser} Certificates from {cert_db}:")
        try:
            output = subprocess.check_output(["certutil", "-L", "-d", f"sql:{cert_db}"], text=True)
            print(output)
            #================================================================
            # Extract certificate nicknames and details
            lines = output.splitlines()[2:]  # Skip the header lines
            for line in lines:
                
                try:
                    #nickname = line.split()[0]
                    nickname = line.split('  ')[0]
                    print(f"Nickname: {nickname}  Browser: {browser}")
                    # Export each certificate in PEM format
                    cert_output = subprocess.check_output(
                        ["certutil", "-L", "-n", nickname, "-d", f"sql:{cert_db}", "-a"], text=True
                    )
                    certDict=parse_certificate(browser,[cert_output.encode(), nickname, cert_db ])
                    allCertsDict.update(certDict) #add to all
                   
                except Exception as e:
                    print(f"Failed to export certificate '{line}'")
        
        except Exception as e:
            print(f"Error reading {browser} certificates: {e}")
    #return certs
    return allCertsDict



def list_user_certificates_mac():
    """List user-installed certificates on macOS and display their details."""
    user_certs = []
    allCertsDict={}
    try:
        output = subprocess.check_output(
            ["security", "find-certificate", "-c", "User", "-a", "-p"],
            text=True
        )
        certs = output.split("-----END CERTIFICATE-----")
        for cert in certs:
            if cert.strip():
                pem_cert = cert + "-----END CERTIFICATE-----"
                print("\nCertificate PEM Format:")
                print(pem_cert)
                user_certs.append(pem_cert)
                certDict=parse_certificate(pem_cert.encode())
                allCertsDict.update(certDict)
    except Exception as e:
        print(f"Error accessing user certificates on macOS: {e}")
    #return user_certs
    return allCertsDict


def main():
    
    print("Listing all user-installed certificates...\n")
    user_certs = []

    if platform.system() == "Linux":
        # Linux
        home_dir = os.path.expanduser("~")
        chrome_path = os.path.join(home_dir, ".pki/nssdb")
        #export_certificate_and_key_linux(chrome_path, "/home/edu/MyCerts/Prova", "EPN1", "my-password")
            
        print("User Certificates (Linux):")
        user_certs = list_user_certificates_linux()
        
        print("===================================================================")
        for k,v in user_certs.items():
            print(k)
            print("         ",v)
            export_certificate_and_key_linux(nssDir=v[2], output_path="/home/edu/MyCerts/Prova", 
                nickname=v[1],pkcs12_password="my-password", exportKey=False )
            print("-------------------------------")

    

    elif platform.system() == "Windows":
        # Windows
        print("User Certificates (Windows):")
        export_user_certs_windows("C:\\Users\\edu\\MyCerts\\Prova", export_format="pem")

    elif platform.system() == "Darwin":
        # macOS
        print("User Certificates (macOS):")
        user_certs = list_user_certificates_mac()

    
if __name__ == "__main__":
    main()










miércoles, 12 de agosto de 2020

Certificados en Java (2). Configurar Tomcat (tambien en Eclipse) https autentificacion cliente certificado. Tarjeta, Smartcard cliente

1. Configurar Tomcat  para https

Segun Namecheap  podemos instalar en Tomcat certificados .jks y tembién .p12 (pkcs12)

1.a con certificado jks

Supongamos que tenemos un certificado p12 llamado mykeystore.jks con contraseña "mypassword", entonces:

Modificamos el conector en el fichero server.xml de la carpeta conf de tomcat y para el puerto 8443 para que quede así

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<!-- Define a SSL HTTP/1.1 Connector on port 8443
        This connector uses the JSSE configuration, when using APR, the
        connector should be using the OpenSSL style configuration
        described in the APR documentation -->
    <Connector port="8443" 
              protocol="HTTP/1.1"
              SSLEnabled="true"
              maxThreads="150" 
              scheme="https" 
              secure="true"
              clientAuth="false" <!-- true to read client certificate -->
              sslProtocol="TLS" <!--"TLSv1.2" -->
              keyAlias="tomcat" <!-- Alias cuando se crea mykeystore,jks -->
	      keystoreFile="/home/ximo/mykeystore.jks"
	      keystorePass="mypassword" 
              
    /> 

Y ahora vamos al directorio "bin" del tomcat y paramos y rearrancamos el servicio

./shutdown.sh
./startup.sh

1.b con certificado pem

Supongamos que hemos obtenido de LetsEncrypt, estos certificados que estan en la carpeta  /etc/letsencrypt/live/midominio.es
  • cert.pem (certificado "solo")
  • chain.pem (cadena de certificados del root)
  • fullchain.pem (certificado "solo" + cadena de certificados del root. Equivale a los 2 ficheros anteriores juntos)
  • privkey.pem (clave privada)
Modificamos el conector en el fichero server.xml de la carpeta conf de tomcat y para el puerto 19443 para que quede así

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
 <Connector port="19443"
      protocol="HTTP/1.1"
      SSLEnabled="true"
      maxThreads="150"
      scheme="https"
      secure="true"
      sslProtocol="TLS"

      clientAuth="true"
      keyAlias="tomcat"


      SSLCertificateFile="/etc/letsencrypt/live/midominio.es/cert.pem"
      SSLCertificateChainFile="/etc/letsencrypt/live/midominio.es/chain.pem"
      SSLCertificateKeyFile="/etc/letsencrypt/live/midominio.es/privkey.pem"
   />

  
Como vemos,:
  1.  No nos ha hecho falta el fullchain.pem
  2. Tampoco nos ha hecho falta ninguna contraseña
  3. Estamos trabajando en un puerto https adicional 19443 (junto con el anterior 8443) sin ningún problema

Y ahora vamos al directorio "bin" del tomcat y paramos y rearrancamos el servicio

./shutdown.sh
./startup.sh


2. Obtener un certificado jks versión fácil


En un blog anterior hemos creeado una entidad certificadora. 


Para ello hay que seguir las instrucciones de Mkyong :

Nos situamos en el directorio /home/ximo/mycerts y creamos un keystore con un certificado auto firmado:

keytool -genkey -alias tomcat -keyalg RSA -keystore mykeystore.jks

OJO: El alias tomcat del mykeystore es el que se debe de indicar en el "keyAlias" del web.xml del tomcat
nos pide una nueva contraseña para el nuevo keystore por ejemplo "mypassword"

podemos listar el contenido del keystore con

keytool -list -v -keystore mykeystore.jks



3. Obtener un certificado jks con un certificado emitido por nuestra entidad certificadora.

Aprovechamos todos los pasos anteriores y generamos el Certificate Signing Request CSR. Para ello volvemos al directorio  /home/ximo/mycerts y tecleamos

keytool -certreq -alias tomcat1 -file mytomcat.csr -keystore mykeystore.jks

Observar que el alias el mismo que hemos creado antes (tomcat)  y nos ha creado el fichero mytomcat.csr


OJO: Para obtener cada una de las DNS, debemos hacer este comando:

nslookup 192.168.2.2

siendo 182.168.2.2 la dirección IP del servidor que queremos crear el certificado, y nos devuelve:

ws.ximodante.es
otro.ximodante.es

Y con esta información de los DNS creamos el fichero de configuración siguiente (mytomcat.conf):

authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names

[alt_names]
DNS.1 = 192.168.2.2
DNS.2 = localhost --> SOLO PARA PUEBAS en PRE
DNS.3 = otro.ximodante.es
DNS.4 = ws.ximodante.es

Por tanto debeis cambiar a la IP que realmente está usando el servidor 

Ahora generamos el certificado

openssl x509 -req -in mytomcat.csr -CA myCA.pem -CAkey myCA.key -CAcreateserial -out mytomcat.crt -days 825 -sha256 -extfile mytomcat.conf
 
Hay que tener en cuenta que debemos disponer de los certificados de nuestra entidad certificadora (myCA.key y myCA.pem) obtenidos en el post anterior.

Finalmente importamos el certificado generado usando el mismo alias "tomcat" a nuestro almacén de claves.

keytool -import -alias tomcat1 -file mytomcat.crt -keystore mykeysore.jks

Y rearrancamos el servicio de Tomcat como hemos hecho antes:


./shutdown.sh
./startup.sh

Y si entramos en el navegador se quejará, salvo que le indiquemos al navegador que confie en nuestra entidad certificadora.

4. Autentificación en el servidor con certificado de cliente.


Si queremos que el cliente nos muestre su certificado, hay que indicarle en la línea 11 del fragmento anterior de servers.xml:

clientAuth="true" 

Con lo que nos pide el certificado de cliente y podemos autenticarnos en el servidor mediante certificado.

5. Autentificación en el servidor con tarjeta criptográfica (en cliente).

Cuando se intenta acceder con tarjeta criptográfica en el cliente, nos da este error en el cliente:
SSL_ERROR_BAD_CERT_ALERT

Supongo que tal vez haya que indicar un truststore que contenga el certificado raíz.
Parece ser que tomcat utiliza el alacen de certificados de java.

Se va a copiar el fichero keystore  java_path/lib/security/cacerts a una carpeta de pruebas y con el programa keystore explorer, añadimos los certificados raiz de la etidad certificadora de la tarjeta obtenidas de la ACCV 

En concreto añadimos el certificado raiz, los 110 y 120

y vamos a modificar el server.xml para que tenga un truststore


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
<!-- Define a SSL HTTP/1.1 Connector on port 8443
        This connector uses the JSSE configuration, when using APR, the
        connector should be using the OpenSSL style configuration
        described in the APR documentation -->
    <Connector port="8443" 
              protocol="HTTP/1.1"
              SSLEnabled="true"
              maxThreads="150" 
              scheme="https" 
              secure="true"
              clientAuth="false" <!-- true to read client certificate -->
              sslProtocol="TLS" <!--"TLSv1.2" -->
              keyAlias="tomcat" <!-- Alias cuando se crea mykeystore,jks -->
	      keystoreFile="/home/ximo/mykeystore.jks"
	      keystorePass="mypassword" 
              
    /> 



6. Configurar el tomcat de Eclipse.



"If you've already created the server, you can edit the server.xml template it copies. If you use the project explorer, It is under Other Projects->Servers->Tomcat Server Name->server.xml"

Así de fácil localizamos el server.xml y lo configuramos como si fuera un tomcat normal.