Mostra notizie nelle discussioni
  • Avatar
    ☺
    Scritto da
    ::1
    il 2013-05-03 20:53:21.0 alle 2013-05-03 20:53:21.0
    Trollate totali: 12321
    cifratura asimmetrica e certificati
    Stavo pensando a un modo per distribuire un file in modo che avesse una "scadenza", però non so quanto possano essere giuste le mie elucubrazioni.
    Ve le espongo, vediamo se potete darmi una dritta.

    Creo la mia certification authority:
    $ openssl genrsa -out ca.key
    Generating RSA private key, 1024 bit long modulus
    ..............++++++
    ..........++++++
    e is 65537 (0x10001)
    $ openssl req -new -key ca.key -out ca.csr -batch
    $ openssl x509 -req -in ca.csr -out ca.crt -signkey ca.key
    Signature ok
    subject=/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd
    Getting Private key
    $ 

    Predispongo la directory corrente per poter essere la base dalla CA con openssl:
    $ echo 01 > serial
    $ touch index.txt
    $ mkdir newcerts
    $ cp ca.crt cacert.pem
    $ 

    Preparo una conf modificata di openssl per digli di salvare tutto nella directory corrente, così da non dover usare i privilegi di root e non dover sporcare /etc/ssl/:
    $ sed s:/etc/ssl:.: < /etc/ssl/openssl.cnf > custom.openssl.cnf
    $ 

    Ora con la mia CA posso creare dei certificati:
    $ openssl genrsa -out client.key
    Generating RSA private key, 1024 bit long modulus
    .......................++++++
    .....................................++++++
    e is 65537 (0x10001)
    $ openssl req -new -subj "/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd/CN=client=$(cat serial)" -key client.key -out client.csr -batch
    $ openssl ca -config custom.openssl.cnf -in client.csr -keyfile ca.key -out client.crt -batch
    Using configuration from custom.openssl.cnf
    Check that the request matches the signature
    Signature ok
    Certificate Details:
            Serial Number: 1 (0x1)
            Validity
                Not Before: May  3 18:29:44 2013 GMT
                Not After : May  3 18:29:44 2014 GMT
            Subject:
                countryName               = AU
                stateOrProvinceName       = Some-State
                organizationName          = Internet Widgits Pty Ltd
                commonName                = client=01
            X509v3 extensions:
                X509v3 Basic Constraints: 
                    CA:FALSE
                Netscape Comment: 
                    OpenSSL Generated Certificate
                X509v3 Subject Key Identifier: 
                    53:9C:AA:C6:66:ED:71:FC:75:F2:7E:B9:BF:57:B6:55:E5:90:E2:59
                X509v3 Authority Key Identifier: 
                    DirName:/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd
                    serial:F9:8F:CD:C6:46:20:9F:72
    
    Certificate is to be certified until May  3 18:29:44 2014 GMT (365 days)
    
    Write out database with 1 new entries
    Data Base Updated
    $ 

    Esporto la chiave pubblica della chiave privata di questo certificato appena creato, sia in PEM che in DER, perché dovrò usarlo da java che legge solo quest'ultimo:
     $  openssl rsa -in client.key -outform PEM -pubout -out client.pub.pem
    writing RSA key
    $ openssl rsa -in client.key -outform DER -pubout -out client.pub.der
    writing RSA key
    $ 


    A questo punto vengono fuori i miei dubbi.
    Il primo è il fatto che per cifrare vuole la chiave pubblica e per decifrare vuole quella privata: pensavo fosse il contrario.
    $ echo ciao | openssl rsautl -encrypt -pubin -inkey client.pub.pem -out ciao.enc
    $ openssl rsautl -decrypt -inkey client.key -in ciao.enc
    ciao
    $ 

    Il secondo è il fatto che non è possibile cifrare files più grandi della chiave, in particolare più grandi di dim_chiave / 8 - 11.
    PGP riesce a scavalcare questo limite, ma non ho capito come e ho visto che ci sono delle implementazioni in java per questo.
    Alternativamente si può usare il comando smime di openssl, ma dagli esempi che ho trovato non sono riuscito a farli funzionare, perché non vedono la mia CA e non c'è modo di dargli la configurazione custom che ho fatto.

    Infine tutto questo ambaradan dovrebbe permettere di decodificare il file solo fino alla scadenza del certificato. Secondo voi funziona o mi sto inventando troppe cose?
    Che mi consigliate?

    **Modificato dall'autore il 03.05.2013 20:54**
    Young professional woman and busy mom.
    • Avatar
      Scritto da
      Non Autenticato
      il 2013-05-03 22:01:58.0 alle 2013-05-03 22:01:58.0
      Re: cifratura asimmetrica e certificati
      Scritto da: ::1
      > Stavo pensando a un modo per distribuire un file in modo che avesse una "scadenza", però non so quanto possano essere giuste le mie elucubrazioni.
      > Ve le espongo, vediamo se potete darmi una dritta.
      >
      > Creo la mia certification authority:
      $ openssl genrsa -out ca.key
      > Generating RSA private key, 1024 bit long modulus
      > ..............++++++
      > ..........++++++
      > e is 65537 (0x10001)
      > $ openssl req -new -key ca.key -out ca.csr -batch
      > $ openssl x509 -req -in ca.csr -out ca.crt -signkey ca.key
      > Signature ok
      > subject=/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd
      > Getting Private key
      > $ 

      > Predispongo la directory corrente per poter essere la base dalla CA con openssl:
      $ echo 01 > serial
      > $ touch index.txt
      > $ mkdir newcerts
      > $ cp ca.crt cacert.pem
      > $ 

      > Preparo una conf modificata di openssl per digli di salvare tutto nella directory corrente, così da non dover usare i privilegi di root e non dover sporcare /etc/ssl/:
      $ sed s:/etc/ssl:.: < /etc/ssl/openssl.cnf > custom.openssl.cnf
      > $ 

      > Ora con la mia CA posso creare dei certificati:
      $ openssl genrsa -out client.key
      > Generating RSA private key, 1024 bit long modulus
      > .......................++++++
      > .....................................++++++
      > e is 65537 (0x10001)
      > $ openssl req -new -subj "/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd/CN=client=$(cat serial)" -key client.key -out client.csr -batch
      > $ openssl ca -config custom.openssl.cnf -in client.csr -keyfile ca.key -out client.crt -batch
      > Using configuration from custom.openssl.cnf
      > Check that the request matches the signature
      > Signature ok
      > Certificate Details:
      > Serial Number: 1 (0x1)
      > Validity
      > Not Before: May  3 18:29:44 2013 GMT
      > Not After : May  3 18:29:44 2014 GMT
      > Subject:
      > countryName               = AU
      > stateOrProvinceName       = Some-State
      > organizationName          = Internet Widgits Pty Ltd
      > commonName                = client=01
      > X509v3 extensions:
      > X509v3 Basic Constraints: 
      > CA:FALSE
      > Netscape Comment: 
      > OpenSSL Generated Certificate
      > X509v3 Subject Key Identifier: 
      > 53:9C:AA:C6:66:ED:71:FC:75:F2:7E:B9:BF:57:B6:55:E5:90:E2:59
      > X509v3 Authority Key Identifier: 
      > DirName:/C=AU/ST=Some-State/O=Internet Widgits Pty Ltd
      > serial:F9:8F:CD:C6:46:20:9F:72
      > 
      > Certificate is to be certified until May  3 18:29:44 2014 GMT (365 days)
      > 
      > Write out database with 1 new entries
      > Data Base Updated
      > $ 

      > Esporto la chiave pubblica della chiave privata di questo certificato appena creato, sia in PEM che in DER, perché dovrò usarlo da java che legge solo quest'ultimo:
       $  openssl rsa -in client.key -outform PEM -pubout -out client.pub.pem
      > writing RSA key
      > $ openssl rsa -in client.key -outform DER -pubout -out client.pub.der
      > writing RSA key
      > $ 

      >
      > A questo punto vengono fuori i miei dubbi.
      > Il primo è il fatto che per cifrare vuole la chiave pubblica e per decifrare vuole quella privata: pensavo fosse il contrario.
      $ echo ciao | openssl rsautl -encrypt -pubin -inkey client.pub.pem -out ciao.enc
      > $ openssl rsautl -decrypt -inkey client.key -in ciao.enc
      > ciao
      > $ 

      > Il secondo è il fatto che non è possibile cifrare files più grandi della chiave, in particolare più grandi di dim_chiave / 8 - 11.
      > PGP riesce a scavalcare questo limite, ma non ho capito come e ho visto che ci sono delle implementazioni in java per questo.
      > Alternativamente si può usare il comando smime di openssl, ma dagli esempi che ho trovato non sono riuscito a farli funzionare, perché non vedono la mia CA e non c'è modo di dargli la configurazione custom che ho fatto.
      >
      > Infine tutto questo ambaradan dovrebbe permettere di decodificare il file solo fino alla scadenza del certificato. Secondo voi funziona o mi sto inventando troppe cose?
      > Che mi consigliate?

      basta che uno si scarichi la chiave pubblica e ti ha fottuto no?
<softv>

Pagina generata in 136 millisecondi

Utenti attivi: 9 nell'ultimo minuto, 27 negli ultimi cinque minuti, 46 negli ultimi 15 minuti