Kann der private ECC-Schlüssel zur Verschlüsselung verwendet werden?

Question

Ich möchte einen privaten ECC-Schlüssel für die Verschlüsselung wegen der gegenseitigen Authentifizierung verwenden. Aber ich kann keine Methode (oder Funktion) in wolfcrypt (wolfSSL) oder der Micro-ECC-Bibliothek finden.

Ist es in Ordnung, einen (ECC) privaten Schlüssel für die Verschlüsselung zu verwenden? Und wenn ja, wie kann ich das tun?

Answer 1

Um die erste Frage zu beantworten "Ist es möglich, ECC privaten Schlüssel für die Verschlüsselung zu verwenden?"

In der Regel verwalten Benutzer einen privaten Schlüssel und teilen ihren öffentlichen Schlüssel. Der öffentliche Schlüssel ist mathematisch mit dem privaten Schlüssel verschränkt, so dass mit dem öffentlichen Schlüssel verschlüsselte Nachrichten mit dem privaten Schlüssel entschlüsselt werden können. Auf diese Weise bleibt der private Schlüssel genau so, privat! Es wird nicht empfohlen, einen privaten Schlüssel zum Verschlüsseln zu verwenden. Wenn Sie Ihren Grund dafür erklären können, erklären Sie dies bitte. Glücklich, deine Argumentation zu hören. Wenn Sie jedoch lernen und nur unsicher sind, dann vermeiden Sie bitte das, was Sie gefragt haben.

