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

sábado, 4 de octubre de 2025

Disco NTFS con problemas de lectura.Multiples ficheros duplicados.Copiar sin duplicados

 1. Detectar el problema

En la herramienta "disks" de Ubuntu me dice:

s'ha produit un error en muntar el sistema de fitxers Error mounting /dev/sdc4 at /media/eduard/22143F41143F176F;wrong fs type, bad option, bad superblock on /dev/sdc4, missing codepage or helper program, or other error (udisks-error-quark,0)

Por tanto el problema es en el disco /dev/sdc4


2. Detectar el tipo de partición

Ejecutamos:

sudo fdisk -l

Y vemos que es NTFS (que también se podía ver en la herramienta "Disks" de ubuntu

3. Probar a montar manualmente

Ejecutamos:

sudo mount -t ntfs /dev/sdc4 /mnt

y responde:

$MFTMirr does not match $MFT (record 3). Failed to mount '/dev/sdc4': Error d’Entrada/Sortida NTFS is either inconsistent, or there is a hardware fault, or it's a SoftRAID/FakeRAID hardware. In the first case run chkdsk /f on Windows then reboot into Windows twice. The usage of the /f parameter is very important! If the device is a SoftRAID/FakeRAID then first activate it and mount a different device under the /dev/mapper/ directory, (e.g. /dev/mapper/nvidia_eahaabcc1). Please see the 'dmraid' documentation for more details.

4. Instalar software adicional y utilizarlo


sudo apt install ntfs-3g

sudo ntfsfix /dev/sdc4

y contesta:
Mounting volume... Windows is hibernated, refused to mount. FAILED Attempting to correct errors... Processing $MFT and $MFTMirr... Reading $MFT... OK Reading $MFTMirr... OK Comparing $MFTMirr to $MFT... OK Processing of $MFT and $MFTMirr completed successfully. Setting required flags on partition... OK Going to empty the journal ($LogFile)... OK Windows is hibernated, refused to mount. Remount failed: Operation not permitted

cosa que dice que windows está "hibernated" y se debe a que se interrumpioun proceso de E/AS en el disco y que no se debe acceder a el para modificar nada si no se opera desde windows.

Por tanto lo que podemos hacer es montarlo de solo lectura y copiar los datos 

4. Montar el disco de solo lectura


sudo mount -t ntfs-3g -o ro /dev/sdc4 /mnt

y ya podemos acceder a el disco o la partición en el directorio /mnt

5. Copia de seguridad multifichero


Se opta por copiar a otro disco mas grande y luego crear un zip multivolumen de ficheros de 4 gigas con:

cd /home/eduard
zip -r -s 4g MIS_DATOS.zip MIS_DATOS

donde la carpeta que contiene los datos a guradar es /home/eduard/MIS_DATOS
 y esto genera estos ficheros:

MIS_DATOS.z01, MIS_DATOS.z02, ....MIS_DATOS.88, MIS_DATOS.zip

Siendo MIS_DATOS.88 en mi caso el penúltimo fichero y MIS_DATOS.zip el último

Para descomprimir utilizar:

unzip MIS_DATOS.zip

asegurándose que todos los ficheros generados esten disponibles en la misma carpeta.

Si solo se quiere extraer una subcarpeta llamada MI_SUBCARPETA se haría_

unzip MIS_DATOS.zip "MIS_DATOS/MI_SUBCARPETA/*" -d /ruta/de/destino

y si solo queremos listar el contenido:

unzip -l MIS_DATOS.zip | less


6. Ver si hay muchos duplicados. Borrado y copia sin duplicados


Con chatgpt he creado un bash para detectar duplicados y en su caso borrarlos. Pero en el siguiente punto se ha hecho un bash que solo copia los ficheros no duplicados.

El fichero a no borrar de los duplicados es aquel que tiene menor numero de anidamientos en carpeta.

Ver y/o eliminar duplicados (buscar_duplicados_carpeta.sh)

#!/bin/bash
# buscar_duplicados.sh
# Busca y (opcionalmente) elimina ficheros duplicados (por nombre y tamaño)
# e informa del espacio total y del potencial ahorro.

# Uso:
#   ./buscar_duplicados.sh /ruta/a/carpeta [eliminar_duplicados]

BASE_DIR="$1"
ACCION="$2"

# --- Validaciones iniciales
if [[ -z "$BASE_DIR" ]]; then
  echo "❌ Uso: $0 /ruta/a/carpeta [eliminar_duplicados]"
  exit 1
fi

if [[ ! -d "$BASE_DIR" ]]; then
  echo "❌ No existe el directorio: $BASE_DIR"
  exit 1
fi

# --- Variables
REPORT_FILE="duplicados_$(date +%Y%m%d_%H%M%S).txt"
> "$REPORT_FILE"
ELIMINAR=false
if [[ "$ACCION" == "eliminar_duplicados" ]]; then
  ELIMINAR=true
fi

echo "🔍 Buscando duplicados en: $BASE_DIR"
echo "📝 Informe: $REPORT_FILE"
echo

# --- Calcular espacio total de la carpeta (en bytes)
TOTAL_BYTES=$(du -sb "$BASE_DIR" | awk '{print $1}')
TOTAL_HUMAN=$(du -sh "$BASE_DIR" | awk '{print $1}')

echo "💾 Espacio total actual ocupado por la carpeta: $TOTAL_HUMAN ($TOTAL_BYTES bytes)"
echo "💾 Espacio total actual ocupado por la carpeta: $TOTAL_HUMAN ($TOTAL_BYTES bytes)" >> "$REPORT_FILE"
echo

# --- Buscar duplicados
POTENCIAL_AHORRO=0

find "$BASE_DIR" -type f -printf '%s\t%p\n' | \
while IFS=$'\t' read -r SIZE FILE; do
    BASENAME=$(basename "$FILE")
    echo -e "$BASENAME\t$SIZE\t$FILE"
done | sort -k1,1 -k2,2n | \
awk -F'\t' -v ELIMINAR="$ELIMINAR" -v REPORT_FILE="$REPORT_FILE" -v BASE_DIR="$BASE_DIR" '
function human(bytes) {
    hum[1024^4]="TB"; hum[1024^3]="GB"; hum[1024^2]="MB"; hum[1024]="KB";
    for (x=1024^4; x>=1024; x/=1024) if (bytes>=x) return sprintf("%.2f %s", bytes/x, hum[x]);
    return bytes " B";
}

{
    name=$1; size=$2; path=$3;
    key=name"|"size;
    files[key]=files[key]?files[key]"\n"path:path;
    sizes[key]=size;
}
END {
    total_savings=0;
    for (k in files) {
        split(files[k], arr, "\n");
        if (length(arr) > 1) {
            print "📁 Duplicado: " k >> REPORT_FILE;
            print "📁 Duplicado: " k;

            # Calcular profundidad
            min=999999; minpath="";
            for (i in arr) {
                split(arr[i], dirs, "/");
                depth[i]=length(dirs);
                if (depth[i] < min) {
                    min=depth[i];
                    minpath=arr[i];
                }
            }

            print "   ✅ Se conservará: " minpath >> REPORT_FILE;
            print "   ✅ Se conservará: " minpath;

            print "   ❌ Duplicados encontrados:" >> REPORT_FILE;
            for (i in arr) {
                if (arr[i] != minpath && arr[i] != "") {
                    print "      " arr[i] >> REPORT_FILE;
                    print "      " arr[i];
                    total_savings += sizes[k];  # sumamos el tamaño de los que se podrían eliminar
                }
            }

            if (ELIMINAR == "true") {
                printf "\n¿Eliminar todos los duplicados de este grupo (excepto el conservado)? (s/n): ";
                getline resp < "/dev/tty";
                if (resp == "s" || resp == "S") {
                    for (i in arr) {
                        if (arr[i] != minpath && arr[i] != "") {
                            cmd="rm -i \""arr[i]"\"";
                            system(cmd);
                            print "      ➜ Eliminado: " arr[i] >> REPORT_FILE;
                        }
                    }
                } else {
                    print "      ➜ No se eliminaron duplicados de este grupo." >> REPORT_FILE;
                }
            }
            print "" >> REPORT_FILE;
            print "";
        }
    }
    print "--------------------------------------------" >> REPORT_FILE;
    print "📊 Espacio total potencial a liberar: " human(total_savings) " (" total_savings " bytes)" >> REPORT_FILE;
    print "--------------------------------------------" >> REPORT_FILE;

    print "\n📊 Espacio total potencial a liberar: " human(total_savings) " (" total_savings " bytes)";
}' 

echo
echo "✅ Proceso finalizado."
echo "📄 Informe generado en: $(realpath "$REPORT_FILE")"

# --- Calcular de nuevo el tamaño si se eliminaron duplicados
if [[ "$ELIMINAR" == "true" ]]; then
  FINAL_BYTES=$(du -sb "$BASE_DIR" | awk '{print $1}')
  FINAL_HUMAN=$(du -sh "$BASE_DIR" | awk '{print $1}')
  echo
  echo "💾 Espacio tras eliminar duplicados: $FINAL_HUMAN ($FINAL_BYTES bytes)"
  echo "💾 Espacio tras eliminar duplicados: $FINAL_HUMAN ($FINAL_BYTES bytes)" >> "$REPORT_FILE"
fi

copiar carpeta sin duplicados creando un fichero de duplicados dentro de la carpeta destino (copiar_carpeta_no_duplicados.sh)


#!/bin/bash
# copiar_sin_duplicados.sh
# Copia solo los ficheros no duplicados (por nombre y tamaño)
# y genera informes de los archivos copiados y duplicados.

echo "📁 Introduce la ruta de la carpeta origen:"
read -r ORIGEN

if [[ ! -d "$ORIGEN" ]]; then
  echo "❌ La carpeta origen no existe."
  exit 1
fi

echo "📂 Introduce la ruta de la carpeta destino:"
read -r DESTINO

# Crear carpeta destino si no existe
mkdir -p "$DESTINO"

# Archivos temporales e informes
TMP_FILE=$(mktemp)
REPORT_FILE="copiados_$(date +%Y%m%d_%H%M%S).txt"
DUPLICADOS_FILE="$DESTINO/duplicados_$(date +%Y%m%d_%H%M%S).txt"
> "$REPORT_FILE"
> "$DUPLICADOS_FILE"

echo "🔍 Analizando duplicados en: $ORIGEN"
echo

# --- Calcular tamaño total de la carpeta origen
TOTAL_BYTES=$(du -sb "$ORIGEN" | awk '{print $1}')
TOTAL_HUMAN=$(du -sh "$ORIGEN" | awk '{print $1}')
echo "💾 Tamaño total de la carpeta origen: $TOTAL_HUMAN ($TOTAL_BYTES bytes)"
echo "💾 Tamaño total de la carpeta origen: $TOTAL_HUMAN ($TOTAL_BYTES bytes)" >> "$REPORT_FILE"
echo >> "$REPORT_FILE"

# --- Buscar duplicados (por nombre + tamaño)
find "$ORIGEN" -type f -printf '%s\t%p\n' | \
while IFS=$'\t' read -r SIZE FILE; do
    BASENAME=$(basename "$FILE")
    echo -e "$BASENAME\t$SIZE\t$FILE"
done | sort -k1,1 -k2,2n | \
awk -F'\t' -v TMP_FILE="$TMP_FILE" -v DUPLICADOS_FILE="$DUPLICADOS_FILE" '
{
    name=$1; size=$2; path=$3;
    key=name"|"size;
    files[key]=files[key]?files[key]"\n"path:path;
    sizes[key]=size;
}
END {
    for (k in files) {
        split(files[k], arr, "\n");
        if (length(arr) > 1) {
            print "-----------------------------------" >> DUPLICADOS_FILE;
            print "Duplicado (" k "):" >> DUPLICADOS_FILE;
            for (i in arr) {
                print arr[i] >> TMP_FILE;
                print "   " arr[i] >> DUPLICADOS_FILE;
            }
        }
    }
}'

# --- Copiar solo los no duplicados
echo "🚀 Iniciando copia de ficheros no duplicados..."
echo >> "$REPORT_FILE"
echo "=============================" >> "$REPORT_FILE"
echo "COPIA DE FICHEROS NO DUPLICADOS" >> "$REPORT_FILE"
echo "=============================" >> "$REPORT_FILE"
echo >> "$REPORT_FILE"

COUNT=0
BYTES_TOTAL_COPIADOS=0
BYTES_DUPLICADOS=0

# Calcular espacio potencial de duplicados
while IFS= read -r FILE_DUP; do
    if [[ -f "$FILE_DUP" ]]; then
        SIZE=$(stat -c%s "$FILE_DUP")
        BYTES_DUPLICADOS=$((BYTES_DUPLICADOS + SIZE))
    fi
done < "$TMP_FILE"

# Copiar los no duplicados
while IFS= read -r FILE; do
    # Saltar duplicados
    if grep -Fxq "$FILE" "$TMP_FILE"; then
        continue
    fi

    REL_PATH="${FILE#$ORIGEN/}"
    DEST_PATH="$DESTINO/$REL_PATH"
    DEST_DIR=$(dirname "$DEST_PATH")

    mkdir -p "$DEST_DIR"
    cp -p "$FILE" "$DEST_PATH"

    SIZE=$(stat -c%s "$FILE")
    BYTES_TOTAL_COPIADOS=$((BYTES_TOTAL_COPIADOS + SIZE))
    COUNT=$((COUNT + 1))

    echo "✔ Copiado: $DEST_PATH" >> "$REPORT_FILE"
done < <(find "$ORIGEN" -type f)

# --- Función para tamaños legibles
function human_readable {
    local bytes=$1
    local units=("B" "KB" "MB" "GB" "TB")
    local i=0
    local value=$bytes
    while (( value >= 1024 && i < 4 )); do
        value=$(( value / 1024 ))
        ((i++))
    done
    echo "${value} ${units[$i]}"
}

TOTAL_HUMAN_COPIADOS=$(human_readable "$BYTES_TOTAL_COPIADOS")
TOTAL_HUMAN_DUPLICADOS=$(human_readable "$BYTES_DUPLICADOS")

# --- Resultados finales
echo
echo "✅ Copia completada."
echo "📊 Archivos copiados: $COUNT"
echo "📦 Tamaño total origen: $TOTAL_HUMAN ($TOTAL_BYTES bytes)"
echo "📥 Tamaño copiado (sin duplicados): $TOTAL_HUMAN_COPIADOS ($BYTES_TOTAL_COPIADOS bytes)"
echo "💾 Espacio ahorrado (duplicados no copiados): $TOTAL_HUMAN_DUPLICADOS ($BYTES_DUPLICADOS bytes)"
echo
echo "📄 Informe de copiados: $(realpath "$REPORT_FILE")"
echo "📁 Listado de duplicados: $(realpath "$DUPLICADOS_FILE")"

echo >> "$REPORT_FILE"
echo "-------------------------------------" >> "$REPORT_FILE"
echo "📦 Tamaño total origen: $TOTAL_HUMAN ($TOTAL_BYTES bytes)" >> "$REPORT_FILE"
echo "📥 Tamaño copiado (sin duplicados): $TOTAL_HUMAN_COPIADOS ($BYTES_TOTAL_COPIADOS bytes)" >> "$REPORT_FILE"
echo "💾 Espacio ahorrado (duplicados no copiados): $TOTAL_HUMAN_DUPLICADOS ($BYTES_DUPLICADOS bytes)" >> "$REPORT_FILE"
echo "-------------------------------------" >> "$REPORT_FILE"

# --- Limpieza
rm -f "$TMP_FILE"




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()