Enable and fix many extra warnings supported by GCC and Clang.
[tinc] / src / gcrypt / cipher.c
index ce93fb1..c1ecf50 100644 (file)
@@ -1,6 +1,6 @@
 /*
     cipher.c -- Symmetric block cipher handling
-    Copyright (C) 2007 Guus Sliepen <guus@tinc-vpn.org>
+    Copyright (C) 2007-2022 Guus Sliepen <guus@tinc-vpn.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#include "system.h"
+#include "../system.h"
 
 #include "cipher.h"
-#include "logger.h"
-#include "xalloc.h"
+#include "../cipher.h"
+#include "../logger.h"
+#include "../xalloc.h"
 
 static struct {
        const char *name;
@@ -36,26 +37,24 @@ static struct {
        {NULL, GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CFB, 93},
        {NULL, GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_OFB, 94},
 
-       {NULL, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 418},
-       {"aes", GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC, 419},
-       {NULL, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CFB, 421},
-       {NULL, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_OFB, 420},
+       {"aes-128-ecb", GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 418},
+       {"aes-128-cbc", GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC, 419},
+       {"aes-128-cfb", GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CFB, 421},
+       {"aes-128-ofb", GCRY_CIPHER_AES, GCRY_CIPHER_MODE_OFB, 420},
 
-       {NULL, GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB, 422},
-       {"aes192", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC, 423},
-       {NULL, GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB, 425},
-       {NULL, GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB, 424},
+       {"aes-192-ecb", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB, 422},
+       {"aes-192-cbc", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC, 423},
+       {"aes-192-cfb", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB, 425},
+       {"aes-192-ofb", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB, 424},
 
-       {NULL, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB, 426},
-       {"aes256", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC, 427},
-       {NULL, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB, 429},
-       {NULL, GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB, 428},
+       {"aes-256-ecb", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB, 426},
+       {"aes-256-cbc", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC, 427},
+       {"aes-256-cfb", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB, 429},
+       {"aes-256-ofb", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB, 428},
 };
 
 static bool nametocipher(const char *name, int *algo, int *mode) {
-       size_t i;
-
-       for(i = 0; i < sizeof ciphertable / sizeof *ciphertable; i++) {
+       for(size_t i = 0; i < sizeof(ciphertable) / sizeof(*ciphertable); i++) {
                if(ciphertable[i].name && !strcasecmp(name, ciphertable[i].name)) {
                        *algo = ciphertable[i].algo;
                        *mode = ciphertable[i].mode;
@@ -67,9 +66,7 @@ static bool nametocipher(const char *name, int *algo, int *mode) {
 }
 
 static bool nidtocipher(int nid, int *algo, int *mode) {
-       size_t i;
-
-       for(i = 0; i < sizeof ciphertable / sizeof *ciphertable; i++) {
+       for(size_t i = 0; i < sizeof(ciphertable) / sizeof(*ciphertable); i++) {
                if(nid == ciphertable[i].nid) {
                        *algo = ciphertable[i].algo;
                        *mode = ciphertable[i].mode;
@@ -81,9 +78,7 @@ static bool nidtocipher(int nid, int *algo, int *mode) {
 }
 
 static bool ciphertonid(int algo, int mode, int *nid) {
-       size_t i;
-
-       for(i = 0; i < sizeof ciphertable / sizeof *ciphertable; i++) {
+       for(size_t i = 0; i < sizeof(ciphertable) / sizeof(*ciphertable); i++) {
                if(algo == ciphertable[i].algo && mode == ciphertable[i].mode) {
                        *nid = ciphertable[i].nid;
                        return true;
@@ -102,7 +97,7 @@ static bool cipher_open(cipher_t *cipher, int algo, int mode) {
        }
 
        if((err = gcry_cipher_open(&cipher->handle, algo, mode, 0))) {
-               logger(DEBUG_ALWAYS, LOG_DEBUG, "Unable to intialise cipher %d mode %d: %s", algo, mode, gcry_strerror(err));
+               logger(DEBUG_ALWAYS, LOG_DEBUG, "Unable to initialise cipher %d mode %d: %s", algo, mode, gcry_strerror(err));
                return false;
        }
 
@@ -136,31 +131,54 @@ bool cipher_open_by_nid(cipher_t *cipher, int nid) {
        return cipher_open(cipher, algo, mode);
 }
 
-bool cipher_open_blowfish_ofb(cipher_t *cipher) {
-       return cipher_open(cipher, GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_OFB);
-}
-
 void cipher_close(cipher_t *cipher) {
        if(cipher->handle) {
                gcry_cipher_close(cipher->handle);
                cipher->handle = NULL;
        }
 
-       if(cipher->key) {
-               free(cipher->key);
-               cipher->key = NULL;
-       }
+       free(cipher->key);
+
+       memset(cipher, 0, sizeof(*cipher));
 }
 
 size_t cipher_keylength(const cipher_t *cipher) {
+       if(!cipher) {
+               return 0;
+       }
+
        return cipher->keylen + cipher->blklen;
 }
 
-void cipher_get_key(const cipher_t *cipher, void *key) {
-       memcpy(key, cipher->key, cipher->keylen + cipher->blklen);
+uint64_t cipher_budget(const cipher_t *cipher) {
+       if(!cipher) {
+               return UINT64_MAX; // NULL cipher
+       }
+
+       size_t ivlen = cipher->blklen;
+       size_t blklen = cipher->blklen;
+
+       size_t len = blklen > 1
+                    ? blklen
+                    : ivlen > 1 ? ivlen : 8;
+       size_t bits = len * 4 - 1;
+
+       return bits < 64
+              ? UINT64_C(1) << bits
+              : UINT64_MAX;
+}
+
+size_t cipher_blocksize(const cipher_t *cipher) {
+       if(!cipher || !cipher->blklen) {
+               return 1;
+       }
+
+       return cipher->blklen;
 }
 
 bool cipher_set_key(cipher_t *cipher, void *key, bool encrypt) {
+       (void)encrypt;
+
        memcpy(cipher->key, key, cipher->keylen + cipher->blklen);
 
        gcry_cipher_setkey(cipher->handle, cipher->key, cipher->keylen);
@@ -170,19 +188,12 @@ bool cipher_set_key(cipher_t *cipher, void *key, bool encrypt) {
 }
 
 bool cipher_set_key_from_rsa(cipher_t *cipher, void *key, size_t len, bool encrypt) {
-       memcpy(cipher->key, key + len - cipher->keylen, cipher->keylen + cipher->blklen);
-       memcpy(cipher->key + cipher->keylen, key + len - cipher->keylen - cipher->blklen, cipher->blklen);
+       (void)encrypt;
 
+       memcpy(cipher->key, (char *)key + len - cipher->keylen, cipher->keylen);
        gcry_cipher_setkey(cipher->handle, cipher->key, cipher->keylen);
-       gcry_cipher_setiv(cipher->handle, cipher->key + cipher->keylen, cipher->blklen);
-
-       return true;
-}
 
-bool cipher_regenerate_key(cipher_t *cipher, bool encrypt) {
-       gcry_create_nonce(cipher->key, cipher->keylen + cipher->blklen);
-
-       gcry_cipher_setkey(cipher->handle, cipher->key, cipher->keylen);
+       memcpy((char *)cipher->key + cipher->keylen, (char *)key + len - cipher->blklen - cipher->keylen, cipher->blklen);
        gcry_cipher_setiv(cipher->handle, cipher->key + cipher->keylen, cipher->blklen);
 
        return true;
@@ -193,8 +204,9 @@ bool cipher_encrypt(cipher_t *cipher, const void *indata, size_t inlen, void *ou
        uint8_t pad[cipher->blklen];
 
        if(cipher->padding) {
-               if(!oneshot)
+               if(!oneshot) {
                        return false;
+               }
 
                size_t reqlen = ((inlen + cipher->blklen) / cipher->blklen) * cipher->blklen;
 
@@ -207,14 +219,16 @@ bool cipher_encrypt(cipher_t *cipher, const void *indata, size_t inlen, void *ou
                inlen = reqlen - cipher->blklen;
 
                for(int i = 0; i < cipher->blklen; i++)
-                       if(i < cipher->blklen - padbyte)
+                       if(i < cipher->blklen - padbyte) {
                                pad[i] = ((uint8_t *)indata)[inlen + i];
-                       else
+                       } else {
                                pad[i] = padbyte;
+                       }
        }
 
-       if(oneshot)
+       if(oneshot) {
                gcry_cipher_setiv(cipher->handle, cipher->key + cipher->keylen, cipher->blklen);
+       }
 
        if((err = gcry_cipher_encrypt(cipher->handle, outdata, *outlen, indata, inlen))) {
                logger(DEBUG_ALWAYS, LOG_ERR, "Error while encrypting: %s", gcry_strerror(err));
@@ -222,7 +236,7 @@ bool cipher_encrypt(cipher_t *cipher, const void *indata, size_t inlen, void *ou
        }
 
        if(cipher->padding) {
-               if((err = gcry_cipher_encrypt(cipher->handle, outdata + inlen, cipher->blklen, pad, cipher->blklen))) {
+               if((err = gcry_cipher_encrypt(cipher->handle, (char *)outdata + inlen, cipher->blklen, pad, cipher->blklen))) {
                        logger(DEBUG_ALWAYS, LOG_ERR, "Error while encrypting: %s", gcry_strerror(err));
                        return false;
                }
@@ -237,8 +251,9 @@ bool cipher_encrypt(cipher_t *cipher, const void *indata, size_t inlen, void *ou
 bool cipher_decrypt(cipher_t *cipher, const void *indata, size_t inlen, void *outdata, size_t *outlen, bool oneshot) {
        gcry_error_t err;
 
-       if(oneshot)
+       if(oneshot) {
                gcry_cipher_setiv(cipher->handle, cipher->key + cipher->keylen, cipher->blklen);
+       }
 
        if((err = gcry_cipher_decrypt(cipher->handle, outdata, *outlen, indata, inlen))) {
                logger(DEBUG_ALWAYS, LOG_ERR, "Error while decrypting: %s", gcry_strerror(err));
@@ -246,8 +261,9 @@ bool cipher_decrypt(cipher_t *cipher, const void *indata, size_t inlen, void *ou
        }
 
        if(cipher->padding) {
-               if(!oneshot)
+               if(!oneshot) {
                        return false;
+               }
 
                uint8_t padbyte = ((uint8_t *)outdata)[inlen - 1];
 
@@ -258,20 +274,25 @@ bool cipher_decrypt(cipher_t *cipher, const void *indata, size_t inlen, void *ou
 
                size_t origlen = inlen - padbyte;
 
-               for(int i = inlen - 1; i >= origlen; i--)
+               for(size_t i = inlen - 1; i >= origlen; i--)
                        if(((uint8_t *)outdata)[i] != padbyte) {
                                logger(DEBUG_ALWAYS, LOG_ERR, "Error while decrypting: invalid padding");
                                return false;
                        }
 
                *outlen = origlen;
-       } else
+       } else {
                *outlen = inlen;
+       }
 
        return true;
 }
 
 int cipher_get_nid(const cipher_t *cipher) {
+       if(!cipher || !cipher->nid) {
+               return 0;
+       }
+
        return cipher->nid;
 }