Fix from HEAD.

diff --git a/crypto/aes/aes_ige.c b/crypto/aes/aes_ige.c
index eda7922c6debec1d3a0d1c88c3d53f2907db9e8a..2082d060cf94f880fe00a6f3beebc75bab823a21 100644 (file)
--- a/crypto/aes/aes_ige.c
+++ b/crypto/aes/aes_ige.c
@@ -49,7 +49,7 @@
  *
  */
 
-#include <assert.h>
+#include "cryptlib.h"
 
 #include <openssl/aes.h>
 #include "aes_locl.h"
@@ -84,9 +84,9 @@ void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
        const unsigned char *iv = ivec;
        const unsigned char *iv2 = ivec + AES_BLOCK_SIZE;
 
-       assert(in && out && key && ivec);
-       assert((AES_ENCRYPT == enc)||(AES_DECRYPT == enc));
-       assert((length%AES_BLOCK_SIZE) == 0);
+       OPENSSL_assert(in && out && key && ivec);
+       OPENSSL_assert((AES_ENCRYPT == enc)||(AES_DECRYPT == enc));
+       OPENSSL_assert((length%AES_BLOCK_SIZE) == 0);
 
        if (AES_ENCRYPT == enc)
                {
@@ -94,17 +94,17 @@ void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
                   check for overlap, too) */
                while (len >= AES_BLOCK_SIZE)
                        {
-                       //                      hexdump(stdout, "in", in, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in", in, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] = in[n] ^ iv[n];
-                       //                      hexdump(stdout, "in ^ iv", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in ^ iv", out, AES_BLOCK_SIZE); */
                        AES_encrypt(out, out, key);
-                       //                      hexdump(stdout,"enc", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout,"enc", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] ^= iv2[n];
-                       //                      hexdump(stdout,"out", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout,"out", out, AES_BLOCK_SIZE); */
                        iv = out;
                        memcpy(prev, in, AES_BLOCK_SIZE);
                        iv2 = prev;
@@ -121,17 +121,17 @@ void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
                        {
                        memcpy(tmp, in, AES_BLOCK_SIZE);
                        memcpy(tmp2, in, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "in", in, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in", in, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                tmp[n] ^= iv2[n];
-                       //                      hexdump(stdout, "in ^ iv2", tmp, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in ^ iv2", tmp, AES_BLOCK_SIZE); */
                        AES_decrypt(tmp, out, key);
-                       //                      hexdump(stdout, "dec", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv", ivec, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "dec", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv", ivec, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] ^= ivec[n];
-                       //                      hexdump(stdout, "out", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "out", out, AES_BLOCK_SIZE); */
                        memcpy(ivec, tmp2, AES_BLOCK_SIZE);
                        iv2 = out;
                        len -= AES_BLOCK_SIZE;
@@ -163,9 +163,9 @@ void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
        const unsigned char *iv;
        const unsigned char *iv2;
 
-       assert(in && out && key && ivec);
-       assert((AES_ENCRYPT == enc)||(AES_DECRYPT == enc));
-       assert((length%AES_BLOCK_SIZE) == 0);
+       OPENSSL_assert(in && out && key && ivec);
+       OPENSSL_assert((AES_ENCRYPT == enc)||(AES_DECRYPT == enc));
+       OPENSSL_assert((length%AES_BLOCK_SIZE) == 0);
 
        if (AES_ENCRYPT == enc)
                {
@@ -177,17 +177,17 @@ void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
                iv2 = ivec + AES_BLOCK_SIZE;
                while (len >= AES_BLOCK_SIZE)
                        {
-                       //                      hexdump(stdout, "in", in, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in", in, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] = in[n] ^ iv[n];
-                       //                      hexdump(stdout, "in ^ iv", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in ^ iv", out, AES_BLOCK_SIZE); */
                        AES_encrypt(out, out, key);
-                       //                      hexdump(stdout,"enc", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout,"enc", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] ^= iv2[n];
-                       //                      hexdump(stdout,"out", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout,"out", out, AES_BLOCK_SIZE); */
                        iv = out;
                        memcpy(prev, in, AES_BLOCK_SIZE);
                        iv2 = prev;
@@ -203,19 +203,19 @@ void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
                while(len >= AES_BLOCK_SIZE)
                        {
                        out -= AES_BLOCK_SIZE;
-                       //                      hexdump(stdout, "intermediate", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
-                       // XXX: reduce copies by alternating between buffers
+                       /*                      hexdump(stdout, "intermediate", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE); */
+                       /* XXX: reduce copies by alternating between buffers */
                        memcpy(tmp, out, AES_BLOCK_SIZE);
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] ^= iv[n];
-                       //                      hexdump(stdout, "out ^ iv", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "out ^ iv", out, AES_BLOCK_SIZE); */
                        AES_encrypt(out, out, key);
-                       //                      hexdump(stdout,"enc", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout,"enc", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] ^= iv2[n];
-                       //                      hexdump(stdout,"out", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout,"out", out, AES_BLOCK_SIZE); */
                        iv = out;
                        memcpy(prev, tmp, AES_BLOCK_SIZE);
                        iv2 = prev;
@@ -235,17 +235,17 @@ void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
                        out -= AES_BLOCK_SIZE;
                        memcpy(tmp, in, AES_BLOCK_SIZE);
                        memcpy(tmp2, in, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "in", in, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in", in, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                tmp[n] ^= iv2[n];
-                       //                      hexdump(stdout, "in ^ iv2", tmp, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "in ^ iv2", tmp, AES_BLOCK_SIZE); */
                        AES_decrypt(tmp, out, key);
-                       //                      hexdump(stdout, "dec", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "dec", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv", iv, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] ^= iv[n];
-                       //                      hexdump(stdout, "out", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "out", out, AES_BLOCK_SIZE); */
                        memcpy(tmp3, tmp2, AES_BLOCK_SIZE);
                        iv = tmp3;
                        iv2 = out;
@@ -260,17 +260,17 @@ void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
                        {
                        memcpy(tmp, out, AES_BLOCK_SIZE);
                        memcpy(tmp2, out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "intermediate", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "intermediate", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv2", iv2, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                tmp[n] ^= iv2[n];
-                       //                      hexdump(stdout, "out ^ iv2", tmp, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "out ^ iv2", tmp, AES_BLOCK_SIZE); */
                        AES_decrypt(tmp, out, key);
-                       //                      hexdump(stdout, "dec", out, AES_BLOCK_SIZE);
-                       //                      hexdump(stdout, "iv", ivec, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "dec", out, AES_BLOCK_SIZE); */
+                       /*                      hexdump(stdout, "iv", ivec, AES_BLOCK_SIZE); */
                        for(n=0 ; n < AES_BLOCK_SIZE ; ++n)
                                out[n] ^= iv[n];
-                       //                      hexdump(stdout, "out", out, AES_BLOCK_SIZE);
+                       /*                      hexdump(stdout, "out", out, AES_BLOCK_SIZE); */
                        memcpy(tmp3, tmp2, AES_BLOCK_SIZE);
                        iv = tmp3;
                        iv2 = out;

diff --git a/crypto/evp/e_camellia.c b/crypto/evp/e_camellia.c
index 8bb7c320d3986f196e81ae6a9592b2c052e2e34c..a7b40d1c6001065a34ca1a745c3678046a505689 100644 (file)
--- a/crypto/evp/e_camellia.c
+++ b/crypto/evp/e_camellia.c
@@ -122,4 +122,10 @@ static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
        return 1;
        }
 
+#else
+
+# ifdef PEDANTIC
+static void *dummy=&dummy;
+# endif
+
 #endif

diff --git a/test/igetest.c b/test/igetest.c
index 2f2271b4a784ebff7493d0d906942e6dbce3803a..d93428f42baa2ef84b237b701bd827c8cc5a19fa 100644 (file)
--- a/test/igetest.c
+++ b/test/igetest.c
@@ -285,9 +285,9 @@ int main(int argc, char **argv)
        RAND_pseudo_bytes(iv, sizeof iv);
        memcpy(saved_iv, iv, sizeof saved_iv);
 
-       // Forward IGE only...
+       /* Forward IGE only... */
 
-       // Straight encrypt/decrypt
+       /* Straight encrypt/decrypt */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, iv,
                                        AES_ENCRYPT);
@@ -305,7 +305,7 @@ int main(int argc, char **argv)
                ++err;
                }
 
-       // Now check encrypt chaining works
+       /* Now check encrypt chaining works */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        memcpy(iv, saved_iv, sizeof iv);
        AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE/2, &key, iv,
@@ -327,7 +327,7 @@ int main(int argc, char **argv)
                ++err;
                }
 
-       // And check decrypt chaining
+       /* And check decrypt chaining */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        memcpy(iv, saved_iv, sizeof iv);
        AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE/2, &key, iv,
@@ -352,13 +352,13 @@ int main(int argc, char **argv)
                ++err;
                }
 
-       // make sure garble extends forwards only
+       /* make sure garble extends forwards only */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        memcpy(iv, saved_iv, sizeof iv);
        AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                                        AES_ENCRYPT);
 
-       // corrupt halfway through
+       /* corrupt halfway through */
        ++ciphertext[sizeof ciphertext/2];
        AES_set_decrypt_key(rkey, 8*sizeof rkey, &key);
        memcpy(iv, saved_iv, sizeof iv);
@@ -382,14 +382,14 @@ int main(int argc, char **argv)
                ++err;
                }
 
-       // Bi-directional IGE
+       /* Bi-directional IGE */
 
-       // Note that we don't have to recover the IV, because chaining isn't
-       // possible with biIGE, so the IV is not updated.
+       /* Note that we don't have to recover the IV, because chaining isn't */
+       /* possible with biIGE, so the IV is not updated. */
 
        RAND_pseudo_bytes(rkey2, sizeof rkey2);
 
-       // Straight encrypt/decrypt
+       /* Straight encrypt/decrypt */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        AES_set_encrypt_key(rkey2, 8*sizeof rkey2, &key2);
        AES_bi_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, &key2, iv,
@@ -408,13 +408,13 @@ int main(int argc, char **argv)
                ++err;
                }
 
