Python LanguageSocket e crittografia / decrittografia dei messaggi tra client e server


introduzione

La crittografia viene utilizzata per motivi di sicurezza. Non ci sono molti esempi di crittografia / decodifica in Python utilizzando CTR di codifica IDEA di crittografia. Scopo di questa documentazione:

Estendere e implementare lo schema RSA Digital Signature nella comunicazione da stazione a stazione. Utilizzando l'hashing per l'integrità del messaggio, questo è SHA-1. Produce un semplice protocollo Key Transport. Cripta chiave con crittografia IDEA. La modalità di Block Cipher è Counter Mode

Osservazioni

Lingua utilizzata: Python 2.7 (Link per il download: https://www.python.org/downloads/ )

Libreria utilizzata:

* PyCrypto (Link per il download: https://pypi.python.org/pypi/pycrypto )

* PyCryptoPlus (Link per il download: https://github.com/doegox/python-cryptoplus )

Installazione della libreria:

PyCrypto: decomprimere il file. Vai alla directory e apri il terminale per linux (alt + ctrl + t) e CMD (shift + tasto destro + seleziona prompt dei comandi aperto qui) per windows. Dopodiché scrivi python setup.py install (Make Sure Python Environment è impostato correttamente nel sistema operativo Windows)

PyCryptoPlus: come l'ultima libreria.

Implementazione delle attività: l'attività è suddivisa in due parti. Uno è il processo di handshake e un altro è il processo di comunicazione. Impostazione socket:

  • Come la creazione di chiavi pubbliche e private e l'hashing della chiave pubblica, ora dobbiamo configurare il socket. Per configurare il socket, dobbiamo importare un altro modulo con "import socket" e connettere (per client) o bind (per server) l'indirizzo IP e la porta con il socket che viene prelevato dall'utente.

    ----------Dalla parte del cliente----------

      server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      host = raw_input("Server Address To Be Connected -> ")
      port = int(input("Port of The Server -> "))
      server.connect((host, port))
    

    ----------Lato server---------

      try:
      #setting up socket
      server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)     
      server.bind((host,port))
      server.listen(5)
      except BaseException: print "-----Check Server Address or Port-----"
    

    "Socket.AF_INET, socket.SOCK_STREAM" ci consentirà di utilizzare la funzione accept () e i fondamentali della messaggistica. Invece, possiamo usare "socket.AF_INET, socket.SOCK_DGRAM" anche se questa volta dovremo usare il setblocking (valore).

Processo di handshake:

  • (CLIENT) Il primo compito è creare una chiave pubblica e privata. Per creare la chiave privata e pubblica, dobbiamo importare alcuni moduli. Sono: da Crypto import Random e da Crypto.PublicKey import RSA. Per creare le chiavi, dobbiamo scrivere poche semplici righe di codici:
random_generator = Random.new().read
        key = RSA.generate(1024,random_generator) 
        public = key.publickey().exportKey()

random_generator è derivato dal modulo " from Crypto import Random ". La chiave è derivata da " da Crypto.PublicKey import RSA " che creerà una chiave privata, dimensione di 1024 generando caratteri casuali. Il pubblico sta esportando la chiave pubblica dalla chiave privata precedentemente generata.

  • (CLIENT) Dopo aver creato la chiave pubblica e privata, dobbiamo hash la chiave pubblica da inviare al server usando l'hash SHA-1. Per usare l'hash SHA-1 dobbiamo importare un altro modulo scrivendo "import hashlib". Per cancellare la chiave pubblica abbiamo scritto due righe di codice:

      hash_object = hashlib.sha1(public) 
      hex_digest = hash_object.hexdigest()
    

Qui hash_object e hex_digest è la nostra variabile. Dopodiché, il client invierà hex_digest e pubblico al server e Server li verificherà confrontando l'hash ottenuto dal client e il nuovo hash della chiave pubblica. Se il nuovo hash e l'hash del client corrispondono, passerà alla procedura successiva. Dato che il pubblico inviato dal client è in forma di stringa, non potrà essere utilizzato come chiave sul lato server. Per evitare ciò e convertire la chiave pubblica stringa in chiave pubblica rsa, dobbiamo scrivere server_public_key = RSA.importKey(getpbk) , qui getpbk è la chiave pubblica del client.

  • (SERVER) Il prossimo passo è creare una chiave di sessione. Qui, ho usato il modulo "os" per creare una chiave casuale "key = os.urandom (16)" che ci darà una chiave lunga 16 bit e dopo di che ho crittografato quella chiave in "AES.MODE_CTR" e l'ho cancellato di nuovo con SHA-1:

     #encrypt CTR MODE session key
     en = AES.new(key_128,AES.MODE_CTR,counter = lambda:key_128) encrypto = en.encrypt(key_128)
     #hashing sha1
     en_object = hashlib.sha1(encrypto)
     en_digest = en_object.hexdigest()
    

Quindi en_digest sarà la nostra chiave di sessione.

  • (SERVER) Per la parte finale del processo di handshake è necessario crittografare la chiave pubblica ricevuta dal client e la chiave di sessione creata sul lato server.

     #encrypting session key and public key
     E = server_public_key.encrypt(encrypto,16)
    

Dopo la crittografia, il server invierà la chiave al client come stringa.

  • (CLIENT) Dopo aver ottenuto la stringa crittografata di (chiave pubblica e di sessione) dal server, il client la decrittografa utilizzando la chiave privata che è stata creata in precedenza insieme alla chiave pubblica. Dato che la chiave crittografata (pubblica e di sessione) era in forma di stringa, ora dobbiamo recuperarla come chiave utilizzando eval (). Se la decrittografia è stata eseguita, il processo di handshake è completato anche quando entrambi i lati confermano che stanno utilizzando le stesse chiavi. Per decifrare:

     en = eval(msg)
     decrypt = key.decrypt(en)
     # hashing sha1
     en_object = hashlib.sha1(decrypt) en_digest = en_object.hexdigest()
    

Ho usato lo SHA-1 qui in modo che sia leggibile nell'output.

Processo di comunicazione:

Per il processo di comunicazione, dobbiamo utilizzare la chiave di sessione da entrambi i lati come KEY per la crittografia IDEA MODE_CTR. Entrambe le parti cripteranno e decodificheranno i messaggi con IDEA.MODE_CTR utilizzando la chiave di sessione.

  • (Crittografia) Per la crittografia IDEA, abbiamo bisogno di una chiave di 16 bit in dimensioni e contatore come deve essere richiamabile. Il contatore è obbligatorio in MODE_CTR. La chiave di sessione che abbiamo crittografato e con hash è ora una dimensione di 40 che supererà la chiave di limite della crittografia IDEA. Quindi, abbiamo bisogno di ridurre la dimensione della chiave di sessione. Per la riduzione, possiamo usare la normale stringa di funzione python incorporata [valore: valore]. Dove il valore può essere qualsiasi valore in base alla scelta dell'utente. Nel nostro caso, ho fatto "key [: 16]" dove ci vorranno da 0 a 16 valori dalla chiave. Questa conversione può essere eseguita in molti modi come chiave [1:17] o chiave [16:]. La parte successiva è creare una nuova funzione di crittografia IDEA scrivendo IDEA.new () che richiederà 3 argomenti per l'elaborazione. Il primo argomento sarà KEY, il secondo argomento sarà la modalità della crittografia IDEA (nel nostro caso, IDEA.MODE_CTR) e il terzo argomento sarà il counter = che è una funzione callable obbligatoria. Il contatore = manterrà una dimensione di stringa che verrà restituita dalla funzione. Per definire il contatore =, dobbiamo usare valori ragionevoli. In questo caso, ho usato la dimensione della KEY definendo lambda. Invece di usare lambda, potremmo usare Counter.Util che genera un valore casuale per counter =. Per utilizzare Counter.Util, è necessario importare il modulo contatore da crypto. Quindi, il codice sarà:

      ideaEncrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda : key)
    

Una volta che definiamo "ideaEncrypt" come la nostra variabile di crittografia IDEA, possiamo usare la funzione di crittografia integrata per crittografare qualsiasi messaggio.

eMsg = ideaEncrypt.encrypt(whole)
#converting the encrypted message to HEXADECIMAL to readable eMsg =         
eMsg.encode("hex").upper()

In questo segmento di codice, intero è il messaggio da crittografare e eMsg è il messaggio crittografato. Dopo aver crittografato il messaggio, l'ho convertito in HEXADECIMAL per renderlo leggibile e upper () è la funzione incorporata per rendere i caratteri maiuscoli. Successivamente, questo messaggio crittografato verrà inviato alla stazione opposta per la decrittografia.

  • (Decodificazione)

Per decodificare i messaggi crittografati, sarà necessario creare un'altra variabile di crittografia utilizzando gli stessi argomenti e la stessa chiave, ma questa volta la variabile decodificherà i messaggi crittografati. Il codice per questo come l'ultima volta. Tuttavia, prima di decifrare i messaggi, abbiamo bisogno di decodificare il messaggio da esadecimale perché nella nostra parte di crittografia abbiamo codificato il messaggio crittografato in esadecimale per renderlo leggibile. Quindi, l'intero codice sarà:

decoded = newmess.decode("hex")
ideaDecrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda: key) 
dMsg = ideaDecrypt.decrypt(decoded)

Questi processi saranno eseguiti sia lato server che lato client per la crittografia e la decrittografia.

Socket e crittografia / decrittografia dei messaggi tra client e server Esempi correlati