Um die Aussage über die private Schlüsselverschlüsselung für die gegenseitige Authentifizierung zu beantworten ... Ich bin mir nicht sicher, wie das zur gegenseitigen Authentifizierung beitragen wird und ich bin wirklich neugierig, worüber @comomind dort sprach. Hier ist ein Link, wie SSL/TLS, das Problem der gegenseitigen Authentifizierung lösen können: (https://www.codeproject.com/Articles/326574/An-Introduction-to-Mutual-SSL-Authentication)

Für den zweiten Teil der Frage, wo wolfCrypt betrifft, das Verfahren (oder Funktion) in wolfSSL der wolfCrypt Bibliothek:

wc_ecc_encrypt 

Hier ist der Abschnitt von der manuellen diese API beschreiben und die Argumente: (https://www.wolfssl.com/wolfSSL/Docs-wolfssl-manual-18-14-wolfcrypt-api-ecc.html)

wc_ecc_encrypt

Synopsis:

umfassen Header: wolfssl/wolfcrypt/ecc.h

int wc_ecc_encrypt (ecc_key * PrivKey, ecc_key * pubkey, const Byte * msg, word32 msgsz enthält, Byte * out, word32 * outSz , ecEncCtx * ctx);

Beschreibung: Diese Funktion verschlüsselt die angegebene Eingangsnachricht von der Nachricht nach out. Diese Funktion verwendet ein optionales ctx-Objekt als Parameter. Wenn geliefert wird, wird die Verschlüsselung basierend auf ecAlcgo, ecEncCtx kdfAlgo und macAlgo fortgesetzt. Wenn ctx nicht geliefert wird, wird die Verarbeitung mit den Standardalgorithmen ecAES_128_CBC, ecHKDF_SHA256 und ecHMAC_SHA256 zu abgeschlossen.

Diese Funktion erfordert, dass die Nachrichten entsprechend dem Verschlüsselungstyp aufgefüllt werden, der von CTX angegeben wird.

Rückgabewerte: 0: Retour auf erfolgreich die Eingangs Nachricht BAD_FUNC_ARG Verschlüsseln: zurückgegeben, wenn PrivKey, pubkey, msg, msgsz enthält, heraus, oder outSz sind NULL oder CTX-Objekt eine nicht unterstützte Verschlüsselungs Typ BAD_ENC_STATE_E angibt: Retour wenn das angegebene ctx-Objekt sich in einem für die Verschlüsselung ungeeigneten Zustand befindet BUFFER_E: Wird zurückgegeben, wenn der ausgegebene Ausgabepuffer zu klein ist, um den verschlüsselten Chiffretext zu speichern MEMORY_E: Wird zurückgegeben, wenn ein Fehler bei der Speicherzuweisung für den freigegebenen geheimen Schlüssel vorliegt

Parameter: privKey - Zeiger auf die ecc_key Objekt enthält den privaten Schlüssel für die Verschlüsselung pubKey - Zeiger auf den ecc_key Objekt enthält den öffentlichen Schlüssel des Peers, mit dem man möchte kommunizieren msg- Zeiger auf den Puffer mit der Nachricht zu verschlüsseln msgSz - Größe der Puffer zum Verschlüsseln - Zeiger auf den Puffer in , der den verschlüsselten Chiffretext speichert outSz - Zeiger auf ein Word32 Objekt, das die verfügbare Größe im Ausgangspuffer enthält. Nach erfolgreich die Nachricht verschlüsseln, enthält die Anzahl von Bytes an den Ausgangspuffer ctx geschrieben - Optional: Zeiger auf ein ecEncCtx Objekt verschiedene Verschlüsselungsalgorithmen spezifiziert verwenden

Beispiel:

byte msg[] = { /* initialize with msg to encrypt. Ensure 
padded to block size */ }; 
byte out[sizeof(msg)]; word32 outSz = sizeof(out); 
int ret; 
ecc_key cli, serv; // initialize cli with 
private key // initialize serv with received public key 

ecEncCtx* cliCtx, servCtx; // initialize cliCtx and servCtx // 
exchange salts 

ret = wc_ecc_encrypt(&cli, &serv, msg, sizeof(msg), out, &outSz, 
cliCtx); 

if(ret != 0) { // error encrypting message } 

Siehe auch: wc_ecc_decrypt

Beachten Sie, dass diese API in einer öffentlichen nimmt und privater Schlüssel, wobei der öffentliche Schlüssel von dem Peer stammt und der private Schlüssel dein eigener privater Schlüssel ist. Diese API wird dann ECDH verwenden, um ein gemeinsames Geheimnis zu generieren. Das gemeinsame Geheimnis ist, was zum Verschlüsseln und Entschlüsseln verwendet werden sollte. Die Partei, mit der Sie sprechen möchten, nimmt auch Ihren öffentlichen Schlüssel und seinen privaten Schlüssel, um seinen eigenen gemeinsamen geheimen Schlüssel zu generieren. Das gemeinsame Geheimnis wird niemals von beiden Parteien über das Kabel gesendet. Mehr Infos zum Thema Shared Secret hier: (https://crypto.stackexchange.com/questions/21169/how-does-ecdh-arrive-on-a-shared-secret)

TEST CASE: (https://github.com/wolfSSL/wolfssl/blob/master/wolfcrypt/test/test.c#L8701)

#ifdef HAVE_ECC_ENCRYPT 

int ecc_encrypt_test(void) 
{ 
    WC_RNG rng; 
    int  ret; 
    ecc_key userA, userB; 
    byte msg[48]; 
    byte plain[48]; 
    byte out[80]; 
    word32 outSz = sizeof(out); 
    word32 plainSz = sizeof(plain); 
    int  i; 

    ret = wc_InitRng(&rng); 
    if (ret != 0) 
     return -3001; 

    wc_ecc_init(&userA); 
    wc_ecc_init(&userB); 

    ret = wc_ecc_make_key(&rng, 32, &userA); 
    ret += wc_ecc_make_key(&rng, 32, &userB); 

    if (ret != 0) 
     return -3002; 

    for (i = 0; i < 48; i++) 
     msg[i] = i; 

    /* encrypt msg to send to userB */ 
    ret = wc_ecc_encrypt(&userA, &userB, msg, sizeof(msg), out, &outSz, NULL); 
    if (ret != 0) 
     return -3003; 

    /* userB decrypt the message received from userA */ 
    ret = wc_ecc_decrypt(&userB, &userA, out, outSz, plain, &plainSz, NULL); 
    if (ret != 0) 
     return -3004; 

    if (XMEMCMP(plain, msg, sizeof(msg)) != 0) 
     return -3005; 


    { /* let's verify message exchange works, A is client, B is server */ 
     ecEncCtx* cliCtx = wc_ecc_ctx_new(REQ_RESP_CLIENT, &rng); 
     ecEncCtx* srvCtx = wc_ecc_ctx_new(REQ_RESP_SERVER, &rng); 

     byte cliSalt[EXCHANGE_SALT_SZ]; 
     byte srvSalt[EXCHANGE_SALT_SZ]; 
     const byte* tmpSalt; 

     if (cliCtx == NULL || srvCtx == NULL) 
      return -3006; 

     /* get salt to send to peer */ 
     tmpSalt = wc_ecc_ctx_get_own_salt(cliCtx); 
     if (tmpSalt == NULL) 
      return -3007; 
     XMEMCPY(cliSalt, tmpSalt, EXCHANGE_SALT_SZ); 

     tmpSalt = wc_ecc_ctx_get_own_salt(srvCtx); 
     if (tmpSalt == NULL) 
      return -3007; 
     XMEMCPY(srvSalt, tmpSalt, EXCHANGE_SALT_SZ); 

     /* in actual use, we'd get the peer's salt over the transport */ 
     ret = wc_ecc_ctx_set_peer_salt(cliCtx, srvSalt); 
     ret += wc_ecc_ctx_set_peer_salt(srvCtx, cliSalt); 

     ret += wc_ecc_ctx_set_info(cliCtx, (byte*)"wolfSSL MSGE", 11); 
     ret += wc_ecc_ctx_set_info(srvCtx, (byte*)"wolfSSL MSGE", 11); 

     if (ret != 0) 
      return -3008; 

     /* get encrypted msg (request) to send to B */ 
     outSz = sizeof(out); 
     ret = wc_ecc_encrypt(&userA, &userB, msg, sizeof(msg), out, &outSz,cliCtx); 
     if (ret != 0) 
      return -3009; 

     /* B decrypts msg (request) from A */ 
     plainSz = sizeof(plain); 
     ret = wc_ecc_decrypt(&userB, &userA, out, outSz, plain, &plainSz, srvCtx); 
     if (ret != 0) 
      return -3010; 

     if (XMEMCMP(plain, msg, sizeof(msg)) != 0) 
      return -3011; 

     { 
      /* msg2 (response) from B to A */ 
      byte msg2[48]; 
      byte plain2[48]; 
      byte out2[80]; 
      word32 outSz2 = sizeof(out2); 
      word32 plainSz2 = sizeof(plain2); 

      for (i = 0; i < 48; i++) 
       msg2[i] = i+48; 

      /* get encrypted msg (response) to send to B */ 
      ret = wc_ecc_encrypt(&userB, &userA, msg2, sizeof(msg2), out2, 
           &outSz2, srvCtx); 
      if (ret != 0) 
       return -3012; 

      /* A decrypts msg (response) from B */ 
      ret = wc_ecc_decrypt(&userA, &userB, out2, outSz2, plain2, &plainSz2, 
          cliCtx); 
      if (ret != 0) 
       return -3013; 

      if (XMEMCMP(plain2, msg2, sizeof(msg2)) != 0) 
       return -3014; 
     } 

     /* cleanup */ 
     wc_ecc_ctx_free(srvCtx); 
     wc_ecc_ctx_free(cliCtx); 
    } 

    /* cleanup */ 
    wc_ecc_free(&userB); 
    wc_ecc_free(&userA); 
    wc_FreeRng(&rng); 

    return 0; 
} 

#endif /* HAVE_ECC_ENCRYPT */ 

Answer 2

ich wegen der gegenseitigen Authentifizierung einen privaten ECC-Schlüssel für die Verschlüsselung verwendet werden soll. Aber ich kann keine Methode (oder Funktion) in wolfcrypt (wolfSSL) oder der micro-ecc-Bibliothek finden.

Es gibt einen feinen Unterschied in den Definitionen und Operationen. "Verschlüsseln mit dem privaten Schlüssel" ist nicht eine gültige kryptografische Operation. In der Regel, was Sie wollen, ist ein Signatur-Schema mit Recovery.

Wenn Bibliotheken wie OpenSSL oder wolfSSL eine Nachricht signieren, wenden sie oft eine Formatierungsfunktion an und behandeln dann die resultierende Nachricht als eine Instanz von Chiffretext. Dann wird der private Schlüssel verwendet, um den Geheimtext zu entschlüsseln.

---

Ist es in Ordnung, ein (ECC) private Schlüssel für die Verschlüsselung zu benutzen?

Wahrscheinlich nicht, aber wir müssen mehr über das wissen, was Sie tun möchten. Wenn Sie Hilfe beim Entwerfen des Schemas benötigen, sollten Sie wahrscheinlich Cryptography Stack Exchange oder Information Security Stack Exchange besuchen.

---

[Wenn sein OK] Und wenn ja, wie kann ich dies tun?

Wieder hängt es davon ab, was Sie tun. Zu einem bestimmten Zeitpunkt müssen Sie eine formatierte Nachricht als eine Instanz des Chiffretextes behandeln. Ich kann nicht mehr sagen, weil ich mit wolfSSL nicht vertraut bin.

könnten Sie auch Should we sign-then-encrypt, or encrypt-then-sign? auf dem Crypto.SE interessiert. Es scheint eine Überschneidung mit dem zu haben, was Sie tun.