Skip to content
Snippets Groups Projects
Select Git revision
  • c8f4de1f38d88b9bcbc28c91e983616d4e3253e2
  • x86_ghash
  • x86_poly
  • ppc-poly1305-multi
  • ppc-poly-multi-44
  • power7-chacha-fix
  • ppc-r64-44-n
  • ppc-r64-44
  • s390x-gief-fix
  • chacha_m4_fix
  • arm64-poly
  • poly_avx2
  • s390x-poly
  • ppc-poly
  • s390x-ghash-refactor
  • arm64-chacha
  • s390x-ecc-7748
  • s390x-ecc-mod
  • s390x-vf-fix
  • s390x-chacha
  • s390x-sha1
  • nettle_3.6_release_20200429
  • nettle_3.6rc3
  • nettle_3.6rc2
  • nettle_3.6rc1
  • nettle_3.5.1_release_20190627
  • nettle_3.5_release_20190626
  • nettle_3.5rc1
  • nettle_3.4.1_release_20181204
  • nettle_3.4.1rc1
  • nettle_3.4_release_20171119
  • nettle_3.4rc2
  • nettle_3.4rc1
  • nettle_3.3_release_20161001
  • nettle_3.2_release_20160128
  • nettle_3.1.1_release_20150424
  • nettle_3.1_release_20150407
  • nettle_3.1rc3
  • nettle_3.1rc2
  • nettle_3.1rc1
  • nettle_3.0_release_20140607
41 results

camellia-internal.h

Blame
  • Forked from Nettle / nettle
    Source project has a limited visibility.
    cbc.c 2.96 KiB
    /* cbc.c
     *
     * Cipher block chaining mode.
     */
    
    /* nettle, low-level cryptographics library
     *
     * Copyright (C) 2001 Niels Mller
     *  
     * The nettle library is free software; you can redistribute it and/or modify
     * it under the terms of the GNU Lesser General Public License as published by
     * the Free Software Foundation; either version 2.1 of the License, or (at your
     * option) any later version.
     * 
     * The nettle library is distributed in the hope that it will be useful, but
     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
     * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
     * License for more details.
     * 
     * You should have received a copy of the GNU Lesser General Public License
     * along with the nettle library; see the file COPYING.LIB.  If not, write to
     * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
     * MA 02111-1307, USA.
     */
    
    #include "cbc.h"
    
    #include "memxor.h"
    
    #include <assert.h>
    #include <stdlib.h>
    #include <string.h>
    
    void
    cbc_encrypt(void *ctx, void (*f)(void *ctx,
    				 unsigned length, uint8_t *dst,
    				 const uint8_t *src),
    	    unsigned block_size, uint8_t *iv,
    	    unsigned length, uint8_t *dst,
    	    const uint8_t *src)
    {
      assert(!(length % block_size));
    
      for ( ; length; length -= block_size, src += block_size, dst += block_size)
        {
          memxor(iv, src, block_size);
          f(ctx, block_size, dst, iv);
          memcpy(iv, dst, block_size);
        }
    }
    
    void
    cbc_decrypt(void *ctx, void (*f)(void *ctx,
    				 unsigned length, uint8_t *dst,
    				 const uint8_t *src),
    	    unsigned block_size, uint8_t *iv,
    	    unsigned length, uint8_t *dst,
    	    const uint8_t *src)
    {
      assert(!(length % block_size));
    
      if (!length)
        return;
    
      if (src == dst)
        {
          /* Keep a copy of the ciphertext. */
          /* FIXME: If length is large enough, allocate a smaller buffer
           * and process one buffer size at a time */
          uint8_t *tmp = alloca(length);
          memcpy(tmp, src, length);
          src = tmp;
        }
    
      /* Decrypt in ECB mode */
      f(ctx, length, dst, src);
    
      /* XOR the cryptotext, shifted one block */
      memxor(dst, iv, block_size);
      memxor(dst + block_size, src, length - block_size);
      memcpy(iv, src + length - block_size, block_size);
    }
    
    #if 0
    #include "twofish.h"
    #include "aes.h"
    
    static void foo(void)
    {
      struct CBC_CTX(struct twofish_ctx, TWOFISH_BLOCK_SIZE) ctx;
      uint8_t src[TWOFISH_BLOCK_SIZE];
      uint8_t dst[TWOFISH_BLOCK_SIZE];
      
      CBC_ENCRYPT(&ctx, twofish_encrypt, TWOFISH_BLOCK_SIZE, dst, src);
    
      /* Should result in a warning */
      CBC_ENCRYPT(&ctx, aes_encrypt, TWOFISH_BLOCK_SIZE, dst, src);
      
    }
    
    static void foo2(void)
    {
      struct twofish_ctx ctx;
      uint8_t iv[TWOFISH_BLOCK_SIZE];
      uint8_t src[TWOFISH_BLOCK_SIZE];
      uint8_t dst[TWOFISH_BLOCK_SIZE];
      
      CBC_ENCRYPT2(&ctx, twofish_encrypt, TWOFISH_BLOCK_SIZE, iv, TWOFISH_BLOCK_SIZE, dst, src);
      /* Should result in a warning */
      CBC_ENCRYPT2(&ctx, aes_encrypt, TWOFISH_BLOCK_SIZE, iv, TWOFISH_BLOCK_SIZE, dst, src);
    }
    
    #endif