-       // make sure garble extends both ways
+       /* make sure garble extends both ways */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        AES_set_encrypt_key(rkey2, 8*sizeof rkey2, &key2);
        AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                                        AES_ENCRYPT);
 
-       // corrupt halfway through
+       /* corrupt halfway through */
        ++ciphertext[sizeof ciphertext/2];
        AES_set_decrypt_key(rkey, 8*sizeof rkey, &key);
        AES_set_decrypt_key(rkey2, 8*sizeof rkey2, &key2);
@@ -432,13 +432,13 @@ int main(int argc, char **argv)
                ++err;
                }
 
-       // make sure garble extends both ways (2)
+       /* make sure garble extends both ways (2) */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        AES_set_encrypt_key(rkey2, 8*sizeof rkey2, &key2);
        AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                                        AES_ENCRYPT);
 
-       // corrupt right at the end
+       /* corrupt right at the end */
        ++ciphertext[sizeof ciphertext-1];
        AES_set_decrypt_key(rkey, 8*sizeof rkey, &key);
        AES_set_decrypt_key(rkey2, 8*sizeof rkey2, &key2);
@@ -456,13 +456,13 @@ int main(int argc, char **argv)
                ++err;
                }
 
-       // make sure garble extends both ways (3)
+       /* make sure garble extends both ways (3) */
        AES_set_encrypt_key(rkey, 8*sizeof rkey, &key);
        AES_set_encrypt_key(rkey2, 8*sizeof rkey2, &key2);
        AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                                        AES_ENCRYPT);
 
-       // corrupt right at the start
+       /* corrupt right at the start */
        ++ciphertext[0];
        AES_set_decrypt_key(rkey, 8*sizeof rkey, &key);
        AES_set_decrypt_key(rkey2, 8*sizeof rkey2, &key2);