FS-11816: [Build-System] Update libsrtp to 2.2.0

libs/srtp/.clang-format

@@ -0,0 +1,79 @@
+AccessModifierOffset: -4
+
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands:   true
+AlignTrailingComments: true
+
+AllowAllParametersOfDeclarationOnNextLine: false
+
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+
+BinPackArguments: true
+BinPackParameters: false
+BraceWrapping:
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   true
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+ContinuationIndentWidth: 4
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+
+IndentCaseLabels: false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+
+KeepEmptyLinesAtTheStartOfBlocks: false
+
+MaxEmptyLinesToKeep: 1
+
+PenaltyBreakBeforeFirstCallParameter: 16
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000
+PenaltyReturnTypeOnItsOwnLine: 9000
+
+Cpp11BracedListStyle: false
+
+PointerAlignment: Right
+
+ReflowComments:  true
+
+SortIncludes: false
+
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth:        4
+UseTab:          Never

libs/srtp/.gitignore

@@ -0,0 +1,50 @@
+# Misc crap
+*~
+old
+old?
+*.pc
+
+# Object files
+*.o
+
+# Libraries
+*.lib
+*.a
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# srtp things
+Debug
+Makefile
+Root
+autom4te.cache
+config.log
+config.status
+crypto/include/config.h
+crypto/test/aes_calc
+crypto/test/cipher_driver
+crypto/test/datatypes_driver
+crypto/test/env
+crypto/test/kernel_driver
+crypto/test/rand_gen
+crypto/test/sha1_driver
+crypto/test/stat_driver
+crypto/test/rand_gen_soak
+tables/aes_tables
+test/dtls_srtp_driver
+test/rdbx_driver
+test/replay_driver
+test/roc_driver
+test/rtp_decoder
+test/rtpw
+test/srtp_driver
+test/test_srtp

libs/srtp/.travis.yml

@@ -0,0 +1,131 @@
+dist: trusty
+sudo: false
+language: c
+
+env:
+  global:
+    - secure: "QD09MuUxftXRXtz7ZrB7S0NV/3O9yVhjvIlCSbXN8B87rNSDC8wxMThKMT7iZewnqGk53m+Up19PiMw5ERlHose5tm2cmY1FO/l+c9oAyWZaAL+4XNXryq6zI5F5FX5I61NbfqV3xcnfLTI2QIJF6WqDojNxhPjTbNzQGxIDuqw="
+
+matrix:
+  include:
+
+    # default linux build with gcc
+    - os: linux
+      env:
+        - TEST="linux gcc"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+          - gcc-6
+      script:
+        - CC=gcc-6 EXTRA_CFLAGS=-Werror ./configure
+        - make
+        - make runtest
+
+    # linux build with openssl and gcc
+    - os: linux
+      env:
+        - TEST="linux gcc (openssl)"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - gcc-6
+      script:
+        - CC=gcc-6 EXTRA_CFLAGS=-Werror ./configure --enable-openssl
+        - make
+        - make runtest
+
+    # linux build with openssl and clang
+    - os: linux
+      env:
+        - TEST="linux clang (openssl)"
+      addons:
+        apt:
+          packages:
+            - clang
+      script:
+        - CC=clang EXTRA_CFLAGS=-Werror ./configure --enable-openssl
+        - make
+        - make runtest
+
+    # default osx build with xcode (clang)
+    - os: osx
+      env:
+        - TEST="osx XCode 8.2"
+      osx_image: xcode8.2
+      script:
+        - EXTRA_CFLAGS=-Werror ./configure
+        - make
+        - make runtest
+
+    # code format check
+    - os: linux
+      env:
+        - TEST="clang-format"
+      addons:
+        apt:
+          packages:
+            - clang-format-3.9
+      script:
+        - CLANG_FORMAT=clang-format-3.9 ./format.sh -d
+
+    # valgrind
+    - os: linux
+      env:
+        - TEST="valgrind (openssl)"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - gcc-6
+            - valgrind
+      script:
+        - CC=gcc-6 ./configure --enable-openssl
+        - make
+        - make runtest-valgrind
+
+    # big-endian
+    - os: linux
+      sudo: true
+      env:
+        - TEST="big-endian"
+      services:
+        - docker
+      addons:
+        apt:
+          packages:
+            - qemu-user-static
+            - qemu-system-mips
+      before_install:
+        - sudo docker run --volume $(pwd):/src --workdir /src --name mipsX --tty --detach ubuntu:16.04 tail
+        - sudo docker exec --tty mipsX apt-get update
+        - sudo docker exec --tty mipsX apt-get install build-essential -y
+        - sudo docker exec --tty mipsX apt-get install gcc-mips-linux-gnu -y
+      script:
+        - sudo docker exec --tty mipsX bash -c 'EXTRA_CFLAGS=-static CC=mips-linux-gnu-gcc ./configure --host=mips-linux-gnu'
+        - sudo docker exec --tty mipsX make
+        - sudo docker kill mipsX
+        - file test/srtp_driver
+        - make runtest
+
+    # coverity scan
+    - os: linux
+      env:
+        - TEST="Coverity Scan"
+      addons:
+        coverity_scan:
+          project:
+            name: "cisco-libSRTP"
+            description: "Build submitted via Travis CI"
+            version: 2
+          notification_email: pabuhler@cisco.com
+          build_command_prepend: "./configure"
+          build_command: "make"
+          branch_pattern: master
+      script:
+        - echo -n | openssl s_client -connect scan.coverity.com:443 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | sudo tee -a /etc/ssl/certs/ca-

libs/srtp/.update

@@ -1 +1 @@
-Wed Apr  9 03:14:42 CDT 2014
+Fri Apr 26 00:00:02 CDT 2019

libs/srtp/CHANGES

@@ -1,5 +1,65 @@
 Changelog
 
+2.2.0-pre (This version)
+
+Major changes
+
+All code has been reformatted to be consistent. A .clang-format file and format.sh script has been added that can be use to verify and enforce consistent formatting. An automated check on code formatting is now part of travis build.
+
+Other changes
+
+PR #409 - Compatibilty with LibreSSL
+
+PR #406 - Fix unprotect when pktlen < (2*mki_size + tag_len)
+
+PR #405 - Prevent potential double free
+
+PR #404 - Add back extern to global variables
+
+PR #403 - Set gcm IV directly with EVP_CipherInit_ex
+
+PR #401 - Fix memory access issue in srtp_get_session_keys()
+
+PR #398 - Fix memory access fixes when invalid profiles where used
+
+PR #391 - Return NULL when allocating memory of size zero
+
+PR #390 - Bitvector of length zero is not valid
+
+PR #385 - Treat warnings as errors on travis builds
+
+PR #388 - Moved externs from crypto_kernel into its own header
+
+PR #379 - Fixed several compiler warnings from Firefox builds
+
+PR #377 - Removed variable init code in rdbx which never gets used
+
+PR #381 - Added error in case the platform is not detected
+
+PR #376 - Add coverity scan to travis builds
+
+PR #374 - Add a big endian build on travis
+
+PR #373 - Fixed buffer size issue in test/srtp_driver.c
+
+PR #372 - Make rtp_decoder compile on MinGW
+
+PR #367 - Rename configure.in to configure.ac
+
+PR #365 - Replace calls to free() with srtp_crypto_free()
+
+PR #364 - Add valgrind to travis and fix leaks in tests
+
+PR #363 - Change smtp_crypto_alloc to initialize memory to zero
+
+PR #354 - Fix potential leak if cloning of stream fails
+
+PR #340 - Fix potential leak in srtp_add_stream()
+
+PR #323 - Fix running test in out of source builds
+
+Issue #316  - Remove VERSION file
+
 2.1.0
 
 Compatibility changes

libs/srtp/COPYING

@@ -1,35 +0,0 @@
-/*
- *	
- * Copyright (c) 2001-2005 Cisco Systems, Inc.
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- *   Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * 
- *   Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following
- *   disclaimer in the documentation and/or other materials provided
- *   with the distribution.
- * 
- *   Neither the name of the Cisco Systems, Inc. nor the names of its
- *   contributors may be used to endorse or promote products derived
- *   from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */

libs/srtp/INSTALL

@@ -1,236 +0,0 @@
-Installation Instructions
-*************************
-
-Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free
-Software Foundation, Inc.
-
-This file is free documentation; the Free Software Foundation gives
-unlimited permission to copy, distribute and modify it.
-
-Basic Installation
-==================
-
-These are generic installation instructions.
-
-   The `configure' shell script attempts to guess correct values for
-various system-dependent variables used during compilation.  It uses
-those values to create a `Makefile' in each directory of the package.
-It may also create one or more `.h' files containing system-dependent
-definitions.  Finally, it creates a shell script `config.status' that
-you can run in the future to recreate the current configuration, and a
-file `config.log' containing compiler output (useful mainly for
-debugging `configure').
-
-   It can also use an optional file (typically called `config.cache'
-and enabled with `--cache-file=config.cache' or simply `-C') that saves
-the results of its tests to speed up reconfiguring.  (Caching is
-disabled by default to prevent problems with accidental use of stale
-cache files.)
-
-   If you need to do unusual things to compile the package, please try
-to figure out how `configure' could check whether to do them, and mail
-diffs or instructions to the address given in the `README' so they can
-be considered for the next release.  If you are using the cache, and at
-some point `config.cache' contains results you don't want to keep, you
-may remove or edit it.
-
-   The file `configure.ac' (or `configure.in') is used to create
-`configure' by a program called `autoconf'.  You only need
-`configure.ac' if you want to change it or regenerate `configure' using
-a newer version of `autoconf'.
-
-The simplest way to compile this package is:
-
-  1. `cd' to the directory containing the package's source code and type
-     `./configure' to configure the package for your system.  If you're
-     using `csh' on an old version of System V, you might need to type
-     `sh ./configure' instead to prevent `csh' from trying to execute
-     `configure' itself.
-
-     Running `configure' takes awhile.  While running, it prints some
-     messages telling which features it is checking for.
-
-  2. Type `make' to compile the package.
-
-  3. Optionally, type `make check' to run any self-tests that come with
-     the package.
-
-  4. Type `make install' to install the programs and any data files and
-     documentation.
-
-  5. You can remove the program binaries and object files from the
-     source code directory by typing `make clean'.  To also remove the
-     files that `configure' created (so you can compile the package for
-     a different kind of computer), type `make distclean'.  There is
-     also a `make maintainer-clean' target, but that is intended mainly
-     for the package's developers.  If you use it, you may have to get
-     all sorts of other programs in order to regenerate files that came
-     with the distribution.
-
-Compilers and Options
-=====================
-
-Some systems require unusual options for compilation or linking that the
-`configure' script does not know about.  Run `./configure --help' for
-details on some of the pertinent environment variables.
-
-   You can give `configure' initial values for configuration parameters
-by setting variables in the command line or in the environment.  Here
-is an example:
-
-     ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
-
-   *Note Defining Variables::, for more details.
-
-Compiling For Multiple Architectures
-====================================
-
-You can compile the package for more than one kind of computer at the
-same time, by placing the object files for each architecture in their
-own directory.  To do this, you must use a version of `make' that
-supports the `VPATH' variable, such as GNU `make'.  `cd' to the
-directory where you want the object files and executables to go and run
-the `configure' script.  `configure' automatically checks for the
-source code in the directory that `configure' is in and in `..'.
-
-   If you have to use a `make' that does not support the `VPATH'
-variable, you have to compile the package for one architecture at a
-time in the source code directory.  After you have installed the
-package for one architecture, use `make distclean' before reconfiguring
-for another architecture.
-
-Installation Names
-==================
-
-By default, `make install' installs the package's commands under
-`/usr/local/bin', include files under `/usr/local/include', etc.  You
-can specify an installation prefix other than `/usr/local' by giving
-`configure' the option `--prefix=PREFIX'.
-
-   You can specify separate installation prefixes for
-architecture-specific files and architecture-independent files.  If you
-pass the option `--exec-prefix=PREFIX' to `configure', the package uses
-PREFIX as the prefix for installing programs and libraries.
-Documentation and other data files still use the regular prefix.
-
-   In addition, if you use an unusual directory layout you can give
-options like `--bindir=DIR' to specify different values for particular
-kinds of files.  Run `configure --help' for a list of the directories
-you can set and what kinds of files go in them.
-
-   If the package supports it, you can cause programs to be installed
-with an extra prefix or suffix on their names by giving `configure' the
-option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
-
-Optional Features
-=================
-
-Some packages pay attention to `--enable-FEATURE' options to
-`configure', where FEATURE indicates an optional part of the package.
-They may also pay attention to `--with-PACKAGE' options, where PACKAGE
-is something like `gnu-as' or `x' (for the X Window System).  The
-`README' should mention any `--enable-' and `--with-' options that the
-package recognizes.
-
-   For packages that use the X Window System, `configure' can usually
-find the X include and library files automatically, but if it doesn't,
-you can use the `configure' options `--x-includes=DIR' and
-`--x-libraries=DIR' to specify their locations.
-
-Specifying the System Type
-==========================
-
-There may be some features `configure' cannot figure out automatically,
-but needs to determine by the type of machine the package will run on.
-Usually, assuming the package is built to be run on the _same_
-architectures, `configure' can figure that out, but if it prints a
-message saying it cannot guess the machine type, give it the
-`--build=TYPE' option.  TYPE can either be a short name for the system
-type, such as `sun4', or a canonical name which has the form:
-
-     CPU-COMPANY-SYSTEM
-
-where SYSTEM can have one of these forms:
-
-     OS KERNEL-OS
-
-   See the file `config.sub' for the possible values of each field.  If
-`config.sub' isn't included in this package, then this package doesn't
-need to know the machine type.
-
-   If you are _building_ compiler tools for cross-compiling, you should
-use the option `--target=TYPE' to select the type of system they will
-produce code for.
-
-   If you want to _use_ a cross compiler, that generates code for a
-platform different from the build platform, you should specify the
-"host" platform (i.e., that on which the generated programs will
-eventually be run) with `--host=TYPE'.
-
-Sharing Defaults
-================
-
-If you want to set default values for `configure' scripts to share, you
-can create a site shell script called `config.site' that gives default
-values for variables like `CC', `cache_file', and `prefix'.
-`configure' looks for `PREFIX/share/config.site' if it exists, then
-`PREFIX/etc/config.site' if it exists.  Or, you can set the
-`CONFIG_SITE' environment variable to the location of the site script.
-A warning: not all `configure' scripts look for a site script.
-
-Defining Variables
-==================
-
-Variables not defined in a site shell script can be set in the
-environment passed to `configure'.  However, some packages may run
-configure again during the build, and the customized values of these
-variables may be lost.  In order to avoid this problem, you should set
-them in the `configure' command line, using `VAR=value'.  For example:
-
-     ./configure CC=/usr/local2/bin/gcc
-
-causes the specified `gcc' to be used as the C compiler (unless it is
-overridden in the site shell script).  Here is a another example:
-
-     /bin/bash ./configure CONFIG_SHELL=/bin/bash
-
-Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent
-configuration-related scripts to be executed by `/bin/bash'.
-
-`configure' Invocation
-======================
-
-`configure' recognizes the following options to control how it operates.
-
-`--help'
-`-h'
-     Print a summary of the options to `configure', and exit.
-
-`--version'
-`-V'
-     Print the version of Autoconf used to generate the `configure'
-     script, and exit.
-
-`--cache-file=FILE'
-     Enable the cache: use and save the results of the tests in FILE,
-     traditionally `config.cache'.  FILE defaults to `/dev/null' to
-     disable caching.
-
-`--config-cache'
-`-C'
-     Alias for `--cache-file=config.cache'.
-
-`--quiet'
-`--silent'
-`-q'
-     Do not print messages saying which checks are being made.  To
-     suppress all normal output, redirect it to `/dev/null' (any error
-     messages will still be shown).
-
-`--srcdir=DIR'
-     Look for the package's source code in directory DIR.  Usually
-     `configure' can determine that directory automatically.
-
-`configure' also accepts some other, not widely useful, options.  Run
-`configure --help' for more details.
-

libs/srtp/Makefile.am

@@ -34,7 +34,8 @@ libsrtp_la_SOURCES += gdoi/srtp+gdoi.c
 endif
 
 library_includedir =  $(prefix)/include/srtp
-library_include_HEADERS = include/rtp.h include/srtp.h include/ut_sim.h crypto/include/auth.h \
+library_include_HEADERS = include/srtp.h include/ut_sim.h crypto/include/auth.h \
+          crypto/include/cipher_types.h \
           crypto/include/datatypes.h crypto/include/integers.h crypto/include/null_cipher.h \
           crypto/include/rdbx.h crypto/include/aes_icm.h crypto/include/cipher.h crypto/include/crypto_types.h  \
           crypto/include/err.h crypto/include/sha1.h \
@@ -43,4 +44,4 @@ library_include_HEADERS = include/rtp.h include/srtp.h include/ut_sim.h crypto/i
           crypto/include/hmac.h crypto/include/null_auth.h crypto/include/rdb.h
 
 pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = srtp-1.42.pc
+pkgconfig_DATA = libsrtp2.pc

libs/srtp/README.md

@@ -1,3 +1,6 @@
+[![Build Status](https://travis-ci.org/cisco/libsrtp.svg?branch=master)](https://travis-ci.org/cisco/libsrtp)
+[![Coverity Scan Build Status](https://scan.coverity.com/projects/14274/badge.svg)](https://scan.coverity.com/projects/cisco-libsrtp)
+
 <a name="introduction-to-libsrtp"></a>
 # Introduction to libSRTP
 
@@ -51,6 +54,7 @@ because it does its work behind the scenes.
   - [Supported Features](#supported-features)
   - [Implementation Notes](#implementation-notes)
 - [Installing and Building libSRTP](#installing-and-building-libsrtp)
+  - [Changing Build Configuration](#changing-build-configuration)
 - [Applications](#applications)
   - [Example Code](#example-code)
 - [Credits](#credits)
@@ -291,6 +295,26 @@ OpenBSD (sparc-unknown-openbsd2.7).
 
 --------------------------------------------------------------------------------
 
+<a name="changing-build-configuration"></a>
+## Changing Build Configuration
+
+To build the `./configure` script mentioned above, libSRTP relies on the
+[automake](https://www.gnu.org/software/automake/) toolchain.  Since
+`./configure` is built from `configure.in` by automake, if you make changes in
+how `./configure` works (e.g., to add a new library dependency), you will need
+to rebuild `./configure` and commit the updated version.  In addition to
+automake itself, you will need to have the `pkgconfig` tools installed as well.
+
+For example, on macOS:
+
+```
+brew install automake pkgconfig
+# Edit configure.in
+autoremake -ivf
+```
+
+--------------------------------------------------------------------------------
+
 <a name="applications"></a>
 # Applications
 
@@ -397,6 +421,9 @@ uint8_t key[30] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 // initialize libSRTP
 srtp_init();
 
+// default policy values
+memset(&policy, 0x0, sizeof(srtp_policy_t));
+
 // set policy to describe a policy for an SRTP stream
 crypto_policy_set_rtp_default(&policy.rtp);
 crypto_policy_set_rtcp_default(&policy.rtcp);

libs/srtp/TODO

@@ -1,66 +0,0 @@
-TODO List
-
-1.4.1
-
-  - document which fields are in NBO/HBO, and check for consistency.
-
-  - move HAVE_U_LONG_LONG inside of datatypes.c, or some other
-    separate file
-
-  - re-write configure.in to make cross-compilation easier
-
-  - eliminate GENERIC_AESICM by generalizing the code a bit
-
-Older comments
-
-  - add tests for key_limit_t datatype 
-
-  - move octet_get_weight() from datatypes.c to math.c (any other
-    funcs?)
-
-Changes and additions planned
-
-  Make cipher and auth dealloc() functions zeroize the key-storage
-  areas before calling free().
-
-  Eliminate key_len from auth_init()
-
-  Doucument internal APIs (cipher, auth, srtp_protect, ...)
-
-
-SRTP options not (yet) included in this libaray:
-
- - the aes-f8-mode cipher
- - the Master Key Index
- - re-keying using the key derivation function (only the initial
-   use of the PRF has been implemented, as it's sufficient
-   for most uses)
-
-
-(OLD) PLANNED CHANGES
-
-   strip out test/lfsr.c
-
-   Write new documentation!!!
-
-   Fix the x86 assembly code in aes.c.
-
-   Eliminate /* DAM */ - there's one in srtp.c
-
-   Change debugging so that it can print more than one line.  Or perhaps
-   just change it so that a single check of the debug-enabled flag is
-   needed.
-
-   Improve interface between cipher and rdbx - perhaps generalize rdbx
-   into 'nonce' datatype.
-
-   Make rijndael_icm accept variable sized keys.
-
-   Add rdbx functions that allow different-sized explicit sequence
-   numbers to be used.
-
-   Write uniform byte-buffering code for PRFs, preferably as macros.
-
-   Consider eliminating low-level alloc functions in favor of len()
-   functions, so that there need not be multiple allocations within a
-   particular alloc() function.

libs/srtp/VERSION

@@ -1 +0,0 @@
-2.1.0-pre

libs/srtp/acsite.m4

@@ -1,6 +0,0 @@
-m4_include([build/config/ax_compiler_vendor.m4])
-m4_include([build/config/ax_cflags_warn_all_ansi.m4])
-m4_include([build/config/ax_cc_maxopt.m4])
-m4_include([build/config/ax_check_compiler_flags.m4])
-m4_include([build/config/ac_gcc_archflag.m4])
-m4_include([build/config/ac_gcc_x86_cpuid.m4])

libs/srtp/config.hw

@@ -181,5 +181,4 @@ typedef __int64		int64_t;
 
 #ifdef _MSC_VER
 #pragma warning(disable:4311)
-#define OPENSSL
 #endif

libs/srtp/config.hw.orig

@@ -1,182 +0,0 @@
-/* crypto/include/config.h.  Generated by configure.  */
-/* config_in.h.  Generated from configure.in by autoheader.  */
-
-#if (_MSC_VER >= 1400)
-# define HAVE_RAND_S	1
-# define _CRT_RAND_S
-#endif
-
-/* Define if building for a CISC machine (e.g. Intel). */
-#define CPU_CISC 1
-
-/* Define if building for a RISC machine (assume slow byte access). */
-/* #undef CPU_RISC */
-
-/* Define to enabled debug logging for all mudules. */
-#undef ENABLE_DEBUG_LOGGING
-
-/* Logging statments will be writen to this file. */
-/* #undef ERR_REPORTING_FILE */
-
-/* Define to redirect logging to stdout. */
-#undef ERR_REPORTING_STDOUT
-
-/* Define to 1 if you have the <arpa/inet.h> header file. */
-/* #undef HAVE_ARPA_INET_H */
-
-/* Define to 1 if you have the <byteswap.h> header file. */
-/* #undef HAVE_BYTESWAP_H */
-
-/* Define to 1 if you have the `inet_aton' function. */
-/* #undef HAVE_INET_ATON */
-
-/* Define to 1 if the system has the type `int16_t'. */
-#define HAVE_INT16_T 1
-
-/* Define to 1 if the system has the type `int32_t'. */
-#define HAVE_INT32_T 1
-
-/* Define to 1 if the system has the type `int8_t'. */
-#define HAVE_INT8_T 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-/* #undef HAVE_INTTYPES_H */
-
-/* Define to 1 if you have the `socket' library (-lsocket). */
-/* #undef HAVE_LIBSOCKET */
-
-/* Define to 1 if you have the <machine/types.h> header file. */
-/* #undef HAVE_MACHINE_TYPES_H */
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-/* #undef HAVE_NETINET_IN_H */
-
-/* Define to 1 if you have the `socket' function. */
-/* #undef HAVE_SOCKET */
-
-/* Define to 1 if you have the <stdint.h> header file. */
-/* #undef HAVE_STDINT_H */
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the <sys/int_types.h> header file. */
-/* #undef HAVE_SYS_INT_TYPES_H */
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-/* #undef HAVE_SYS_SOCKET_H */
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <sys/uio.h> header file. */
-/* #undef HAVE_SYS_UIO_H */
-
-/* Define to 1 if the system has the type `uint16_t'. */
-#define HAVE_UINT16_T 1
-
-/* Define to 1 if the system has the type `uint32_t'. */
-#define HAVE_UINT32_T 1
-
-/* Define to 1 if the system has the type `uint64_t'. */
-#define HAVE_UINT64_T 1
-
-/* Define to 1 if the system has the type `uint8_t'. */
-#define HAVE_UINT8_T 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-/* #undef HAVE_UNISTD_H */
-
-/* Define to 1 if you have the `usleep' function. */
-/* #undef HAVE_USLEEP */
-
-/* Define to 1 if you have the <windows.h> header file. */
-#define HAVE_WINDOWS_H 1
-
-/* Define to 1 if you have the <winsock2.h> header file. */
-#define HAVE_WINSOCK2_H 1
-
-/* Define to use X86 inlined assembly code */
-/* #undef HAVE_X86 */
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT ""
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME ""
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING ""
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME ""
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION ""
-
-/* The size of a `unsigned long', as computed by sizeof. */
-#define SIZEOF_UNSIGNED_LONG 4
-
-/* The size of a `unsigned long long', as computed by sizeof. */
-#define SIZEOF_UNSIGNED_LONG_LONG 8
-
-/* Define to use GDOI. */
-/* #undef SRTP_GDOI */
-
-/* Define to compile for kernel contexts. */
-/* #undef SRTP_KERNEL */
-
-/* Define to compile for Linux kernel context. */
-/* #undef SRTP_KERNEL_LINUX */
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Define to 1 if your processor stores words with the most significant byte
-   first (like Motorola and SPARC, unlike Intel and VAX). */
-/* #undef WORDS_BIGENDIAN */
-
-/* Define to empty if `const' does not conform to ANSI C. */
-/* #undef const */
-
-/* Define 'inline' to nothing, since the MSVC compiler doesn't support it.  */
-#define inline 
-
-/* Define to `unsigned' if <sys/types.h> does not define. */
-/* #undef size_t */
-
-#if (_MSC_VER >= 1400) // VC8+
-#ifndef _CRT_SECURE_NO_DEPRECATE
-#define _CRT_SECURE_NO_DEPRECATE
-#endif
-#ifndef _CRT_NONSTDC_NO_DEPRECATE
-#define _CRT_NONSTDC_NO_DEPRECATE
-#endif
-#endif // VC8+
-
-#ifndef uint32_t
-typedef unsigned __int8		uint8_t;
-typedef unsigned __int16	uint16_t;
-typedef unsigned __int32	uint32_t;
-typedef unsigned __int64    uint64_t;
-typedef __int8		int8_t;
-typedef __int16		int16_t;
-typedef __int32		int32_t;
-typedef __int64		int64_t;
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(disable:4311)
-#endif

libs/srtp/configure.ac

@@ -333,7 +333,7 @@ AM_CONDITIONAL([GDOI],[test "SRTP_GDOI" = "1"])
 
 AC_CONFIG_HEADERS(crypto/include/config.h:config_in.h)
 
-AC_OUTPUT(Makefile crypto/Makefile doc/Makefile test/Makefile srtp-1.42.pc)
+AC_OUTPUT(Makefile crypto/Makefile doc/Makefile test/Makefile libsrtp2.pc)
 
 # This is needed when building outside the source dir.
 AS_MKDIR_P(crypto/cipher)

libs/srtp/crypto/Makefile.in

@@ -1,4 +1,4 @@
-# Makefile for libcryptomodule.a
+# Makefile for crypto test suite
 #
 # David A. McGrew
 # Cisco Systems, Inc.
@@ -9,14 +9,14 @@ top_builddir = @top_builddir@
 VPATH = @srcdir@
 
 CC	= @CC@
-INCDIR	= -Iinclude -I$(srcdir)/include 
+INCDIR	= -Iinclude -I$(srcdir)/include -I$(top_srcdir)/include
 DEFS	= @DEFS@
 CPPFLAGS= @CPPFLAGS@
 CFLAGS	= @CFLAGS@
 LIBS	= @LIBS@
 LDFLAGS	= @LDFLAGS@ -L. -L..
 COMPILE = $(CC) $(DEFS) $(INCDIR) $(CPPFLAGS) $(CFLAGS)
-CRYPTOLIB = -lsrtp
+CRYPTOLIB = -lsrtp2
 
 RANLIB	= @RANLIB@
 
@@ -46,7 +46,7 @@ endif
 
 testapp = test/cipher_driver$(EXE) test/datatypes_driver$(EXE) \
 	  test/stat_driver$(EXE) test/sha1_driver$(EXE) \
-	  test/kernel_driver$(EXE) $(AES_CALC) test/rand_gen$(EXE) \
+	  test/kernel_driver$(EXE) $(AES_CALC) \
 	  test/env$(EXE)
 
 # data values used to test the aes_calc application for AES-128
@@ -73,7 +73,6 @@ endif
 	test/stat_driver$(EXE) >/dev/null
 	test/sha1_driver$(EXE) -v >/dev/null
 	test/kernel_driver$(EXE) -v >/dev/null
-	test/rand_gen$(EXE) -n 256 >/dev/null
 	@echo "crypto test applications passed."
 
 
@@ -82,15 +81,14 @@ endif
 %.o: %.c
 	$(COMPILE) -c $< -o $@
 
-%$(EXE): %.c  
+%$(EXE): %.c $(srcdir)/../test/getopt_s.c
-	$(COMPILE) $(LDFLAGS) $< -o $@ $(CRYPTOLIB) $(LIBS)
+	$(COMPILE) $(LDFLAGS) $< $(srcdir)/../test/getopt_s.c -o $@ $(CRYPTOLIB) $(LIBS)
 
 all: $(testapp)
 
 # housekeeping functions
 
 clean:
-	rm -f libcryptomodule.a
 	rm -f $(testapp) *.o */*.o
 	for a in * .* */*; do if [ -f "$$a~" ] ; then rm $$a~; fi; done;
 	rm -f `find . -name "*.[ch]~*~"`
@@ -99,13 +97,4 @@ clean:
 superclean: clean
 	rm -f *core TAGS ktrace.out
 
-
-# the target 'package' builds a compressed tar archive of the source code
-
-distname = crypto-$(shell cat VERSION)
-
-package: superclean
-	cd ..; tar cvzf $(distname).tgz crypto/
-
-
 # EOF

libs/srtp/crypto/cipher/aes.c

@@ -63,7 +63,7 @@
  */
 
 #ifndef WORDS_BIGENDIAN
-
+/* clang-format off */
 static const uint32_t T0[256] = {
     0xa56363c6, 0x847c7cf8,  0x997777ee,  0x8d7b7bf6,
     0xdf2f2ff,  0xbd6b6bd6,  0xb16f6fde,  0x54c5c591,
@@ -130,7 +130,9 @@ static const uint32_t T0[256] = {
     0xc3414182, 0xb0999929,  0x772d2d5a,  0x110f0f1e,
     0xcbb0b07b, 0xfc5454a8,  0xd6bbbb6d,  0x3a16162c,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t T1[256] = {
     0x6363c6a5, 0x7c7cf884,  0x7777ee99,  0x7b7bf68d,
     0xf2f2ff0d, 0x6b6bd6bd,  0x6f6fdeb1,  0xc5c59154,
@@ -197,7 +199,9 @@ static const uint32_t T1[256] = {
     0x414182c3, 0x999929b0,  0x2d2d5a77,  0xf0f1e11,
     0xb0b07bcb, 0x5454a8fc,  0xbbbb6dd6,  0x16162c3a,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t T2[256] = {
     0x63c6a563, 0x7cf8847c,  0x77ee9977,  0x7bf68d7b,
     0xf2ff0df2, 0x6bd6bd6b,  0x6fdeb16f,  0xc59154c5,
@@ -264,7 +268,9 @@ static const uint32_t T2[256] = {
     0x4182c341, 0x9929b099,  0x2d5a772d,  0xf1e110f,
     0xb07bcbb0, 0x54a8fc54,  0xbb6dd6bb,  0x162c3a16,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t T3[256] = {
     0xc6a56363, 0xf8847c7c,  0xee997777,  0xf68d7b7b,
     0xff0df2f2, 0xd6bd6b6b,  0xdeb16f6f,  0x9154c5c5,
@@ -331,7 +337,9 @@ static const uint32_t T3[256] = {
     0x82c34141, 0x29b09999,  0x5a772d2d,  0x1e110f0f,
     0x7bcbb0b0, 0xa8fc5454,  0x6dd6bbbb,  0x2c3a1616,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U0[256] = {
     0x50a7f451, 0x5365417e,  0xc3a4171a,  0x965e273a,
     0xcb6bab3b, 0xf1459d1f,  0xab58faac,  0x9303e34b,
@@ -398,7 +406,9 @@ static const uint32_t U0[256] = {
     0x7101a839, 0xdeb30c08,  0x9ce4b4d8,  0x90c15664,
     0x6184cb7b, 0x70b632d5,  0x745c6c48,  0x4257b8d0,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U1[256] = {
     0xa7f45150, 0x65417e53,  0xa4171ac3,  0x5e273a96,
     0x6bab3bcb, 0x459d1ff1,  0x58faacab,  0x3e34b93,
@@ -465,7 +475,9 @@ static const uint32_t U1[256] = {
     0x1a83971,  0xb30c08de,  0xe4b4d89c,  0xc1566490,
     0x84cb7b61, 0xb632d570,  0x5c6c4874,  0x57b8d042,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U2[256] = {
     0xf45150a7, 0x417e5365,  0x171ac3a4,  0x273a965e,
     0xab3bcb6b, 0x9d1ff145,  0xfaacab58,  0xe34b9303,
@@ -532,7 +544,9 @@ static const uint32_t U2[256] = {
     0xa8397101, 0xc08deb3,   0xb4d89ce4,  0x566490c1,
     0xcb7b6184, 0x32d570b6,  0x6c48745c,  0xb8d04257,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U3[256] = {
     0x5150a7f4, 0x7e536541,  0x1ac3a417,  0x3a965e27,
     0x3bcb6bab, 0x1ff1459d,  0xacab58fa,  0x4b9303e3,
@@ -599,9 +613,10 @@ static const uint32_t U3[256] = {
     0x397101a8, 0x8deb30c,   0xd89ce4b4,  0x6490c156,
     0x7b6184cb, 0xd570b632,  0x48745c6c,  0xd04257b8,
 };
+/* clang-format on */
 
 #else /* assume big endian */
-
+/* clang-format off */
 static const uint32_t T0[256] = {
     0xc66363a5, 0xf87c7c84,  0xee777799,  0xf67b7b8d,
     0xfff2f20d, 0xd66b6bbd,  0xde6f6fb1,  0x91c5c554,
@@ -668,7 +683,9 @@ static const uint32_t T0[256] = {
     0x824141c3, 0x299999b0,  0x5a2d2d77,  0x1e0f0f11,
     0x7bb0b0cb, 0xa85454fc,  0x6dbbbbd6,  0x2c16163a,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t T1[256] = {
     0xa5c66363, 0x84f87c7c,  0x99ee7777,  0x8df67b7b,
     0xdfff2f2,  0xbdd66b6b,  0xb1de6f6f,  0x5491c5c5,
@@ -735,7 +752,9 @@ static const uint32_t T1[256] = {
     0xc3824141, 0xb0299999,  0x775a2d2d,  0x111e0f0f,
     0xcb7bb0b0, 0xfca85454,  0xd66dbbbb,  0x3a2c1616,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t T2[256] = {
     0x63a5c663, 0x7c84f87c,  0x7799ee77,  0x7b8df67b,
     0xf20dfff2, 0x6bbdd66b,  0x6fb1de6f,  0xc55491c5,
@@ -802,7 +821,9 @@ static const uint32_t T2[256] = {
     0x41c38241, 0x99b02999,  0x2d775a2d,  0xf111e0f,
     0xb0cb7bb0, 0x54fca854,  0xbbd66dbb,  0x163a2c16,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t T3[256] = {
     0x6363a5c6, 0x7c7c84f8,  0x777799ee,  0x7b7b8df6,
     0xf2f20dff, 0x6b6bbdd6,  0x6f6fb1de,  0xc5c55491,
@@ -869,7 +890,9 @@ static const uint32_t T3[256] = {
     0x4141c382, 0x9999b029,  0x2d2d775a,  0xf0f111e,
     0xb0b0cb7b, 0x5454fca8,  0xbbbbd66d,  0x16163a2c,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U0[256] = {
     0x51f4a750, 0x7e416553,  0x1a17a4c3,  0x3a275e96,
     0x3bab6bcb, 0x1f9d45f1,  0xacfa58ab,  0x4be30393,
@@ -936,7 +959,9 @@ static const uint32_t U0[256] = {
     0x39a80171, 0x80cb3de,   0xd8b4e49c,  0x6456c190,
     0x7bcb8461, 0xd532b670,  0x486c5c74,  0xd0b85742
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U1[256] = {
     0x5051f4a7, 0x537e4165,  0xc31a17a4,  0x963a275e,
     0xcb3bab6b, 0xf11f9d45,  0xabacfa58,  0x934be303,
@@ -1003,7 +1028,9 @@ static const uint32_t U1[256] = {
     0x7139a801, 0xde080cb3,  0x9cd8b4e4,  0x906456c1,
     0x617bcb84, 0x70d532b6,  0x74486c5c,  0x42d0b857
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U2[256] = {
     0xa75051f4, 0x65537e41,  0xa4c31a17,  0x5e963a27,
     0x6bcb3bab, 0x45f11f9d,  0x58abacfa,  0x3934be3,
@@ -1070,7 +1097,9 @@ static const uint32_t U2[256] = {
     0x17139a8,  0xb3de080c,  0xe49cd8b4,  0xc1906456,
     0x84617bcb, 0xb670d532,  0x5c74486c,  0x5742d0b8
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U3[256] = {
     0xf4a75051, 0x4165537e,  0x17a4c31a,  0x275e963a,
     0xab6bcb3b, 0x9d45f11f,  0xfa58abac,  0xe303934b,
@@ -1137,16 +1166,15 @@ static const uint32_t U3[256] = {
     0xa8017139, 0xcb3de08,   0xb4e49cd8,  0x56c19064,
     0xcb84617b, 0x32b670d5,  0x6c5c7448,  0xb85742d0
 };
-
+/* clang-format on */
 #endif
 
 /*
  * the following tables (aes_sbox, aes_inv_sbox, T4, U4) are
  * endian-neutral
  */
-
+/* clang-format off */
-static const uint8_t
+static const uint8_t aes_sbox[256] = {
-    aes_sbox[256] = {
     0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
     0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
     0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
@@ -1180,10 +1208,11 @@ static const uint8_t
     0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
     0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
 };
+/* clang-format on */
 
 #ifndef CPU_RISC
-static const uint8_t
+/* clang-format off */
-    aes_inv_sbox[256] = {
+static const uint8_t aes_inv_sbox[256] = {
     0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38,
     0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
     0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
@@ -1217,11 +1246,12 @@ static const uint8_t
     0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26,
     0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
 };
+/* clang-format on */
 #endif /* ! CPU_RISC */
 
 #ifdef CPU_RISC
-static const uint32_t
+/* clang-format off */
-    T4[256] = {
+static const uint32_t T4[256] = {
     0x63636363, 0x7c7c7c7c, 0x77777777, 0x7b7b7b7b,
     0xf2f2f2f2, 0x6b6b6b6b, 0x6f6f6f6f, 0xc5c5c5c5,
     0x30303030, 0x01010101, 0x67676767, 0x2b2b2b2b,
@@ -1287,7 +1317,9 @@ static const uint32_t
     0x41414141, 0x99999999, 0x2d2d2d2d, 0x0f0f0f0f,
     0xb0b0b0b0, 0x54545454, 0xbbbbbbbb, 0x16161616
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint32_t U4[256] = {
     0x52525252, 0x9090909,   0x6a6a6a6a,  0xd5d5d5d5,
     0x30303030, 0x36363636,  0xa5a5a5a5,  0x38383838,
@@ -1354,6 +1386,7 @@ static const uint32_t U4[256] = {
     0xe1e1e1e1, 0x69696969,  0x14141414,  0x63636363,
     0x55555555, 0x21212121,  0xc0c0c0c,   0x7d7d7d7d
 };
+/* clang-format on */
 #endif /* CPU_RISC */
 
 #define gf2_8_field_polynomial 0x1B
@@ -1363,15 +1396,12 @@ static const uint32_t U4[256] = {
  * next gf2_8 value in the cyclic representation of that field.  The
  * value z should be an uint8_t.
  */
-#define gf2_8_shift(z) (((z) & 128) ? \
+#define gf2_8_shift(z)                                                         \
-                        (((z) << 1) ^ gf2_8_field_polynomial) : ((z) << 1))
+    (((z)&128) ? (((z) << 1) ^ gf2_8_field_polynomial) : ((z) << 1))
 
 /* aes internals */
 
-extern srtp_debug_module_t srtp_mod_aes_icm;
+static void aes_128_expand_encryption_key(const uint8_t *key,
-
-static void
-aes_128_expand_encryption_key (const uint8_t *key,
                                           srtp_aes_expanded_key_t *expanded_key)
 {
     int i;
@@ -1391,12 +1421,15 @@ aes_128_expand_encryption_key (const uint8_t *key,
 
     /* loop over round keys */
     for (i = 1; i < 11; i++) {
-
         /* munge first word of round key */
-        expanded_key->round[i].v8[0] = aes_sbox[expanded_key->round[i - 1].v8[13]] ^ rc;
+        expanded_key->round[i].v8[0] =
-        expanded_key->round[i].v8[1] = aes_sbox[expanded_key->round[i - 1].v8[14]];
+            aes_sbox[expanded_key->round[i - 1].v8[13]] ^ rc;
-        expanded_key->round[i].v8[2] = aes_sbox[expanded_key->round[i - 1].v8[15]];
+        expanded_key->round[i].v8[1] =
-        expanded_key->round[i].v8[3] = aes_sbox[expanded_key->round[i - 1].v8[12]];
+            aes_sbox[expanded_key->round[i - 1].v8[14]];
+        expanded_key->round[i].v8[2] =
+            aes_sbox[expanded_key->round[i - 1].v8[15]];
+        expanded_key->round[i].v8[3] =
+            aes_sbox[expanded_key->round[i - 1].v8[12]];
 
         expanded_key->round[i].v32[0] ^= expanded_key->round[i - 1].v32[0];
 
@@ -1419,12 +1452,10 @@ aes_128_expand_encryption_key (const uint8_t *key,
 
         /* modify round constant */
         rc = gf2_8_shift(rc);
-
     }
 }
 
-static void
+static void aes_256_expand_encryption_key(const unsigned char *key,
-aes_256_expand_encryption_key (const unsigned char *key,
                                           srtp_aes_expanded_key_t *expanded_key)
 {
     int i;
@@ -1447,21 +1478,28 @@ aes_256_expand_encryption_key (const unsigned char *key,
 
     /* loop over rest of round keys */
     for (i = 2; i < 15; i++) {
-
         /* munge first word of round key */
         if ((i & 1) == 0) {
-            expanded_key->round[i].v8[0] = aes_sbox[expanded_key->round[i - 1].v8[13]] ^ rc;
+            expanded_key->round[i].v8[0] =
-            expanded_key->round[i].v8[1] = aes_sbox[expanded_key->round[i - 1].v8[14]];
+                aes_sbox[expanded_key->round[i - 1].v8[13]] ^ rc;
-            expanded_key->round[i].v8[2] = aes_sbox[expanded_key->round[i - 1].v8[15]];
+            expanded_key->round[i].v8[1] =
-            expanded_key->round[i].v8[3] = aes_sbox[expanded_key->round[i - 1].v8[12]];
+                aes_sbox[expanded_key->round[i - 1].v8[14]];
+            expanded_key->round[i].v8[2] =
+                aes_sbox[expanded_key->round[i - 1].v8[15]];
+            expanded_key->round[i].v8[3] =
+                aes_sbox[expanded_key->round[i - 1].v8[12]];
 
             /* modify round constant */
             rc = gf2_8_shift(rc);
         } else {
-            expanded_key->round[i].v8[0] = aes_sbox[expanded_key->round[i - 1].v8[12]];
+            expanded_key->round[i].v8[0] =
-            expanded_key->round[i].v8[1] = aes_sbox[expanded_key->round[i - 1].v8[13]];
+                aes_sbox[expanded_key->round[i - 1].v8[12]];
-            expanded_key->round[i].v8[2] = aes_sbox[expanded_key->round[i - 1].v8[14]];
+            expanded_key->round[i].v8[1] =
-            expanded_key->round[i].v8[3] = aes_sbox[expanded_key->round[i - 1].v8[15]];
+                aes_sbox[expanded_key->round[i - 1].v8[13]];
+            expanded_key->round[i].v8[2] =
+                aes_sbox[expanded_key->round[i - 1].v8[14]];
+            expanded_key->round[i].v8[3] =
+                aes_sbox[expanded_key->round[i - 1].v8[15]];
         }
 
         expanded_key->round[i].v32[0] ^= expanded_key->round[i - 2].v32[0];
@@ -1482,11 +1520,11 @@ aes_256_expand_encryption_key (const unsigned char *key,
         debug_print2(srtp_mod_aes_icm,
                      "expanded key[%d]:  %s", i, v128_hex_string(&expanded_key->round[i]));
 #endif
-
     }
 }
 
-srtp_err_status_t srtp_aes_expand_encryption_key (const uint8_t *key,
+srtp_err_status_t srtp_aes_expand_encryption_key(
+    const uint8_t *key,
     int key_len,
     srtp_aes_expanded_key_t *expanded_key)
 {
@@ -1504,7 +1542,8 @@ srtp_err_status_t srtp_aes_expand_encryption_key (const uint8_t *key,
     }
 }
 
-srtp_err_status_t srtp_aes_expand_decryption_key (const uint8_t *key,
+srtp_err_status_t srtp_aes_expand_decryption_key(
+    const uint8_t *key,
     int key_len,
     srtp_aes_expanded_key_t *expanded_key)
 {
@@ -1521,7 +1560,8 @@ srtp_err_status_t srtp_aes_expand_decryption_key (const uint8_t *key,
     for (i = 0; i < num_rounds / 2; i++) {
         v128_t tmp;
         v128_copy(&tmp, &expanded_key->round[num_rounds - i]);
-        v128_copy(&expanded_key->round[num_rounds - i], &expanded_key->round[i]);
+        v128_copy(&expanded_key->round[num_rounds - i],
+                  &expanded_key->round[i]);
         v128_copy(&expanded_key->round[i], &tmp);
     }
 
@@ -1538,6 +1578,7 @@ srtp_err_status_t srtp_aes_expand_decryption_key (const uint8_t *key,
         uint32_t tmp;
 
 #ifdef WORDS_BIGENDIAN
+        /* clang-format off */
         tmp = expanded_key->round[i].v32[0];
         expanded_key->round[i].v32[0] =
             U0[T4[(tmp >> 24)       ] & 0xff] ^
@@ -1593,31 +1634,32 @@ srtp_err_status_t srtp_aes_expand_decryption_key (const uint8_t *key,
             U2[T4[(tmp >> 16) & 0xff] & 0xff] ^
             U1[T4[(tmp >> 8)  & 0xff] & 0xff] ^
             U0[T4[(tmp)       & 0xff] & 0xff];
+/* clang-format on */
 #endif /* WORDS_BIGENDIAN */
 
 #else /* assume CPU_CISC */
 
         uint32_t c0, c1, c2, c3;
 
-        c0 = U0[aes_sbox[expanded_key->round[i].v8[0]]]
+        c0 = U0[aes_sbox[expanded_key->round[i].v8[0]]] ^
-             ^ U1[aes_sbox[expanded_key->round[i].v8[1]]]
+             U1[aes_sbox[expanded_key->round[i].v8[1]]] ^
-             ^ U2[aes_sbox[expanded_key->round[i].v8[2]]]
+             U2[aes_sbox[expanded_key->round[i].v8[2]]] ^
-             ^ U3[aes_sbox[expanded_key->round[i].v8[3]]];
+             U3[aes_sbox[expanded_key->round[i].v8[3]]];
 
-        c1 = U0[aes_sbox[expanded_key->round[i].v8[4]]]
+        c1 = U0[aes_sbox[expanded_key->round[i].v8[4]]] ^
-             ^ U1[aes_sbox[expanded_key->round[i].v8[5]]]
+             U1[aes_sbox[expanded_key->round[i].v8[5]]] ^
-             ^ U2[aes_sbox[expanded_key->round[i].v8[6]]]
+             U2[aes_sbox[expanded_key->round[i].v8[6]]] ^
-             ^ U3[aes_sbox[expanded_key->round[i].v8[7]]];
+             U3[aes_sbox[expanded_key->round[i].v8[7]]];
 
-        c2 = U0[aes_sbox[expanded_key->round[i].v8[8]]]
+        c2 = U0[aes_sbox[expanded_key->round[i].v8[8]]] ^
-             ^ U1[aes_sbox[expanded_key->round[i].v8[9]]]
+             U1[aes_sbox[expanded_key->round[i].v8[9]]] ^
-             ^ U2[aes_sbox[expanded_key->round[i].v8[10]]]
+             U2[aes_sbox[expanded_key->round[i].v8[10]]] ^
-             ^ U3[aes_sbox[expanded_key->round[i].v8[11]]];
+             U3[aes_sbox[expanded_key->round[i].v8[11]]];
 
-        c3 = U0[aes_sbox[expanded_key->round[i].v8[12]]]
+        c3 = U0[aes_sbox[expanded_key->round[i].v8[12]]] ^
-             ^ U1[aes_sbox[expanded_key->round[i].v8[13]]]
+             U1[aes_sbox[expanded_key->round[i].v8[13]]] ^
-             ^ U2[aes_sbox[expanded_key->round[i].v8[14]]]
+             U2[aes_sbox[expanded_key->round[i].v8[14]]] ^
-             ^ U3[aes_sbox[expanded_key->round[i].v8[15]]];
+             U3[aes_sbox[expanded_key->round[i].v8[15]]];
 
         expanded_key->round[i].v32[0] = c0;
         expanded_key->round[i].v32[1] = c1;
@@ -1632,7 +1674,6 @@ srtp_err_status_t srtp_aes_expand_decryption_key (const uint8_t *key,
 
 #ifdef CPU_CISC
 
-
 static inline void aes_round(v128_t *state, const v128_t *round_key)
 {
     uint32_t column0, column1, column2, column3;
@@ -1640,26 +1681,24 @@ static inline void aes_round (v128_t *state, const v128_t *round_key)
     /* compute the columns of the output square in terms of the octets
        of state, using the tables T0, T1, T2, T3 */
 
-    column0 = T0[state->v8[0]] ^ T1[state->v8[5]]
+    column0 = T0[state->v8[0]] ^ T1[state->v8[5]] ^ T2[state->v8[10]] ^
-              ^ T2[state->v8[10]] ^ T3[state->v8[15]];
+              T3[state->v8[15]];
 
-    column1 = T0[state->v8[4]] ^ T1[state->v8[9]]
+    column1 = T0[state->v8[4]] ^ T1[state->v8[9]] ^ T2[state->v8[14]] ^
-              ^ T2[state->v8[14]] ^ T3[state->v8[3]];
+              T3[state->v8[3]];
 
-    column2 = T0[state->v8[8]] ^ T1[state->v8[13]]
+    column2 = T0[state->v8[8]] ^ T1[state->v8[13]] ^ T2[state->v8[2]] ^
-              ^ T2[state->v8[2]] ^ T3[state->v8[7]];
+              T3[state->v8[7]];
 
-    column3 = T0[state->v8[12]] ^ T1[state->v8[1]]
+    column3 = T0[state->v8[12]] ^ T1[state->v8[1]] ^ T2[state->v8[6]] ^
-              ^ T2[state->v8[6]] ^ T3[state->v8[11]];
+              T3[state->v8[11]];
 
     state->v32[0] = column0 ^ round_key->v32[0];
     state->v32[1] = column1 ^ round_key->v32[1];
     state->v32[2] = column2 ^ round_key->v32[2];
     state->v32[3] = column3 ^ round_key->v32[3];
-
 }
 
-
 static inline void aes_inv_round(v128_t *state, const v128_t *round_key)
 {
     uint32_t column0, column1, column2, column3;
@@ -1667,23 +1706,22 @@ static inline void aes_inv_round (v128_t *state, const v128_t *round_key)
     /* compute the columns of the output square in terms of the octets
        of state, using the tables U0, U1, U2, U3 */
 
-    column0 = U0[state->v8[0]] ^ U1[state->v8[13]]
+    column0 = U0[state->v8[0]] ^ U1[state->v8[13]] ^ U2[state->v8[10]] ^
-              ^ U2[state->v8[10]] ^ U3[state->v8[7]];
+              U3[state->v8[7]];
 
-    column1 = U0[state->v8[4]] ^ U1[state->v8[1]]
+    column1 = U0[state->v8[4]] ^ U1[state->v8[1]] ^ U2[state->v8[14]] ^
-              ^ U2[state->v8[14]] ^ U3[state->v8[11]];
+              U3[state->v8[11]];
 
-    column2 = U0[state->v8[8]] ^ U1[state->v8[5]]
+    column2 = U0[state->v8[8]] ^ U1[state->v8[5]] ^ U2[state->v8[2]] ^
-              ^ U2[state->v8[2]] ^ U3[state->v8[15]];
+              U3[state->v8[15]];
 
-    column3 = U0[state->v8[12]] ^ U1[state->v8[9]]
+    column3 = U0[state->v8[12]] ^ U1[state->v8[9]] ^ U2[state->v8[6]] ^
-              ^ U2[state->v8[6]] ^ U3[state->v8[3]];
+              U3[state->v8[3]];
 
     state->v32[0] = column0 ^ round_key->v32[0];
     state->v32[1] = column1 ^ round_key->v32[1];
     state->v32[2] = column2 ^ round_key->v32[2];
     state->v32[3] = column3 ^ round_key->v32[3];
-
 }
 
 static inline void aes_final_round(v128_t *state, const v128_t *round_key)
@@ -1758,7 +1796,6 @@ static inline void aes_inv_final_round (v128_t *state, const v128_t *round_key)
     v128_xor_eq(state, round_key);
 }
 
-
 #elif CPU_RISC
 
 static inline void aes_round(v128_t *state, const v128_t *round_key)
@@ -1768,36 +1805,35 @@ static inline void aes_round (v128_t *state, const v128_t *round_key)
 /* compute the columns of the output square in terms of the octets
    of state, using the tables T0, T1, T2, T3 */
 #ifdef WORDS_BIGENDIAN
-    column0 = T0[state->v32[0] >> 24] ^ T1[(state->v32[1] >> 16) & 0xff]
+    column0 = T0[state->v32[0] >> 24] ^ T1[(state->v32[1] >> 16) & 0xff] ^
-              ^ T2[(state->v32[2] >> 8) & 0xff] ^ T3[state->v32[3] & 0xff];
+              T2[(state->v32[2] >> 8) & 0xff] ^ T3[state->v32[3] & 0xff];
 
-    column1 = T0[state->v32[1] >> 24] ^ T1[(state->v32[2] >> 16) & 0xff]
+    column1 = T0[state->v32[1] >> 24] ^ T1[(state->v32[2] >> 16) & 0xff] ^
-              ^ T2[(state->v32[3] >> 8) & 0xff] ^ T3[state->v32[0] & 0xff];
+              T2[(state->v32[3] >> 8) & 0xff] ^ T3[state->v32[0] & 0xff];
 
-    column2 = T0[state->v32[2] >> 24] ^ T1[(state->v32[3] >> 16) & 0xff]
+    column2 = T0[state->v32[2] >> 24] ^ T1[(state->v32[3] >> 16) & 0xff] ^
-              ^ T2[(state->v32[0] >> 8) & 0xff] ^ T3[state->v32[1] & 0xff];
+              T2[(state->v32[0] >> 8) & 0xff] ^ T3[state->v32[1] & 0xff];
 
-    column3 = T0[state->v32[3] >> 24] ^ T1[(state->v32[0] >> 16) & 0xff]
+    column3 = T0[state->v32[3] >> 24] ^ T1[(state->v32[0] >> 16) & 0xff] ^
-              ^ T2[(state->v32[1] >> 8) & 0xff] ^ T3[state->v32[2] & 0xff];
+              T2[(state->v32[1] >> 8) & 0xff] ^ T3[state->v32[2] & 0xff];
 #else
-    column0 = T0[state->v32[0] & 0xff] ^ T1[(state->v32[1] >> 8) & 0xff]
+    column0 = T0[state->v32[0] & 0xff] ^ T1[(state->v32[1] >> 8) & 0xff] ^
-              ^ T2[(state->v32[2] >> 16) & 0xff] ^ T3[state->v32[3] >> 24];
+              T2[(state->v32[2] >> 16) & 0xff] ^ T3[state->v32[3] >> 24];
 
-    column1 = T0[state->v32[1] & 0xff] ^ T1[(state->v32[2] >> 8) & 0xff]
+    column1 = T0[state->v32[1] & 0xff] ^ T1[(state->v32[2] >> 8) & 0xff] ^
-              ^ T2[(state->v32[3] >> 16) & 0xff] ^ T3[state->v32[0] >> 24];
+              T2[(state->v32[3] >> 16) & 0xff] ^ T3[state->v32[0] >> 24];
 
-    column2 = T0[state->v32[2] & 0xff] ^ T1[(state->v32[3] >> 8) & 0xff]
+    column2 = T0[state->v32[2] & 0xff] ^ T1[(state->v32[3] >> 8) & 0xff] ^
-              ^ T2[(state->v32[0] >> 16) & 0xff] ^ T3[state->v32[1] >> 24];
+              T2[(state->v32[0] >> 16) & 0xff] ^ T3[state->v32[1] >> 24];
 
-    column3 = T0[state->v32[3] & 0xff] ^ T1[(state->v32[0] >> 8) & 0xff]
+    column3 = T0[state->v32[3] & 0xff] ^ T1[(state->v32[0] >> 8) & 0xff] ^
-              ^ T2[(state->v32[1] >> 16) & 0xff] ^ T3[state->v32[2] >> 24];
+              T2[(state->v32[1] >> 16) & 0xff] ^ T3[state->v32[2] >> 24];
 #endif /* WORDS_BIGENDIAN */
 
     state->v32[0] = column0 ^ round_key->v32[0];
     state->v32[1] = column1 ^ round_key->v32[1];
     state->v32[2] = column2 ^ round_key->v32[2];
     state->v32[3] = column3 ^ round_key->v32[3];
-
 }
 
 static inline void aes_inv_round(v128_t *state, const v128_t *round_key)
@@ -1808,36 +1844,39 @@ static inline void aes_inv_round (v128_t *state, const v128_t *round_key)
    of state, using the tables U0, U1, U2, U3 */
 
 #ifdef WORDS_BIGENDIAN
-    column0 = U0[state->v32[0] >> 24] ^ U1[(state->v32[3] >> 16) & 0xff]
+    column0 = U0[state->v32[0] >> 24] ^ U1[(state->v32[3] >> 16) & 0xff] ^
-              ^ U2[(state->v32[2] >> 8) & 0xff] ^ U3[state->v32[1] & 0xff];
+              U2[(state->v32[2] >> 8) & 0xff] ^ U3[state->v32[1] & 0xff];
 
-    column1 = U0[state->v32[1] >> 24] ^ U1[(state->v32[0] >> 16) & 0xff]
+    column1 = U0[state->v32[1] >> 24] ^ U1[(state->v32[0] >> 16) & 0xff] ^
-              ^ U2[(state->v32[3] >> 8) & 0xff] ^ U3[state->v32[2] & 0xff];
+              U2[(state->v32[3] >> 8) & 0xff] ^ U3[state->v32[2] & 0xff];
 
-    column2 = U0[state->v32[2] >> 24] ^ U1[(state->v32[1] >> 16) & 0xff]
+    column2 = U0[state->v32[2] >> 24] ^ U1[(state->v32[1] >> 16) & 0xff] ^
-              ^ U2[(state->v32[0] >> 8) & 0xff] ^ U3[state->v32[3] & 0xff];
+              U2[(state->v32[0] >> 8) & 0xff] ^ U3[state->v32[3] & 0xff];
 
-    column3 = U0[state->v32[3] >> 24] ^ U1[(state->v32[2] >> 16) & 0xff]
+    column3 = U0[state->v32[3] >> 24] ^ U1[(state->v32[2] >> 16) & 0xff] ^
-              ^ U2[(state->v32[1] >> 8) & 0xff] ^ U3[state->v32[0] & 0xff];
+              U2[(state->v32[1] >> 8) & 0xff] ^ U3[state->v32[0] & 0xff];
 #else
-    column0 = U0[state->v32[0] & 0xff] ^ U1[(state->v32[3] >> 8) & 0xff]
+    column0 = U0[state->v32[0] & 0xff] ^ U1[(state->v32[3] >> 8) & 0xff] ^
-              ^ U2[(state->v32[2] >> 16) & 0xff] ^ U3[(state->v32[1] >> 24) & 0xff];
+              U2[(state->v32[2] >> 16) & 0xff] ^
+              U3[(state->v32[1] >> 24) & 0xff];
 
-    column1 = U0[state->v32[1] & 0xff] ^ U1[(state->v32[0] >> 8) & 0xff]
+    column1 = U0[state->v32[1] & 0xff] ^ U1[(state->v32[0] >> 8) & 0xff] ^
-              ^ U2[(state->v32[3] >> 16) & 0xff] ^ U3[(state->v32[2] >> 24) & 0xff];
+              U2[(state->v32[3] >> 16) & 0xff] ^
+              U3[(state->v32[2] >> 24) & 0xff];
 
-    column2 = U0[state->v32[2] & 0xff] ^ U1[(state->v32[1] >> 8) & 0xff]
+    column2 = U0[state->v32[2] & 0xff] ^ U1[(state->v32[1] >> 8) & 0xff] ^
-              ^ U2[(state->v32[0] >> 16) & 0xff] ^ U3[(state->v32[3] >> 24) & 0xff];
+              U2[(state->v32[0] >> 16) & 0xff] ^
+              U3[(state->v32[3] >> 24) & 0xff];
 
-    column3 = U0[state->v32[3] & 0xff] ^ U1[(state->v32[2] >> 8) & 0xff]
+    column3 = U0[state->v32[3] & 0xff] ^ U1[(state->v32[2] >> 8) & 0xff] ^
-              ^ U2[(state->v32[1] >> 16) & 0xff] ^ U3[(state->v32[0] >> 24) & 0xff];
+              U2[(state->v32[1] >> 16) & 0xff] ^
+              U3[(state->v32[0] >> 24) & 0xff];
 #endif /* WORDS_BIGENDIAN */
 
     state->v32[0] = column0 ^ round_key->v32[0];
     state->v32[1] = column1 ^ round_key->v32[1];
     state->v32[2] = column2 ^ round_key->v32[2];
     state->v32[3] = column3 ^ round_key->v32[3];
-
 }
 
 static inline void aes_final_round(v128_t *state, const v128_t *round_key)
@@ -1845,60 +1884,61 @@ static inline void aes_final_round (v128_t *state, const v128_t *round_key)
     uint32_t tmp0, tmp1, tmp2, tmp3;
 
 #ifdef WORDS_BIGENDIAN
-    tmp0 = (T4[(state->v32[0] >> 24)]        & 0xff000000)
+    /* clang-format off */
-           ^ (T4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000)
+    tmp0 = (T4[(state->v32[0] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[3]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ round_key->v32[0];
+           (T4[(state->v32[3]      ) & 0xff] & 0x000000ff) ^
+           round_key->v32[0];
 
-    tmp1 = (T4[(state->v32[1] >> 24)]        & 0xff000000)
+    tmp1 = (T4[(state->v32[1] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000)
+           (T4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (T4[(state->v32[0]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[0]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[1];
+           round_key->v32[1];
 
-    tmp2 = (T4[(state->v32[2] >> 24)]        & 0xff000000)
+    tmp2 = (T4[(state->v32[2] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000)
+           (T4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (T4[(state->v32[1]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[1]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[2];
+           round_key->v32[2];
 
-    tmp3 = (T4[(state->v32[3] >> 24)]        & 0xff000000)
+    tmp3 = (T4[(state->v32[3] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
+           (T4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (T4[(state->v32[2]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[2]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[3];
+           round_key->v32[3];
 #else
-    tmp0 = (T4[(state->v32[3] >> 24)]        & 0xff000000)
+    tmp0 = (T4[(state->v32[3] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000)
+           (T4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (T4[(state->v32[0]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[0]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[0];
+           round_key->v32[0];
 
-    tmp1 = (T4[(state->v32[0] >> 24)]        & 0xff000000)
+    tmp1 = (T4[(state->v32[0] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000)
+           (T4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (T4[(state->v32[1]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[1]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[1];
+           round_key->v32[1];
 
-    tmp2 = (T4[(state->v32[1] >> 24)]        & 0xff000000)
+    tmp2 = (T4[(state->v32[1] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
+           (T4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (T4[(state->v32[2]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[2]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[2];
+           round_key->v32[2];
 
-    tmp3 = (T4[(state->v32[2] >> 24)]        & 0xff000000)
+    tmp3 = (T4[(state->v32[2] >> 24)]        & 0xff000000) ^
-           ^ (T4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000)
+           (T4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (T4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
+           (T4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (T4[(state->v32[3]      ) & 0xff] & 0x000000ff)
+           (T4[(state->v32[3]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[3];
+           round_key->v32[3];
+/* clang-format on */
 #endif /* WORDS_BIGENDIAN */
 
     state->v32[0] = tmp0;
     state->v32[1] = tmp1;
     state->v32[2] = tmp2;
     state->v32[3] = tmp3;
-
 }
 
 static inline void aes_inv_final_round(v128_t *state, const v128_t *round_key)
@@ -1906,53 +1946,55 @@ static inline void aes_inv_final_round (v128_t *state, const v128_t *round_key)
     uint32_t tmp0, tmp1, tmp2, tmp3;
 
 #ifdef WORDS_BIGENDIAN
-    tmp0 = (U4[(state->v32[0] >> 24)]        & 0xff000000)
+    /* clang-format off */
-           ^ (U4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000)
+    tmp0 = (U4[(state->v32[0] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[1]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ round_key->v32[0];
+           (U4[(state->v32[1]      ) & 0xff] & 0x000000ff) ^
+           round_key->v32[0];
 
-    tmp1 = (U4[(state->v32[1] >> 24)]        & 0xff000000)
+    tmp1 = (U4[(state->v32[1] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
+           (U4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (U4[(state->v32[2]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[2]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[1];
+           round_key->v32[1];
 
-    tmp2 = (U4[(state->v32[2] >> 24)]        & 0xff000000)
+    tmp2 = (U4[(state->v32[2] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000)
+           (U4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (U4[(state->v32[3]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[3]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[2];
+           round_key->v32[2];
 
-    tmp3 = (U4[(state->v32[3] >> 24)]        & 0xff000000)
+    tmp3 = (U4[(state->v32[3] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000)
+           (U4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (U4[(state->v32[0]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[0]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[3];
+           round_key->v32[3];
 #else
-    tmp0 = (U4[(state->v32[1] >> 24)]        & 0xff000000)
+    tmp0 = (U4[(state->v32[1] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000)
+           (U4[(state->v32[2] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[3] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (U4[(state->v32[0]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[0]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[0];
+           round_key->v32[0];
 
-    tmp1 = (U4[(state->v32[2] >> 24)]        & 0xff000000)
+    tmp1 = (U4[(state->v32[2] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000)
+           (U4[(state->v32[3] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[0] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (U4[(state->v32[1]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[1]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[1];
+           round_key->v32[1];
 
-    tmp2 = (U4[(state->v32[3] >> 24)]        & 0xff000000)
+    tmp2 = (U4[(state->v32[3] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000)
+           (U4[(state->v32[0] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[1] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (U4[(state->v32[2]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[2]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[2];
+           round_key->v32[2];
 
-    tmp3 = (U4[(state->v32[0] >> 24)]        & 0xff000000)
+    tmp3 = (U4[(state->v32[0] >> 24)]        & 0xff000000) ^
-           ^ (U4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000)
+           (U4[(state->v32[1] >> 16) & 0xff] & 0x00ff0000) ^
-           ^ (U4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00)
+           (U4[(state->v32[2] >>  8) & 0xff] & 0x0000ff00) ^
-           ^ (U4[(state->v32[3]      ) & 0xff] & 0x000000ff)
+           (U4[(state->v32[3]      ) & 0xff] & 0x000000ff) ^
-           ^ round_key->v32[3];
+           round_key->v32[3];
+/* clang-format on */
 #endif /* WORDS_BIGENDIAN */
 
     state->v32[0] = tmp0;
@@ -1966,30 +2008,27 @@ static inline void aes_inv_final_round (v128_t *state, const v128_t *round_key)
 static inline void aes_round(v128_t *state, const v128_t *round_key)
 {
     uint32_t column0, column1, column2, column3;
-    uint16_t c
     /* compute the columns of the output square in terms of the octets
        of state, using the tables T0, T1, T2, T3 */
 
-        column0 = T0[state->v8[0]] ^ T1[state->v8[5]]
+    column0 = T0[state->v8[0]] ^ T1[state->v8[5]] ^ T2[state->v8[10]] ^
-                  ^ T2[state->v8[10]] ^ T3[state->v8[15]];
+              T3[state->v8[15]];
 
-    column1 = T0[state->v8[4]] ^ T1[state->v8[9]]
+    column1 = T0[state->v8[4]] ^ T1[state->v8[9]] ^ T2[state->v8[14]] ^
-              ^ T2[state->v8[14]] ^ T3[state->v8[3]];
+              T3[state->v8[3]];
 
-    column2 = T0[state->v8[8]] ^ T1[state->v8[13]]
+    column2 = T0[state->v8[8]] ^ T1[state->v8[13]] ^ T2[state->v8[2]] ^
-              ^ T2[state->v8[2]] ^ T3[state->v8[7]];
+              T3[state->v8[7]];
 
-    column3 = T0[state->v8[12]] ^ T1[state->v8[1]]
+    column3 = T0[state->v8[12]] ^ T1[state->v8[1]] ^ T2[state->v8[6]] ^
-              ^ T2[state->v8[6]] ^ T3[state->v8[11]];
+              T3[state->v8[11]];
 
     state->v32[0] = column0 ^ round_key->v32[0];
     state->v32[1] = column1 ^ round_key->v32[1];
     state->v32[2] = column2 ^ round_key->v32[2];
     state->v32[3] = column3 ^ round_key->v32[3];
-
 }
 
-
 static inline void aes_inv_round(v128_t *state, const v128_t *round_key)
 {
     uint32_t column0, column1, column2, column3;
@@ -1997,23 +2036,22 @@ static inline void aes_inv_round (v128_t *state, const v128_t *round_key)
     /* compute the columns of the output square in terms of the octets
        of state, using the tables U0, U1, U2, U3 */
 
-    column0 = U0[state->v8[0]] ^ U1[state->v8[5]]
+    column0 = U0[state->v8[0]] ^ U1[state->v8[5]] ^ U2[state->v8[10]] ^
-              ^ U2[state->v8[10]] ^ U3[state->v8[15]];
+              U3[state->v8[15]];
 
-    column1 = U0[state->v8[4]] ^ U1[state->v8[9]]
+    column1 = U0[state->v8[4]] ^ U1[state->v8[9]] ^ U2[state->v8[14]] ^
-              ^ U2[state->v8[14]] ^ U3[state->v8[3]];
+              U3[state->v8[3]];
 
-    column2 = U0[state->v8[8]] ^ U1[state->v8[13]]
+    column2 = U0[state->v8[8]] ^ U1[state->v8[13]] ^ U2[state->v8[2]] ^
-              ^ U2[state->v8[2]] ^ U3[state->v8[7]];
+              U3[state->v8[7]];
 
-    column3 = U0[state->v8[12]] ^ U1[state->v8[1]]
+    column3 = U0[state->v8[12]] ^ U1[state->v8[1]] ^ U2[state->v8[6]] ^
-              ^ U2[state->v8[6]] ^ U3[state->v8[11]];
+              U3[state->v8[11]];
 
     state->v32[0] = column0 ^ round_key->v32[0];
     state->v32[1] = column1 ^ round_key->v32[1];
     state->v32[2] = column2 ^ round_key->v32[2];
     state->v32[3] = column3 ^ round_key->v32[3];
-
 }
 
 static inline void aes_final_round(v128_t *state, const v128_t *round_key)
@@ -2090,10 +2128,8 @@ static inline void aes_inv_final_round (v128_t *state, const v128_t *round_key)
 
 #endif /* CPU type */
 
-
 void srtp_aes_encrypt(v128_t *plaintext, const srtp_aes_expanded_key_t *exp_key)
 {
-
     /* add in the subkey */
     v128_xor_eq(plaintext, &exp_key->round[0]);
 
@@ -2124,7 +2160,6 @@ void srtp_aes_encrypt (v128_t *plaintext, const srtp_aes_expanded_key_t *exp_key
 
 void srtp_aes_decrypt(v128_t *plaintext, const srtp_aes_expanded_key_t *exp_key)
 {
-
     /* add in the subkey */
     v128_xor_eq(plaintext, &exp_key->round[0]);
 

libs/srtp/crypto/cipher/aes_gcm_ossl.c

@@ -54,20 +54,13 @@
 #include "alloc.h"
 #include "err.h" /* for srtp_debug */
 #include "crypto_types.h"
-
+#include "cipher_types.h"
 
 srtp_debug_module_t srtp_mod_aes_gcm = {
     0,        /* debugging is off by default */
     "aes gcm" /* printable module name       */
 };
 
-/*
- * The following are the global singleton instances for the
- * 128-bit and 256-bit GCM ciphers.
- */
-extern const srtp_cipher_type_t srtp_aes_gcm_128_openssl;
-extern const srtp_cipher_type_t srtp_aes_gcm_256_openssl;
-
 /*
  * For now we only support 8 and 16 octet tags.  The spec allows for
  * optional 12 byte tag, which may be supported in the future.
@@ -75,7 +68,6 @@ extern const srtp_cipher_type_t srtp_aes_gcm_256_openssl;
 #define GCM_AUTH_TAG_LEN 16
 #define GCM_AUTH_TAG_LEN_8 8
 
-
 /*
  * This function allocates a new instance of this crypto engine.
  * The key_len parameter should be one of 28 or 44 for
@@ -83,11 +75,14 @@ extern const srtp_cipher_type_t srtp_aes_gcm_256_openssl;
  * key length includes the 14 byte salt value that is used when
  * initializing the KDF.
  */
-static srtp_err_status_t srtp_aes_gcm_openssl_alloc (srtp_cipher_t **c, int key_len, int tlen)
+static srtp_err_status_t srtp_aes_gcm_openssl_alloc(srtp_cipher_t **c,
+                                                    int key_len,
+                                                    int tlen)
 {
     srtp_aes_gcm_ctx_t *gcm;
 
-    debug_print(srtp_mod_aes_gcm, "allocating cipher with key length %d", key_len);
+    debug_print(srtp_mod_aes_gcm, "allocating cipher with key length %d",
+                key_len);
     debug_print(srtp_mod_aes_gcm, "allocating cipher with tag length %d", tlen);
 
     /*
@@ -98,8 +93,7 @@ static srtp_err_status_t srtp_aes_gcm_openssl_alloc (srtp_cipher_t **c, int key_
         return (srtp_err_status_bad_param);
     }
 
-    if (tlen != GCM_AUTH_TAG_LEN &&
+    if (tlen != GCM_AUTH_TAG_LEN && tlen != GCM_AUTH_TAG_LEN_8) {
-        tlen != GCM_AUTH_TAG_LEN_8) {
         return (srtp_err_status_bad_param);
     }
 
@@ -108,7 +102,6 @@ static srtp_err_status_t srtp_aes_gcm_openssl_alloc (srtp_cipher_t **c, int key_
     if (*c == NULL) {
         return (srtp_err_status_alloc_fail);
     }
-    memset(*c, 0x0, sizeof(srtp_cipher_t));
 
     gcm = (srtp_aes_gcm_ctx_t *)srtp_crypto_alloc(sizeof(srtp_aes_gcm_ctx_t));
     if (gcm == NULL) {
@@ -116,7 +109,6 @@ static srtp_err_status_t srtp_aes_gcm_openssl_alloc (srtp_cipher_t **c, int key_
         *c = NULL;
         return (srtp_err_status_alloc_fail);
     }
-    memset(gcm, 0x0, sizeof(srtp_aes_gcm_ctx_t));
 
     gcm->ctx = EVP_CIPHER_CTX_new();
     if (gcm->ctx == NULL) {
@@ -151,7 +143,6 @@ static srtp_err_status_t srtp_aes_gcm_openssl_alloc (srtp_cipher_t **c, int key_
     return (srtp_err_status_ok);
 }
 
-
 /*
  * This function deallocates a GCM session
  */
@@ -179,14 +170,16 @@ static srtp_err_status_t srtp_aes_gcm_openssl_dealloc (srtp_cipher_t *c)
  *
  * the key is the secret key
  */
-static srtp_err_status_t srtp_aes_gcm_openssl_context_init (void* cv, const uint8_t *key)
+static srtp_err_status_t srtp_aes_gcm_openssl_context_init(void *cv,
+                                                           const uint8_t *key)
 {
     srtp_aes_gcm_ctx_t *c = (srtp_aes_gcm_ctx_t *)cv;
     const EVP_CIPHER *evp;
 
     c->dir = srtp_direction_any;
 
-    debug_print(srtp_mod_aes_gcm, "key:  %s", srtp_octet_string_hex_string(key, c->key_size));
+    debug_print(srtp_mod_aes_gcm, "key:  %s",
+                srtp_octet_string_hex_string(key, c->key_size));
 
     switch (c->key_size) {
     case SRTP_AES_256_KEY_LEN:
@@ -207,35 +200,32 @@ static srtp_err_status_t srtp_aes_gcm_openssl_context_init (void* cv, const uint
     return (srtp_err_status_ok);
 }
 
-
 /*
  * aes_gcm_openssl_set_iv(c, iv) sets the counter value to the exor of iv with
  * the offset
  */
-static srtp_err_status_t srtp_aes_gcm_openssl_set_iv (void *cv, uint8_t *iv, srtp_cipher_direction_t direction)
+static srtp_err_status_t srtp_aes_gcm_openssl_set_iv(
+    void *cv,
+    uint8_t *iv,
+    srtp_cipher_direction_t direction)
 {
     srtp_aes_gcm_ctx_t *c = (srtp_aes_gcm_ctx_t *)cv;
 
-    if (direction != srtp_direction_encrypt && direction != srtp_direction_decrypt) {
+    if (direction != srtp_direction_encrypt &&
+        direction != srtp_direction_decrypt) {
         return (srtp_err_status_bad_param);
     }
     c->dir = direction;
 
-    debug_print(srtp_mod_aes_gcm, "setting iv: %s", v128_hex_string((v128_t*)iv));
+    debug_print(srtp_mod_aes_gcm, "setting iv: %s",
+                v128_hex_string((v128_t *)iv));
 
-    if (!EVP_CipherInit_ex(c->ctx, NULL, NULL, NULL,
-                           NULL, (c->dir == srtp_direction_encrypt ? 1 : 0))) {
-        return (srtp_err_status_init_fail);
-    }
-
-    /* set IV len  and the IV value, the followiong 3 calls are required */
     if (!EVP_CIPHER_CTX_ctrl(c->ctx, EVP_CTRL_GCM_SET_IVLEN, 12, 0)) {
         return (srtp_err_status_init_fail);
     }
-    if (!EVP_CIPHER_CTX_ctrl(c->ctx, EVP_CTRL_GCM_SET_IV_FIXED, -1, (void*)iv)) {
+
-        return (srtp_err_status_init_fail);
+    if (!EVP_CipherInit_ex(c->ctx, NULL, NULL, NULL, iv,
-    }
+                           (c->dir == srtp_direction_encrypt ? 1 : 0))) {
-    if (!EVP_CIPHER_CTX_ctrl(c->ctx, EVP_CTRL_GCM_IV_GEN, 0, (void*)iv)) {
         return (srtp_err_status_init_fail);
     }
 
@@ -250,7 +240,9 @@ static srtp_err_status_t srtp_aes_gcm_openssl_set_iv (void *cv, uint8_t *iv, srt
  *	aad	Additional data to process for AEAD cipher suites
  *	aad_len	length of aad buffer
  */
-static srtp_err_status_t srtp_aes_gcm_openssl_set_aad (void *cv, const uint8_t *aad, uint32_t aad_len)
+static srtp_err_status_t srtp_aes_gcm_openssl_set_aad(void *cv,
+                                                      const uint8_t *aad,
+                                                      uint32_t aad_len)
 {
     srtp_aes_gcm_ctx_t *c = (srtp_aes_gcm_ctx_t *)cv;
     int rv;
@@ -286,7 +278,9 @@ static srtp_err_status_t srtp_aes_gcm_openssl_set_aad (void *cv, const uint8_t *
  *	buf	data to encrypt
  *	enc_len	length of encrypt buffer
  */
-static srtp_err_status_t srtp_aes_gcm_openssl_encrypt (void *cv, unsigned char *buf, unsigned int *enc_len)
+static srtp_err_status_t srtp_aes_gcm_openssl_encrypt(void *cv,
+                                                      unsigned char *buf,
+                                                      unsigned int *enc_len)
 {
     srtp_aes_gcm_ctx_t *c = (srtp_aes_gcm_ctx_t *)cv;
     if (c->dir != srtp_direction_encrypt && c->dir != srtp_direction_decrypt) {
@@ -312,7 +306,9 @@ static srtp_err_status_t srtp_aes_gcm_openssl_encrypt (void *cv, unsigned char *
  *	buf	data to encrypt
  *	len	length of encrypt buffer
  */
-static srtp_err_status_t srtp_aes_gcm_openssl_get_tag (void *cv, uint8_t *buf, uint32_t *len)
+static srtp_err_status_t srtp_aes_gcm_openssl_get_tag(void *cv,
+                                                      uint8_t *buf,
+                                                      uint32_t *len)
 {
     srtp_aes_gcm_ctx_t *c = (srtp_aes_gcm_ctx_t *)cv;
     /*
@@ -333,7 +329,6 @@ static srtp_err_status_t srtp_aes_gcm_openssl_get_tag (void *cv, uint8_t *buf, u
     return (srtp_err_status_ok);
 }
 
-
 /*
  * This function decrypts a buffer using AES GCM mode
  *
@@ -342,7 +337,9 @@ static srtp_err_status_t srtp_aes_gcm_openssl_get_tag (void *cv, uint8_t *buf, u
  *	buf	data to encrypt
  *	enc_len	length of encrypt buffer
  */
-static srtp_err_status_t srtp_aes_gcm_openssl_decrypt (void *cv, unsigned char *buf, unsigned int *enc_len)
+static srtp_err_status_t srtp_aes_gcm_openssl_decrypt(void *cv,
+                                                      unsigned char *buf,
+                                                      unsigned int *enc_len)
 {
     srtp_aes_gcm_ctx_t *c = (srtp_aes_gcm_ctx_t *)cv;
     if (c->dir != srtp_direction_encrypt && c->dir != srtp_direction_decrypt) {
@@ -372,32 +369,36 @@ static srtp_err_status_t srtp_aes_gcm_openssl_decrypt (void *cv, unsigned char *
     return (srtp_err_status_ok);
 }
 
-
-
 /*
  * Name of this crypto engine
  */
-static const char srtp_aes_gcm_128_openssl_description[] = "AES-128 GCM using openssl";
+static const char srtp_aes_gcm_128_openssl_description[] =
-static const char srtp_aes_gcm_256_openssl_description[] = "AES-256 GCM using openssl";
+    "AES-128 GCM using openssl";
-
+static const char srtp_aes_gcm_256_openssl_description[] =
+    "AES-256 GCM using openssl";
 
 /*
  * KAT values for AES self-test.  These
  * values we're derived from independent test code
  * using OpenSSL.
  */
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_0_key[SRTP_AES_GCM_128_KEY_LEN_WSALT] = {
     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
     0x09, 0x0a, 0x0b, 0x0c,
 };
+/* clang-format on */
 
+/* clang-format off */
 static uint8_t srtp_aes_gcm_test_case_0_iv[12] = {
     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
     0xde, 0xca, 0xf8, 0x88
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_0_plaintext[60] =  {
     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
@@ -409,12 +410,15 @@ static const uint8_t srtp_aes_gcm_test_case_0_plaintext[60] =  {
     0xba, 0x63, 0x7b, 0x39
 };
 
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_0_aad[20] = {
     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
     0xab, 0xad, 0xda, 0xd2
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_0_ciphertext[76] = {
     0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
@@ -428,6 +432,7 @@ static const uint8_t srtp_aes_gcm_test_case_0_ciphertext[76] = {
     0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb,
     0x94, 0xfa, 0xe9, 0x5a, 0xe7, 0x12, 0x1a, 0x47,
 };
+/* clang-format on */
 
 static const srtp_cipher_test_case_t srtp_aes_gcm_test_case_0a = {
     SRTP_AES_GCM_128_KEY_LEN_WSALT,      /* octets in key            */
@@ -439,7 +444,7 @@ static const srtp_cipher_test_case_t srtp_aes_gcm_test_case_0a = {
     srtp_aes_gcm_test_case_0_ciphertext, /* ciphertext  + tag        */
     20,                                  /* octets in AAD            */
     srtp_aes_gcm_test_case_0_aad,        /* AAD                      */
-    GCM_AUTH_TAG_LEN_8,
+    GCM_AUTH_TAG_LEN_8,                  /* */
     NULL                                 /* pointer to next testcase */
 };
 
@@ -453,10 +458,11 @@ static const srtp_cipher_test_case_t srtp_aes_gcm_test_case_0 = {
     srtp_aes_gcm_test_case_0_ciphertext, /* ciphertext  + tag        */
     20,                                  /* octets in AAD            */
     srtp_aes_gcm_test_case_0_aad,        /* AAD                      */
-    GCM_AUTH_TAG_LEN,
+    GCM_AUTH_TAG_LEN,                    /* */
     &srtp_aes_gcm_test_case_0a           /* pointer to next testcase */
 };
 
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_1_key[SRTP_AES_GCM_256_KEY_LEN_WSALT] = {
     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
     0xa5, 0x59, 0x09, 0xc5, 0x54, 0x66, 0x93, 0x1c,
@@ -464,14 +470,17 @@ static const uint8_t srtp_aes_gcm_test_case_1_key[SRTP_AES_GCM_256_KEY_LEN_WSALT
     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08,
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
     0x09, 0x0a, 0x0b, 0x0c,
-
 };
+/* clang-format on */
 
+/* clang-format off */
 static uint8_t srtp_aes_gcm_test_case_1_iv[12] = {
     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
     0xde, 0xca, 0xf8, 0x88
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_1_plaintext[60] =  {
     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
@@ -482,13 +491,17 @@ static const uint8_t srtp_aes_gcm_test_case_1_plaintext[60] =  {
     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
     0xba, 0x63, 0x7b, 0x39
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_1_aad[20] = {
     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
     0xab, 0xad, 0xda, 0xd2
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_gcm_test_case_1_ciphertext[76] = {
     0x0b, 0x11, 0xcf, 0xaf, 0x68, 0x4d, 0xae, 0x46,
     0xc7, 0x90, 0xb8, 0x8e, 0xb7, 0x6a, 0x76, 0x2a,
@@ -502,6 +515,7 @@ static const uint8_t srtp_aes_gcm_test_case_1_ciphertext[76] = {
     0x45, 0xbc, 0x03, 0xe6, 0xe1, 0xac, 0x0a, 0x9f,
     0x81, 0xcb, 0x8e, 0x5b, 0x46, 0x65, 0x63, 0x1d,
 };
+/* clang-format on */
 
 static const srtp_cipher_test_case_t srtp_aes_gcm_test_case_1a = {
     SRTP_AES_GCM_256_KEY_LEN_WSALT,      /* octets in key            */
@@ -513,7 +527,7 @@ static const srtp_cipher_test_case_t srtp_aes_gcm_test_case_1a = {
     srtp_aes_gcm_test_case_1_ciphertext, /* ciphertext  + tag        */
     20,                                  /* octets in AAD            */
     srtp_aes_gcm_test_case_1_aad,        /* AAD                      */
-    GCM_AUTH_TAG_LEN_8,
+    GCM_AUTH_TAG_LEN_8,                  /* */
     NULL                                 /* pointer to next testcase */
 };
 
@@ -527,7 +541,7 @@ static const srtp_cipher_test_case_t srtp_aes_gcm_test_case_1 = {
     srtp_aes_gcm_test_case_1_ciphertext, /* ciphertext  + tag        */
     20,                                  /* octets in AAD            */
     srtp_aes_gcm_test_case_1_aad,        /* AAD                      */
-    GCM_AUTH_TAG_LEN,
+    GCM_AUTH_TAG_LEN,                    /* */
     &srtp_aes_gcm_test_case_1a           /* pointer to next testcase */
 };
 
@@ -564,4 +578,3 @@ const srtp_cipher_type_t srtp_aes_gcm_256_openssl = {
     &srtp_aes_gcm_test_case_1,
     SRTP_AES_GCM_256
 };
-

libs/srtp/crypto/cipher/aes_icm.c

@@ -51,14 +51,12 @@
 
 #include "aes_icm.h"
 #include "alloc.h"
-
+#include "cipher_types.h"
 
 srtp_debug_module_t srtp_mod_aes_icm = {
     0,        /* debugging is off by default */
     "aes icm" /* printable module name       */
 };
-extern const srtp_cipher_type_t srtp_aes_icm_128;
-extern const srtp_cipher_type_t srtp_aes_icm_256;
 
 /*
  * integer counter mode works as follows:
@@ -94,12 +92,14 @@ extern const srtp_cipher_type_t srtp_aes_icm_256;
  *
  */
 
-static srtp_err_status_t srtp_aes_icm_alloc (srtp_cipher_t **c, int key_len, int tlen)
+static srtp_err_status_t srtp_aes_icm_alloc(srtp_cipher_t **c,
+                                            int key_len,
+                                            int tlen)
 {
     srtp_aes_icm_ctx_t *icm;
 
-    debug_print(srtp_mod_aes_icm,
+    debug_print(srtp_mod_aes_icm, "allocating cipher with key length %d",
-                "allocating cipher with key length %d", key_len);
+                key_len);
 
     /*
      * The check for key_len = 30/46 does not apply. Our usage
@@ -107,7 +107,8 @@ static srtp_err_status_t srtp_aes_icm_alloc (srtp_cipher_t **c, int key_len, int
      * has not broken anything. Don't know what would be the
      * effect of skipping this check for srtp in general.
      */
-    if (key_len != SRTP_AES_ICM_128_KEY_LEN_WSALT && key_len != SRTP_AES_ICM_256_KEY_LEN_WSALT) {
+    if (key_len != SRTP_AES_ICM_128_KEY_LEN_WSALT &&
+        key_len != SRTP_AES_ICM_256_KEY_LEN_WSALT) {
         return srtp_err_status_bad_param;
     }
 
@@ -116,14 +117,13 @@ static srtp_err_status_t srtp_aes_icm_alloc (srtp_cipher_t **c, int key_len, int
     if (*c == NULL) {
         return srtp_err_status_alloc_fail;
     }
-    memset(*c, 0x0, sizeof(srtp_cipher_t));
 
     icm = (srtp_aes_icm_ctx_t *)srtp_crypto_alloc(sizeof(srtp_aes_icm_ctx_t));
     if (icm == NULL) {
         srtp_crypto_free(*c);
+        *c = NULL;
         return srtp_err_status_alloc_fail;
     }
-    memset(icm, 0x0, sizeof(srtp_aes_icm_ctx_t));
 
     /* set pointers */
     (*c)->state = icm;
@@ -167,7 +167,6 @@ static srtp_err_status_t srtp_aes_icm_dealloc (srtp_cipher_t *c)
     return srtp_err_status_ok;
 }
 
-
 /*
  * aes_icm_context_init(...) initializes the aes_icm_context
  * using the value in key[].
@@ -184,7 +183,8 @@ static srtp_err_status_t srtp_aes_icm_context_init (void *cv, const uint8_t *key
     srtp_err_status_t status;
     int base_key_len, copy_len;
 
-    if (c->key_size == SRTP_AES_ICM_128_KEY_LEN_WSALT || c->key_size == SRTP_AES_ICM_256_KEY_LEN_WSALT) {
+    if (c->key_size == SRTP_AES_ICM_128_KEY_LEN_WSALT ||
+        c->key_size == SRTP_AES_ICM_256_KEY_LEN_WSALT) {
         base_key_len = c->key_size - SRTP_SALT_LEN;
     } else {
         return srtp_err_status_bad_param;
@@ -198,7 +198,8 @@ static srtp_err_status_t srtp_aes_icm_context_init (void *cv, const uint8_t *key
     v128_set_to_zero(&c->offset);
 
     copy_len = c->key_size - base_key_len;
-    /* force last two octets of the offset to be left zero (for srtp compatibility) */
+    /* force last two octets of the offset to be left zero (for srtp
+     * compatibility) */
     if (copy_len > SRTP_SALT_LEN) {
         copy_len = SRTP_SALT_LEN;
     }
@@ -206,13 +207,13 @@ static srtp_err_status_t srtp_aes_icm_context_init (void *cv, const uint8_t *key
     memcpy(&c->counter, key + base_key_len, copy_len);
     memcpy(&c->offset, key + base_key_len, copy_len);
 
-    debug_print(srtp_mod_aes_icm,
+    debug_print(srtp_mod_aes_icm, "key:  %s",
-                "key:  %s", srtp_octet_string_hex_string(key, base_key_len));
+                srtp_octet_string_hex_string(key, base_key_len));
-    debug_print(srtp_mod_aes_icm,
+    debug_print(srtp_mod_aes_icm, "offset: %s", v128_hex_string(&c->offset));
-                "offset: %s", v128_hex_string(&c->offset));
 
     /* expand key */
-    status = srtp_aes_expand_encryption_key(key, base_key_len, &c->expanded_key);
+    status =
+        srtp_aes_expand_encryption_key(key, base_key_len, &c->expanded_key);
     if (status) {
         v128_set_to_zero(&c->counter);
         v128_set_to_zero(&c->offset);
@@ -230,7 +231,9 @@ static srtp_err_status_t srtp_aes_icm_context_init (void *cv, const uint8_t *key
  * the offset
  */
 
-static srtp_err_status_t srtp_aes_icm_set_iv (void *cv, uint8_t *iv, srtp_cipher_direction_t direction)
+static srtp_err_status_t srtp_aes_icm_set_iv(void *cv,
+                                             uint8_t *iv,
+                                             srtp_cipher_direction_t direction)
 {
     srtp_aes_icm_ctx_t *c = (srtp_aes_icm_ctx_t *)cv;
     v128_t nonce;
@@ -238,13 +241,12 @@ static srtp_err_status_t srtp_aes_icm_set_iv (void *cv, uint8_t *iv, srtp_cipher
     /* set nonce (for alignment) */
     v128_copy_octet_string(&nonce, iv);
 
-    debug_print(srtp_mod_aes_icm,
+    debug_print(srtp_mod_aes_icm, "setting iv: %s", v128_hex_string(&nonce));
-                "setting iv: %s", v128_hex_string(&nonce));
 
     v128_xor(&c->counter, &c->offset, &nonce);
 
-    debug_print(srtp_mod_aes_icm,
+    debug_print(srtp_mod_aes_icm, "set_counter: %s",
-                "set_counter: %s", v128_hex_string(&c->counter));
+                v128_hex_string(&c->counter));
 
     /* indicate that the keystream_buffer is empty */
     c->bytes_in_buffer = 0;
@@ -252,8 +254,6 @@ static srtp_err_status_t srtp_aes_icm_set_iv (void *cv, uint8_t *iv, srtp_cipher
     return srtp_err_status_ok;
 }
 
-
-
 /*
  * aes_icm_advance(...) refills the keystream_buffer and
  * advances the block index of the sicm_context forward by one
@@ -278,7 +278,7 @@ static void srtp_aes_icm_advance (srtp_aes_icm_ctx_t *c)
     }
 }
 
-/*e
+/*
  * icm_encrypt deals with the following cases:
  *
  * bytes_to_encr < bytes_in_buffer
@@ -292,7 +292,8 @@ static void srtp_aes_icm_advance (srtp_aes_icm_ctx_t *c)
  */
 
 static srtp_err_status_t srtp_aes_icm_encrypt(void *cv,
-                                               unsigned char *buf, unsigned int *enc_len)
+                                              unsigned char *buf,
+                                              unsigned int *enc_len)
 {
     srtp_aes_icm_ctx_t *c = (srtp_aes_icm_ctx_t *)cv;
     unsigned int bytes_to_encr = *enc_len;
@@ -304,10 +305,8 @@ static srtp_err_status_t srtp_aes_icm_encrypt (void *cv,
         return srtp_err_status_terminus;
     }
 
-    debug_print(srtp_mod_aes_icm, "block index: %d",
+    debug_print(srtp_mod_aes_icm, "block index: %d", htons(c->counter.v16[7]));
-                htons(c->counter.v16[7]));
     if (bytes_to_encr <= (unsigned int)c->bytes_in_buffer) {
-
         /* deal with odd case of small bytes_to_encr */
         for (i = (sizeof(v128_t) - c->bytes_in_buffer);
              i < (sizeof(v128_t) - c->bytes_in_buffer + bytes_to_encr); i++) {
@@ -320,20 +319,18 @@ static srtp_err_status_t srtp_aes_icm_encrypt (void *cv,
         return srtp_err_status_ok;
 
     } else {
-
         /* encrypt bytes until the remaining data is 16-byte aligned */
-        for (i = (sizeof(v128_t) - c->bytes_in_buffer); i < sizeof(v128_t); i++) {
+        for (i = (sizeof(v128_t) - c->bytes_in_buffer); i < sizeof(v128_t);
+             i++) {
             *buf++ ^= c->keystream_buffer.v8[i];
         }
 
         bytes_to_encr -= c->bytes_in_buffer;
         c->bytes_in_buffer = 0;
-
     }
 
     /* now loop over entire 16-byte blocks of keystream */
     for (i = 0; i < (bytes_to_encr / sizeof(v128_t)); i++) {
-
         /* fill buffer with new keystream */
         srtp_aes_icm_advance(c);
 
@@ -350,7 +347,7 @@ static srtp_err_status_t srtp_aes_icm_encrypt (void *cv,
         *b++ ^= c->keystream_buffer.v32[3];
         buf = (uint8_t *)b;
 #else
-        if ((((unsigned long)buf) & 0x03) != 0) {
+        if ((((uintptr_t)buf) & 0x03) != 0) {
             *buf++ ^= c->keystream_buffer.v8[0];
             *buf++ ^= c->keystream_buffer.v8[1];
             *buf++ ^= c->keystream_buffer.v8[2];
@@ -376,12 +373,10 @@ static srtp_err_status_t srtp_aes_icm_encrypt (void *cv,
             buf = (uint8_t *)b;
         }
 #endif /* #if ALIGN_32 */
-
     }
 
     /* if there is a tail end of the data, process it */
     if ((bytes_to_encr & 0xf) != 0) {
-
         /* fill buffer with new keystream */
         srtp_aes_icm_advance(c);
 
@@ -392,43 +387,51 @@ static srtp_err_status_t srtp_aes_icm_encrypt (void *cv,
         /* reset the keystream buffer size to right value */
         c->bytes_in_buffer = sizeof(v128_t) - i;
     } else {
-
         /* no tail, so just reset the keystream buffer size to zero */
         c->bytes_in_buffer = 0;
-
     }
 
     return srtp_err_status_ok;
 }
 
-static const char srtp_aes_icm_128_description[] = "AES-128 integer counter mode";
+static const char srtp_aes_icm_128_description[] =
-static const char srtp_aes_icm_256_description[] = "AES-256 integer counter mode";
+    "AES-128 integer counter mode";
+static const char srtp_aes_icm_256_description[] =
+    "AES-256 integer counter mode";
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_128_test_case_0_key[SRTP_AES_ICM_128_KEY_LEN_WSALT] = {
     0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
     0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd
 };
+/* clang-format on */
 
+/* clang-format off */
 static uint8_t srtp_aes_icm_128_test_case_0_nonce[16] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_128_test_case_0_plaintext[32] =  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_128_test_case_0_ciphertext[32] = {
     0xe0, 0x3e, 0xad, 0x09, 0x35, 0xc9, 0x5e, 0x80,
     0xe1, 0x66, 0xb1, 0x6d, 0xd9, 0x2b, 0x4e, 0xb4,
     0xd2, 0x35, 0x13, 0x16, 0x2b, 0x02, 0xd0, 0xf7,
     0x2a, 0x43, 0xa2, 0xfe, 0x4a, 0x5f, 0x97, 0xab
 };
+/* clang-format on */
 
 static const srtp_cipher_test_case_t srtp_aes_icm_128_test_case_0 = {
     SRTP_AES_ICM_128_KEY_LEN_WSALT,          /* octets in key            */
@@ -438,12 +441,13 @@ static const srtp_cipher_test_case_t srtp_aes_icm_128_test_case_0 = {
     srtp_aes_icm_128_test_case_0_plaintext,  /* plaintext                */
     32,                                      /* octets in ciphertext     */
     srtp_aes_icm_128_test_case_0_ciphertext, /* ciphertext               */
-    0,
+    0,                                       /* */
-    NULL,
+    NULL,                                    /* */
-    0,
+    0,                                       /* */
     NULL                                     /* pointer to next testcase */
 };
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_256_test_case_0_key[SRTP_AES_ICM_256_KEY_LEN_WSALT] = {
     0x57, 0xf8, 0x2f, 0xe3, 0x61, 0x3f, 0xd1, 0x70,
     0xa8, 0x5e, 0xc9, 0x3c, 0x40, 0xb1, 0xf0, 0x92,
@@ -452,25 +456,32 @@ static const uint8_t srtp_aes_icm_256_test_case_0_key[SRTP_AES_ICM_256_KEY_LEN_W
     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd
 };
+/* clang-format on */
 
+/* clang-format off */
 static uint8_t srtp_aes_icm_256_test_case_0_nonce[16] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_256_test_case_0_plaintext[32] =  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_256_test_case_0_ciphertext[32] = {
     0x92, 0xbd, 0xd2, 0x8a, 0x93, 0xc3, 0xf5, 0x25,
     0x11, 0xc6, 0x77, 0xd0, 0x8b, 0x55, 0x15, 0xa4,
     0x9d, 0xa7, 0x1b, 0x23, 0x78, 0xa8, 0x54, 0xf6,
     0x70, 0x50, 0x75, 0x6d, 0xed, 0x16, 0x5b, 0xac
 };
+/* clang-format on */
 
 static const srtp_cipher_test_case_t srtp_aes_icm_256_test_case_0 = {
     SRTP_AES_ICM_256_KEY_LEN_WSALT,          /* octets in key            */
@@ -480,42 +491,40 @@ static const srtp_cipher_test_case_t srtp_aes_icm_256_test_case_0 = {
     srtp_aes_icm_256_test_case_0_plaintext,  /* plaintext                */
     32,                                      /* octets in ciphertext     */
     srtp_aes_icm_256_test_case_0_ciphertext, /* ciphertext               */
-    0,
+    0,                                       /* */
-    NULL,
+    NULL,                                    /* */
-    0,
+    0,                                       /* */
     NULL,                                    /* pointer to next testcase */
 };
 
-
-
 /*
  * note: the encrypt function is identical to the decrypt function
  */
 
 const srtp_cipher_type_t srtp_aes_icm_128 = {
-    srtp_aes_icm_alloc,
+    srtp_aes_icm_alloc,            /* */
-    srtp_aes_icm_dealloc,
+    srtp_aes_icm_dealloc,          /* */
-    srtp_aes_icm_context_init,
+    srtp_aes_icm_context_init,     /* */
     0,                             /* set_aad */
-    srtp_aes_icm_encrypt,
+    srtp_aes_icm_encrypt,          /* */
-    srtp_aes_icm_encrypt,
+    srtp_aes_icm_encrypt,          /* */
-    srtp_aes_icm_set_iv,
+    srtp_aes_icm_set_iv,           /* */
     0,                             /* get_tag */
-    srtp_aes_icm_128_description,
+    srtp_aes_icm_128_description,  /* */
-    &srtp_aes_icm_128_test_case_0,
+    &srtp_aes_icm_128_test_case_0, /* */
-    SRTP_AES_ICM_128
+    SRTP_AES_ICM_128               /* */
 };
 
 const srtp_cipher_type_t srtp_aes_icm_256 = {
-    srtp_aes_icm_alloc,
+    srtp_aes_icm_alloc,            /* */
-    srtp_aes_icm_dealloc,
+    srtp_aes_icm_dealloc,          /* */
-    srtp_aes_icm_context_init,
+    srtp_aes_icm_context_init,     /* */
     0,                             /* set_aad */
-    srtp_aes_icm_encrypt,
+    srtp_aes_icm_encrypt,          /* */
-    srtp_aes_icm_encrypt,
+    srtp_aes_icm_encrypt,          /* */
-    srtp_aes_icm_set_iv,
+    srtp_aes_icm_set_iv,           /* */
     0,                             /* get_tag */
-    srtp_aes_icm_256_description,
+    srtp_aes_icm_256_description,  /* */
-    &srtp_aes_icm_256_test_case_0,
+    &srtp_aes_icm_256_test_case_0, /* */
-    SRTP_AES_ICM_256
+    SRTP_AES_ICM_256               /* */
 };

libs/srtp/crypto/cipher/aes_icm_ossl.c

@@ -57,15 +57,12 @@
 #include "crypto_types.h"
 #include "err.h" /* for srtp_debug */
 #include "alloc.h"
-
+#include "cipher_types.h"
 
 srtp_debug_module_t srtp_mod_aes_icm = {
     0,             /* debugging is off by default */
     "aes icm ossl" /* printable module name       */
 };
-extern const srtp_cipher_type_t srtp_aes_icm_128;
-extern const srtp_cipher_type_t srtp_aes_icm_192;
-extern const srtp_cipher_type_t srtp_aes_icm_256;
 
 /*
  * integer counter mode works as follows:
@@ -109,16 +106,20 @@ extern const srtp_cipher_type_t srtp_aes_icm_256;
  * value.  The tlen argument is for the AEAD tag length, which
  * isn't used in counter mode.
  */
-static srtp_err_status_t srtp_aes_icm_openssl_alloc (srtp_cipher_t **c, int key_len, int tlen)
+static srtp_err_status_t srtp_aes_icm_openssl_alloc(srtp_cipher_t **c,
+                                                    int key_len,
+                                                    int tlen)
 {
     srtp_aes_icm_ctx_t *icm;
 
-    debug_print(srtp_mod_aes_icm, "allocating cipher with key length %d", key_len);
+    debug_print(srtp_mod_aes_icm, "allocating cipher with key length %d",
+                key_len);
 
     /*
      * Verify the key_len is valid for one of: AES-128/192/256
      */
-    if (key_len != SRTP_AES_ICM_128_KEY_LEN_WSALT && key_len != SRTP_AES_ICM_192_KEY_LEN_WSALT &&
+    if (key_len != SRTP_AES_ICM_128_KEY_LEN_WSALT &&
+        key_len != SRTP_AES_ICM_192_KEY_LEN_WSALT &&
         key_len != SRTP_AES_ICM_256_KEY_LEN_WSALT) {
         return srtp_err_status_bad_param;
     }
@@ -128,7 +129,6 @@ static srtp_err_status_t srtp_aes_icm_openssl_alloc (srtp_cipher_t **c, int key_
     if (*c == NULL) {
         return srtp_err_status_alloc_fail;
     }
-    memset(*c, 0x0, sizeof(srtp_cipher_t));
 
     icm = (srtp_aes_icm_ctx_t *)srtp_crypto_alloc(sizeof(srtp_aes_icm_ctx_t));
     if (icm == NULL) {
@@ -136,7 +136,6 @@ static srtp_err_status_t srtp_aes_icm_openssl_alloc (srtp_cipher_t **c, int key_
         *c = NULL;
         return srtp_err_status_alloc_fail;
     }
-    memset(icm, 0x0, sizeof(srtp_aes_icm_ctx_t));
 
     icm->ctx = EVP_CIPHER_CTX_new();
     if (icm->ctx == NULL) {
@@ -174,7 +173,6 @@ static srtp_err_status_t srtp_aes_icm_openssl_alloc (srtp_cipher_t **c, int key_
     return srtp_err_status_ok;
 }
 
-
 /*
  * This function deallocates an instance of this engine
  */
@@ -212,7 +210,8 @@ static srtp_err_status_t srtp_aes_icm_openssl_dealloc (srtp_cipher_t *c)
  * the salt is unpredictable (but not necessarily secret) data which
  * randomizes the starting point in the keystream
  */
-static srtp_err_status_t srtp_aes_icm_openssl_context_init (void* cv, const uint8_t *key)
+static srtp_err_status_t srtp_aes_icm_openssl_context_init(void *cv,
+                                                           const uint8_t *key)
 {
     srtp_aes_icm_ctx_t *c = (srtp_aes_icm_ctx_t *)cv;
     const EVP_CIPHER *evp;
@@ -230,7 +229,8 @@ static srtp_err_status_t srtp_aes_icm_openssl_context_init (void* cv, const uint
     c->offset.v8[SRTP_SALT_LEN] = c->offset.v8[SRTP_SALT_LEN + 1] = 0;
     c->counter.v8[SRTP_SALT_LEN] = c->counter.v8[SRTP_SALT_LEN + 1] = 0;
 
-    debug_print(srtp_mod_aes_icm, "key:  %s", srtp_octet_string_hex_string(key, c->key_size));
+    debug_print(srtp_mod_aes_icm, "key:  %s",
+                srtp_octet_string_hex_string(key, c->key_size));
     debug_print(srtp_mod_aes_icm, "offset: %s", v128_hex_string(&c->offset));
 
     switch (c->key_size) {
@@ -248,8 +248,7 @@ static srtp_err_status_t srtp_aes_icm_openssl_context_init (void* cv, const uint
         break;
     }
 
-    if (!EVP_EncryptInit_ex(c->ctx, evp,
+    if (!EVP_EncryptInit_ex(c->ctx, evp, NULL, key, NULL)) {
-                            NULL, key, NULL)) {
         return srtp_err_status_fail;
     } else {
         return srtp_err_status_ok;
@@ -258,12 +257,14 @@ static srtp_err_status_t srtp_aes_icm_openssl_context_init (void* cv, const uint
     return srtp_err_status_ok;
 }
 
-
 /*
  * aes_icm_set_iv(c, iv) sets the counter value to the exor of iv with
  * the offset
  */
-static srtp_err_status_t srtp_aes_icm_openssl_set_iv (void *cv, uint8_t *iv, srtp_cipher_direction_t dir)
+static srtp_err_status_t srtp_aes_icm_openssl_set_iv(
+    void *cv,
+    uint8_t *iv,
+    srtp_cipher_direction_t dir)
 {
     srtp_aes_icm_ctx_t *c = (srtp_aes_icm_ctx_t *)cv;
     v128_t nonce;
@@ -275,10 +276,10 @@ static srtp_err_status_t srtp_aes_icm_openssl_set_iv (void *cv, uint8_t *iv, srt
 
     v128_xor(&c->counter, &c->offset, &nonce);
 
-    debug_print(srtp_mod_aes_icm, "set_counter: %s", v128_hex_string(&c->counter));
+    debug_print(srtp_mod_aes_icm, "set_counter: %s",
+                v128_hex_string(&c->counter));
 
-    if (!EVP_EncryptInit_ex(c->ctx, NULL,
+    if (!EVP_EncryptInit_ex(c->ctx, NULL, NULL, NULL, c->counter.v8)) {
-                            NULL, NULL, c->counter.v8)) {
         return srtp_err_status_fail;
     } else {
         return srtp_err_status_ok;
@@ -293,7 +294,9 @@ static srtp_err_status_t srtp_aes_icm_openssl_set_iv (void *cv, uint8_t *iv, srt
  *	buf	data to encrypt
  *	enc_len	length of encrypt buffer
  */
-static srtp_err_status_t srtp_aes_icm_openssl_encrypt (void *cv, unsigned char *buf, unsigned int *enc_len)
+static srtp_err_status_t srtp_aes_icm_openssl_encrypt(void *cv,
+                                                      unsigned char *buf,
+                                                      unsigned int *enc_len)
 {
     srtp_aes_icm_ctx_t *c = (srtp_aes_icm_ctx_t *)cv;
     int len = 0;
@@ -316,40 +319,50 @@ static srtp_err_status_t srtp_aes_icm_openssl_encrypt (void *cv, unsigned char *
 /*
  * Name of this crypto engine
  */
-static const char srtp_aes_icm_128_openssl_description[] = "AES-128 counter mode using openssl";
+static const char srtp_aes_icm_128_openssl_description[] =
-static const char srtp_aes_icm_192_openssl_description[] = "AES-192 counter mode using openssl";
+    "AES-128 counter mode using openssl";
-static const char srtp_aes_icm_256_openssl_description[] = "AES-256 counter mode using openssl";
+static const char srtp_aes_icm_192_openssl_description[] =
-
+    "AES-192 counter mode using openssl";
+static const char srtp_aes_icm_256_openssl_description[] =
+    "AES-256 counter mode using openssl";
 
 /*
  * KAT values for AES self-test.  These
  * values came from the legacy libsrtp code.
  */
+/* clang-format off */
 static const uint8_t srtp_aes_icm_128_test_case_0_key[SRTP_AES_ICM_128_KEY_LEN_WSALT] = {
     0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
     0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd
 };
+/* clang-format on */
 
+/* clang-format off */
 static uint8_t srtp_aes_icm_128_test_case_0_nonce[16] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_128_test_case_0_plaintext[32] =  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_128_test_case_0_ciphertext[32] = {
     0xe0, 0x3e, 0xad, 0x09, 0x35, 0xc9, 0x5e, 0x80,
     0xe1, 0x66, 0xb1, 0x6d, 0xd9, 0x2b, 0x4e, 0xb4,
     0xd2, 0x35, 0x13, 0x16, 0x2b, 0x02, 0xd0, 0xf7,
     0x2a, 0x43, 0xa2, 0xfe, 0x4a, 0x5f, 0x97, 0xab
 };
+/* clang-format on */
 
 static const srtp_cipher_test_case_t srtp_aes_icm_128_test_case_0 = {
     SRTP_AES_ICM_128_KEY_LEN_WSALT,          /* octets in key            */
@@ -359,9 +372,9 @@ static const srtp_cipher_test_case_t srtp_aes_icm_128_test_case_0 = {
     srtp_aes_icm_128_test_case_0_plaintext,  /* plaintext                */
     32,                                      /* octets in ciphertext     */
     srtp_aes_icm_128_test_case_0_ciphertext, /* ciphertext               */
-    0,
+    0,                                       /* */
-    NULL,
+    NULL,                                    /* */
-    0,
+    0,                                       /* */
     NULL                                     /* pointer to next testcase */
 };
 
@@ -369,6 +382,7 @@ static const srtp_cipher_test_case_t srtp_aes_icm_128_test_case_0 = {
  * KAT values for AES-192-CTR self-test.  These
  * values came from section 7 of RFC 6188.
  */
+/* clang-format off */
 static const uint8_t srtp_aes_icm_192_test_case_0_key[SRTP_AES_ICM_192_KEY_LEN_WSALT] = {
     0xea, 0xb2, 0x34, 0x76, 0x4e, 0x51, 0x7b, 0x2d,
     0x3d, 0x16, 0x0d, 0x58, 0x7d, 0x8c, 0x86, 0x21,
@@ -376,25 +390,32 @@ static const uint8_t srtp_aes_icm_192_test_case_0_key[SRTP_AES_ICM_192_KEY_LEN_W
     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd
 };
+/* clang-format on */
 
+/* clang-format off */
 static uint8_t srtp_aes_icm_192_test_case_0_nonce[16] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_192_test_case_0_plaintext[32] =  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_192_test_case_0_ciphertext[32] = {
     0x35, 0x09, 0x6c, 0xba, 0x46, 0x10, 0x02, 0x8d,
     0xc1, 0xb5, 0x75, 0x03, 0x80, 0x4c, 0xe3, 0x7c,
     0x5d, 0xe9, 0x86, 0x29, 0x1d, 0xcc, 0xe1, 0x61,
     0xd5, 0x16, 0x5e, 0xc4, 0x56, 0x8f, 0x5c, 0x9a
 };
+/* clang-format on */
 
 static const srtp_cipher_test_case_t srtp_aes_icm_192_test_case_0 = {
     SRTP_AES_ICM_192_KEY_LEN_WSALT,          /* octets in key            */
@@ -404,9 +425,9 @@ static const srtp_cipher_test_case_t srtp_aes_icm_192_test_case_0 = {
     srtp_aes_icm_192_test_case_0_plaintext,  /* plaintext                */
     32,                                      /* octets in ciphertext     */
     srtp_aes_icm_192_test_case_0_ciphertext, /* ciphertext               */
-    0,
+    0,                                       /* */
-    NULL,
+    NULL,                                    /* */
-    0,
+    0,                                       /* */
     NULL                                     /* pointer to next testcase */
 };
 
@@ -414,6 +435,7 @@ static const srtp_cipher_test_case_t srtp_aes_icm_192_test_case_0 = {
  * KAT values for AES-256-CTR self-test.  These
  * values came from section 7 of RFC 6188.
  */
+/* clang-format off */
 static const uint8_t srtp_aes_icm_256_test_case_0_key[SRTP_AES_ICM_256_KEY_LEN_WSALT] = {
     0x57, 0xf8, 0x2f, 0xe3, 0x61, 0x3f, 0xd1, 0x70,
     0xa8, 0x5e, 0xc9, 0x3c, 0x40, 0xb1, 0xf0, 0x92,
@@ -422,25 +444,32 @@ static const uint8_t srtp_aes_icm_256_test_case_0_key[SRTP_AES_ICM_256_KEY_LEN_W
     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd
 };
+/* clang-format on */
 
+/* clang-format off */
 static uint8_t srtp_aes_icm_256_test_case_0_nonce[16] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_256_test_case_0_plaintext[32] =  {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_aes_icm_256_test_case_0_ciphertext[32] = {
     0x92, 0xbd, 0xd2, 0x8a, 0x93, 0xc3, 0xf5, 0x25,
     0x11, 0xc6, 0x77, 0xd0, 0x8b, 0x55, 0x15, 0xa4,
     0x9d, 0xa7, 0x1b, 0x23, 0x78, 0xa8, 0x54, 0xf6,
     0x70, 0x50, 0x75, 0x6d, 0xed, 0x16, 0x5b, 0xac
 };
+/* clang-format on */
 
 static const srtp_cipher_test_case_t srtp_aes_icm_256_test_case_0 = {
     SRTP_AES_ICM_256_KEY_LEN_WSALT,          /* octets in key            */
@@ -450,9 +479,9 @@ static const srtp_cipher_test_case_t srtp_aes_icm_256_test_case_0 = {
     srtp_aes_icm_256_test_case_0_plaintext,  /* plaintext                */
     32,                                      /* octets in ciphertext     */
     srtp_aes_icm_256_test_case_0_ciphertext, /* ciphertext               */
-    0,
+    0,                                       /* */
-    NULL,
+    NULL,                                    /* */
-    0,
+    0,                                       /* */
     NULL                                     /* pointer to next testcase */
 };
 
@@ -461,17 +490,17 @@ static const srtp_cipher_test_case_t srtp_aes_icm_256_test_case_0 = {
  * note: the encrypt function is identical to the decrypt function
  */
 const srtp_cipher_type_t srtp_aes_icm_128 = {
-    srtp_aes_icm_openssl_alloc,
+    srtp_aes_icm_openssl_alloc,           /* */
-    srtp_aes_icm_openssl_dealloc,
+    srtp_aes_icm_openssl_dealloc,         /* */
-    srtp_aes_icm_openssl_context_init,
+    srtp_aes_icm_openssl_context_init,    /* */
     0,                                    /* set_aad */
-    srtp_aes_icm_openssl_encrypt,
+    srtp_aes_icm_openssl_encrypt,         /* */
-    srtp_aes_icm_openssl_encrypt,
+    srtp_aes_icm_openssl_encrypt,         /* */
-    srtp_aes_icm_openssl_set_iv,
+    srtp_aes_icm_openssl_set_iv,          /* */
     0,                                    /* get_tag */
-    srtp_aes_icm_128_openssl_description,
+    srtp_aes_icm_128_openssl_description, /* */
-    &srtp_aes_icm_128_test_case_0,
+    &srtp_aes_icm_128_test_case_0,        /* */
-    SRTP_AES_ICM_128
+    SRTP_AES_ICM_128                      /* */
 };
 
 /*
@@ -479,17 +508,17 @@ const srtp_cipher_type_t srtp_aes_icm_128 = {
  * note: the encrypt function is identical to the decrypt function
  */
 const srtp_cipher_type_t srtp_aes_icm_192 = {
-    srtp_aes_icm_openssl_alloc,
+    srtp_aes_icm_openssl_alloc,           /* */
-    srtp_aes_icm_openssl_dealloc,
+    srtp_aes_icm_openssl_dealloc,         /* */
-    srtp_aes_icm_openssl_context_init,
+    srtp_aes_icm_openssl_context_init,    /* */
     0,                                    /* set_aad */
-    srtp_aes_icm_openssl_encrypt,
+    srtp_aes_icm_openssl_encrypt,         /* */
-    srtp_aes_icm_openssl_encrypt,
+    srtp_aes_icm_openssl_encrypt,         /* */
-    srtp_aes_icm_openssl_set_iv,
+    srtp_aes_icm_openssl_set_iv,          /* */
     0,                                    /* get_tag */
-    srtp_aes_icm_192_openssl_description,
+    srtp_aes_icm_192_openssl_description, /* */
-    &srtp_aes_icm_192_test_case_0,
+    &srtp_aes_icm_192_test_case_0,        /* */
-    SRTP_AES_ICM_192
+    SRTP_AES_ICM_192                      /* */
 };
 
 /*
@@ -497,16 +526,15 @@ const srtp_cipher_type_t srtp_aes_icm_192 = {
  * note: the encrypt function is identical to the decrypt function
  */
 const srtp_cipher_type_t srtp_aes_icm_256 = {
-    srtp_aes_icm_openssl_alloc,
+    srtp_aes_icm_openssl_alloc,           /* */
-    srtp_aes_icm_openssl_dealloc,
+    srtp_aes_icm_openssl_dealloc,         /* */
-    srtp_aes_icm_openssl_context_init,
+    srtp_aes_icm_openssl_context_init,    /* */
     0,                                    /* set_aad */
-    srtp_aes_icm_openssl_encrypt,
+    srtp_aes_icm_openssl_encrypt,         /* */
-    srtp_aes_icm_openssl_encrypt,
+    srtp_aes_icm_openssl_encrypt,         /* */
-    srtp_aes_icm_openssl_set_iv,
+    srtp_aes_icm_openssl_set_iv,          /* */
     0,                                    /* get_tag */
-    srtp_aes_icm_256_openssl_description,
+    srtp_aes_icm_256_openssl_description, /* */
-    &srtp_aes_icm_256_test_case_0,
+    &srtp_aes_icm_256_test_case_0,        /* */
-    SRTP_AES_ICM_256
+    SRTP_AES_ICM_256                      /* */
 };
-

libs/srtp/crypto/cipher/cipher.c

@@ -58,7 +58,10 @@ srtp_debug_module_t srtp_mod_cipher = {
     "cipher" /* printable module name       */
 };
 
-srtp_err_status_t srtp_cipher_type_alloc (const srtp_cipher_type_t *ct, srtp_cipher_t **c, int key_len, int tlen)
+srtp_err_status_t srtp_cipher_type_alloc(const srtp_cipher_type_t *ct,
+                                         srtp_cipher_t **c,
+                                         int key_len,
+                                         int tlen)
 {
     if (!ct || !ct->alloc) {
         return (srtp_err_status_bad_param);
@@ -82,8 +85,9 @@ srtp_err_status_t srtp_cipher_init (srtp_cipher_t *c, const uint8_t *key)
     return (((c)->type)->init(((c)->state), (key)));
 }
 
-
+srtp_err_status_t srtp_cipher_set_iv(srtp_cipher_t *c,
-srtp_err_status_t srtp_cipher_set_iv (srtp_cipher_t *c, uint8_t *iv, int direction)
+                                     uint8_t *iv,
+                                     int direction)
 {
     if (!c || !c->type || !c->state) {
         return (srtp_err_status_bad_param);
@@ -92,9 +96,10 @@ srtp_err_status_t srtp_cipher_set_iv (srtp_cipher_t *c, uint8_t *iv, int directi
     return (((c)->type)->set_iv(((c)->state), iv, direction));
 }
 
-srtp_err_status_t srtp_cipher_output (srtp_cipher_t *c, uint8_t *buffer, uint32_t *num_octets_to_output)
+srtp_err_status_t srtp_cipher_output(srtp_cipher_t *c,
+                                     uint8_t *buffer,
+                                     uint32_t *num_octets_to_output)
 {
-
     /* zeroize the buffer */
     octet_string_set_to_zero(buffer, *num_octets_to_output);
 
@@ -102,7 +107,9 @@ srtp_err_status_t srtp_cipher_output (srtp_cipher_t *c, uint8_t *buffer, uint32_
     return (((c)->type)->encrypt(((c)->state), buffer, num_octets_to_output));
 }
 
-srtp_err_status_t srtp_cipher_encrypt (srtp_cipher_t *c, uint8_t *buffer, uint32_t *num_octets_to_output)
+srtp_err_status_t srtp_cipher_encrypt(srtp_cipher_t *c,
+                                      uint8_t *buffer,
+                                      uint32_t *num_octets_to_output)
 {
     if (!c || !c->type || !c->state) {
         return (srtp_err_status_bad_param);
@@ -111,7 +118,9 @@ srtp_err_status_t srtp_cipher_encrypt (srtp_cipher_t *c, uint8_t *buffer, uint32
     return (((c)->type)->encrypt(((c)->state), buffer, num_octets_to_output));
 }
 
-srtp_err_status_t srtp_cipher_decrypt (srtp_cipher_t *c, uint8_t *buffer, uint32_t *num_octets_to_output)
+srtp_err_status_t srtp_cipher_decrypt(srtp_cipher_t *c,
+                                      uint8_t *buffer,
+                                      uint32_t *num_octets_to_output)
 {
     if (!c || !c->type || !c->state) {
         return (srtp_err_status_bad_param);
@@ -120,7 +129,9 @@ srtp_err_status_t srtp_cipher_decrypt (srtp_cipher_t *c, uint8_t *buffer, uint32
     return (((c)->type)->decrypt(((c)->state), buffer, num_octets_to_output));
 }
 
-srtp_err_status_t srtp_cipher_get_tag (srtp_cipher_t *c, uint8_t *buffer, uint32_t *tag_len)
+srtp_err_status_t srtp_cipher_get_tag(srtp_cipher_t *c,
+                                      uint8_t *buffer,
+                                      uint32_t *tag_len)
 {
     if (!c || !c->type || !c->state) {
         return (srtp_err_status_bad_param);
@@ -132,7 +143,9 @@ srtp_err_status_t srtp_cipher_get_tag (srtp_cipher_t *c, uint8_t *buffer, uint32
     return (((c)->type)->get_tag(((c)->state), buffer, tag_len));
 }
 
-srtp_err_status_t srtp_cipher_set_aad (srtp_cipher_t *c, const uint8_t *aad, uint32_t aad_len)
+srtp_err_status_t srtp_cipher_set_aad(srtp_cipher_t *c,
+                                      const uint8_t *aad,
+                                      uint32_t aad_len)
 {
     if (!c || !c->type || !c->state) {
         return (srtp_err_status_bad_param);
@@ -151,7 +164,6 @@ int srtp_cipher_get_key_length (const srtp_cipher_t *c)
     return c->key_len;
 }
 
-
 /*
  * A trivial platform independent random source.  The random
  * data is used for some of the cipher self-tests.
@@ -160,8 +172,7 @@ static srtp_err_status_t srtp_cipher_rand (void *dest, uint32_t len)
 {
 #if defined(HAVE_RAND_S)
     uint8_t *dst = (uint8_t *)dest;
-  while (len)
+    while (len) {
-  {
         unsigned int val;
         errno_t err = rand_s(&val);
 
@@ -175,8 +186,7 @@ static srtp_err_status_t srtp_cipher_rand (void *dest, uint32_t len)
     /* Generic C-library (rand()) version */
     /* This is a random source of last resort */
     uint8_t *dst = (uint8_t *)dest;
-  while (len)
+    while (len) {
-  {
         int val = rand();
         /* rand() returns 0-32767 (ugh) */
         /* Is this a good enough way to get random bytes?
@@ -196,7 +206,9 @@ static srtp_err_status_t srtp_cipher_rand (void *dest, uint32_t len)
  * test cases provided in a list test_data of values of key, salt, iv,
  * plaintext, and ciphertext that is known to be good
  */
-srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srtp_cipher_test_case_t *test_data)
+srtp_err_status_t srtp_cipher_type_test(
+    const srtp_cipher_type_t *ct,
+    const srtp_cipher_test_case_t *test_data)
 {
     const srtp_cipher_test_case_t *test_case = test_data;
     srtp_cipher_t *c;
@@ -206,6 +218,7 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
     uint32_t tag_len;
     unsigned int len;
     int i, j, case_num = 0;
+    unsigned k = 0;
 
     debug_print(srtp_mod_cipher, "running self-test for cipher %s",
                 ct->description);
@@ -224,7 +237,8 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
      */
     while (test_case != NULL) {
         /* allocate cipher */
-        status = srtp_cipher_type_alloc(ct, &c, test_case->key_length_octets, test_case->tag_length_octets);
+        status = srtp_cipher_type_alloc(ct, &c, test_case->key_length_octets,
+                                        test_case->tag_length_octets);
         if (status) {
             return status;
         }
@@ -246,36 +260,39 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             srtp_cipher_dealloc(c);
             return srtp_err_status_bad_param;
         }
-        for (i = 0; i < test_case->plaintext_length_octets; i++) {
+        for (k = 0; k < test_case->plaintext_length_octets; k++) {
-            buffer[i] = test_case->plaintext[i];
+            buffer[k] = test_case->plaintext[k];
         }
 
         debug_print(srtp_mod_cipher, "plaintext:    %s",
-                    srtp_octet_string_hex_string(buffer,
+                    srtp_octet_string_hex_string(
-                                                 test_case->plaintext_length_octets));
+                        buffer, test_case->plaintext_length_octets));
 
         /* set the initialization vector */
-        status = srtp_cipher_set_iv(c, (uint8_t*)test_case->idx, srtp_direction_encrypt);
+        status = srtp_cipher_set_iv(c, (uint8_t *)test_case->idx,
+                                    srtp_direction_encrypt);
         if (status) {
             srtp_cipher_dealloc(c);
             return status;
         }
 
-        if (c->algorithm == SRTP_AES_GCM_128 || c->algorithm == SRTP_AES_GCM_256) {
+        if (c->algorithm == SRTP_AES_GCM_128 ||
+            c->algorithm == SRTP_AES_GCM_256) {
             debug_print(srtp_mod_cipher, "IV:    %s",
                         srtp_octet_string_hex_string(test_case->idx, 12));
 
             /*
              * Set the AAD
              */
-            status = srtp_cipher_set_aad(c, test_case->aad, test_case->aad_length_octets);
+            status = srtp_cipher_set_aad(c, test_case->aad,
+                                         test_case->aad_length_octets);
             if (status) {
                 srtp_cipher_dealloc(c);
                 return status;
             }
             debug_print(srtp_mod_cipher, "AAD:    %s",
-                        srtp_octet_string_hex_string(test_case->aad,
+                        srtp_octet_string_hex_string(
-                                                     test_case->aad_length_octets));
+                            test_case->aad, test_case->aad_length_octets));
         }
 
         /* encrypt */
@@ -286,7 +303,8 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             return status;
         }
 
-        if (c->algorithm == SRTP_AES_GCM_128 || c->algorithm == SRTP_AES_GCM_256) {
+        if (c->algorithm == SRTP_AES_GCM_128 ||
+            c->algorithm == SRTP_AES_GCM_256) {
             /*
              * Get the GCM tag
              */
@@ -299,8 +317,8 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
         }
 
         debug_print(srtp_mod_cipher, "ciphertext:   %s",
-                    srtp_octet_string_hex_string(buffer,
+                    srtp_octet_string_hex_string(
-                                                 test_case->ciphertext_length_octets));
+                        buffer, test_case->ciphertext_length_octets));
 
         /* compare the resulting ciphertext with that in the test case */
         if (len != test_case->ciphertext_length_octets) {
@@ -308,21 +326,21 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             return srtp_err_status_algo_fail;
         }
         status = srtp_err_status_ok;
-        for (i = 0; i < test_case->ciphertext_length_octets; i++) {
+        for (k = 0; k < test_case->ciphertext_length_octets; k++) {
-            if (buffer[i] != test_case->ciphertext[i]) {
+            if (buffer[k] != test_case->ciphertext[k]) {
                 status = srtp_err_status_algo_fail;
                 debug_print(srtp_mod_cipher, "test case %d failed", case_num);
-                debug_print(srtp_mod_cipher, "(failure at byte %d)", i);
+                debug_print(srtp_mod_cipher, "(failure at byte %u)", k);
                 break;
             }
         }
         if (status) {
-
             debug_print(srtp_mod_cipher, "c computed: %s",
-                        srtp_octet_string_hex_string(buffer,
+                        srtp_octet_string_hex_string(
-                                                     2 * test_case->plaintext_length_octets));
+                            buffer, 2 * test_case->plaintext_length_octets));
             debug_print(srtp_mod_cipher, "c expected: %s",
-                        srtp_octet_string_hex_string(test_case->ciphertext,
+                        srtp_octet_string_hex_string(
+                            test_case->ciphertext,
                             2 * test_case->plaintext_length_octets));
 
             srtp_cipher_dealloc(c);
@@ -346,33 +364,36 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             srtp_cipher_dealloc(c);
             return srtp_err_status_bad_param;
         }
-        for (i = 0; i < test_case->ciphertext_length_octets; i++) {
+        for (k = 0; k < test_case->ciphertext_length_octets; k++) {
-            buffer[i] = test_case->ciphertext[i];
+            buffer[k] = test_case->ciphertext[k];
         }
 
         debug_print(srtp_mod_cipher, "ciphertext:    %s",
-                    srtp_octet_string_hex_string(buffer,
+                    srtp_octet_string_hex_string(
-                                                 test_case->plaintext_length_octets));
+                        buffer, test_case->plaintext_length_octets));
 
         /* set the initialization vector */
-        status = srtp_cipher_set_iv(c, (uint8_t*)test_case->idx, srtp_direction_decrypt);
+        status = srtp_cipher_set_iv(c, (uint8_t *)test_case->idx,
+                                    srtp_direction_decrypt);
         if (status) {
             srtp_cipher_dealloc(c);
             return status;
         }
 
-        if (c->algorithm == SRTP_AES_GCM_128 || c->algorithm == SRTP_AES_GCM_256) {
+        if (c->algorithm == SRTP_AES_GCM_128 ||
+            c->algorithm == SRTP_AES_GCM_256) {
             /*
              * Set the AAD
              */
-            status = srtp_cipher_set_aad(c, test_case->aad, test_case->aad_length_octets);
+            status = srtp_cipher_set_aad(c, test_case->aad,
+                                         test_case->aad_length_octets);
             if (status) {
                 srtp_cipher_dealloc(c);
                 return status;
             }
             debug_print(srtp_mod_cipher, "AAD:    %s",
-                        srtp_octet_string_hex_string(test_case->aad,
+                        srtp_octet_string_hex_string(
-                                                     test_case->aad_length_octets));
+                            test_case->aad, test_case->aad_length_octets));
         }
 
         /* decrypt */
@@ -384,8 +405,8 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
         }
 
         debug_print(srtp_mod_cipher, "plaintext:   %s",
-                    srtp_octet_string_hex_string(buffer,
+                    srtp_octet_string_hex_string(
-                                                 test_case->plaintext_length_octets));
+                        buffer, test_case->plaintext_length_octets));
 
         /* compare the resulting plaintext with that in the test case */
         if (len != test_case->plaintext_length_octets) {
@@ -393,20 +414,20 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             return srtp_err_status_algo_fail;
         }
         status = srtp_err_status_ok;
-        for (i = 0; i < test_case->plaintext_length_octets; i++) {
+        for (k = 0; k < test_case->plaintext_length_octets; k++) {
-            if (buffer[i] != test_case->plaintext[i]) {
+            if (buffer[k] != test_case->plaintext[k]) {
                 status = srtp_err_status_algo_fail;
                 debug_print(srtp_mod_cipher, "test case %d failed", case_num);
-                debug_print(srtp_mod_cipher, "(failure at byte %d)", i);
+                debug_print(srtp_mod_cipher, "(failure at byte %u)", k);
             }
         }
         if (status) {
-
             debug_print(srtp_mod_cipher, "p computed: %s",
-                        srtp_octet_string_hex_string(buffer,
+                        srtp_octet_string_hex_string(
-                                                     2 * test_case->plaintext_length_octets));
+                            buffer, 2 * test_case->plaintext_length_octets));
             debug_print(srtp_mod_cipher, "p expected: %s",
-                        srtp_octet_string_hex_string(test_case->plaintext,
+                        srtp_octet_string_hex_string(
+                            test_case->plaintext,
                             2 * test_case->plaintext_length_octets));
 
             srtp_cipher_dealloc(c);
@@ -431,14 +452,15 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
 
     /* allocate cipher, using paramaters from the first test case */
     test_case = test_data;
-    status = srtp_cipher_type_alloc(ct, &c, test_case->key_length_octets, test_case->tag_length_octets);
+    status = srtp_cipher_type_alloc(ct, &c, test_case->key_length_octets,
+                                    test_case->tag_length_octets);
     if (status) {
         return status;
     }
 
     for (j = 0; j < NUM_RAND_TESTS; j++) {
-        unsigned length;
+        unsigned int length;
-        int plaintext_len;
+        unsigned int plaintext_len;
         uint8_t key[MAX_KEY_LEN];
         uint8_t iv[MAX_KEY_LEN];
 
@@ -485,24 +507,27 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
         }
 
         /* set initialization vector */
-        status = srtp_cipher_set_iv(c, (uint8_t*)test_case->idx, srtp_direction_encrypt);
+        status = srtp_cipher_set_iv(c, (uint8_t *)test_case->idx,
+                                    srtp_direction_encrypt);
         if (status) {
             srtp_cipher_dealloc(c);
             return status;
         }
 
-        if (c->algorithm == SRTP_AES_GCM_128 || c->algorithm == SRTP_AES_GCM_256) {
+        if (c->algorithm == SRTP_AES_GCM_128 ||
+            c->algorithm == SRTP_AES_GCM_256) {
             /*
              * Set the AAD
              */
-            status = srtp_cipher_set_aad(c, test_case->aad, test_case->aad_length_octets);
+            status = srtp_cipher_set_aad(c, test_case->aad,
+                                         test_case->aad_length_octets);
             if (status) {
                 srtp_cipher_dealloc(c);
                 return status;
             }
             debug_print(srtp_mod_cipher, "AAD:    %s",
-                        srtp_octet_string_hex_string(test_case->aad,
+                        srtp_octet_string_hex_string(
-                                                     test_case->aad_length_octets));
+                            test_case->aad, test_case->aad_length_octets));
         }
 
         /* encrypt buffer with cipher */
@@ -512,7 +537,8 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             srtp_cipher_dealloc(c);
             return status;
         }
-        if (c->algorithm == SRTP_AES_GCM_128 || c->algorithm == SRTP_AES_GCM_256) {
+        if (c->algorithm == SRTP_AES_GCM_128 ||
+            c->algorithm == SRTP_AES_GCM_256) {
             /*
              * Get the GCM tag
              */
@@ -535,23 +561,26 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             srtp_cipher_dealloc(c);
             return status;
         }
-        status = srtp_cipher_set_iv(c, (uint8_t*)test_case->idx, srtp_direction_decrypt);
+        status = srtp_cipher_set_iv(c, (uint8_t *)test_case->idx,
+                                    srtp_direction_decrypt);
         if (status) {
             srtp_cipher_dealloc(c);
             return status;
         }
-        if (c->algorithm == SRTP_AES_GCM_128 || c->algorithm == SRTP_AES_GCM_256) {
+        if (c->algorithm == SRTP_AES_GCM_128 ||
+            c->algorithm == SRTP_AES_GCM_256) {
             /*
              * Set the AAD
              */
-            status = srtp_cipher_set_aad(c, test_case->aad, test_case->aad_length_octets);
+            status = srtp_cipher_set_aad(c, test_case->aad,
+                                         test_case->aad_length_octets);
             if (status) {
                 srtp_cipher_dealloc(c);
                 return status;
             }
             debug_print(srtp_mod_cipher, "AAD:    %s",
-                        srtp_octet_string_hex_string(test_case->aad,
+                        srtp_octet_string_hex_string(
-                                                     test_case->aad_length_octets));
+                            test_case->aad, test_case->aad_length_octets));
         }
         status = srtp_cipher_decrypt(c, buffer, &length);
         if (status) {
@@ -568,18 +597,18 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
             return srtp_err_status_algo_fail;
         }
         status = srtp_err_status_ok;
-        for (i = 0; i < plaintext_len; i++) {
+        for (k = 0; k < plaintext_len; k++) {
-            if (buffer[i] != buffer2[i]) {
+            if (buffer[k] != buffer2[k]) {
                 status = srtp_err_status_algo_fail;
-                debug_print(srtp_mod_cipher, "random test case %d failed", case_num);
+                debug_print(srtp_mod_cipher, "random test case %d failed",
-                debug_print(srtp_mod_cipher, "(failure at byte %d)", i);
+                            case_num);
+                debug_print(srtp_mod_cipher, "(failure at byte %u)", k);
             }
         }
         if (status) {
             srtp_cipher_dealloc(c);
             return srtp_err_status_algo_fail;
         }
-
     }
 
     status = srtp_cipher_dealloc(c);
@@ -590,10 +619,9 @@ srtp_err_status_t srtp_cipher_type_test (const srtp_cipher_type_t *ct, const srt
     return srtp_err_status_ok;
 }
 
-
 /*
- * srtp_cipher_type_self_test(ct) performs srtp_cipher_type_test on ct's internal
+ * srtp_cipher_type_self_test(ct) performs srtp_cipher_type_test on ct's
- * list of test data.
+ * internal list of test data.
  */
 srtp_err_status_t srtp_cipher_type_self_test(const srtp_cipher_type_t *ct)
 {
@@ -610,7 +638,9 @@ srtp_err_status_t srtp_cipher_type_self_test (const srtp_cipher_type_t *ct)
  *
  * if an error is encountered, the value 0 is returned
  */
-uint64_t srtp_cipher_bits_per_second (srtp_cipher_t *c, int octets_in_buffer, int num_trials)
+uint64_t srtp_cipher_bits_per_second(srtp_cipher_t *c,
+                                     int octets_in_buffer,
+                                     int num_trials)
 {
     int i;
     v128_t nonce;
@@ -621,13 +651,13 @@ uint64_t srtp_cipher_bits_per_second (srtp_cipher_t *c, int octets_in_buffer, in
     enc_buf = (unsigned char *)srtp_crypto_alloc(octets_in_buffer);
     if (enc_buf == NULL) {
         return 0; /* indicate bad parameters by returning null */
-
     }
     /* time repeated trials */
     v128_set_to_zero(&nonce);
     timer = clock();
     for (i = 0; i < num_trials; i++, nonce.v32[3] = i) {
-        if (srtp_cipher_set_iv(c, (uint8_t*)&nonce, srtp_direction_encrypt) != srtp_err_status_ok) {
+        if (srtp_cipher_set_iv(c, (uint8_t *)&nonce, srtp_direction_encrypt) !=
+            srtp_err_status_ok) {
             srtp_crypto_free(enc_buf);
             return 0;
         }

libs/srtp/crypto/cipher/null_cipher.c

@@ -52,24 +52,22 @@
 #include "null_cipher.h"
 #include "err.h" /* for srtp_debug */
 #include "alloc.h"
+#include "cipher_types.h"
 
-/* the null_cipher uses the cipher debug module  */
+static srtp_err_status_t srtp_null_cipher_alloc(srtp_cipher_t **c,
-
+                                                int key_len,
-extern srtp_debug_module_t srtp_mod_cipher;
+                                                int tlen)
-
-static srtp_err_status_t srtp_null_cipher_alloc (srtp_cipher_t **c, int key_len, int tlen)
 {
     extern const srtp_cipher_type_t srtp_null_cipher;
 
-    debug_print(srtp_mod_cipher,
+    debug_print(srtp_mod_cipher, "allocating cipher with key length %d",
-                "allocating cipher with key length %d", key_len);
+                key_len);
 
     /* allocate memory a cipher of type null_cipher */
     *c = (srtp_cipher_t *)srtp_crypto_alloc(sizeof(srtp_cipher_t));
     if (*c == NULL) {
         return srtp_err_status_alloc_fail;
     }
-    memset(*c, 0x0, sizeof(srtp_cipher_t));
 
     /* set pointers */
     (*c)->algorithm = SRTP_NULL_CIPHER;
@@ -80,7 +78,6 @@ static srtp_err_status_t srtp_null_cipher_alloc (srtp_cipher_t **c, int key_len,
     (*c)->key_len = key_len;
 
     return srtp_err_status_ok;
-
 }
 
 static srtp_err_status_t srtp_null_cipher_dealloc(srtp_cipher_t *c)
@@ -94,7 +91,6 @@ static srtp_err_status_t srtp_null_cipher_dealloc (srtp_cipher_t *c)
     srtp_crypto_free(c);
 
     return srtp_err_status_ok;
-
 }
 
 static srtp_err_status_t srtp_null_cipher_init(void *cv, const uint8_t *key)
@@ -106,14 +102,17 @@ static srtp_err_status_t srtp_null_cipher_init (void *cv, const uint8_t *key)
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_null_cipher_set_iv (void *cv, uint8_t *iv, srtp_cipher_direction_t dir)
+static srtp_err_status_t srtp_null_cipher_set_iv(void *cv,
+                                                 uint8_t *iv,
+                                                 srtp_cipher_direction_t dir)
 {
     /* srtp_null_cipher_ctx_t *c = (srtp_null_cipher_ctx_t *)cv; */
     return srtp_err_status_ok;
 }
 
 static srtp_err_status_t srtp_null_cipher_encrypt(void *cv,
-                                            unsigned char *buf, unsigned int *bytes_to_encr)
+                                                  unsigned char *buf,
+                                                  unsigned int *bytes_to_encr)
 {
     /* srtp_null_cipher_ctx_t *c = (srtp_null_cipher_ctx_t *)cv; */
     return srtp_err_status_ok;
@@ -129,28 +128,26 @@ static const srtp_cipher_test_case_t srtp_null_cipher_test_0 = {
     NULL, /* plaintext                */
     0,    /* octets in plaintext      */
     NULL, /* ciphertext               */
-    0,
+    0,    /* */
-    NULL,
+    NULL, /* */
-    0,
+    0,    /* */
     NULL  /* pointer to next testcase */
 };
 
-
 /*
  * note: the decrypt function is idential to the encrypt function
  */
 
 const srtp_cipher_type_t srtp_null_cipher = {
-    srtp_null_cipher_alloc,
+    srtp_null_cipher_alloc,       /* */
-    srtp_null_cipher_dealloc,
+    srtp_null_cipher_dealloc,     /* */
-    srtp_null_cipher_init,
+    srtp_null_cipher_init,        /* */
     0,                            /* set_aad */
-    srtp_null_cipher_encrypt,
+    srtp_null_cipher_encrypt,     /* */
-    srtp_null_cipher_encrypt,
+    srtp_null_cipher_encrypt,     /* */
-    srtp_null_cipher_set_iv,
+    srtp_null_cipher_set_iv,      /* */
     0,                            /* get_tag */
-    srtp_null_cipher_description,
+    srtp_null_cipher_description, /* */
-    &srtp_null_cipher_test_0,
+    &srtp_null_cipher_test_0,     /* */
-    SRTP_NULL_CIPHER
+    SRTP_NULL_CIPHER              /* */
 };
-

libs/srtp/crypto/hash/auth.c

@@ -58,7 +58,6 @@ srtp_debug_module_t srtp_mod_auth = {
     "auth func" /* printable name for module   */
 };
 
-
 int srtp_auth_get_key_length(const srtp_auth_t *a)
 {
     return a->key_len;
@@ -83,8 +82,8 @@ int srtp_auth_get_prefix_length (const srtp_auth_t *a)
 /* should be big enough for most occasions */
 #define SELF_TEST_TAG_BUF_OCTETS 32
 
-srtp_err_status_t
+srtp_err_status_t srtp_auth_type_test(const srtp_auth_type_t *at,
-srtp_auth_type_test (const srtp_auth_type_t *at, const srtp_auth_test_case_t *test_data)
+                                      const srtp_auth_test_case_t *test_data)
 {
     const srtp_auth_test_case_t *test_case = test_data;
     srtp_auth_t *a;
@@ -105,7 +104,6 @@ srtp_auth_type_test (const srtp_auth_type_t *at, const srtp_auth_test_case_t *te
 
     /* loop over all test cases */
     while (test_case != NULL) {
-
         /* check test case parameters */
         if (test_case->tag_length_octets > SELF_TEST_TAG_BUF_OCTETS) {
             return srtp_err_status_bad_param;
@@ -138,9 +136,10 @@ srtp_auth_type_test (const srtp_auth_type_t *at, const srtp_auth_test_case_t *te
                     srtp_octet_string_hex_string(test_case->key,
                                                  test_case->key_length_octets));
         debug_print(srtp_mod_auth, "data: %s",
-                    srtp_octet_string_hex_string(test_case->data,
+                    srtp_octet_string_hex_string(
-                                                 test_case->data_length_octets));
+                        test_case->data, test_case->data_length_octets));
-        debug_print(srtp_mod_auth, "tag computed: %s",
+        debug_print(
+            srtp_mod_auth, "tag computed: %s",
             srtp_octet_string_hex_string(tag, test_case->tag_length_octets));
         debug_print(srtp_mod_auth, "tag expected: %s",
                     srtp_octet_string_hex_string(test_case->tag,
@@ -177,9 +176,8 @@ srtp_auth_type_test (const srtp_auth_type_t *at, const srtp_auth_test_case_t *te
     return srtp_err_status_ok;
 }
 
-
 /*
- * auth_type_self_test(at) performs srtp_auth_type_test on at's internal
+ * srtp_auth_type_self_test(at) performs srtp_auth_type_test on at's internal
  * list of test data.
  */
 
@@ -187,4 +185,3 @@ srtp_err_status_t srtp_auth_type_self_test (const srtp_auth_type_t *at)
 {
     return srtp_auth_type_test(at, at->test_data);
 }
-

libs/srtp/crypto/hash/hmac.c

@@ -48,6 +48,7 @@
 
 #include "hmac.h"
 #include "alloc.h"
+#include "cipher_types.h"
 
 /* the debug module for authentiation */
 
@@ -56,14 +57,17 @@ srtp_debug_module_t srtp_mod_hmac = {
     "hmac sha-1" /* printable name for module   */
 };
 
-
+static srtp_err_status_t srtp_hmac_alloc(srtp_auth_t **a,
-static srtp_err_status_t srtp_hmac_alloc (srtp_auth_t **a, int key_len, int out_len)
+                                         int key_len,
+                                         int out_len)
 {
     extern const srtp_auth_type_t srtp_hmac;
     uint8_t *pointer;
 
-    debug_print(srtp_mod_hmac, "allocating auth func with key length %d", key_len);
+    debug_print(srtp_mod_hmac, "allocating auth func with key length %d",
-    debug_print(srtp_mod_hmac, "                          tag length %d", out_len);
+                key_len);
+    debug_print(srtp_mod_hmac, "                          tag length %d",
+                out_len);
 
     /*
      * check key length - note that we don't support keys larger
@@ -79,7 +83,8 @@ static srtp_err_status_t srtp_hmac_alloc (srtp_auth_t **a, int key_len, int out_
     }
 
     /* allocate memory for auth and srtp_hmac_ctx_t structures */
-    pointer = (uint8_t*)srtp_crypto_alloc(sizeof(srtp_hmac_ctx_t) + sizeof(srtp_auth_t));
+    pointer = (uint8_t *)srtp_crypto_alloc(sizeof(srtp_hmac_ctx_t) +
+                                           sizeof(srtp_auth_t));
     if (pointer == NULL) {
         return srtp_err_status_alloc_fail;
     }
@@ -106,7 +111,9 @@ static srtp_err_status_t srtp_hmac_dealloc (srtp_auth_t *a)
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_hmac_init (void *statev, const uint8_t *key, int key_len)
+static srtp_err_status_t srtp_hmac_init(void *statev,
+                                        const uint8_t *key,
+                                        int key_len)
 {
     srtp_hmac_ctx_t *state = (srtp_hmac_ctx_t *)statev;
     int i;
@@ -134,7 +141,8 @@ static srtp_err_status_t srtp_hmac_init (void *statev, const uint8_t *key, int k
         ((uint8_t *)state->opad)[i] = 0x5c;
     }
 
-    debug_print(srtp_mod_hmac, "ipad: %s", srtp_octet_string_hex_string(ipad, 64));
+    debug_print(srtp_mod_hmac, "ipad: %s",
+                srtp_octet_string_hex_string(ipad, 64));
 
     /* initialize sha1 context */
     srtp_sha1_init(&state->init_ctx);
@@ -155,7 +163,9 @@ static srtp_err_status_t srtp_hmac_start (void *statev)
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_hmac_update (void *statev, const uint8_t *message, int msg_octets)
+static srtp_err_status_t srtp_hmac_update(void *statev,
+                                          const uint8_t *message,
+                                          int msg_octets)
 {
     srtp_hmac_ctx_t *state = (srtp_hmac_ctx_t *)statev;
 
@@ -168,8 +178,11 @@ static srtp_err_status_t srtp_hmac_update (void *statev, const uint8_t *message,
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_hmac_compute (void *statev, const uint8_t *message,
+static srtp_err_status_t srtp_hmac_compute(void *statev,
-                                            int msg_octets, int tag_len, uint8_t *result)
+                                           const uint8_t *message,
+                                           int msg_octets,
+                                           int tag_len,
+                                           uint8_t *result)
 {
     srtp_hmac_ctx_t *state = (srtp_hmac_ctx_t *)statev;
     uint32_t hash_value[5];
@@ -215,24 +228,28 @@ static srtp_err_status_t srtp_hmac_compute (void *statev, const uint8_t *message
     return srtp_err_status_ok;
 }
 
-
 /* begin test case 0 */
-
+/* clang-format off */
 static const uint8_t srtp_hmac_test_case_0_key[20] = {
     0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
     0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
     0x0b, 0x0b, 0x0b, 0x0b
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_hmac_test_case_0_data[8] = {
     0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65 /* "Hi There" */
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_hmac_test_case_0_tag[20] = {
     0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
     0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e,
     0xf1, 0x46, 0xbe, 0x00
 };
+/* clang-format on */
 
 static const srtp_auth_test_case_t srtp_hmac_test_case_0 = {
     20,                         /* octets in key            */
@@ -246,21 +263,21 @@ static const srtp_auth_test_case_t srtp_hmac_test_case_0 = {
 
 /* end test case 0 */
 
-static const char srtp_hmac_description[] = "hmac sha-1 authentication function";
+static const char srtp_hmac_description[] =
+    "hmac sha-1 authentication function";
 
 /*
  * srtp_auth_type_t hmac is the hmac metaobject
  */
 
 const srtp_auth_type_t srtp_hmac = {
-    srtp_hmac_alloc,
+    srtp_hmac_alloc,        /* */
-    srtp_hmac_dealloc,
+    srtp_hmac_dealloc,      /* */
-    srtp_hmac_init,
+    srtp_hmac_init,         /* */
-    srtp_hmac_compute,
+    srtp_hmac_compute,      /* */
-    srtp_hmac_update,
+    srtp_hmac_update,       /* */
-    srtp_hmac_start,
+    srtp_hmac_start,        /* */
-    srtp_hmac_description,
+    srtp_hmac_description,  /* */
-    &srtp_hmac_test_case_0,
+    &srtp_hmac_test_case_0, /* */
-    SRTP_HMAC_SHA1
+    SRTP_HMAC_SHA1          /* */
 };
-

libs/srtp/crypto/hash/hmac_ossl.c

@@ -61,13 +61,16 @@ srtp_debug_module_t srtp_mod_hmac = {
     "hmac sha-1 openssl" /* printable name for module   */
 };
 
-
+static srtp_err_status_t srtp_hmac_alloc(srtp_auth_t **a,
-static srtp_err_status_t srtp_hmac_alloc (srtp_auth_t **a, int key_len, int out_len)
+                                         int key_len,
+                                         int out_len)
 {
     extern const srtp_auth_type_t srtp_hmac;
 
-    debug_print(srtp_mod_hmac, "allocating auth func with key length %d", key_len);
+    debug_print(srtp_mod_hmac, "allocating auth func with key length %d",
-    debug_print(srtp_mod_hmac, "                          tag length %d", out_len);
+                key_len);
+    debug_print(srtp_mod_hmac, "                          tag length %d",
+                out_len);
 
     /* check output length - should be less than 20 bytes */
     if (out_len > SHA1_DIGEST_SIZE) {
@@ -76,12 +79,13 @@ static srtp_err_status_t srtp_hmac_alloc (srtp_auth_t **a, int key_len, int out_
 
 /* OpenSSL 1.1.0 made HMAC_CTX an opaque structure, which must be allocated
    using HMAC_CTX_new.  But this function doesn't exist in OpenSSL 1.0.x. */
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || LIBRESSL_VERSION_NUMBER
     {
         /* allocate memory for auth and HMAC_CTX structures */
         uint8_t *pointer;
         HMAC_CTX *new_hmac_ctx;
-        pointer = (uint8_t*)srtp_crypto_alloc(sizeof(HMAC_CTX) + sizeof(srtp_auth_t));
+        pointer = (uint8_t *)srtp_crypto_alloc(sizeof(HMAC_CTX) +
+                                               sizeof(srtp_auth_t));
         if (pointer == NULL) {
             return srtp_err_status_alloc_fail;
         }
@@ -121,7 +125,7 @@ static srtp_err_status_t srtp_hmac_dealloc (srtp_auth_t *a)
 
     hmac_ctx = (HMAC_CTX *)a->state;
 
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || LIBRESSL_VERSION_NUMBER
     HMAC_CTX_cleanup(hmac_ctx);
 
     /* zeroize entire state*/
@@ -150,7 +154,9 @@ static srtp_err_status_t srtp_hmac_start (void *statev)
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_hmac_init (void *statev, const uint8_t *key, int key_len)
+static srtp_err_status_t srtp_hmac_init(void *statev,
+                                        const uint8_t *key,
+                                        int key_len)
 {
     HMAC_CTX *state = (HMAC_CTX *)statev;
 
@@ -160,7 +166,9 @@ static srtp_err_status_t srtp_hmac_init (void *statev, const uint8_t *key, int k
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_hmac_update (void *statev, const uint8_t *message, int msg_octets)
+static srtp_err_status_t srtp_hmac_update(void *statev,
+                                          const uint8_t *message,
+                                          int msg_octets)
 {
     HMAC_CTX *state = (HMAC_CTX *)statev;
 
@@ -173,8 +181,11 @@ static srtp_err_status_t srtp_hmac_update (void *statev, const uint8_t *message,
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_hmac_compute (void *statev, const uint8_t *message,
+static srtp_err_status_t srtp_hmac_compute(void *statev,
-              int msg_octets, int tag_len, uint8_t *result)
+                                           const uint8_t *message,
+                                           int msg_octets,
+                                           int tag_len,
+                                           uint8_t *result)
 {
     HMAC_CTX *state = (HMAC_CTX *)statev;
     uint8_t hash_value[SHA1_DIGEST_SIZE];
@@ -207,24 +218,28 @@ static srtp_err_status_t srtp_hmac_compute (void *statev, const uint8_t *message
     return srtp_err_status_ok;
 }
 
-
 /* begin test case 0 */
-
+/* clang-format off */
 static const uint8_t srtp_hmac_test_case_0_key[SHA1_DIGEST_SIZE] = {
     0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
     0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
     0x0b, 0x0b, 0x0b, 0x0b
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_hmac_test_case_0_data[8] = {
     0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65 /* "Hi There" */
 };
+/* clang-format on */
 
+/* clang-format off */
 static const uint8_t srtp_hmac_test_case_0_tag[SHA1_DIGEST_SIZE] = {
     0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
     0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e,
     0xf1, 0x46, 0xbe, 0x00
 };
+/* clang-format on */
 
 static const srtp_auth_test_case_t srtp_hmac_test_case_0 = {
     sizeof(srtp_hmac_test_case_0_key),  /* octets in key            */
@@ -238,21 +253,21 @@ static const srtp_auth_test_case_t srtp_hmac_test_case_0 = {
 
 /* end test case 0 */
 
-static const char srtp_hmac_description[] = "hmac sha-1 authentication function";
+static const char srtp_hmac_description[] =
+    "hmac sha-1 authentication function";
 
 /*
  * srtp_auth_type_t hmac is the hmac metaobject
  */
 
 const srtp_auth_type_t srtp_hmac = {
-    srtp_hmac_alloc,
+    srtp_hmac_alloc,        /* */
-    srtp_hmac_dealloc,
+    srtp_hmac_dealloc,      /* */
-    srtp_hmac_init,
+    srtp_hmac_init,         /* */
-    srtp_hmac_compute,
+    srtp_hmac_compute,      /* */
-    srtp_hmac_update,
+    srtp_hmac_update,       /* */
-    srtp_hmac_start,
+    srtp_hmac_start,        /* */
-    srtp_hmac_description,
+    srtp_hmac_description,  /* */
-    &srtp_hmac_test_case_0,
+    &srtp_hmac_test_case_0, /* */
-    SRTP_HMAC_SHA1
+    SRTP_HMAC_SHA1          /* */
 };
-

libs/srtp/crypto/hash/null_auth.c

@@ -51,21 +51,23 @@
 #include "null_auth.h"
 #include "err.h" /* for srtp_debug */
 #include "alloc.h"
+#include "cipher_types.h"
 
-/* null_auth uses the auth debug module */
+static srtp_err_status_t srtp_null_auth_alloc(srtp_auth_t **a,
-
+                                              int key_len,
-extern srtp_debug_module_t srtp_mod_auth;
+                                              int out_len)
-
-static srtp_err_status_t srtp_null_auth_alloc (srtp_auth_t **a, int key_len, int out_len)
 {
     extern const srtp_auth_type_t srtp_null_auth;
     uint8_t *pointer;
 
-    debug_print(srtp_mod_auth, "allocating auth func with key length %d", key_len);
+    debug_print(srtp_mod_auth, "allocating auth func with key length %d",
-    debug_print(srtp_mod_auth, "                          tag length %d", out_len);
+                key_len);
+    debug_print(srtp_mod_auth, "                          tag length %d",
+                out_len);
 
     /* allocate memory for auth and srtp_null_auth_ctx_t structures */
-    pointer = (uint8_t*)srtp_crypto_alloc(sizeof(srtp_null_auth_ctx_t) + sizeof(srtp_auth_t));
+    pointer = (uint8_t *)srtp_crypto_alloc(sizeof(srtp_null_auth_ctx_t) +
+                                           sizeof(srtp_auth_t));
     if (pointer == NULL) {
         return srtp_err_status_alloc_fail;
     }
@@ -86,7 +88,8 @@ static srtp_err_status_t srtp_null_auth_dealloc (srtp_auth_t *a)
     extern const srtp_auth_type_t srtp_null_auth;
 
     /* zeroize entire state*/
-    octet_string_set_to_zero(a, sizeof(srtp_null_auth_ctx_t) + sizeof(srtp_auth_t));
+    octet_string_set_to_zero(a, sizeof(srtp_null_auth_ctx_t) +
+                                    sizeof(srtp_auth_t));
 
     /* free memory */
     srtp_crypto_free(a);
@@ -94,7 +97,9 @@ static srtp_err_status_t srtp_null_auth_dealloc (srtp_auth_t *a)
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_null_auth_init (void *statev, const uint8_t *key, int key_len)
+static srtp_err_status_t srtp_null_auth_init(void *statev,
+                                             const uint8_t *key,
+                                             int key_len)
 {
     /* srtp_null_auth_ctx_t *state = (srtp_null_auth_ctx_t *)statev; */
     /* accept any length of key, and do nothing */
@@ -102,15 +107,19 @@ static srtp_err_status_t srtp_null_auth_init (void *statev, const uint8_t *key,
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_null_auth_compute (void *statev, const uint8_t *message,
+static srtp_err_status_t srtp_null_auth_compute(void *statev,
-                                          int msg_octets, int tag_len, uint8_t *result)
+                                                const uint8_t *message,
+                                                int msg_octets,
+                                                int tag_len,
+                                                uint8_t *result)
 {
     /* srtp_null_auth_ctx_t *state = (srtp_null_auth_ctx_t *)statev; */
 
     return srtp_err_status_ok;
 }
 
-static srtp_err_status_t srtp_null_auth_update (void *statev, const uint8_t *message,
+static srtp_err_status_t srtp_null_auth_update(void *statev,
+                                               const uint8_t *message,
                                                int msg_octets)
 {
     /* srtp_null_auth_ctx_t *state = (srtp_null_auth_ctx_t *)statev; */
@@ -147,14 +156,13 @@ static const srtp_auth_test_case_t srtp_null_auth_test_case_0 = {
 static const char srtp_null_auth_description[] = "null authentication function";
 
 const srtp_auth_type_t srtp_null_auth = {
-    srtp_null_auth_alloc,
+    srtp_null_auth_alloc,        /* */
-    srtp_null_auth_dealloc,
+    srtp_null_auth_dealloc,      /* */
-    srtp_null_auth_init,
+    srtp_null_auth_init,         /* */
-    srtp_null_auth_compute,
+    srtp_null_auth_compute,      /* */
-    srtp_null_auth_update,
+    srtp_null_auth_update,       /* */
-    srtp_null_auth_start,
+    srtp_null_auth_start,        /* */
-    srtp_null_auth_description,
+    srtp_null_auth_description,  /* */
-    &srtp_null_auth_test_case_0,
+    &srtp_null_auth_test_case_0, /* */
-    SRTP_NULL_AUTH
+    SRTP_NULL_AUTH               /* */
 };
-

libs/srtp/crypto/hash/sha1.c

@@ -83,7 +83,6 @@ void srtp_sha1 (const uint8_t *msg,  int octets_in_msg, uint32_t hash_value[5])
     srtp_sha1_init(&ctx);
     srtp_sha1_update(&ctx, msg, octets_in_msg);
     srtp_sha1_final(&ctx, hash_value);
-
 }
 
 /*
@@ -134,22 +133,38 @@ void srtp_sha1_core (const uint32_t M[16], uint32_t hash_value[5])
     W[13] = be32_to_cpu(M[13]);
     W[14] = be32_to_cpu(M[14]);
     W[15] = be32_to_cpu(M[15]);
-    TEMP = W[13] ^ W[8]  ^ W[2]  ^ W[0];  W[16] = S1(TEMP);
+    TEMP = W[13] ^ W[8] ^ W[2] ^ W[0];
-    TEMP = W[14] ^ W[9]  ^ W[3]  ^ W[1];  W[17] = S1(TEMP);
+    W[16] = S1(TEMP);
-    TEMP = W[15] ^ W[10] ^ W[4]  ^ W[2];  W[18] = S1(TEMP);
+    TEMP = W[14] ^ W[9] ^ W[3] ^ W[1];
-    TEMP = W[16] ^ W[11] ^ W[5]  ^ W[3];  W[19] = S1(TEMP);
+    W[17] = S1(TEMP);
-    TEMP = W[17] ^ W[12] ^ W[6]  ^ W[4];  W[20] = S1(TEMP);
+    TEMP = W[15] ^ W[10] ^ W[4] ^ W[2];
-    TEMP = W[18] ^ W[13] ^ W[7]  ^ W[5];  W[21] = S1(TEMP);
+    W[18] = S1(TEMP);
-    TEMP = W[19] ^ W[14] ^ W[8]  ^ W[6];  W[22] = S1(TEMP);
+    TEMP = W[16] ^ W[11] ^ W[5] ^ W[3];
-    TEMP = W[20] ^ W[15] ^ W[9]  ^ W[7];  W[23] = S1(TEMP);
+    W[19] = S1(TEMP);
-    TEMP = W[21] ^ W[16] ^ W[10] ^ W[8];  W[24] = S1(TEMP);
+    TEMP = W[17] ^ W[12] ^ W[6] ^ W[4];
-    TEMP = W[22] ^ W[17] ^ W[11] ^ W[9];  W[25] = S1(TEMP);
+    W[20] = S1(TEMP);
-    TEMP = W[23] ^ W[18] ^ W[12] ^ W[10]; W[26] = S1(TEMP);
+    TEMP = W[18] ^ W[13] ^ W[7] ^ W[5];
-    TEMP = W[24] ^ W[19] ^ W[13] ^ W[11]; W[27] = S1(TEMP);
+    W[21] = S1(TEMP);
-    TEMP = W[25] ^ W[20] ^ W[14] ^ W[12]; W[28] = S1(TEMP);
+    TEMP = W[19] ^ W[14] ^ W[8] ^ W[6];
-    TEMP = W[26] ^ W[21] ^ W[15] ^ W[13]; W[29] = S1(TEMP);
+    W[22] = S1(TEMP);
-    TEMP = W[27] ^ W[22] ^ W[16] ^ W[14]; W[30] = S1(TEMP);
+    TEMP = W[20] ^ W[15] ^ W[9] ^ W[7];
-    TEMP = W[28] ^ W[23] ^ W[17] ^ W[15]; W[31] = S1(TEMP);
+    W[23] = S1(TEMP);
+    TEMP = W[21] ^ W[16] ^ W[10] ^ W[8];
+    W[24] = S1(TEMP);
+    TEMP = W[22] ^ W[17] ^ W[11] ^ W[9];
+    W[25] = S1(TEMP);
+    TEMP = W[23] ^ W[18] ^ W[12] ^ W[10];
+    W[26] = S1(TEMP);
+    TEMP = W[24] ^ W[19] ^ W[13] ^ W[11];
+    W[27] = S1(TEMP);
+    TEMP = W[25] ^ W[20] ^ W[14] ^ W[12];
+    W[28] = S1(TEMP);
+    TEMP = W[26] ^ W[21] ^ W[15] ^ W[13];
+    W[29] = S1(TEMP);
+    TEMP = W[27] ^ W[22] ^ W[16] ^ W[14];
+    W[30] = S1(TEMP);
+    TEMP = W[28] ^ W[23] ^ W[17] ^ W[15];
+    W[31] = S1(TEMP);
 
     /* process the remainder of the array */
     for (t = 32; t < 80; t++) {
@@ -157,23 +172,43 @@ void srtp_sha1_core (const uint32_t M[16], uint32_t hash_value[5])
         W[t] = S1(TEMP);
     }
 
-    A = H0; B = H1; C = H2; D = H3; E = H4;
+    A = H0;
+    B = H1;
+    C = H2;
+    D = H3;
+    E = H4;
 
     for (t = 0; t < 20; t++) {
         TEMP = S5(A) + f0(B, C, D) + E + W[t] + SHA_K0;
-        E = D; D = C; C = S30(B); B = A; A = TEMP;
+        E = D;
+        D = C;
+        C = S30(B);
+        B = A;
+        A = TEMP;
     }
     for (; t < 40; t++) {
         TEMP = S5(A) + f1(B, C, D) + E + W[t] + SHA_K1;
-        E = D; D = C; C = S30(B); B = A; A = TEMP;
+        E = D;
+        D = C;
+        C = S30(B);
+        B = A;
+        A = TEMP;
     }
     for (; t < 60; t++) {
         TEMP = S5(A) + f2(B, C, D) + E + W[t] + SHA_K2;
-        E = D; D = C; C = S30(B); B = A; A = TEMP;
+        E = D;
+        D = C;
+        C = S30(B);
+        B = A;
+        A = TEMP;
     }
     for (; t < 80; t++) {
         TEMP = S5(A) + f3(B, C, D) + E + W[t] + SHA_K3;
-        E = D; D = C; C = S30(B); B = A; A = TEMP;
+        E = D;
+        D = C;
+        C = S30(B);
+        B = A;
+        A = TEMP;
     }
 
     hash_value[0] = H0 + A;
@@ -187,7 +222,6 @@ void srtp_sha1_core (const uint32_t M[16], uint32_t hash_value[5])
 
 void srtp_sha1_init(srtp_sha1_ctx_t *ctx)
 {
-
     /* initialize state vector */
     ctx->H[0] = 0x67452301;
     ctx->H[1] = 0xefcdab89;
@@ -200,10 +234,11 @@ void srtp_sha1_init (srtp_sha1_ctx_t *ctx)
 
     /* reset message bit-count to zero */
     ctx->num_bits_in_msg = 0;
-
 }
 
-void srtp_sha1_update (srtp_sha1_ctx_t *ctx, const uint8_t *msg, int octets_in_msg)
+void srtp_sha1_update(srtp_sha1_ctx_t *ctx,
+                      const uint8_t *msg,
+                      int octets_in_msg)
 {
     int i;
     uint8_t *buf = (uint8_t *)ctx->M;
@@ -213,9 +248,7 @@ void srtp_sha1_update (srtp_sha1_ctx_t *ctx, const uint8_t *msg, int octets_in_m
 
     /* loop over 16-word blocks of M */
     while (octets_in_msg > 0) {
-
         if (octets_in_msg + ctx->octets_in_buffer >= 64) {
-
             /*
              * copy words of M into msg buffer until that buffer is full,
              * converting them into host byte order as needed
@@ -228,13 +261,14 @@ void srtp_sha1_update (srtp_sha1_ctx_t *ctx, const uint8_t *msg, int octets_in_m
 
             /* process a whole block */
 
-            debug_print(srtp_mod_sha1, "(update) running srtp_sha1_core()", NULL);
+            debug_print(srtp_mod_sha1, "(update) running srtp_sha1_core()",
+                        NULL);
 
             srtp_sha1_core(ctx->M, ctx->H);
 
         } else {
-
+            debug_print(srtp_mod_sha1, "(update) not running srtp_sha1_core()",
-            debug_print(srtp_mod_sha1, "(update) not running srtp_sha1_core()", NULL);
+                        NULL);
 
             for (i = ctx->octets_in_buffer;
                  i < (ctx->octets_in_buffer + octets_in_msg); i++) {
@@ -243,9 +277,7 @@ void srtp_sha1_update (srtp_sha1_ctx_t *ctx, const uint8_t *msg, int octets_in_m
             ctx->octets_in_buffer += octets_in_msg;
             octets_in_msg = 0;
         }
-
     }
-
 }
 
 /*
@@ -321,19 +353,35 @@ void srtp_sha1_final (srtp_sha1_ctx_t *ctx, uint32_t *output)
 
         for (t = 0; t < 20; t++) {
             TEMP = S5(A) + f0(B, C, D) + E + W[t] + SHA_K0;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
         for (; t < 40; t++) {
             TEMP = S5(A) + f1(B, C, D) + E + W[t] + SHA_K1;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
         for (; t < 60; t++) {
             TEMP = S5(A) + f2(B, C, D) + E + W[t] + SHA_K2;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
         for (; t < 80; t++) {
             TEMP = S5(A) + f3(B, C, D) + E + W[t] + SHA_K3;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
 
         ctx->H[0] += A;
@@ -341,14 +389,13 @@ void srtp_sha1_final (srtp_sha1_ctx_t *ctx, uint32_t *output)
         ctx->H[2] += C;
         ctx->H[3] += D;
         ctx->H[4] += E;
-
     }
 
     debug_print(srtp_mod_sha1, "(final) running srtp_sha1_core()", NULL);
 
     if (ctx->octets_in_buffer >= 56) {
-
+        debug_print(srtp_mod_sha1, "(final) running srtp_sha1_core() again",
-        debug_print(srtp_mod_sha1, "(final) running srtp_sha1_core() again", NULL);
+                    NULL);
 
         /* we need to do one final run of the compression algo */
 
@@ -375,19 +422,35 @@ void srtp_sha1_final (srtp_sha1_ctx_t *ctx, uint32_t *output)
 
         for (t = 0; t < 20; t++) {
             TEMP = S5(A) + f0(B, C, D) + E + W[t] + SHA_K0;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
         for (; t < 40; t++) {
             TEMP = S5(A) + f1(B, C, D) + E + W[t] + SHA_K1;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
         for (; t < 60; t++) {
             TEMP = S5(A) + f2(B, C, D) + E + W[t] + SHA_K2;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
         for (; t < 80; t++) {
             TEMP = S5(A) + f3(B, C, D) + E + W[t] + SHA_K3;
-            E = D; D = C; C = S30(B); B = A; A = TEMP;
+            E = D;
+            D = C;
+            C = S30(B);
+            B = A;
+            A = TEMP;
         }
 
         ctx->H[0] += A;
@@ -409,6 +472,3 @@ void srtp_sha1_final (srtp_sha1_ctx_t *ctx, uint32_t *output)
 
     return;
 }
-
-
-

libs/srtp/crypto/include/aes.h

@@ -70,9 +70,11 @@ srtp_err_status_t srtp_aes_expand_decryption_key(
     int key_len,
     srtp_aes_expanded_key_t *expanded_key);
 
-void srtp_aes_encrypt(v128_t *plaintext, const srtp_aes_expanded_key_t *exp_key);
+void srtp_aes_encrypt(v128_t *plaintext,
+                      const srtp_aes_expanded_key_t *exp_key);
 
-void srtp_aes_decrypt(v128_t *plaintext, const srtp_aes_expanded_key_t *exp_key);
+void srtp_aes_decrypt(v128_t *plaintext,
+                      const srtp_aes_expanded_key_t *exp_key);
 
 #ifdef __cplusplus
 }

libs/srtp/crypto/include/aes_gcm_ossl.h

@@ -60,4 +60,3 @@ typedef struct {
 } srtp_aes_gcm_ctx_t;
 
 #endif /* AES_GCM_OSSL_H */
-

libs/srtp/crypto/include/aes_icm.h

@@ -60,4 +60,3 @@ typedef struct {
 } srtp_aes_icm_ctx_t;
 
 #endif /* AES_ICM_H */
-

libs/srtp/crypto/include/aes_icm_ossl.h

@@ -59,4 +59,3 @@ typedef struct {
 } srtp_aes_icm_ctx_t;
 
 #endif /* AES_ICM_H */
-

libs/srtp/crypto/include/alloc.h

@@ -42,7 +42,6 @@
  *
  */
 
-
 #ifndef CRYPTO_ALLOC_H
 #define CRYPTO_ALLOC_H
 
@@ -52,8 +51,22 @@
 extern "C" {
 #endif
 
+/*
+ * srtp_crypto_alloc
+ *
+ * Allocates a block of memory  of given size. The memory will be
+ * initialized to zero's. Free the memory with a call to srtp_crypto_free.
+ *
+ * returns pointer to memory on success or else NULL
+ */
 void *srtp_crypto_alloc(size_t size);
 
+/*
+ * srtp_crypto_free
+ *
+ * Frees the block of memory  ptr previously  allocated with
+ * srtp_crypto_alloc
+ */
 void srtp_crypto_free(void *ptr);
 
 #ifdef __cplusplus

libs/srtp/crypto/include/auth.h

@@ -56,20 +56,25 @@ extern "C" {
 typedef const struct srtp_auth_type_t *srtp_auth_type_pointer;
 typedef struct srtp_auth_t *srtp_auth_pointer_t;
 
-typedef srtp_err_status_t (*srtp_auth_alloc_func)
+typedef srtp_err_status_t (*srtp_auth_alloc_func)(srtp_auth_pointer_t *ap,
-    (srtp_auth_pointer_t *ap, int key_len, int out_len);
+                                                  int key_len,
+                                                  int out_len);
 
-typedef srtp_err_status_t (*srtp_auth_init_func)
+typedef srtp_err_status_t (*srtp_auth_init_func)(void *state,
-    (void *state, const uint8_t *key, int key_len);
+                                                 const uint8_t *key,
+                                                 int key_len);
 
 typedef srtp_err_status_t (*srtp_auth_dealloc_func)(srtp_auth_pointer_t ap);
 
-typedef srtp_err_status_t (*srtp_auth_compute_func)
+typedef srtp_err_status_t (*srtp_auth_compute_func)(void *state,
-    (void *state, const uint8_t *buffer, int octets_to_auth,
+                                                    const uint8_t *buffer,
-    int tag_len, uint8_t *tag);
+                                                    int octets_to_auth,
+                                                    int tag_len,
+                                                    uint8_t *tag);
 
-typedef srtp_err_status_t (*srtp_auth_update_func)
+typedef srtp_err_status_t (*srtp_auth_update_func)(void *state,
-    (void *state, const uint8_t *buffer, int octets_to_auth);
+                                                   const uint8_t *buffer,
+                                                   int octets_to_auth);
 
 typedef srtp_err_status_t (*srtp_auth_start_func)(void *state);
 
@@ -111,7 +116,8 @@ typedef struct srtp_auth_test_case_t {
     const uint8_t *data;    /* data                     */
     int tag_length_octets;  /* octets in tag            */
     const uint8_t *tag;     /* tag                      */
-    const struct srtp_auth_test_case_t *next_test_case; /* pointer to next testcase */
+    const struct srtp_auth_test_case_t
+        *next_test_case; /* pointer to next testcase */
 } srtp_auth_test_case_t;
 
 /* srtp_auth_type_t */
@@ -157,7 +163,8 @@ srtp_err_status_t srtp_auth_type_test(const srtp_auth_type_t *at,
  * with a new one passed in externally.  The new auth type must pass all the
  * existing auth_type's self tests as well as its own.
  */
-srtp_err_status_t srtp_replace_auth_type(const srtp_auth_type_t *ct, srtp_auth_type_id_t id);
+srtp_err_status_t srtp_replace_auth_type(const srtp_auth_type_t *ct,
+                                         srtp_auth_type_id_t id);
 
 #ifdef __cplusplus
 }

libs/srtp/crypto/include/cipher.h

@@ -42,14 +42,12 @@
  *
  */
 
-
 #ifndef SRTP_CIPHER_H
 #define SRTP_CIPHER_H
 
 #include "srtp.h"
 #include "crypto_types.h" /* for values of cipher_type_id_t */
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -74,48 +72,57 @@ typedef enum {
 typedef struct srtp_cipher_t *srtp_cipher_pointer_t;
 
 /*
- *  a srtp_cipher_alloc_func_t allocates (but does not initialize) a srtp_cipher_t
+ *  a srtp_cipher_alloc_func_t allocates (but does not initialize) a
+ * srtp_cipher_t
  */
-typedef srtp_err_status_t (*srtp_cipher_alloc_func_t)
+typedef srtp_err_status_t (*srtp_cipher_alloc_func_t)(srtp_cipher_pointer_t *cp,
-    (srtp_cipher_pointer_t *cp, int key_len, int tag_len);
+                                                      int key_len,
+                                                      int tag_len);
 
 /*
  * a srtp_cipher_init_func_t [re-]initializes a cipher_t with a given key
  */
-typedef srtp_err_status_t (*srtp_cipher_init_func_t)
+typedef srtp_err_status_t (*srtp_cipher_init_func_t)(void *state,
-    (void *state, const uint8_t *key);
+                                                     const uint8_t *key);
 
 /* a srtp_cipher_dealloc_func_t de-allocates a cipher_t */
-typedef srtp_err_status_t (*srtp_cipher_dealloc_func_t)(srtp_cipher_pointer_t cp);
+typedef srtp_err_status_t (*srtp_cipher_dealloc_func_t)(
+    srtp_cipher_pointer_t cp);
 
 /*
  * a srtp_cipher_set_aad_func_t processes the AAD data for AEAD ciphers
  */
-typedef srtp_err_status_t (*srtp_cipher_set_aad_func_t)
+typedef srtp_err_status_t (*srtp_cipher_set_aad_func_t)(void *state,
-    (void *state, const uint8_t *aad, uint32_t aad_len);
+                                                        const uint8_t *aad,
-
+                                                        uint32_t aad_len);
 
 /* a srtp_cipher_encrypt_func_t encrypts data in-place */
-typedef srtp_err_status_t (*srtp_cipher_encrypt_func_t)
+typedef srtp_err_status_t (*srtp_cipher_encrypt_func_t)(
-    (void *state, uint8_t *buffer, unsigned int *octets_to_encrypt);
+    void *state,
+    uint8_t *buffer,
+    unsigned int *octets_to_encrypt);
 
 /* a srtp_cipher_decrypt_func_t decrypts data in-place */
-typedef srtp_err_status_t (*srtp_cipher_decrypt_func_t)
+typedef srtp_err_status_t (*srtp_cipher_decrypt_func_t)(
-    (void *state, uint8_t *buffer, unsigned int *octets_to_decrypt);
+    void *state,
+    uint8_t *buffer,
+    unsigned int *octets_to_decrypt);
 
 /*
  * a srtp_cipher_set_iv_func_t function sets the current initialization vector
  */
-typedef srtp_err_status_t (*srtp_cipher_set_iv_func_t)
+typedef srtp_err_status_t (*srtp_cipher_set_iv_func_t)(
-    (void *state, uint8_t *iv, srtp_cipher_direction_t direction);
+    void *state,
+    uint8_t *iv,
+    srtp_cipher_direction_t direction);
 
 /*
  * a cipher_get_tag_func_t function is used to get the authentication
  * tag that was calculated by an AEAD cipher.
  */
-typedef srtp_err_status_t (*srtp_cipher_get_tag_func_t)
+typedef srtp_err_status_t (*srtp_cipher_get_tag_func_t)(void *state,
-    (void *state, uint8_t *tag, uint32_t *len);
+                                                        uint8_t *tag,
-
+                                                        uint32_t *len);
 
 /*
  * srtp_cipher_test_case_t is a (list of) key, salt, plaintext, ciphertext,
@@ -128,14 +135,15 @@ typedef struct srtp_cipher_test_case_t {
     int key_length_octets;                 /* octets in key            */
     const uint8_t *key;                    /* key                      */
     uint8_t *idx;                          /* packet index             */
-    int plaintext_length_octets;                    /* octets in plaintext      */
+    unsigned int plaintext_length_octets;  /* octets in plaintext      */
     const uint8_t *plaintext;              /* plaintext                */
-    int ciphertext_length_octets;                   /* octets in plaintext      */
+    unsigned int ciphertext_length_octets; /* octets in plaintext      */
     const uint8_t *ciphertext;             /* ciphertext               */
     int aad_length_octets;                 /* octets in AAD            */
     const uint8_t *aad;                    /* AAD                      */
     int tag_length_octets;                 /* Length of AEAD tag       */
-    const struct srtp_cipher_test_case_t *next_test_case; /* pointer to next testcase */
+    const struct srtp_cipher_test_case_t
+        *next_test_case; /* pointer to next testcase */
 } srtp_cipher_test_case_t;
 
 /* srtp_cipher_type_t defines the 'metadata' for a particular cipher type */
@@ -167,7 +175,6 @@ typedef struct srtp_cipher_t {
 /* some bookkeeping functions */
 int srtp_cipher_get_key_length(const srtp_cipher_t *c);
 
-
 /*
  * srtp_cipher_type_self_test() tests a cipher against test cases provided in
  * an array of values of key/srtp_xtd_seq_num_t/plaintext/ciphertext
@@ -175,14 +182,15 @@ int srtp_cipher_get_key_length(const srtp_cipher_t *c);
  */
 srtp_err_status_t srtp_cipher_type_self_test(const srtp_cipher_type_t *ct);
 
-
 /*
- * srtp_cipher_type_test() tests a cipher against external test cases provided in
+ * srtp_cipher_type_test() tests a cipher against external test cases provided
+ * in
  * an array of values of key/srtp_xtd_seq_num_t/plaintext/ciphertext
  * that is known to be good
  */
-srtp_err_status_t srtp_cipher_type_test(const srtp_cipher_type_t *ct, const srtp_cipher_test_case_t *test_data);
+srtp_err_status_t srtp_cipher_type_test(
-
+    const srtp_cipher_type_t *ct,
+    const srtp_cipher_test_case_t *test_data);
 
 /*
  * srtp_cipher_bits_per_second(c, l, t) computes (an estimate of) the
@@ -194,17 +202,34 @@ srtp_err_status_t srtp_cipher_type_test(const srtp_cipher_type_t *ct, const srtp
  *
  * if an error is encountered, then the value 0 is returned
  */
-uint64_t srtp_cipher_bits_per_second(srtp_cipher_t *c, int octets_in_buffer, int num_trials);
+uint64_t srtp_cipher_bits_per_second(srtp_cipher_t *c,
+                                     int octets_in_buffer,
+                                     int num_trials);
 
-srtp_err_status_t srtp_cipher_type_alloc(const srtp_cipher_type_t *ct, srtp_cipher_t **c, int key_len, int tlen);
+srtp_err_status_t srtp_cipher_type_alloc(const srtp_cipher_type_t *ct,
+                                         srtp_cipher_t **c,
+                                         int key_len,
+                                         int tlen);
 srtp_err_status_t srtp_cipher_dealloc(srtp_cipher_t *c);
 srtp_err_status_t srtp_cipher_init(srtp_cipher_t *c, const uint8_t *key);
-srtp_err_status_t srtp_cipher_set_iv(srtp_cipher_t *c, uint8_t *iv, int direction);
+srtp_err_status_t srtp_cipher_set_iv(srtp_cipher_t *c,
-srtp_err_status_t srtp_cipher_output(srtp_cipher_t *c, uint8_t *buffer, uint32_t *num_octets_to_output); 
+                                     uint8_t *iv,
-srtp_err_status_t srtp_cipher_encrypt(srtp_cipher_t *c, uint8_t *buffer, uint32_t *num_octets_to_output); 
+                                     int direction);
-srtp_err_status_t srtp_cipher_decrypt(srtp_cipher_t *c, uint8_t *buffer, uint32_t *num_octets_to_output); 
+srtp_err_status_t srtp_cipher_output(srtp_cipher_t *c,
-srtp_err_status_t srtp_cipher_get_tag(srtp_cipher_t *c, uint8_t *buffer, uint32_t *tag_len);
+                                     uint8_t *buffer,
-srtp_err_status_t srtp_cipher_set_aad(srtp_cipher_t *c, const uint8_t *aad, uint32_t aad_len);
+                                     uint32_t *num_octets_to_output);
+srtp_err_status_t srtp_cipher_encrypt(srtp_cipher_t *c,
+                                      uint8_t *buffer,
+                                      uint32_t *num_octets_to_output);
+srtp_err_status_t srtp_cipher_decrypt(srtp_cipher_t *c,
+                                      uint8_t *buffer,
+                                      uint32_t *num_octets_to_output);
+srtp_err_status_t srtp_cipher_get_tag(srtp_cipher_t *c,
+                                      uint8_t *buffer,
+                                      uint32_t *tag_len);
+srtp_err_status_t srtp_cipher_set_aad(srtp_cipher_t *c,
+                                      const uint8_t *aad,
+                                      uint32_t aad_len);
 
 /*
  * srtp_replace_cipher_type(ct, id)
@@ -213,7 +238,8 @@ srtp_err_status_t srtp_cipher_set_aad(srtp_cipher_t *c, const uint8_t *aad, uint
  * with a new one passed in externally.  The new cipher must pass all the
  * existing cipher_type's self tests as well as its own.
  */
-srtp_err_status_t srtp_replace_cipher_type(const srtp_cipher_type_t *ct, srtp_cipher_type_id_t id);
+srtp_err_status_t srtp_replace_cipher_type(const srtp_cipher_type_t *ct,
+                                           srtp_cipher_type_id_t id);
 
 #ifdef __cplusplus
 }

libs/srtp/crypto/include/cipher_types.h

@@ -1,14 +1,6 @@
-/*
- * rtp_priv.h
- *
- * private, internal header file for RTP
- *
- * David A. McGrew
- * Cisco Systems, Inc.
- */
 /*
  *
- * Copyright (c) 2001-2006 Cisco Systems, Inc.
+ * Copyright(c) 2001-2017 Cisco Systems, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -42,33 +34,48 @@
  *
  */
 
+#ifndef CIHPER_TYPES_H
+#define CIHPER_TYPES_H
 
-#ifndef RTP_PRIV_H
+#include "cipher.h"
-#define RTP_PRIV_H
+#include "auth.h"
 
-#include "srtp_priv.h"
+/*
-#include "rtp.h"
+ * cipher types that can be included in the kernel
+ */
 
-typedef srtp_hdr_t rtp_hdr_t;
+extern const srtp_cipher_type_t srtp_null_cipher;
+extern const srtp_cipher_type_t srtp_aes_icm_128;
+extern const srtp_cipher_type_t srtp_aes_icm_256;
+#ifdef OPENSSL
+extern const srtp_cipher_type_t srtp_aes_icm_192;
+extern const srtp_cipher_type_t srtp_aes_gcm_128_openssl;
+extern const srtp_cipher_type_t srtp_aes_gcm_256_openssl;
+#endif
 
-typedef struct {
+/*
-  srtp_hdr_t header;        
+ * auth func types that can be included in the kernel
-  char body[RTP_MAX_BUF_LEN];  
+ */
-} rtp_msg_t;
 
-typedef struct rtp_sender_ctx_t {
+extern const srtp_auth_type_t srtp_null_auth;
-  rtp_msg_t message;         
+extern const srtp_auth_type_t srtp_hmac;
-  int socket;
-  srtp_ctx_t *srtp_ctx;
-  struct sockaddr_in addr;   /* reciever's address */
-} rtp_sender_ctx_t;
 
-typedef struct rtp_receiver_ctx_t {
+/*
-  rtp_msg_t message;
+ * other generic debug modules that can be included in the kernel
-  int socket;
+ */
-  srtp_ctx_t *srtp_ctx;
-  struct sockaddr_in addr;   /* receiver's address */
-} rtp_receiver_ctx_t;
 
+extern srtp_debug_module_t srtp_mod_auth;
+extern srtp_debug_module_t srtp_mod_cipher;
+extern srtp_debug_module_t srtp_mod_stat;
+extern srtp_debug_module_t srtp_mod_alloc;
 
-#endif /* RTP_PRIV_H */
+/* debug modules for cipher types */
+extern srtp_debug_module_t srtp_mod_aes_icm;
+#ifdef OPENSSL
+extern srtp_debug_module_t srtp_mod_aes_gcm;
+#endif
+
+/* debug modules for auth types */
+extern srtp_debug_module_t srtp_mod_hmac;
+
+#endif

libs/srtp/crypto/include/crypto_kernel.h

@@ -42,7 +42,6 @@
  *
  */
 
-
 #ifndef CRYPTO_KERNEL
 #define CRYPTO_KERNEL
 
@@ -93,7 +92,6 @@ typedef struct srtp_kernel_debug_module {
     struct srtp_kernel_debug_module *next;
 } srtp_kernel_debug_module_t;
 
-
 /*
  * crypto_kernel_t is the data structure for the crypto kernel
  *
@@ -104,15 +102,14 @@ typedef struct {
     srtp_crypto_kernel_state_t state; /* current state of kernel     */
     srtp_kernel_cipher_type_t *cipher_type_list; /* list of all cipher types */
     srtp_kernel_auth_type_t *auth_type_list; /* list of all auth func types */
-    srtp_kernel_debug_module_t *debug_module_list; /* list of all debug modules   */
+    srtp_kernel_debug_module_t
+        *debug_module_list; /* list of all debug modules   */
 } srtp_crypto_kernel_t;
 
-
 /*
  * srtp_crypto_kernel_t external api
  */
 
-
 /*
  * The function srtp_crypto_kernel_init() initialized the crypto kernel and
  * runs the self-test operations on the random number generators and
@@ -126,7 +123,6 @@ typedef struct {
  */
 srtp_err_status_t srtp_crypto_kernel_init(void);
 
-
 /*
  * The function srtp_crypto_kernel_shutdown() de-initializes the
  * crypto_kernel, zeroizes keys and other cryptographic material, and
@@ -150,7 +146,6 @@ srtp_err_status_t srtp_crypto_kernel_shutdown(void);
  */
 srtp_err_status_t srtp_crypto_kernel_status(void);
 
-
 /*
  * srtp_crypto_kernel_list_debug_modules() outputs a list of debugging modules
  *
@@ -161,11 +156,15 @@ srtp_err_status_t srtp_crypto_kernel_list_debug_modules(void);
  * srtp_crypto_kernel_load_cipher_type()
  *
  */
-srtp_err_status_t srtp_crypto_kernel_load_cipher_type(const srtp_cipher_type_t *ct, srtp_cipher_type_id_t id);
+srtp_err_status_t srtp_crypto_kernel_load_cipher_type(
+    const srtp_cipher_type_t *ct,
+    srtp_cipher_type_id_t id);
 
-srtp_err_status_t srtp_crypto_kernel_load_auth_type(const srtp_auth_type_t *ct, srtp_auth_type_id_t id);
+srtp_err_status_t srtp_crypto_kernel_load_auth_type(const srtp_auth_type_t *ct,
+                                                    srtp_auth_type_id_t id);
 
-srtp_err_status_t srtp_crypto_kernel_load_debug_module(srtp_debug_module_t *new_dm);
+srtp_err_status_t srtp_crypto_kernel_load_debug_module(
+    srtp_debug_module_t *new_dm);
 
 /*
  * srtp_crypto_kernel_alloc_cipher(id, cp, key_len);
@@ -177,7 +176,10 @@ srtp_err_status_t srtp_crypto_kernel_load_debug_module(srtp_debug_module_t *new_
  *    srtp_err_status_alloc_fail   an allocation failure occured
  *    srtp_err_status_fail         couldn't find cipher with identifier 'id'
  */
-srtp_err_status_t srtp_crypto_kernel_alloc_cipher(srtp_cipher_type_id_t id, srtp_cipher_pointer_t *cp, int key_len, int tag_len);
+srtp_err_status_t srtp_crypto_kernel_alloc_cipher(srtp_cipher_type_id_t id,
+                                                  srtp_cipher_pointer_t *cp,
+                                                  int key_len,
+                                                  int tag_len);
 
 /*
  * srtp_crypto_kernel_alloc_auth(id, ap, key_len, tag_len);
@@ -190,8 +192,10 @@ srtp_err_status_t srtp_crypto_kernel_alloc_cipher(srtp_cipher_type_id_t id, srtp
  *    srtp_err_status_alloc_fail   an allocation failure occured
  *    srtp_err_status_fail         couldn't find auth with identifier 'id'
  */
-srtp_err_status_t srtp_crypto_kernel_alloc_auth(srtp_auth_type_id_t id, srtp_auth_pointer_t *ap, int key_len, int tag_len);
+srtp_err_status_t srtp_crypto_kernel_alloc_auth(srtp_auth_type_id_t id,
-
+                                                srtp_auth_pointer_t *ap,
+                                                int key_len,
+                                                int tag_len);
 
 /*
  * srtp_crypto_kernel_set_debug_module(mod_name, v)
@@ -201,7 +205,8 @@ srtp_err_status_t srtp_crypto_kernel_alloc_auth(srtp_auth_type_id_t id, srtp_aut
  *
  * returns srtp_err_status_ok on success, srtp_err_status_fail otherwise
  */
-srtp_err_status_t srtp_crypto_kernel_set_debug_module(const char *mod_name, int v);
+srtp_err_status_t srtp_crypto_kernel_set_debug_module(const char *mod_name,
+                                                      int v);
 
 #ifdef __cplusplus
 }

libs/srtp/crypto/include/datatypes.h

@@ -43,7 +43,6 @@
  *
  */
 
-
 #ifndef DATATYPES_H
 #define DATATYPES_H
 
@@ -59,13 +58,14 @@
 #include <netinet/in.h>
 #elif defined HAVE_WINSOCK2_H
 #include <winsock2.h>
+#else
+#error "Platform not recognized"
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 /* if DATATYPES_USE_MACROS is defined, then little functions are macros */
 #define DATATYPES_USE_MACROS
 
@@ -101,41 +101,32 @@ typedef union {
     uint64_t v64[4];
 } v256_t;
 
-
 /* some useful and simple math functions */
 
 #define pow_2(X) ((unsigned int)1 << (X)) /* 2^X     */
 
 #define pow_minus_one(X) ((X) ? -1 : 1) /* (-1)^X  */
 
-
 /*
  * octet_get_weight(x) returns the hamming weight (number of bits equal to
  * one) in the octet x
  */
 
-int
+int octet_get_weight(uint8_t octet);
-octet_get_weight(uint8_t octet);
 
 #define MAX_PRINT_STRING_LEN 1024
 
-char *
+char *srtp_octet_string_hex_string(const void *str, int length);
-srtp_octet_string_hex_string(const void *str, int length);
 
-char *
+char *v128_bit_string(v128_t *x);
-v128_bit_string(v128_t *x);
 
-char *
+char *v128_hex_string(v128_t *x);
-v128_hex_string(v128_t *x);
 
-void
+void v128_copy_octet_string(v128_t *x, const uint8_t s[16]);
-v128_copy_octet_string(v128_t *x, const uint8_t s[16]);
 
-void
+void v128_left_shift(v128_t *x, int shift_index);
-v128_left_shift(v128_t *x, int shift_index);
 
-void
+void v128_right_shift(v128_t *x, int shift_index);
-v128_right_shift(v128_t *x, int shift_index);
 
 /*
  * the following macros define the data manipulation functions
@@ -147,72 +138,45 @@ v128_right_shift(v128_t *x, int shift_index);
  */
 
 #define _v128_set_to_zero(x)                                                   \
-(                               \
+    ((x)->v32[0] = 0, (x)->v32[1] = 0, (x)->v32[2] = 0, (x)->v32[3] = 0)
-  (x)->v32[0] = 0,              \
-  (x)->v32[1] = 0,              \
-  (x)->v32[2] = 0,              \
-  (x)->v32[3] = 0               \
-)
 
 #define _v128_copy(x, y)                                                       \
-(                                \
+    ((x)->v32[0] = (y)->v32[0], (x)->v32[1] = (y)->v32[1],                     \
-  (x)->v32[0] = (y)->v32[0],     \
+     (x)->v32[2] = (y)->v32[2], (x)->v32[3] = (y)->v32[3])
-  (x)->v32[1] = (y)->v32[1],     \
-  (x)->v32[2] = (y)->v32[2],     \
-  (x)->v32[3] = (y)->v32[3]      \
-)
 
 #define _v128_xor(z, x, y)                                                     \
-(                                               \
+    ((z)->v32[0] = (x)->v32[0] ^ (y)->v32[0],                                  \
-   (z)->v32[0] = (x)->v32[0] ^ (y)->v32[0],     \
      (z)->v32[1] = (x)->v32[1] ^ (y)->v32[1],                                  \
      (z)->v32[2] = (x)->v32[2] ^ (y)->v32[2],                                  \
-   (z)->v32[3] = (x)->v32[3] ^ (y)->v32[3]      \
+     (z)->v32[3] = (x)->v32[3] ^ (y)->v32[3])
-)
 
 #define _v128_and(z, x, y)                                                     \
-(                                               \
+    ((z)->v32[0] = (x)->v32[0] & (y)->v32[0],                                  \
-   (z)->v32[0] = (x)->v32[0] & (y)->v32[0],     \
      (z)->v32[1] = (x)->v32[1] & (y)->v32[1],                                  \
      (z)->v32[2] = (x)->v32[2] & (y)->v32[2],                                  \
-   (z)->v32[3] = (x)->v32[3] & (y)->v32[3]      \
+     (z)->v32[3] = (x)->v32[3] & (y)->v32[3])
-)
 
 #define _v128_or(z, x, y)                                                      \
-(                                               \
+    ((z)->v32[0] = (x)->v32[0] | (y)->v32[0],                                  \
-   (z)->v32[0] = (x)->v32[0] | (y)->v32[0],     \
      (z)->v32[1] = (x)->v32[1] | (y)->v32[1],                                  \
      (z)->v32[2] = (x)->v32[2] | (y)->v32[2],                                  \
-   (z)->v32[3] = (x)->v32[3] | (y)->v32[3]      \
+     (z)->v32[3] = (x)->v32[3] | (y)->v32[3])
-)
 
 #define _v128_complement(x)                                                    \
-(                                  \
+    ((x)->v32[0] = ~(x)->v32[0], (x)->v32[1] = ~(x)->v32[1],                   \
-   (x)->v32[0] = ~(x)->v32[0],     \
+     (x)->v32[2] = ~(x)->v32[2], (x)->v32[3] = ~(x)->v32[3])
-   (x)->v32[1] = ~(x)->v32[1],     \
-   (x)->v32[2] = ~(x)->v32[2],     \
-   (x)->v32[3] = ~(x)->v32[3]      \
-)
 
 /* ok for NO_64BIT_MATH if it can compare uint64_t's (even as structures) */
 #define _v128_is_eq(x, y)                                                      \
     (((x)->v64[0] == (y)->v64[0]) && ((x)->v64[1] == (y)->v64[1]))
 
-
 #ifdef NO_64BIT_MATH
 #define _v128_xor_eq(z, x)                                                     \
-(                                  \
+    ((z)->v32[0] ^= (x)->v32[0], (z)->v32[1] ^= (x)->v32[1],                   \
-   (z)->v32[0] ^= (x)->v32[0],     \
+     (z)->v32[2] ^= (x)->v32[2], (z)->v32[3] ^= (x)->v32[3])
-   (z)->v32[1] ^= (x)->v32[1],     \
-   (z)->v32[2] ^= (x)->v32[2],     \
-   (z)->v32[3] ^= (x)->v32[3]      \
-)
 #else
 #define _v128_xor_eq(z, x)                                                     \
-(                                  \
+    ((z)->v64[0] ^= (x)->v64[0], (z)->v64[1] ^= (x)->v64[1])
-   (z)->v64[0] ^= (x)->v64[0],     \
-   (z)->v64[1] ^= (x)->v64[1]      \
-)
 #endif
 
 /* NOTE!  This assumes an odd ordering! */
@@ -224,26 +188,16 @@ v128_right_shift(v128_t *x, int shift_index);
    really care which bit is which.  AES does care which bit is which, but
    doesn't use the 128-bit get/set or 128-bit shifts  */
 
-#define _v128_get_bit(x, bit)                     \
+#define _v128_get_bit(x, bit) (((((x)->v32[(bit) >> 5]) >> ((bit)&31)) & 1))
-(                                                 \
-  ((((x)->v32[(bit) >> 5]) >> ((bit) & 31)) & 1)  \
-)
 
 #define _v128_set_bit(x, bit)                                                  \
-(                                                                \
+    ((((x)->v32[(bit) >> 5]) |= ((uint32_t)1 << ((bit)&31))))
-  (((x)->v32[(bit) >> 5]) |= ((uint32_t)1 << ((bit) & 31))) \
-)
 
 #define _v128_clear_bit(x, bit)                                                \
-(                                                                 \
+    ((((x)->v32[(bit) >> 5]) &= ~((uint32_t)1 << ((bit)&31))))
-  (((x)->v32[(bit) >> 5]) &= ~((uint32_t)1 << ((bit) & 31))) \
-)
 
 #define _v128_set_bit_to(x, bit, value)                                        \
-(                                         \
+    ((value) ? _v128_set_bit(x, bit) : _v128_clear_bit(x, bit))
-   (value) ? _v128_set_bit(x, bit) :      \
-             _v128_clear_bit(x, bit)      \
-)
 
 #ifdef DATATYPES_USE_MACROS /* little functions are really macros */
 
@@ -262,38 +216,27 @@ v128_right_shift(v128_t *x, int shift_index);
 
 #else
 
-void
+void v128_set_to_zero(v128_t *x);
-v128_set_to_zero(v128_t *x);
 
-int
+int v128_is_eq(const v128_t *x, const v128_t *y);
-v128_is_eq(const v128_t *x, const v128_t *y);
 
-void
+void v128_copy(v128_t *x, const v128_t *y);
-v128_copy(v128_t *x, const v128_t *y);
 
-void
+void v128_xor(v128_t *z, v128_t *x, v128_t *y);
-v128_xor(v128_t *z, v128_t *x, v128_t *y);
 
-void
+void v128_and(v128_t *z, v128_t *x, v128_t *y);
-v128_and(v128_t *z, v128_t *x, v128_t *y);
 
-void
+void v128_or(v128_t *z, v128_t *x, v128_t *y);
-v128_or(v128_t *z, v128_t *x, v128_t *y); 
 
-void
+void v128_complement(v128_t *x);
-v128_complement(v128_t *x);
 
-int
+int v128_get_bit(const v128_t *x, int i);
-v128_get_bit(const v128_t *x, int i);
 
-void
+void v128_set_bit(v128_t *x, int i);
-v128_set_bit(v128_t *x, int i) ;     
 
-void
+void v128_clear_bit(v128_t *x, int i);
-v128_clear_bit(v128_t *x, int i);    
 
-void
+void v128_set_bit_to(v128_t *x, int i, int y);
-v128_set_bit_to(v128_t *x, int i, int y);
 
 #endif /* DATATYPES_USE_MACROS */
 
@@ -304,23 +247,20 @@ v128_set_bit_to(v128_t *x, int i, int y);
  * verifying authentication tags.
  */
 
-int
+int octet_string_is_eq(uint8_t *a, uint8_t *b, int len);
-octet_string_is_eq(uint8_t *a, uint8_t *b, int len);
 
 /*
  * A portable way to zero out memory as recommended by
  * https://cryptocoding.net/index.php/Coding_rules#Clean_memory_of_secret_data
  * This is used to zero memory when OPENSSL_cleanse() is not available.
  */
-void
+void srtp_cleanse(void *s, size_t len);
-srtp_cleanse(void *s, size_t len);
 
 /*
  * Functions as a wrapper that delegates to either srtp_cleanse() or
  * OPENSSL_cleanse() if available to zero memory.
  */
-void
+void octet_string_set_to_zero(void *s, size_t len);
-octet_string_set_to_zero(void *s, size_t len);
 
 #if defined(HAVE_CONFIG_H)
 
@@ -336,13 +276,14 @@ octet_string_set_to_zero(void *s, size_t len);
 #include <byteswap.h>
 #define be32_to_cpu(x) bswap_32((x))
 #define be64_to_cpu(x) bswap_64((x))
-#else
+#else /* WORDS_BIGENDIAN */
 
 #if defined(__GNUC__) && defined(HAVE_X86)
 /* Fall back. */
-static inline uint32_t be32_to_cpu(uint32_t v) {
+static inline uint32_t be32_to_cpu(uint32_t v)
+{
     /* optimized for x86. */
-   __asm__("bswap %0" : "=r" (v) : "0" (v));
+    asm("bswap %0" : "=r"(v) : "0"(v));
     return v;
 }
 #else /* HAVE_X86 */
@@ -350,25 +291,27 @@ static inline uint32_t be32_to_cpu(uint32_t v) {
 #include <netinet/in.h>
 #elif defined HAVE_WINSOCK2_H
 #include <winsock2.h>
-#  endif
+#endif /* HAVE_NETINET_IN_H */
 #define be32_to_cpu(x) ntohl((x))
 #endif /* HAVE_X86 */
 
-static inline uint64_t be64_to_cpu(uint64_t v) {
+static inline uint64_t be64_to_cpu(uint64_t v)
+{
 #ifdef NO_64BIT_MATH
     /* use the make64 functions to do 64-bit math */
     v = make64(htonl(low32(v)), htonl(high32(v)));
-# else
+#else  /* NO_64BIT_MATH */
     /* use the native 64-bit math */
-   v= (uint64_t)((be32_to_cpu((uint32_t)(v >> 32))) | (((uint64_t)be32_to_cpu((uint32_t)v)) << 32));
+    v = (uint64_t)((be32_to_cpu((uint32_t)(v >> 32))) |
-# endif
+                   (((uint64_t)be32_to_cpu((uint32_t)v)) << 32));
+#endif /* NO_64BIT_MATH */
     return v;
 }
 
-#endif 
-
 #endif /* WORDS_BIGENDIAN */
 
+#endif /* HAVE_CONFIG_H */
+
 /*
  * functions manipulating bitvector_t
  *
@@ -388,27 +331,16 @@ typedef struct {
     uint32_t *word;
 } bitvector_t;
 
-
 #define _bitvector_get_bit(v, bit_index)                                       \
-(									\
+    (((((v)->word[((bit_index) >> 5)]) >> ((bit_index)&31)) & 1))
- ((((v)->word[((bit_index) >> 5)]) >> ((bit_index) & 31)) & 1)		\
-)
-
 
 #define _bitvector_set_bit(v, bit_index)                                       \
-(									\
+    ((((v)->word[((bit_index) >> 5)] |= ((uint32_t)1 << ((bit_index)&31)))))
- (((v)->word[((bit_index) >> 5)] |= ((uint32_t)1 << ((bit_index) & 31)))) \
-)
 
 #define _bitvector_clear_bit(v, bit_index)                                     \
-(									\
+    ((((v)->word[((bit_index) >> 5)] &= ~((uint32_t)1 << ((bit_index)&31)))))
- (((v)->word[((bit_index) >> 5)] &= ~((uint32_t)1 << ((bit_index) & 31)))) \
-)
 
-#define _bitvector_get_length(v)					\
+#define _bitvector_get_length(v) (((v)->length))
-(									\
- ((v)->length)								\
-)
 
 #ifdef DATATYPES_USE_MACROS /* little functions are really macros */
 
@@ -419,34 +351,25 @@ typedef struct {
 
 #else
 
-int
+int bitvector_get_bit(const bitvector_t *v, int bit_index);
-bitvector_get_bit(const bitvector_t *v, int bit_index);
 
-void
+void bitvector_set_bit(bitvector_t *v, int bit_index);
-bitvector_set_bit(bitvector_t *v, int bit_index);
 
-void
+void bitvector_clear_bit(bitvector_t *v, int bit_index);
-bitvector_clear_bit(bitvector_t *v, int bit_index);
 
-unsigned long
+unsigned long bitvector_get_length(const bitvector_t *v);
-bitvector_get_length(const bitvector_t *v);
 
 #endif
 
-int
+int bitvector_alloc(bitvector_t *v, unsigned long length);
-bitvector_alloc(bitvector_t *v, unsigned long length);
 
-void
+void bitvector_dealloc(bitvector_t *v);
-bitvector_dealloc(bitvector_t *v);
 
-void
+void bitvector_set_to_zero(bitvector_t *x);
-bitvector_set_to_zero(bitvector_t *x);
 
-void
+void bitvector_left_shift(bitvector_t *x, int index);
-bitvector_left_shift(bitvector_t *x, int index);
 
-char *
+char *bitvector_bit_string(bitvector_t *x, char *buf, int len);
-bitvector_bit_string(bitvector_t *x, char* buf, int len);
 
 #ifdef __cplusplus
 }

libs/srtp/crypto/include/err.h

@@ -42,7 +42,6 @@
  *
  */
 
-
 #ifndef ERR_H
 #define ERR_H
 
@@ -62,7 +61,6 @@ extern "C" {
  * @{
  */
 
-
 /**
  * @}
  */
@@ -82,9 +80,11 @@ typedef enum {
 
 srtp_err_status_t srtp_err_reporting_init(void);
 
-typedef void (srtp_err_report_handler_func_t)(srtp_err_reporting_level_t level, const char * msg);
+typedef void(srtp_err_report_handler_func_t)(srtp_err_reporting_level_t level,
+                                             const char *msg);
 
-srtp_err_status_t srtp_install_err_report_handler(srtp_err_report_handler_func_t func);
+srtp_err_status_t srtp_install_err_report_handler(
+    srtp_err_report_handler_func_t func);
 
 /*
  * srtp_err_report reports a 'printf' formatted error
@@ -96,9 +96,7 @@ srtp_err_status_t srtp_install_err_report_handler(srtp_err_report_handler_func_t
  *
  */
 
-void
+void srtp_err_report(srtp_err_reporting_level_t level, const char *format, ...);
-srtp_err_report(srtp_err_reporting_level_t level, const char *format, ...);
-
 
 /*
  * debug_module_t defines a debug module
@@ -114,14 +112,18 @@ typedef struct {
 #define debug_print(mod, format, arg)                                          \
     srtp_err_report(srtp_err_level_debug, ("%s: " format "\n"), mod.name, arg)
 #define debug_print2(mod, format, arg1, arg2)                                  \
-    srtp_err_report(srtp_err_level_debug, ("%s: " format "\n"), mod.name, arg1, arg2)
+    srtp_err_report(srtp_err_level_debug, ("%s: " format "\n"), mod.name,      \
+                    arg1, arg2)
 
 #else
 
 #define debug_print(mod, format, arg)                                          \
-    if (mod.on) srtp_err_report(srtp_err_level_debug, ("%s: " format "\n"), mod.name, arg)
+    if (mod.on)                                                                \
+    srtp_err_report(srtp_err_level_debug, ("%s: " format "\n"), mod.name, arg)
 #define debug_print2(mod, format, arg1, arg2)                                  \
-    if (mod.on) srtp_err_report(srtp_err_level_debug, ("%s: " format "\n"), mod.name, arg1, arg2)
+    if (mod.on)                                                                \
+    srtp_err_report(srtp_err_level_debug, ("%s: " format "\n"), mod.name,      \
+                    arg1, arg2)
 
 #endif
 

libs/srtp/crypto/include/integers.h

@@ -43,11 +43,9 @@
  *
  */
 
-
 #ifndef INTEGERS_H
 #define INTEGERS_H
 
-
 /* use standard integer definitions, if they're available  */
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
@@ -98,7 +96,6 @@ typedef unsigned int		uint32_t;
 typedef int int32_t;
 #endif
 
-
 #if defined(NO_64BIT_MATH) && defined(HAVE_CONFIG_H)
 typedef double uint64_t;
 /* assert that sizeof(double) == 8 */
@@ -107,7 +104,6 @@ extern uint32_t high32(uint64_t value);
 extern uint32_t low32(uint64_t value);
 #endif
 
-
 /* These macros are to load and store 32-bit values from un-aligned
    addresses.  This is required for processors that do not allow unaligned
    loads. */
@@ -121,10 +117,10 @@ extern uint32_t low32(uint64_t value);
         ((unsigned char *)(addr))[2] = (value >> 8) & 0xff;                    \
         ((unsigned char *)(addr))[3] = (value)&0xff;                           \
     }
-#define GET_32(addr) ((((unsigned char *) (addr))[0] << 24) |  \
+#define GET_32(addr)                                                           \
+    ((((unsigned char *)(addr))[0] << 24) |                                    \
      (((unsigned char *)(addr))[1] << 16) |                                    \
-                      (((unsigned char *) (addr))[2] << 8)  |  \
+     (((unsigned char *)(addr))[2] << 8) | (((unsigned char *)(addr))[3]))
-                      (((unsigned char *) (addr))[3])) 
 #else
 #define PUT_32(addr, value)                                                    \
     {                                                                          \
@@ -133,10 +129,10 @@ extern uint32_t low32(uint64_t value);
         ((unsigned char *)(addr))[1] = (value >> 8) & 0xff;                    \
         ((unsigned char *)(addr))[0] = (value)&0xff;                           \
     }
-#define GET_32(addr) ((((unsigned char *) (addr))[3] << 24) |  \
+#define GET_32(addr)                                                           \
+    ((((unsigned char *)(addr))[3] << 24) |                                    \
      (((unsigned char *)(addr))[2] << 16) |                                    \
-                      (((unsigned char *) (addr))[1] << 8)  |  \
+     (((unsigned char *)(addr))[1] << 8) | (((unsigned char *)(addr))[0]))
-                      (((unsigned char *) (addr))[0])) 
 #endif // WORDS_BIGENDIAN
 #else
 #define PUT_32(addr, value) *(((uint32_t *) (addr)) = (value)

libs/srtp/crypto/include/key.h

@@ -60,9 +60,11 @@ typedef enum {
     srtp_key_event_hard_limit
 } srtp_key_event_t;
 
-srtp_err_status_t srtp_key_limit_set(srtp_key_limit_t key, const srtp_xtd_seq_num_t s);
+srtp_err_status_t srtp_key_limit_set(srtp_key_limit_t key,
+                                     const srtp_xtd_seq_num_t s);
 
-srtp_err_status_t srtp_key_limit_clone(srtp_key_limit_t original, srtp_key_limit_t *new_key);
+srtp_err_status_t srtp_key_limit_clone(srtp_key_limit_t original,
+                                       srtp_key_limit_t *new_key);
 
 srtp_err_status_t srtp_key_limit_check(const srtp_key_limit_t key);
 

libs/srtp/crypto/include/null_cipher.h

@@ -44,7 +44,6 @@
  *
  */
 
-
 #ifndef NULL_CIPHER_H
 #define NULL_CIPHER_H
 

libs/srtp/crypto/include/rdb.h

@@ -7,7 +7,6 @@
  * Cisco Systems, Inc.
  */
 
-
 /*
  *
  * Copyright (c) 2001-2017, Cisco Systems, Inc.
@@ -76,7 +75,6 @@ typedef struct {
  */
 srtp_err_status_t srtp_rdb_init(srtp_rdb_t *rdb);
 
-
 /*
  * srtp_rdb_check
  *
@@ -103,7 +101,6 @@ srtp_err_status_t srtp_rdb_add_index(srtp_rdb_t *rdb, uint32_t rdb_index);
  * srtp_rdb_t upon which srtp_rdb_add_index is used!
  */
 
-
 /*
  * srtp_rdb_increment(db) increments the sequence number in db, if it is
  * not too high
@@ -121,7 +118,6 @@ srtp_err_status_t srtp_rdb_increment(srtp_rdb_t *rdb);
  */
 uint32_t srtp_rdb_get_value(const srtp_rdb_t *rdb);
 
-
 #ifdef __cplusplus
 }
 #endif

libs/srtp/crypto/include/rdbx.h

@@ -77,7 +77,6 @@ typedef uint16_t srtp_rollover_counter_t;     /* 16 bit rollover counter */
  */
 typedef uint64_t srtp_xtd_seq_num_t;
 
-
 /*
  * An srtp_rdbx_t is a replay database with extended range; it uses an
  * xtd_seq_num_t and a bitmask of recently received indices.
@@ -87,7 +86,6 @@ typedef struct {
     bitvector_t bitmask;
 } srtp_rdbx_t;
 
-
 /*
  * srtp_rdbx_init(rdbx_ptr, ws)
  *
@@ -96,7 +94,6 @@ typedef struct {
  */
 srtp_err_status_t srtp_rdbx_init(srtp_rdbx_t *rdbx, unsigned long ws);
 
-
 /*
  * srtp_rdbx_dealloc(rdbx_ptr)
  *
@@ -104,7 +101,6 @@ srtp_err_status_t srtp_rdbx_init(srtp_rdbx_t *rdbx, unsigned long ws);
  */
 srtp_err_status_t srtp_rdbx_dealloc(srtp_rdbx_t *rdbx);
 
-
 /*
  * srtp_rdbx_estimate_index(rdbx, guess, s)
  *
@@ -113,7 +109,9 @@ srtp_err_status_t srtp_rdbx_dealloc(srtp_rdbx_t *rdbx);
  * index to which s corresponds, and returns the difference between
  * *guess and the locally stored synch info
  */
-int32_t srtp_rdbx_estimate_index(const srtp_rdbx_t *rdbx, srtp_xtd_seq_num_t *guess, srtp_sequence_number_t s);
+int32_t srtp_rdbx_estimate_index(const srtp_rdbx_t *rdbx,
+                                 srtp_xtd_seq_num_t *guess,
+                                 srtp_sequence_number_t s);
 
 /*
  * srtp_rdbx_check(rdbx, delta);
@@ -136,7 +134,6 @@ srtp_err_status_t srtp_rdbx_check(const srtp_rdbx_t *rdbx, int difference);
  */
 srtp_err_status_t srtp_rdbx_add_index(srtp_rdbx_t *rdbx, int delta);
 
-
 /*
  * srtp_rdbx_set_roc(rdbx, roc) initalizes the srtp_rdbx_t at the location rdbx
  * to have the rollover counter value roc.  If that value is less than
@@ -147,7 +144,8 @@ srtp_err_status_t srtp_rdbx_add_index(srtp_rdbx_t *rdbx, int delta);
 srtp_err_status_t srtp_rdbx_set_roc(srtp_rdbx_t *rdbx, uint32_t roc);
 
 /*
- * srtp_rdbx_get_packet_index(rdbx) returns the value of the rollover counter for
+ * srtp_rdbx_get_packet_index(rdbx) returns the value of the rollover counter
+ * for
  * the srtp_rdbx_t pointed to by rdbx
  *
  */
@@ -166,14 +164,12 @@ srtp_xtd_seq_num_t srtp_rdbx_get_packet_index(const srtp_rdbx_t *rdbx);
  */
 unsigned long srtp_rdbx_get_window_size(const srtp_rdbx_t *rdbx);
 
-
 /* index_init(&pi) initializes a packet index pi (sets it to zero) */
 void srtp_index_init(srtp_xtd_seq_num_t *pi);
 
 /* index_advance(&pi, s) advances a xtd_seq_num_t forward by s */
 void srtp_index_advance(srtp_xtd_seq_num_t *pi, srtp_sequence_number_t s);
 
-
 /*
  * srtp_index_guess(local, guess, s)
  *
@@ -183,7 +179,9 @@ void srtp_index_advance(srtp_xtd_seq_num_t *pi, srtp_sequence_number_t s);
  * guess of the packet index to which s corresponds, and returns the
  * difference between *guess and *local
  */
-int32_t srtp_index_guess(const srtp_xtd_seq_num_t *local, srtp_xtd_seq_num_t *guess, srtp_sequence_number_t s);
+int32_t srtp_index_guess(const srtp_xtd_seq_num_t *local,
+                         srtp_xtd_seq_num_t *guess,
+                         srtp_sequence_number_t s);
 
 /*
  * srtp_rdbx_get_roc(rdbx)

libs/srtp/crypto/include/sha1.h

@@ -81,7 +81,7 @@ extern "C" {
 
 /* OpenSSL 1.1.0 made EVP_MD_CTX an opaque structure, which must be allocated
    using EVP_MD_CTX_new. But this function doesn't exist in OpenSSL 1.0.x. */
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
+#if OPENSSL_VERSION_NUMBER < 0x10100000L || LIBRESSL_VERSION_NUMBER
 
 typedef EVP_MD_CTX srtp_sha1_ctx_t;
 
@@ -91,7 +91,9 @@ static inline void srtp_sha1_init (srtp_sha1_ctx_t *ctx)
     EVP_DigestInit(ctx, EVP_sha1());
 }
 
-static inline void srtp_sha1_update (srtp_sha1_ctx_t *ctx, const uint8_t *M, int octets_in_msg)
+static inline void srtp_sha1_update(srtp_sha1_ctx_t *ctx,
+                                    const uint8_t *M,
+                                    int octets_in_msg)
 {
     EVP_DigestUpdate(ctx, M, octets_in_msg);
 }
@@ -114,7 +116,9 @@ static inline void srtp_sha1_init (srtp_sha1_ctx_t *ctx)
     EVP_DigestInit(*ctx, EVP_sha1());
 }
 
-static inline void srtp_sha1_update (srtp_sha1_ctx_t *ctx, const uint8_t *M, int octets_in_msg)
+static inline void srtp_sha1_update(srtp_sha1_ctx_t *ctx,
+                                    const uint8_t *M,
+                                    int octets_in_msg)
 {
     EVP_DigestUpdate(*ctx, M, octets_in_msg);
 }
@@ -137,7 +141,6 @@ typedef struct {
     uint32_t num_bits_in_msg; /* total number of bits in message */
 } srtp_sha1_ctx_t;
 
-
 /*
  * srtp_sha1_init(&ctx) initializes the SHA1 context ctx
  *
@@ -150,7 +153,9 @@ typedef struct {
  */
 void srtp_sha1_init(srtp_sha1_ctx_t *ctx);
 
-void srtp_sha1_update(srtp_sha1_ctx_t *ctx, const uint8_t *M, int octets_in_msg);
+void srtp_sha1_update(srtp_sha1_ctx_t *ctx,
+                      const uint8_t *M,
+                      int octets_in_msg);
 
 void srtp_sha1_final(srtp_sha1_ctx_t *ctx, uint32_t output[5]);
 

libs/srtp/crypto/include/stat.h

@@ -43,7 +43,6 @@
  *
  */
 
-
 #ifndef STAT_H
 #define STAT_H
 

libs/srtp/crypto/kernel/alloc.c

@@ -51,7 +51,7 @@
 
 /* the debug module for memory allocation */
 
-srtp_debug_module_t mod_alloc = {
+srtp_debug_module_t srtp_mod_alloc = {
     0,      /* debugging is off by default */
     "alloc" /* printable name for module   */
 };
@@ -67,23 +67,29 @@ srtp_debug_module_t mod_alloc = {
 
 #if defined(HAVE_STDLIB_H)
 
-void * srtp_crypto_alloc(size_t size) {
+void *srtp_crypto_alloc(size_t size)
+{
     void *ptr;
 
-  ptr = malloc(size);
+    if (!size) {
+        return NULL;
+    }
+
+    ptr = calloc(1, size);
 
     if (ptr) {
-    debug_print(mod_alloc, "(location: %p) allocated", ptr);
+        debug_print(srtp_mod_alloc, "(location: %p) allocated", ptr);
     } else {
-    debug_print(mod_alloc, "allocation failed (asked for %d bytes)\n", size);
+        debug_print(srtp_mod_alloc, "allocation failed (asked for %d bytes)\n",
+                    size);
     }
 
     return ptr;
 }
 
-void srtp_crypto_free(void *ptr) {
+void srtp_crypto_free(void *ptr)
-
+{
-  debug_print(mod_alloc, "(location: %p) freed", ptr);
+    debug_print(srtp_mod_alloc, "(location: %p) freed", ptr);
 
     free(ptr);
 }

libs/srtp/crypto/kernel/crypto_kernel.c

@@ -42,7 +42,6 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -50,6 +49,7 @@
 #include "alloc.h"
 
 #include "crypto_kernel.h"
+#include "cipher_types.h"
 
 /* the debug module for the crypto_kernel */
 
@@ -58,44 +58,6 @@ srtp_debug_module_t srtp_mod_crypto_kernel = {
     "crypto kernel" /* printable name for module   */
 };
 
-/*
- * other generic debug modules that can be included in the kernel
- */
-
-extern srtp_debug_module_t srtp_mod_auth;
-extern srtp_debug_module_t srtp_mod_cipher;
-extern srtp_debug_module_t mod_stat;
-extern srtp_debug_module_t mod_alloc;
-
-/*
- * cipher types that can be included in the kernel
- */
-
-extern srtp_cipher_type_t srtp_null_cipher;
-extern srtp_cipher_type_t srtp_aes_icm_128;
-extern srtp_cipher_type_t srtp_aes_icm_256;
-#ifdef OPENSSL
-extern srtp_cipher_type_t srtp_aes_icm_192;
-extern srtp_cipher_type_t srtp_aes_gcm_128_openssl;
-extern srtp_cipher_type_t srtp_aes_gcm_256_openssl;
-#endif
-
-/* debug modules for cipher types */
-extern srtp_debug_module_t srtp_mod_aes_icm;
-#ifdef OPENSSL
-extern srtp_debug_module_t srtp_mod_aes_gcm;
-#endif
-
-/*
- * auth func types that can be included in the kernel
- */
-
-extern srtp_auth_type_t srtp_null_auth;
-extern srtp_auth_type_t srtp_hmac;
-
-/* debug modules for auth types */
-extern srtp_debug_module_t srtp_mod_hmac;
-
 /* crypto_kernel is a global variable, the only one of its datatype */
 
 srtp_crypto_kernel_t crypto_kernel = {
@@ -113,7 +75,6 @@ srtp_err_status_t srtp_crypto_kernel_init ()
 
     /* check the security state */
     if (crypto_kernel.state == srtp_crypto_kernel_state_secure) {
-
         /*
          * we're already in the secure state, but we've been asked to
          * re-initialize, so we just re-run the self-tests and then return
@@ -140,25 +101,28 @@ srtp_err_status_t srtp_crypto_kernel_init ()
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_debug_module(&mod_stat);
+    status = srtp_crypto_kernel_load_debug_module(&srtp_mod_stat);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_debug_module(&mod_alloc);
+    status = srtp_crypto_kernel_load_debug_module(&srtp_mod_alloc);
     if (status) {
         return status;
     }
 
     /* load cipher types */
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_null_cipher, SRTP_NULL_CIPHER);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_null_cipher,
+                                                 SRTP_NULL_CIPHER);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_128, SRTP_AES_ICM_128);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_128,
+                                                 SRTP_AES_ICM_128);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_256, SRTP_AES_ICM_256);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_256,
+                                                 SRTP_AES_ICM_256);
     if (status) {
         return status;
     }
@@ -167,15 +131,18 @@ srtp_err_status_t srtp_crypto_kernel_init ()
         return status;
     }
 #ifdef OPENSSL
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_192, SRTP_AES_ICM_192);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_icm_192,
+                                                 SRTP_AES_ICM_192);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_128_openssl, SRTP_AES_GCM_128);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_128_openssl,
+                                                 SRTP_AES_GCM_128);
     if (status) {
         return status;
     }
-    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_256_openssl, SRTP_AES_GCM_256);
+    status = srtp_crypto_kernel_load_cipher_type(&srtp_aes_gcm_256_openssl,
+                                                 SRTP_AES_GCM_256);
     if (status) {
         return status;
     }
@@ -213,11 +180,13 @@ srtp_err_status_t srtp_crypto_kernel_status ()
 
     /* for each cipher type, describe and test */
     while (ctype != NULL) {
-        srtp_err_report(srtp_err_level_info, "cipher: %s\n", ctype->cipher_type->description);
+        srtp_err_report(srtp_err_level_info, "cipher: %s\n",
+                        ctype->cipher_type->description);
         srtp_err_report(srtp_err_level_info, "  self-test: ");
         status = srtp_cipher_type_self_test(ctype->cipher_type);
         if (status) {
-            srtp_err_report(srtp_err_level_error, "failed with error code %d\n", status);
+            srtp_err_report(srtp_err_level_error, "failed with error code %d\n",
+                            status);
             exit(status);
         }
         srtp_err_report(srtp_err_level_info, "passed\n");
@@ -226,11 +195,13 @@ srtp_err_status_t srtp_crypto_kernel_status ()
 
     /* for each auth type, describe and test */
     while (atype != NULL) {
-        srtp_err_report(srtp_err_level_info, "auth func: %s\n", atype->auth_type->description);
+        srtp_err_report(srtp_err_level_info, "auth func: %s\n",
+                        atype->auth_type->description);
         srtp_err_report(srtp_err_level_info, "  self-test: ");
         status = srtp_auth_type_self_test(atype->auth_type);
         if (status) {
-            srtp_err_report(srtp_err_level_error, "failed with error code %d\n", status);
+            srtp_err_report(srtp_err_level_error, "failed with error code %d\n",
+                            status);
             exit(status);
         }
         srtp_err_report(srtp_err_level_info, "passed\n");
@@ -271,8 +242,7 @@ srtp_err_status_t srtp_crypto_kernel_shutdown ()
     while (crypto_kernel.cipher_type_list != NULL) {
         srtp_kernel_cipher_type_t *ctype = crypto_kernel.cipher_type_list;
         crypto_kernel.cipher_type_list = ctype->next;
-        debug_print(srtp_mod_crypto_kernel,
+        debug_print(srtp_mod_crypto_kernel, "freeing memory for cipher %s",
-                    "freeing memory for cipher %s",
                     ctype->cipher_type->description);
         srtp_crypto_free(ctype);
     }
@@ -292,8 +262,7 @@ srtp_err_status_t srtp_crypto_kernel_shutdown ()
         srtp_kernel_debug_module_t *kdm = crypto_kernel.debug_module_list;
         crypto_kernel.debug_module_list = kdm->next;
         debug_print(srtp_mod_crypto_kernel,
-                    "freeing memory for debug module %s",
+                    "freeing memory for debug module %s", kdm->mod->name);
-                    kdm->mod->name);
         srtp_crypto_free(kdm);
     }
 
@@ -303,7 +272,10 @@ srtp_err_status_t srtp_crypto_kernel_shutdown ()
     return srtp_err_status_ok;
 }
 
-static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const srtp_cipher_type_t *new_ct, srtp_cipher_type_id_t id, int replace)
+static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type(
+    const srtp_cipher_type_t *new_ct,
+    srtp_cipher_type_id_t id,
+    int replace)
 {
     srtp_kernel_cipher_type_t *ctype, *new_ctype;
     srtp_err_status_t status;
@@ -330,7 +302,8 @@ static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const sr
             if (!replace) {
                 return srtp_err_status_bad_param;
             }
-            status = srtp_cipher_type_test(new_ct, ctype->cipher_type->test_data);
+            status =
+                srtp_cipher_type_test(new_ct, ctype->cipher_type->test_data);
             if (status) {
                 return status;
             }
@@ -345,7 +318,8 @@ static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const sr
     /* if not found, put new_ct at the head of the list */
     if (ctype == NULL) {
         /* allocate memory */
-        new_ctype = (srtp_kernel_cipher_type_t*)srtp_crypto_alloc(sizeof(srtp_kernel_cipher_type_t));
+        new_ctype = (srtp_kernel_cipher_type_t *)srtp_crypto_alloc(
+            sizeof(srtp_kernel_cipher_type_t));
         if (new_ctype == NULL) {
             return srtp_err_status_alloc_fail;
         }
@@ -362,17 +336,23 @@ static inline srtp_err_status_t srtp_crypto_kernel_do_load_cipher_type (const sr
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_crypto_kernel_load_cipher_type (const srtp_cipher_type_t *new_ct, srtp_cipher_type_id_t id)
+srtp_err_status_t srtp_crypto_kernel_load_cipher_type(
+    const srtp_cipher_type_t *new_ct,
+    srtp_cipher_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_cipher_type(new_ct, id, 0);
 }
 
-srtp_err_status_t srtp_replace_cipher_type (const srtp_cipher_type_t *new_ct, srtp_cipher_type_id_t id)
+srtp_err_status_t srtp_replace_cipher_type(const srtp_cipher_type_t *new_ct,
+                                           srtp_cipher_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_cipher_type(new_ct, id, 1);
 }
 
-srtp_err_status_t srtp_crypto_kernel_do_load_auth_type (const srtp_auth_type_t *new_at, srtp_auth_type_id_t id, int replace)
+srtp_err_status_t srtp_crypto_kernel_do_load_auth_type(
+    const srtp_auth_type_t *new_at,
+    srtp_auth_type_id_t id,
+    int replace)
 {
     srtp_kernel_auth_type_t *atype, *new_atype;
     srtp_err_status_t status;
@@ -414,7 +394,8 @@ srtp_err_status_t srtp_crypto_kernel_do_load_auth_type (const srtp_auth_type_t *
     /* if not found, put new_at at the head of the list */
     if (atype == NULL) {
         /* allocate memory */
-        new_atype = (srtp_kernel_auth_type_t*)srtp_crypto_alloc(sizeof(srtp_kernel_auth_type_t));
+        new_atype = (srtp_kernel_auth_type_t *)srtp_crypto_alloc(
+            sizeof(srtp_kernel_auth_type_t));
         if (new_atype == NULL) {
             return srtp_err_status_alloc_fail;
         }
@@ -429,21 +410,23 @@ srtp_err_status_t srtp_crypto_kernel_do_load_auth_type (const srtp_auth_type_t *
     new_atype->id = id;
 
     return srtp_err_status_ok;
-
 }
 
-srtp_err_status_t srtp_crypto_kernel_load_auth_type (const srtp_auth_type_t *new_at, srtp_auth_type_id_t id)
+srtp_err_status_t srtp_crypto_kernel_load_auth_type(
+    const srtp_auth_type_t *new_at,
+    srtp_auth_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_auth_type(new_at, id, 0);
 }
 
-srtp_err_status_t srtp_replace_auth_type (const srtp_auth_type_t *new_at, srtp_auth_type_id_t id)
+srtp_err_status_t srtp_replace_auth_type(const srtp_auth_type_t *new_at,
+                                         srtp_auth_type_id_t id)
 {
     return srtp_crypto_kernel_do_load_auth_type(new_at, id, 1);
 }
 
-
+const srtp_cipher_type_t *srtp_crypto_kernel_get_cipher_type(
-const srtp_cipher_type_t * srtp_crypto_kernel_get_cipher_type (srtp_cipher_type_id_t id)
+    srtp_cipher_type_id_t id)
 {
     srtp_kernel_cipher_type_t *ctype;
 
@@ -460,8 +443,10 @@ const srtp_cipher_type_t * srtp_crypto_kernel_get_cipher_type (srtp_cipher_type_
     return NULL;
 }
 
-
+srtp_err_status_t srtp_crypto_kernel_alloc_cipher(srtp_cipher_type_id_t id,
-srtp_err_status_t srtp_crypto_kernel_alloc_cipher (srtp_cipher_type_id_t id, srtp_cipher_pointer_t *cp, int key_len, int tag_len)
+                                                  srtp_cipher_pointer_t *cp,
+                                                  int key_len,
+                                                  int tag_len)
 {
     const srtp_cipher_type_t *ct;
 
@@ -481,8 +466,6 @@ srtp_err_status_t srtp_crypto_kernel_alloc_cipher (srtp_cipher_type_id_t id, srt
     return ((ct)->alloc(cp, key_len, tag_len));
 }
 
-
-
 const srtp_auth_type_t *srtp_crypto_kernel_get_auth_type(srtp_auth_type_id_t id)
 {
     srtp_kernel_auth_type_t *atype;
@@ -500,7 +483,10 @@ const srtp_auth_type_t * srtp_crypto_kernel_get_auth_type (srtp_auth_type_id_t i
     return NULL;
 }
 
-srtp_err_status_t srtp_crypto_kernel_alloc_auth (srtp_auth_type_id_t id, srtp_auth_pointer_t *ap, int key_len, int tag_len)
+srtp_err_status_t srtp_crypto_kernel_alloc_auth(srtp_auth_type_id_t id,
+                                                srtp_auth_pointer_t *ap,
+                                                int key_len,
+                                                int tag_len)
 {
     const srtp_auth_type_t *at;
 
@@ -520,12 +506,13 @@ srtp_err_status_t srtp_crypto_kernel_alloc_auth (srtp_auth_type_id_t id, srtp_au
     return ((at)->alloc(ap, key_len, tag_len));
 }
 
-srtp_err_status_t srtp_crypto_kernel_load_debug_module (srtp_debug_module_t *new_dm)
+srtp_err_status_t srtp_crypto_kernel_load_debug_module(
+    srtp_debug_module_t *new_dm)
 {
     srtp_kernel_debug_module_t *kdm, *new;
 
     /* defensive coding */
-    if (new_dm == NULL) {
+    if (new_dm == NULL || new_dm->name == NULL) {
         return srtp_err_status_bad_param;
     }
 
@@ -540,7 +527,8 @@ srtp_err_status_t srtp_crypto_kernel_load_debug_module (srtp_debug_module_t *new
 
     /* put new_dm at the head of the list */
     /* allocate memory */
-    new = (srtp_kernel_debug_module_t*)srtp_crypto_alloc(sizeof(srtp_kernel_debug_module_t));
+    new = (srtp_kernel_debug_module_t *)srtp_crypto_alloc(
+        sizeof(srtp_kernel_debug_module_t));
     if (new == NULL) {
         return srtp_err_status_alloc_fail;
     }

libs/srtp/crypto/kernel/err.c

@@ -71,7 +71,8 @@ srtp_err_status_t srtp_err_reporting_init ()
 
 static srtp_err_report_handler_func_t *srtp_err_report_handler = NULL;
 
-srtp_err_status_t srtp_install_err_report_handler(srtp_err_report_handler_func_t func)
+srtp_err_status_t srtp_install_err_report_handler(
+    srtp_err_report_handler_func_t func)
 {
     srtp_err_report_handler = func;
     return srtp_err_status_ok;
@@ -96,7 +97,8 @@ void srtp_err_report (srtp_err_reporting_level_t level, const char *format, ...)
             }
             srtp_err_report_handler(level, msg);
             /*
-             * NOTE, need to be carefull, there is a potential that octet_string_set_to_zero() could
+             * NOTE, need to be carefull, there is a potential that
+             * octet_string_set_to_zero() could
              * call srtp_err_report() in the future, leading to recursion
              */
             octet_string_set_to_zero(msg, sizeof(msg));

libs/srtp/crypto/kernel/key.c

@@ -50,7 +50,8 @@
 
 #define soft_limit 0x10000
 
-srtp_err_status_t srtp_key_limit_set (srtp_key_limit_t key, const srtp_xtd_seq_num_t s)
+srtp_err_status_t srtp_key_limit_set(srtp_key_limit_t key,
+                                     const srtp_xtd_seq_num_t s)
 {
 #ifdef NO_64BIT_MATH
     if (high32(s) == 0 && low32(s) < soft_limit) {
@@ -66,7 +67,8 @@ srtp_err_status_t srtp_key_limit_set (srtp_key_limit_t key, const srtp_xtd_seq_n
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_key_limit_clone (srtp_key_limit_t original, srtp_key_limit_t *new_key)
+srtp_err_status_t srtp_key_limit_clone(srtp_key_limit_t original,
+                                       srtp_key_limit_t *new_key)
 {
     if (original == NULL) {
         return srtp_err_status_bad_param;
@@ -88,7 +90,8 @@ srtp_key_event_t srtp_key_limit_update (srtp_key_limit_t key)
 #ifdef NO_64BIT_MATH
     if (low32(key->num_left) == 0) {
         // carry
-        key->num_left = make64(high32(key->num_left) - 1, low32(key->num_left) - 1);
+        key->num_left =
+            make64(high32(key->num_left) - 1, low32(key->num_left) - 1);
     } else {
         // no carry
         key->num_left = make64(high32(key->num_left), low32(key->num_left) - 1);
@@ -117,4 +120,3 @@ srtp_key_event_t srtp_key_limit_update (srtp_key_limit_t key)
     }
     return srtp_key_event_soft_limit;
 }
-

libs/srtp/crypto/math/datatypes.c

@@ -53,47 +53,23 @@
 
 #include "datatypes.h"
 
-int 
+static const int8_t octet_weight[256] = {
-octet_weight[256] = {
+    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
-  0, 1, 1, 2, 1, 2, 2, 3,
+    2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  1, 2, 2, 3, 2, 3, 3, 4,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4,
-  1, 2, 2, 3, 2, 3, 3, 4,
+    2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-  2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-  1, 2, 2, 3, 2, 3, 3, 4,
+    4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5,
+    3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
-  1, 2, 2, 3, 2, 3, 3, 4,
+    4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-  2, 3, 3, 4, 3, 4, 4, 5,
+    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
-  2, 3, 3, 4, 3, 4, 4, 5,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  2, 3, 3, 4, 3, 4, 4, 5,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  4, 5, 5, 6, 5, 6, 6, 7,
-  1, 2, 2, 3, 2, 3, 3, 4,
-  2, 3, 3, 4, 3, 4, 4, 5,
-  2, 3, 3, 4, 3, 4, 4, 5,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  2, 3, 3, 4, 3, 4, 4, 5,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  4, 5, 5, 6, 5, 6, 6, 7,
-  2, 3, 3, 4, 3, 4, 4, 5,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  4, 5, 5, 6, 5, 6, 6, 7,
-  3, 4, 4, 5, 4, 5, 5, 6,
-  4, 5, 5, 6, 5, 6, 6, 7,
-  4, 5, 5, 6, 5, 6, 6, 7,
-  5, 6, 6, 7, 6, 7, 7, 8
 };
 
-int
+int octet_get_weight(uint8_t octet)
-octet_get_weight(uint8_t octet) {
+{
-  extern int octet_weight[256];
+    return (int)octet_weight[octet];
-
-  return octet_weight[octet];
 }
 
 /*
@@ -105,14 +81,15 @@ octet_get_weight(uint8_t octet) {
 
 char bit_string[MAX_PRINT_STRING_LEN];
 
-uint8_t
+uint8_t srtp_nibble_to_hex_char(uint8_t nibble)
-srtp_nibble_to_hex_char(uint8_t nibble) {
+{
     char buf[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
                      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
     return buf[nibble & 0xF];
 }
 
-char * srtp_octet_string_hex_string(const void *s, int length) {
+char *srtp_octet_string_hex_string(const void *s, int length)
+{
     const uint8_t *str = (const uint8_t *)s;
     int i;
 
@@ -131,8 +108,8 @@ char * srtp_octet_string_hex_string(const void *s, int length) {
     return bit_string;
 }
 
-char *
+char *v128_hex_string(v128_t *x)
-v128_hex_string(v128_t *x) {
+{
     int i, j;
 
     for (i = j = 0; i < 16; i++) {
@@ -144,8 +121,8 @@ v128_hex_string(v128_t *x) {
     return bit_string;
 }
 
-char *
+char *v128_bit_string(v128_t *x)
-v128_bit_string(v128_t *x) {
+{
     int j, i;
     uint32_t mask;
 
@@ -163,8 +140,8 @@ v128_bit_string(v128_t *x) {
     return bit_string;
 }
 
-void
+void v128_copy_octet_string(v128_t *x, const uint8_t s[16])
-v128_copy_octet_string(v128_t *x, const uint8_t s[16]) {
+{
 #ifdef ALIGNMENT_32BIT_REQUIRED
     if ((((uint32_t)&s[0]) & 0x3) != 0)
 #endif
@@ -187,8 +164,7 @@ v128_copy_octet_string(v128_t *x, const uint8_t s[16]) {
         x->v8[15] = s[15];
     }
 #ifdef ALIGNMENT_32BIT_REQUIRED
-  else 
+    else {
-  {
         v128_t *v = (v128_t *)&s[0];
 
         v128_copy(x, v);
@@ -198,71 +174,70 @@ v128_copy_octet_string(v128_t *x, const uint8_t s[16]) {
 
 #ifndef DATATYPES_USE_MACROS /* little functions are not macros */
 
-void
+void v128_set_to_zero(v128_t *x)
-v128_set_to_zero(v128_t *x) {
+{
     _v128_set_to_zero(x);
 }
 
-void
+void v128_copy(v128_t *x, const v128_t *y)
-v128_copy(v128_t *x, const v128_t *y) {
+{
     _v128_copy(x, y);
 }
 
-void
+void v128_xor(v128_t *z, v128_t *x, v128_t *y)
-v128_xor(v128_t *z, v128_t *x, v128_t *y) {
+{
     _v128_xor(z, x, y);
 }
 
-void
+void v128_and(v128_t *z, v128_t *x, v128_t *y)
-v128_and(v128_t *z, v128_t *x, v128_t *y) {
+{
     _v128_and(z, x, y);
 }
 
-void
+void v128_or(v128_t *z, v128_t *x, v128_t *y)
-v128_or(v128_t *z, v128_t *x, v128_t *y) {
+{
     _v128_or(z, x, y);
 }
 
-void
+void v128_complement(v128_t *x)
-v128_complement(v128_t *x) {
+{
     _v128_complement(x);
 }
 
-int
+int v128_is_eq(const v128_t *x, const v128_t *y)
-v128_is_eq(const v128_t *x, const v128_t *y) {
+{
     return _v128_is_eq(x, y);
 }
 
-int
+int v128_xor_eq(v128_t *x, const v128_t *y)
-v128_xor_eq(v128_t *x, const v128_t *y) {
+{
     return _v128_xor_eq(x, y);
 }
 
-int
+int v128_get_bit(const v128_t *x, int i)
-v128_get_bit(const v128_t *x, int i) {
+{
     return _v128_get_bit(x, i);
 }
 
-void
+void v128_set_bit(v128_t *x, int i)
-v128_set_bit(v128_t *x, int i) {
+{
     _v128_set_bit(x, i);
 }
 
-void
+void v128_clear_bit(v128_t *x, int i)
-v128_clear_bit(v128_t *x, int i){
+{
     _v128_clear_bit(x, i);
 }
 
-void
+void v128_set_bit_to(v128_t *x, int i, int y)
-v128_set_bit_to(v128_t *x, int i, int y){
+{
     _v128_set_bit_to(x, i, y);
 }
 
-
 #endif /* DATATYPES_USE_MACROS */
 
-void
+void v128_right_shift(v128_t *x, int shift)
-v128_right_shift(v128_t *x, int shift) {
+{
     const int base_index = shift >> 5;
     const int bit_index = shift & 31;
     int i, from;
@@ -274,14 +249,12 @@ v128_right_shift(v128_t *x, int shift) {
     }
 
     if (bit_index == 0) {
-
         /* copy each word from left size to right side */
         x->v32[4 - 1] = x->v32[4 - 1 - base_index];
         for (i = 4 - 1; i > base_index; i--)
             x->v32[i - 1] = x->v32[i - 1 - base_index];
 
     } else {
-    
         /* set each word to the "or" of the two bit-shifted words */
         for (i = 4; i > base_index; i--) {
             from = i - 1 - base_index;
@@ -290,17 +263,15 @@ v128_right_shift(v128_t *x, int shift) {
                 b |= x->v32[from - 1] >> (32 - bit_index);
             x->v32[i - 1] = b;
         }
-    
     }
 
     /* now wrap up the final portion */
     for (i = 0; i < base_index; i++)
         x->v32[i] = 0;
-  
 }
 
-void
+void v128_left_shift(v128_t *x, int shift)
-v128_left_shift(v128_t *x, int shift) {
+{
     int i;
     const int base_index = shift >> 5;
     const int bit_index = shift & 31;
@@ -323,50 +294,47 @@ v128_left_shift(v128_t *x, int shift) {
     /* now wrap up the final portion */
     for (i = 4 - base_index; i < 4; i++)
         x->v32[i] = 0;
-
 }
 
 /* functions manipulating bitvector_t */
 
 #ifndef DATATYPES_USE_MACROS /* little functions are not macros */
 
-int
+int bitvector_get_bit(const bitvector_t *v, int bit_index)
-bitvector_get_bit(const bitvector_t *v, int bit_index)
 {
     return _bitvector_get_bit(v, bit_index);
 }
 
-void
+void bitvector_set_bit(bitvector_t *v, int bit_index)
-bitvector_set_bit(bitvector_t *v, int bit_index)
 {
     _bitvector_set_bit(v, bit_index);
 }
 
-void
+void bitvector_clear_bit(bitvector_t *v, int bit_index)
-bitvector_clear_bit(bitvector_t *v, int bit_index)
 {
     _bitvector_clear_bit(v, bit_index);
 }
 
-
 #endif /* DATATYPES_USE_MACROS */
 
-int
+int bitvector_alloc(bitvector_t *v, unsigned long length)
-bitvector_alloc(bitvector_t *v, unsigned long length) {
+{
     unsigned long l;
 
     /* Round length up to a multiple of bits_per_word */
-  length = (length + bits_per_word - 1) & ~(unsigned long)((bits_per_word - 1));
+    length =
+        (length + bits_per_word - 1) & ~(unsigned long)((bits_per_word - 1));
 
     l = length / bits_per_word * bytes_per_word;
 
     /* allocate memory, then set parameters */
-  if (l == 0)
+    if (l == 0) {
         v->word = NULL;
-  else {
+        v->length = 0;
+        return -1;
+    } else {
         v->word = (uint32_t *)srtp_crypto_alloc(l);
         if (v->word == NULL) {
-      v->word = NULL;
             v->length = 0;
             return -1;
         }
@@ -379,24 +347,22 @@ bitvector_alloc(bitvector_t *v, unsigned long length) {
     return 0;
 }
 
-
+void bitvector_dealloc(bitvector_t *v)
-void
+{
-bitvector_dealloc(bitvector_t *v) {
     if (v->word != NULL)
         srtp_crypto_free(v->word);
     v->word = NULL;
     v->length = 0;
 }
 
-void
+void bitvector_set_to_zero(bitvector_t *x)
-bitvector_set_to_zero(bitvector_t *x)
 {
     /* C99 guarantees that memset(0) will set the value 0 for uint32_t */
     memset(x->word, 0, x->length >> 3);
 }
 
-char *
+char *bitvector_bit_string(bitvector_t *x, char *buf, int len)
-bitvector_bit_string(bitvector_t *x, char* buf, int len) {
+{
     int j, i;
     uint32_t mask;
 
@@ -416,8 +382,8 @@ bitvector_bit_string(bitvector_t *x, char* buf, int len) {
     return buf;
 }
 
-void
+void bitvector_left_shift(bitvector_t *x, int shift)
-bitvector_left_shift(bitvector_t *x, int shift) {
+{
     int i;
     const int base_index = shift >> 5;
     const int bit_index = shift & 31;
@@ -435,17 +401,17 @@ bitvector_left_shift(bitvector_t *x, int shift) {
         for (i = 0; i < word_length - base_index - 1; i++)
             x->word[i] = (x->word[i + base_index] >> bit_index) ^
                          (x->word[i + base_index + 1] << (32 - bit_index));
-    x->word[word_length - base_index-1] = x->word[word_length-1] >> bit_index;
+        x->word[word_length - base_index - 1] =
+            x->word[word_length - 1] >> bit_index;
     }
 
     /* now wrap up the final portion */
     for (i = word_length - base_index; i < word_length; i++)
         x->word[i] = 0;
-
 }
 
-int
+int octet_string_is_eq(uint8_t *a, uint8_t *b, int len)
-octet_string_is_eq(uint8_t *a, uint8_t *b, int len) {
+{
     uint8_t *end = b + len;
     uint8_t accumulator = 0;
 
@@ -461,15 +427,14 @@ octet_string_is_eq(uint8_t *a, uint8_t *b, int len) {
     return accumulator != 0;
 }
 
-void
+void srtp_cleanse(void *s, size_t len)
-srtp_cleanse(void *s, size_t len)
 {
     volatile unsigned char *p = (volatile unsigned char *)s;
-  while(len--) *p++ = 0;
+    while (len--)
+        *p++ = 0;
 }
 
-void
+void octet_string_set_to_zero(void *s, size_t len)
-octet_string_set_to_zero(void *s, size_t len)
 {
 #ifdef OPENSSL
     OPENSSL_cleanse(s, len);
@@ -483,28 +448,35 @@ octet_string_set_to_zero(void *s, size_t len)
 static const char b64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                "abcdefghijklmnopqrstuvwxyz0123456789+/";
 
-static int base64_block_to_octet_triple(char *out, char *in) {
+static int base64_block_to_octet_triple(char *out, char *in)
+{
     unsigned char sextets[4] = { 0 };
     int j = 0;
     int i;
 
     for (i = 0; i < 4; i++) {
         char *p = strchr(b64chars, in[i]);
-    if (p != NULL) sextets[i] = p - b64chars;
+        if (p != NULL)
-    else j++;
+            sextets[i] = p - b64chars;
+        else
+            j++;
     }
 
     out[0] = (sextets[0] << 2) | (sextets[1] >> 4);
-  if (j < 2) out[1] = (sextets[1]<<4)|(sextets[2]>>2);
+    if (j < 2)
-  if (j < 1) out[2] = (sextets[2]<<6)|sextets[3];
+        out[1] = (sextets[1] << 4) | (sextets[2] >> 2);
+    if (j < 1)
+        out[2] = (sextets[2] << 6) | sextets[3];
     return j;
 }
 
-int base64_string_to_octet_string(char *out, int *pad, char *in, int len) {
+int base64_string_to_octet_string(char *out, int *pad, char *in, int len)
+{
     int k = 0;
     int i = 0;
     int j = 0;
-  if (len % 4 != 0) return 0;
+    if (len % 4 != 0)
+        return 0;
 
     while (i < len && j == 0) {
         j = base64_block_to_octet_triple(out + k, in + i);

libs/srtp/crypto/math/stat.c

@@ -49,7 +49,7 @@
 
 #include "stat.h"
 
-srtp_debug_module_t mod_stat = {
+srtp_debug_module_t srtp_mod_stat = {
     0,                  /* debugging is off by default */
     (char *)"stat test" /* printable module name       */
 };
@@ -61,8 +61,8 @@ srtp_debug_module_t mod_stat = {
 
 #define STAT_TEST_DATA_LEN 2500
 
-srtp_err_status_t
+srtp_err_status_t stat_test_monobit(uint8_t *data)
-stat_test_monobit(uint8_t *data) {
+{
     uint8_t *data_end = data + STAT_TEST_DATA_LEN;
     uint16_t ones_count;
 
@@ -72,7 +72,7 @@ stat_test_monobit(uint8_t *data) {
         data++;
     }
 
-  debug_print(mod_stat, "bit count: %d", ones_count);
+    debug_print(srtp_mod_stat, "bit count: %d", ones_count);
 
     if ((ones_count < 9725) || (ones_count > 10275))
         return srtp_err_status_algo_fail;
@@ -80,15 +80,12 @@ stat_test_monobit(uint8_t *data) {
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t stat_test_poker(uint8_t *data)
-stat_test_poker(uint8_t *data) {
+{
     int i;
     uint8_t *data_end = data + STAT_TEST_DATA_LEN;
     double poker;
-  uint16_t f[16] = {
+    uint16_t f[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0
-  };
 
     while (data < data_end) {
         f[*data & 0x0f]++; /* increment freq. count for low nibble  */
@@ -103,7 +100,7 @@ stat_test_poker(uint8_t *data) {
     poker *= (16.0 / 5000.0);
     poker -= 5000.0;
 
-  debug_print(mod_stat, "poker test: %f\n", poker);
+    debug_print(srtp_mod_stat, "poker test: %f\n", poker);
 
     if ((poker < 2.16) || (poker > 46.17))
         return srtp_err_status_algo_fail;
@@ -111,13 +108,12 @@ stat_test_poker(uint8_t *data) {
     return srtp_err_status_ok;
 }
 
-
 /*
  * runs[i] holds the number of runs of size (i-1)
  */
 
-srtp_err_status_t
+srtp_err_status_t stat_test_runs(uint8_t *data)
-stat_test_runs(uint8_t *data) {
+{
     uint8_t *data_end = data + STAT_TEST_DATA_LEN;
     uint16_t runs[6] = { 0, 0, 0, 0, 0, 0 };
     uint16_t gaps[6] = { 0, 0, 0, 0, 0, 0 };
@@ -133,29 +129,26 @@ stat_test_runs(uint8_t *data) {
      */
 
     while (data < data_end) {
-
         /* loop over the bits of this byte */
         for (mask = 1; mask < 256; mask <<= 1) {
             if (*data & mask) {
-
                 /* next bit is a one  */
                 if (state > 0) {
-
                     /* prefix is a run, so increment the run-count  */
                     state++;
 
                     /* check for long runs */
                     if (state > 25) {
-		debug_print(mod_stat, ">25 runs: %d", state);
+                        debug_print(srtp_mod_stat, ">25 runs: %d", state);
                         return srtp_err_status_algo_fail;
                     }
 
                 } else if (state < 0) {
-
                     /* prefix is a gap  */
                     if (state < -25) {
-		debug_print(mod_stat, ">25 gaps: %d", state);
+                        debug_print(srtp_mod_stat, ">25 gaps: %d", state);
-	    return srtp_err_status_algo_fail;    /* long-runs test failed   */
+                        return srtp_err_status_algo_fail; /* long-runs test
+                                                             failed   */
                     }
                     if (state < -6) {
                         state = -6; /* group together gaps > 5 */
@@ -163,19 +156,17 @@ stat_test_runs(uint8_t *data) {
                     gaps[-1 - state]++; /* increment gap count      */
                     state = 1;          /* set state at one set bit */
                 } else {
-
                     /* state is zero; this happens only at initialization */
                     state = 1;
                 }
             } else {
-
                 /* next bit is a zero  */
                 if (state > 0) {
-
                     /* prefix is a run */
                     if (state > 25) {
-		debug_print(mod_stat, ">25 runs (2): %d", state);
+                        debug_print(srtp_mod_stat, ">25 runs (2): %d", state);
-	    return srtp_err_status_algo_fail;    /* long-runs test failed   */
+                        return srtp_err_status_algo_fail; /* long-runs test
+                                                             failed   */
                     }
                     if (state > 6) {
                         state = 6; /* group together runs > 5 */
@@ -183,18 +174,17 @@ stat_test_runs(uint8_t *data) {
                     runs[state - 1]++; /* increment run count       */
                     state = -1;        /* set state at one zero bit */
                 } else if (state < 0) {
-
+                    /* prefix is a gap, so increment gap-count (decrement state)
-	  /* prefix is a gap, so increment gap-count (decrement state) */
+                     */
                     state--;
 
                     /* check for long gaps */
                     if (state < -25) {
-		debug_print(mod_stat, ">25 gaps (2): %d", state);
+                        debug_print(srtp_mod_stat, ">25 gaps (2): %d", state);
                         return srtp_err_status_algo_fail;
                     }
 
                 } else {
-
                     /* state is zero; this happens only at initialization */
                     state = -1;
                 }
@@ -205,22 +195,19 @@ stat_test_runs(uint8_t *data) {
         data++;
     }
 
-  if (mod_stat.on) {
+    if (srtp_mod_stat.on) {
-    debug_print(mod_stat, "runs test", NULL);
+        debug_print(srtp_mod_stat, "runs test", NULL);
         for (i = 0; i < 6; i++)
-      debug_print(mod_stat, "  runs[]: %d", runs[i]);
+            debug_print(srtp_mod_stat, "  runs[]: %d", runs[i]);
         for (i = 0; i < 6; i++)
-      debug_print(mod_stat, "  gaps[]: %d", gaps[i]);
+            debug_print(srtp_mod_stat, "  gaps[]: %d", gaps[i]);
     }
 
     /* check run and gap counts against the fixed limits */
     for (i = 0; i < 6; i++)
-    if (   (runs[i] < lo_value[i] ) || (runs[i] > hi_value[i])
+        if ((runs[i] < lo_value[i]) || (runs[i] > hi_value[i]) ||
-	|| (gaps[i] < lo_value[i] ) || (gaps[i] > hi_value[i]))
+            (gaps[i] < lo_value[i]) || (gaps[i] > hi_value[i]))
             return srtp_err_status_algo_fail;
 
-  
     return srtp_err_status_ok;
 }
-
-

libs/srtp/crypto/replay/rdb.c

@@ -43,14 +43,12 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include "rdb.h"
 
-
 /*
  * this implementation of a replay database works as follows:
  *
@@ -73,7 +71,6 @@ srtp_err_status_t srtp_rdb_init (srtp_rdb_t *rdb)
  */
 srtp_err_status_t srtp_rdb_check(const srtp_rdb_t *rdb, uint32_t p_index)
 {
-
     /* if the index appears after (or at very end of) the window, its good */
     if (p_index >= rdb->window_start + rdb_bits_in_bitmask) {
         return srtp_err_status_ok;
@@ -103,25 +100,23 @@ srtp_err_status_t srtp_rdb_check (const srtp_rdb_t *rdb, uint32_t p_index)
  */
 srtp_err_status_t srtp_rdb_add_index(srtp_rdb_t *rdb, uint32_t p_index)
 {
-    int delta;
+    unsigned int delta;
 
-    /* here we *assume* that p_index > rdb->window_start */
+    if (p_index < rdb->window_start)
+        return srtp_err_status_replay_fail;
 
     delta = (p_index - rdb->window_start);
     if (delta < rdb_bits_in_bitmask) {
-
         /* if the p_index is within the window, set the appropriate bit */
         v128_set_bit(&rdb->bitmask, delta);
 
     } else {
-
         delta -= rdb_bits_in_bitmask - 1;
 
         /* shift the window forward by delta bits*/
         v128_left_shift(&rdb->bitmask, delta);
         v128_set_bit(&rdb->bitmask, rdb_bits_in_bitmask - 1);
         rdb->window_start += delta;
-
     }
 
     return srtp_err_status_ok;
@@ -129,7 +124,6 @@ srtp_err_status_t srtp_rdb_add_index (srtp_rdb_t *rdb, uint32_t p_index)
 
 srtp_err_status_t srtp_rdb_increment(srtp_rdb_t *rdb)
 {
-
     if (rdb->window_start >= 0x7fffffff) {
         return srtp_err_status_key_expired;
     }

libs/srtp/crypto/replay/rdbx.c

@@ -49,7 +49,6 @@
 
 #include "rdbx.h"
 
-
 /*
  * from RFC 3711:
  *
@@ -64,8 +63,6 @@
  * incremented by one (if the packet containing s is authentic).
  */
 
-
-
 /*
  * rdbx implementation notes
  *
@@ -83,13 +80,12 @@
  * srtp_index_advance(&guess, delta), where delta is the difference.
  *
  *
- * A srtp_rdbx_t consists of a srtp_xtd_seq_num_t and a bitmask.  The index is highest
+ * A srtp_rdbx_t consists of a srtp_xtd_seq_num_t and a bitmask.  The index is
- * sequence number that has been received, and the bitmask indicates
+ * highest sequence number that has been received, and the bitmask indicates
  * which of the recent indicies have been received as well.  The
  * highest bit in the bitmask corresponds to the index in the bitmask.
  */
 
-
 void srtp_index_init(srtp_xtd_seq_num_t *pi)
 {
 #ifdef NO_64BIT_MATH
@@ -110,7 +106,6 @@ void srtp_index_advance (srtp_xtd_seq_num_t *pi, srtp_sequence_number_t s)
 #endif
 }
 
-
 /*
  * srtp_index_guess(local, guess, s)
  *
@@ -124,24 +119,19 @@ void srtp_index_advance (srtp_xtd_seq_num_t *pi, srtp_sequence_number_t s)
  * unsigned integer!
  */
 
-int32_t srtp_index_guess (const srtp_xtd_seq_num_t *local, srtp_xtd_seq_num_t *guess, srtp_sequence_number_t s)
+int32_t srtp_index_guess(const srtp_xtd_seq_num_t *local,
+                         srtp_xtd_seq_num_t *guess,
+                         srtp_sequence_number_t s)
 {
 #ifdef NO_64BIT_MATH
-    uint32_t local_roc = ((high32(*local) << 16) |
+    uint32_t local_roc = ((high32(*local) << 16) | (low32(*local) >> 16));
-                          (low32(*local) >> 16));
     uint16_t local_seq = (uint16_t)(low32(*local));
 #else
     uint32_t local_roc = (uint32_t)(*local >> 16);
     uint16_t local_seq = (uint16_t)*local;
 #endif
-#ifdef NO_64BIT_MATH
+    uint32_t guess_roc;
-    uint32_t guess_roc = ((high32(*guess) << 16) |
+    uint16_t guess_seq;
-                          (low32(*guess) >> 16));
-    uint16_t guess_seq = (uint16_t)(low32(*guess));
-#else
-    uint32_t guess_roc = (uint32_t)(*guess >> 16);
-    uint16_t guess_seq = (uint16_t)*guess;
-#endif
     int32_t difference;
 
     if (local_seq < seq_num_median) {
@@ -165,8 +155,7 @@ int32_t srtp_index_guess (const srtp_xtd_seq_num_t *local, srtp_xtd_seq_num_t *g
 
 /* Note: guess_roc is 32 bits, so this generates a 48-bit result! */
 #ifdef NO_64BIT_MATH
-    *guess = make64(guess_roc >> 16,
+    *guess = make64(guess_roc >> 16, (guess_roc << 16) | guess_seq);
-                    (guess_roc << 16) | guess_seq);
 #else
     *guess = (((uint64_t)guess_roc) << 16) | guess_seq;
 #endif
@@ -179,9 +168,9 @@ int32_t srtp_index_guess (const srtp_xtd_seq_num_t *local, srtp_xtd_seq_num_t *g
  *
  */
 
-
 /*
- *  srtp_rdbx_init(&r, ws) initializes the srtp_rdbx_t pointed to by r with window size ws
+ *  srtp_rdbx_init(&r, ws) initializes the srtp_rdbx_t pointed to by r with
+ * window size ws
  */
 srtp_err_status_t srtp_rdbx_init(srtp_rdbx_t *rdbx, unsigned long ws)
 {
@@ -261,14 +250,15 @@ unsigned long srtp_rdbx_get_window_size (const srtp_rdbx_t *rdbx)
  */
 srtp_err_status_t srtp_rdbx_check(const srtp_rdbx_t *rdbx, int delta)
 {
-
     if (delta > 0) { /* if delta is positive, it's good */
         return srtp_err_status_ok;
     } else if ((int)(bitvector_get_length(&rdbx->bitmask) - 1) + delta < 0) {
         /* if delta is lower than the bitmask, it's bad */
         return srtp_err_status_replay_old;
-    } else if (bitvector_get_bit(&rdbx->bitmask,
+    } else if (bitvector_get_bit(
-                                 (int)(bitvector_get_length(&rdbx->bitmask) - 1) + delta) == 1) {
+                   &rdbx->bitmask,
+                   (int)(bitvector_get_length(&rdbx->bitmask) - 1) + delta) ==
+               1) {
         /* delta is within the window, so check the bitmask */
         return srtp_err_status_replay_fail;
     }
@@ -287,15 +277,16 @@ srtp_err_status_t srtp_rdbx_check (const srtp_rdbx_t *rdbx, int delta)
  */
 srtp_err_status_t srtp_rdbx_add_index(srtp_rdbx_t *rdbx, int delta)
 {
-
     if (delta > 0) {
         /* shift forward by delta */
         srtp_index_advance(&rdbx->index, delta);
         bitvector_left_shift(&rdbx->bitmask, delta);
-        bitvector_set_bit(&rdbx->bitmask, bitvector_get_length(&rdbx->bitmask) - 1);
+        bitvector_set_bit(&rdbx->bitmask,
+                          bitvector_get_length(&rdbx->bitmask) - 1);
     } else {
         /* delta is in window */
-        bitvector_set_bit(&rdbx->bitmask, bitvector_get_length(&rdbx->bitmask) - 1 + delta);
+        bitvector_set_bit(&rdbx->bitmask,
+                          bitvector_get_length(&rdbx->bitmask) - 1 + delta);
     }
 
     /* note that we need not consider the case that delta == 0 */
@@ -303,8 +294,6 @@ srtp_err_status_t srtp_rdbx_add_index (srtp_rdbx_t *rdbx, int delta)
     return srtp_err_status_ok;
 }
 
-
-
 /*
  * srtp_rdbx_estimate_index(rdbx, guess, s)
  *
@@ -313,9 +302,10 @@ srtp_err_status_t srtp_rdbx_add_index (srtp_rdbx_t *rdbx, int delta)
  * index to which s corresponds, and returns the difference between
  * *guess and the locally stored synch info
  */
-int32_t srtp_rdbx_estimate_index (const srtp_rdbx_t *rdbx, srtp_xtd_seq_num_t *guess, srtp_sequence_number_t s)
+int32_t srtp_rdbx_estimate_index(const srtp_rdbx_t *rdbx,
+                                 srtp_xtd_seq_num_t *guess,
+                                 srtp_sequence_number_t s)
 {
-
 /*
  * if the sequence number and rollover counter in the rdbx are
  * non-zero, then use the srtp_index_guess(...) function, otherwise, just
@@ -326,12 +316,13 @@ int32_t srtp_rdbx_estimate_index (const srtp_rdbx_t *rdbx, srtp_xtd_seq_num_t *g
 
 #ifdef NO_64BIT_MATH
     /* seq_num_median = 0x8000 */
-    if (high32(rdbx->index) > 0 ||
+    if (high32(rdbx->index) > 0 || low32(rdbx->index) > seq_num_median)
-        low32(rdbx->index) > seq_num_median)
 #else
     if (rdbx->index > seq_num_median)
 #endif
-    { return srtp_index_guess(&rdbx->index, guess, s); }
+    {
+        return srtp_index_guess(&rdbx->index, guess, s);
+    }
 
 #ifdef NO_64BIT_MATH
     *guess = make64(0, (uint32_t)s);
@@ -393,4 +384,3 @@ srtp_err_status_t srtp_rdbx_set_roc_seq (srtp_rdbx_t *rdbx,
 
     return srtp_err_status_ok;
 }
-

libs/srtp/crypto/replay/ut_sim.c

@@ -44,21 +44,19 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include "ut_sim.h"
 
-
+int ut_compar(const void *a, const void *b)
-int
+{
-ut_compar(const void *a, const void *b) {
     return rand() > (RAND_MAX / 2) ? -1 : 1;
 }
 
-void
+void ut_init(ut_connection *utc)
-ut_init(ut_connection *utc) {
+{
     int i;
     utc->index = 0;
 
@@ -70,8 +68,8 @@ ut_init(ut_connection *utc) {
     utc->index = UT_BUF - 1;
 }
 
-uint32_t
+uint32_t ut_next_index(ut_connection *utc)
-ut_next_index(ut_connection *utc) {
+{
     uint32_t tmp;
 
     tmp = utc->buffer[0];
@@ -83,14 +81,12 @@ ut_next_index(ut_connection *utc) {
     return tmp;
 }
 
-
-
 #ifdef UT_TEST
 
 #include <stdio.h>
 
-int
+int main()
-main() {
+{
     uint32_t i, irecvd, idiff;
     ut_connection utc;
 
@@ -105,5 +101,4 @@ main() {
     return 0;
 }
 
-
 #endif

libs/srtp/crypto/test/aes_calc.c

@@ -47,7 +47,9 @@
 
  Example usage (with first NIST FIPS 197 test case):
 
-[sh]$ test/aes_calc 000102030405060708090a0b0c0d0e0f 00112233445566778899aabbccddeeff -v
+ [sh]$ test/aes_calc 000102030405060708090a0b0c0d0e0f \
+       00112233445566778899aabbccddeeff -v
+
  plaintext:      00112233445566778899aabbccddeeff
  key:            000102030405060708090a0b0c0d0e0f
  ciphertext:     69c4e0d86a7b0430d8cdb78070b4c55a
@@ -63,16 +65,16 @@
 #include <string.h>
 #include "util.h"
 
-void
+void usage(char *prog_name)
-usage(char *prog_name) {
+{
     printf("usage: %s <key> <plaintext> [-v]\n", prog_name);
     exit(255);
 }
 
 #define AES_MAX_KEY_LEN 32
 
-int
+int main(int argc, char *argv[])
-main (int argc, char *argv[]) {
+{
     v128_t data;
     uint8_t key[AES_MAX_KEY_LEN];
     srtp_aes_expanded_key_t exp_key;
@@ -98,8 +100,7 @@ main (int argc, char *argv[]) {
 
     /* read in key, checking length */
     if (strlen(argv[1]) > AES_MAX_KEY_LEN * 2) {
-    fprintf(stderr, 
+        fprintf(stderr, "error: too many digits in key "
-	    "error: too many digits in key "
                         "(should be at most %d hexadecimal digits, found %u)\n",
                 AES_MAX_KEY_LEN * 2, (unsigned)strlen(argv[1]));
         exit(1);
@@ -107,8 +108,7 @@ main (int argc, char *argv[]) {
     len = hex_string_to_octet_string((char *)key, argv[1], AES_MAX_KEY_LEN * 2);
     /* check that hex string is the right length */
     if (len != 32 && len != 48 && len != 64) {
-    fprintf(stderr, 
+        fprintf(stderr, "error: bad number of digits in key "
-	    "error: bad number of digits in key "
                         "(should be 32/48/64 hexadecimal digits, found %d)\n",
                 len);
         exit(1);
@@ -117,8 +117,7 @@ main (int argc, char *argv[]) {
 
     /* read in plaintext, checking length */
     if (strlen(argv[2]) > 16 * 2) {
-    fprintf(stderr, 
+        fprintf(stderr, "error: too many digits in plaintext "
-	    "error: too many digits in plaintext "
                         "(should be %d hexadecimal digits, found %u)\n",
                 16 * 2, (unsigned)strlen(argv[2]));
         exit(1);
@@ -126,8 +125,7 @@ main (int argc, char *argv[]) {
     len = hex_string_to_octet_string((char *)(&data), argv[2], 16 * 2);
     /* check that hex string is the right length */
     if (len < 16 * 2) {
-    fprintf(stderr, 
+        fprintf(stderr, "error: too few digits in plaintext "
-	    "error: too few digits in plaintext "
                         "(should be %d hexadecimal digits, found %d)\n",
                 16 * 2, len);
         exit(1);
@@ -135,14 +133,14 @@ main (int argc, char *argv[]) {
 
     if (verbose) {
         /* print out plaintext */
-    printf("plaintext:\t%s\n", octet_string_hex_string((uint8_t *)&data, 16));
+        printf("plaintext:\t%s\n",
+               octet_string_hex_string((uint8_t *)&data, 16));
     }
 
     /* encrypt plaintext */
     status = srtp_aes_expand_encryption_key(key, key_len, &exp_key);
     if (status) {
-    fprintf(stderr,
+        fprintf(stderr, "error: AES key expansion failed.\n");
-	    "error: AES key expansion failed.\n");
         exit(1);
     }
 
@@ -157,4 +155,3 @@ main (int argc, char *argv[]) {
 
     return 0;
 }
-

libs/srtp/crypto/test/cipher_driver.c

@@ -49,7 +49,6 @@
 
 #include <stdio.h>  /* for printf() */
 #include <stdlib.h> /* for rand() */
-#include <string.h>          /* for memset() */
 #include "getopt_s.h"
 #include "cipher.h"
 #ifdef OPENSSL
@@ -61,12 +60,9 @@
 
 #define PRINT_DEBUG 0
 
-void
+void cipher_driver_test_throughput(srtp_cipher_t *c);
-cipher_driver_test_throughput(srtp_cipher_t *c);
-
-srtp_err_status_t
-cipher_driver_self_test(srtp_cipher_type_t *ct);
 
+srtp_err_status_t cipher_driver_self_test(srtp_cipher_type_t *ct);
 
 /*
  * cipher_driver_test_buffering(ct) tests the cipher's output
@@ -74,39 +70,38 @@ cipher_driver_self_test(srtp_cipher_type_t *ct);
  * calls
  */
 
-srtp_err_status_t
+srtp_err_status_t cipher_driver_test_buffering(srtp_cipher_t *c);
-cipher_driver_test_buffering(srtp_cipher_t *c);
-
 
 /*
  * functions for testing cipher cache thrash
  */
-srtp_err_status_t
+srtp_err_status_t cipher_driver_test_array_throughput(srtp_cipher_type_t *ct,
-cipher_driver_test_array_throughput(srtp_cipher_type_t *ct, 
+                                                      int klen,
-				    int klen, int num_cipher);
+                                                      int num_cipher);
 
-void
+void cipher_array_test_throughput(srtp_cipher_t *ca[], int num_cipher);
-cipher_array_test_throughput(srtp_cipher_t *ca[], int num_cipher);
 
-uint64_t
+uint64_t cipher_array_bits_per_second(srtp_cipher_t *cipher_array[],
-cipher_array_bits_per_second(srtp_cipher_t *cipher_array[], int num_cipher, 
+                                      int num_cipher,
-			     unsigned octets_in_buffer, int num_trials);
+                                      unsigned octets_in_buffer,
+                                      int num_trials);
 
-srtp_err_status_t
+srtp_err_status_t cipher_array_delete(srtp_cipher_t *cipher_array[],
-cipher_array_delete(srtp_cipher_t *cipher_array[], int num_cipher);
+                                      int num_cipher);
 
-srtp_err_status_t
+srtp_err_status_t cipher_array_alloc_init(srtp_cipher_t ***cipher_array,
-cipher_array_alloc_init(srtp_cipher_t ***cipher_array, int num_ciphers,
+                                          int num_ciphers,
-			srtp_cipher_type_t *ctype, int klen);
+                                          srtp_cipher_type_t *ctype,
+                                          int klen);
 
-void
+void usage(char *prog_name)
-usage(char *prog_name) {
+{
     printf("usage: %s [ -t | -v | -a ]\n", prog_name);
     exit(255);
 }
 
-void
+void check_status(srtp_err_status_t s)
-check_status(srtp_err_status_t s) {
+{
     if (s) {
         printf("error (code %d)\n", s);
         exit(s);
@@ -129,10 +124,11 @@ extern srtp_cipher_type_t srtp_aes_gcm_128_openssl;
 extern srtp_cipher_type_t srtp_aes_gcm_256_openssl;
 #endif
 
-int
+int main(int argc, char *argv[])
-main(int argc, char *argv[]) {
+{
     srtp_cipher_t *c = NULL;
     srtp_err_status_t status;
+    /* clang-format off */
     unsigned char test_key[48] = {
         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
@@ -141,6 +137,7 @@ main(int argc, char *argv[]) {
         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
     };
+    /* clang-format on */
     int q;
     unsigned do_timing_test = 0;
     unsigned do_validation = 0;
@@ -179,24 +176,32 @@ main(int argc, char *argv[]) {
         int num_cipher;
 
         for (num_cipher = 1; num_cipher < max_num_cipher; num_cipher *= 8)
-      cipher_driver_test_array_throughput(&srtp_null_cipher, 0, num_cipher); 
+            cipher_driver_test_array_throughput(&srtp_null_cipher, 0,
+                                                num_cipher);
 
         for (num_cipher = 1; num_cipher < max_num_cipher; num_cipher *= 8)
-      cipher_driver_test_array_throughput(&srtp_aes_icm_128, SRTP_AES_ICM_128_KEY_LEN_WSALT, num_cipher);
+            cipher_driver_test_array_throughput(
+                &srtp_aes_icm_128, SRTP_AES_ICM_128_KEY_LEN_WSALT, num_cipher);
 
         for (num_cipher = 1; num_cipher < max_num_cipher; num_cipher *= 8)
-      cipher_driver_test_array_throughput(&srtp_aes_icm_256, SRTP_AES_ICM_256_KEY_LEN_WSALT, num_cipher);
+            cipher_driver_test_array_throughput(
+                &srtp_aes_icm_256, SRTP_AES_ICM_256_KEY_LEN_WSALT, num_cipher);
 
 #ifdef OPENSSL
         for (num_cipher = 1; num_cipher < max_num_cipher; num_cipher *= 8)
-      cipher_driver_test_array_throughput(&srtp_aes_icm_192, SRTP_AES_ICM_192_KEY_LEN_WSALT, num_cipher);
+            cipher_driver_test_array_throughput(
+                &srtp_aes_icm_192, SRTP_AES_ICM_192_KEY_LEN_WSALT, num_cipher);
 
         for (num_cipher = 1; num_cipher < max_num_cipher; num_cipher *= 8) {
-      cipher_driver_test_array_throughput(&srtp_aes_gcm_128_openssl, SRTP_AES_GCM_128_KEY_LEN_WSALT, num_cipher);
+            cipher_driver_test_array_throughput(&srtp_aes_gcm_128_openssl,
+                                                SRTP_AES_GCM_128_KEY_LEN_WSALT,
+                                                num_cipher);
         }
 
         for (num_cipher = 1; num_cipher < max_num_cipher; num_cipher *= 8) {
-      cipher_driver_test_array_throughput(&srtp_aes_gcm_256_openssl, SRTP_AES_GCM_256_KEY_LEN_WSALT, num_cipher);
+            cipher_driver_test_array_throughput(&srtp_aes_gcm_256_openssl,
+                                                SRTP_AES_GCM_256_KEY_LEN_WSALT,
+                                                num_cipher);
         }
 #endif
     }
@@ -228,9 +233,9 @@ main(int argc, char *argv[]) {
     status = srtp_cipher_dealloc(c);
     check_status(status);
 
-
     /* run the throughput test on the aes_icm cipher (128-bit key) */
-    status = srtp_cipher_type_alloc(&srtp_aes_icm_128, &c, SRTP_AES_ICM_128_KEY_LEN_WSALT, 0);
+    status = srtp_cipher_type_alloc(&srtp_aes_icm_128, &c,
+                                    SRTP_AES_ICM_128_KEY_LEN_WSALT, 0);
     if (status) {
         fprintf(stderr, "error: can't allocate cipher\n");
         exit(status);
@@ -251,7 +256,8 @@ main(int argc, char *argv[]) {
     check_status(status);
 
     /* repeat the tests with 256-bit keys */
-    status = srtp_cipher_type_alloc(&srtp_aes_icm_256, &c, SRTP_AES_ICM_256_KEY_LEN_WSALT, 0);
+    status = srtp_cipher_type_alloc(&srtp_aes_icm_256, &c,
+                                    SRTP_AES_ICM_256_KEY_LEN_WSALT, 0);
     if (status) {
         fprintf(stderr, "error: can't allocate cipher\n");
         exit(status);
@@ -273,7 +279,8 @@ main(int argc, char *argv[]) {
 
 #ifdef OPENSSL
     /* run the throughput test on the aes_gcm_128_openssl cipher */
-    status = srtp_cipher_type_alloc(&srtp_aes_gcm_128_openssl, &c, SRTP_AES_GCM_128_KEY_LEN_WSALT, 8);
+    status = srtp_cipher_type_alloc(&srtp_aes_gcm_128_openssl, &c,
+                                    SRTP_AES_GCM_128_KEY_LEN_WSALT, 8);
     if (status) {
         fprintf(stderr, "error: can't allocate GCM 128 cipher\n");
         exit(status);
@@ -292,7 +299,8 @@ main(int argc, char *argv[]) {
     check_status(status);
 
     /* run the throughput test on the aes_gcm_256_openssl cipher */
-    status = srtp_cipher_type_alloc(&srtp_aes_gcm_256_openssl, &c, SRTP_AES_GCM_256_KEY_LEN_WSALT, 16);
+    status = srtp_cipher_type_alloc(&srtp_aes_gcm_256_openssl, &c,
+                                    SRTP_AES_GCM_256_KEY_LEN_WSALT, 16);
     if (status) {
         fprintf(stderr, "error: can't allocate GCM 256 cipher\n");
         exit(status);
@@ -314,23 +322,23 @@ main(int argc, char *argv[]) {
     return 0;
 }
 
-void
+void cipher_driver_test_throughput(srtp_cipher_t *c)
-cipher_driver_test_throughput(srtp_cipher_t *c) {
+{
     int i;
     int min_enc_len = 32;
     int max_enc_len = 2048; /* should be a power of two */
     int num_trials = 1000000;
 
-  printf("timing %s throughput, key length %d:\n", c->type->description, c->key_len);
+    printf("timing %s throughput, key length %d:\n", c->type->description,
+           c->key_len);
     fflush(stdout);
     for (i = min_enc_len; i <= max_enc_len; i = i * 2)
-    printf("msg len: %d\tgigabits per second: %f\n",
+        printf("msg len: %d\tgigabits per second: %f\n", i,
-	   i, srtp_cipher_bits_per_second(c, i, num_trials) / 1e9);
+               srtp_cipher_bits_per_second(c, i, num_trials) / 1e9);
-
 }
 
-srtp_err_status_t
+srtp_err_status_t cipher_driver_self_test(srtp_cipher_type_t *ct)
-cipher_driver_self_test(srtp_cipher_type_t *ct) {
+{
     srtp_err_status_t status;
 
     printf("running cipher self-test for %s...", ct->description);
@@ -351,22 +359,18 @@ cipher_driver_self_test(srtp_cipher_type_t *ct) {
  */
 
 #define INITIAL_BUFLEN 1024
-srtp_err_status_t
+srtp_err_status_t cipher_driver_test_buffering(srtp_cipher_t *c)
-cipher_driver_test_buffering(srtp_cipher_t *c) {
+{
     int i, j, num_trials = 1000;
     unsigned len, buflen = INITIAL_BUFLEN;
     uint8_t buffer0[INITIAL_BUFLEN], buffer1[INITIAL_BUFLEN], *current, *end;
-  uint8_t idx[16] = { 
+    uint8_t idx[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x34 };
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x34
-  };
     srtp_err_status_t status;
 
-  printf("testing output buffering for cipher %s...",
+    printf("testing output buffering for cipher %s...", c->type->description);
-	 c->type->description);
 
     for (i = 0; i < num_trials; i++) {
-
         /* set buffers to zero */
         for (j = 0; j < (int)buflen; j++) {
             buffer0[j] = buffer1[j] = 0;
@@ -391,7 +395,6 @@ cipher_driver_test_buffering(srtp_cipher_t *c) {
         current = buffer1;
         end = buffer1 + buflen;
         while (current < end) {
-
             /* choose a short length */
             len = rand() & 0x01f;
 
@@ -416,8 +419,10 @@ cipher_driver_test_buffering(srtp_cipher_t *c) {
             if (buffer0[j] != buffer1[j]) {
 #if PRINT_DEBUG
                 printf("test case %d failed at byte %d\n", i, j);
-	printf("computed: %s\n", octet_string_hex_string(buffer1, buflen));
+                printf("computed: %s\n",
-	printf("expected: %s\n", octet_string_hex_string(buffer0, buflen));
+                       octet_string_hex_string(buffer1, buflen));
+                printf("expected: %s\n",
+                       octet_string_hex_string(buffer0, buflen));
 #endif
                 return srtp_err_status_algo_fail;
             }
@@ -429,7 +434,6 @@ cipher_driver_test_buffering(srtp_cipher_t *c) {
     return srtp_err_status_ok;
 }
 
-
 /*
  * The function cipher_test_throughput_array() tests the effect of CPU
  * cache thrash on cipher throughput.
@@ -438,9 +442,11 @@ cipher_driver_test_buffering(srtp_cipher_t *c) {
  * of srtp_cipher_t of type ctype
  */
 
-srtp_err_status_t
+srtp_err_status_t cipher_array_alloc_init(srtp_cipher_t ***ca,
-cipher_array_alloc_init(srtp_cipher_t ***ca, int num_ciphers,
+                                          int num_ciphers,
-			srtp_cipher_type_t *ctype, int klen) {
+                                          srtp_cipher_type_t *ctype,
+                                          int klen)
+{
     int i, j;
     srtp_err_status_t status;
     uint8_t *key;
@@ -450,7 +456,8 @@ cipher_array_alloc_init(srtp_cipher_t ***ca, int num_ciphers,
     int klen_pad = ((klen + 15) >> 4) << 4;
 
     /* allocate array of pointers to ciphers */
-  cipher_array = (srtp_cipher_t **) malloc(sizeof(srtp_cipher_t *) * num_ciphers);
+    cipher_array = (srtp_cipher_t **)srtp_crypto_alloc(sizeof(srtp_cipher_t *) *
+                                                       num_ciphers);
     if (cipher_array == NULL)
         return srtp_err_status_alloc_fail;
 
@@ -460,13 +467,12 @@ cipher_array_alloc_init(srtp_cipher_t ***ca, int num_ciphers,
     /* allocate key */
     key = srtp_crypto_alloc(klen_pad);
     if (key == NULL) {
-    free(cipher_array);
+        srtp_crypto_free(cipher_array);
         return srtp_err_status_alloc_fail;
     }
 
     /* allocate and initialize an array of ciphers */
     for (i = 0; i < num_ciphers; i++) {
-
         /* allocate cipher */
         status = srtp_cipher_type_alloc(ctype, cipher_array, klen, 16);
         if (status)
@@ -494,20 +500,20 @@ cipher_array_alloc_init(srtp_cipher_t ***ca, int num_ciphers,
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t cipher_array_delete(srtp_cipher_t *cipher_array[],
-cipher_array_delete(srtp_cipher_t *cipher_array[], int num_cipher) {
+                                      int num_cipher)
+{
     int i;
 
     for (i = 0; i < num_cipher; i++) {
         srtp_cipher_dealloc(cipher_array[i]);
     }
 
-  free(cipher_array);
+    srtp_crypto_free(cipher_array);
 
     return srtp_err_status_ok;
 }
 
-
 /*
  * cipher_array_bits_per_second(c, l, t) computes (an estimate of) the
  * number of bits that a cipher implementation can encrypt in a second
@@ -520,9 +526,11 @@ cipher_array_delete(srtp_cipher_t *cipher_array[], int num_cipher) {
  * if an error is encountered, the value 0 is returned
  */
 
-uint64_t
+uint64_t cipher_array_bits_per_second(srtp_cipher_t *cipher_array[],
-cipher_array_bits_per_second(srtp_cipher_t *cipher_array[], int num_cipher, 
+                                      int num_cipher,
-			      unsigned octets_in_buffer, int num_trials) {
+                                      unsigned octets_in_buffer,
+                                      int num_trials)
+{
     int i;
     v128_t nonce;
     clock_t timer;
@@ -533,26 +541,28 @@ cipher_array_bits_per_second(srtp_cipher_t *cipher_array[], int num_cipher,
     enc_buf = srtp_crypto_alloc(octets_in_buffer + 17);
     if (enc_buf == NULL)
         return 0; /* indicate bad parameters by returning null */
-  memset(enc_buf, 0, octets_in_buffer);
 
     /* time repeated trials */
     v128_set_to_zero(&nonce);
     timer = clock();
     for (i = 0; i < num_trials; i++, nonce.v32[3] = i) {
-    /* length parameter to srtp_cipher_encrypt is in/out -- out is total, padded
+        /* length parameter to srtp_cipher_encrypt is in/out -- out is total,
+         * padded
          * length -- so reset it each time. */
         unsigned octets_to_encrypt = octets_in_buffer;
 
         /* encrypt buffer with cipher */
-    srtp_cipher_set_iv(cipher_array[cipher_index], (uint8_t*)&nonce, srtp_direction_encrypt);
+        srtp_cipher_set_iv(cipher_array[cipher_index], (uint8_t *)&nonce,
-    srtp_cipher_encrypt(cipher_array[cipher_index], enc_buf, &octets_to_encrypt);
+                           srtp_direction_encrypt);
+        srtp_cipher_encrypt(cipher_array[cipher_index], enc_buf,
+                            &octets_to_encrypt);
 
         /* choose a cipher at random from the array*/
         cipher_index = (*((uint32_t *)enc_buf)) % num_cipher;
     }
     timer = clock() - timer;
 
-  free(enc_buf);
+    srtp_crypto_free(enc_buf);
 
     if (timer == 0) {
         /* Too fast! */
@@ -562,8 +572,8 @@ cipher_array_bits_per_second(srtp_cipher_t *cipher_array[], int num_cipher,
     return (uint64_t)CLOCKS_PER_SEC * num_trials * 8 * octets_in_buffer / timer;
 }
 
-void
+void cipher_array_test_throughput(srtp_cipher_t *ca[], int num_cipher)
-cipher_array_test_throughput(srtp_cipher_t *ca[], int num_cipher) {
+{
     int i;
     int min_enc_len = 16;
     int max_enc_len = 2048; /* should be a power of two */
@@ -574,13 +584,14 @@ cipher_array_test_throughput(srtp_cipher_t *ca[], int num_cipher) {
     fflush(stdout);
     for (i = min_enc_len; i <= max_enc_len; i = i * 4)
         printf("msg len: %d\tgigabits per second: %f\n", i,
-	   cipher_array_bits_per_second(ca, num_cipher, i, num_trials) / 1e9);
+               cipher_array_bits_per_second(ca, num_cipher, i, num_trials) /
-
+                   1e9);
 }
 
-srtp_err_status_t
+srtp_err_status_t cipher_driver_test_array_throughput(srtp_cipher_type_t *ct,
-cipher_driver_test_array_throughput(srtp_cipher_type_t *ct, 
+                                                      int klen,
-				    int klen, int num_cipher) {
+                                                      int num_cipher)
+{
     srtp_cipher_t **ca = NULL;
     srtp_err_status_t status;
 

libs/srtp/crypto/test/datatypes_driver.c

@@ -43,7 +43,6 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -53,21 +52,16 @@
 #include "datatypes.h"
 #include "util.h"
 
-void
+void byte_order(void);
-byte_order(void);
 
-void
+void test_hex_string_funcs(void);
-test_hex_string_funcs(void);
 
-void
+void print_string(char *s);
-print_string(char *s);
 
-void
+void test_bswap(void);
-test_bswap(void);
-
-int
-main (void) {
 
+int main(void)
+{
     /*
      * this program includes various and sundry tests for fundamental
      * datatypes.  it's a grab-bag of throwaway code, retained only in
@@ -76,8 +70,7 @@ main (void) {
 
     int i, j;
     v128_t x;
-  char *r = 
+    char *r = "The Moving Finger writes; and, having writ,\n"
-    "The Moving Finger writes; and, having writ,\n"
               "Moves on: nor all thy Piety nor Wit\n"
               "Shall lure it back to cancel half a Line,\n"
               "Nor all thy Tears wash out a Word of it.";
@@ -96,7 +89,6 @@ main (void) {
         printf("%s\n", v128_bit_string(&x));
         v128_clear_bit(&x, j);
         printf("%s\n", v128_bit_string(&x));
-    
     }
 
     printf("----------------------------------------------\n");
@@ -147,11 +139,10 @@ main (void) {
     return 0;
 }
 
-
 /* byte_order() prints out byte ordering of datatypes */
 
-void
+void byte_order(void)
-byte_order(void) {
+{
     int i;
     v128_t e;
 #if 0
@@ -186,11 +177,10 @@ byte_order(void) {
     for (i = 0; i < sizeof(e); i++)
         e.v8[i] = i;
     printf("v128_t: %s\n", v128_hex_string(&e));
-  
 }
 
-void
+void test_hex_string_funcs(void)
-test_hex_string_funcs(void) {
+{
     char hex1[] = "abadcafe";
     char hex2[] = "0123456789abcdefqqqqq";
     char raw[10];
@@ -205,11 +195,10 @@ test_hex_string_funcs(void) {
     printf("computed length: %d\tstring: %s\n", len,
            octet_string_hex_string(raw, len / 2));
     printf("expected length: %d\tstring: %s\n", 16, "0123456789abcdef");
-
 }
 
-void
+void print_string(char *s)
-print_string(char *s) {
+{
     size_t i;
     printf("%s\n", s);
     printf("strlen(s) = %u\n", (unsigned)strlen(s));
@@ -222,8 +211,8 @@ print_string(char *s) {
     printf("}\n");
 }
 
-void
+void test_bswap(void)
-test_bswap(void) {
+{
     uint32_t x = 0x11223344;
     uint64_t y = 0x1122334455667788LL;
 
@@ -234,8 +223,7 @@ test_bswap(void) {
     y = 1234;
 
     printf("1234: %0llx\n", (unsigned long long)y);
-  printf("as octet string: %s\n", 
+    printf("as octet string: %s\n", octet_string_hex_string((uint8_t *)&y, 8));
-	 octet_string_hex_string((uint8_t *) &y, 8));
     y = be64_to_cpu(y);
     printf("bswapped octet string: %s\n",
            octet_string_hex_string((uint8_t *)&y, 8));

libs/srtp/crypto/test/env.c

@@ -46,8 +46,8 @@
 #include <string.h> /* for srtcmp() */
 #include "config.h"
 
-int 
+int main(void)
-main(void) {
+{
     int err_count = 0;
 
 #ifdef WORDS_BIGENDIAN
@@ -61,7 +61,8 @@ main(void) {
 #elif defined(CPU_CISC)
     printf("CPU set to CISC\t\t\t\t(CPU_CISC == 1)\n");
 #else
-  printf("CPU set to an unknown type, probably due to a configuration error\n");
+    printf(
+        "CPU set to an unknown type, probably due to a configuration error\n");
     err_count++;
 #endif
 
@@ -81,7 +82,8 @@ main(void) {
 
     if (err_count)
         printf("warning: configuration is probably in error "
-	   "(found %d problems)\n", err_count);
+               "(found %d problems)\n",
+               err_count);
 
     return err_count;
 }

libs/srtp/crypto/test/kernel_driver.c

@@ -42,7 +42,6 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -51,14 +50,14 @@
 #include "getopt_s.h"
 #include "crypto_kernel.h"
 
-void
+void usage(char *prog_name)
-usage(char *prog_name) {
+{
     printf("usage: %s [ -v ][ -d debug_module ]*\n", prog_name);
     exit(255);
 }
 
-int
+int main(int argc, char *argv[])
-main (int argc, char *argv[]) {
+{
     int q;
     int do_validation = 0;
     srtp_err_status_t status;
@@ -120,9 +119,8 @@ main (int argc, char *argv[]) {
  * of the crypto_kernel
  */
 
-srtp_err_status_t
+srtp_err_status_t crypto_kernel_cipher_test(void)
-crypto_kernel_cipher_test(void) {
+{
-
     /* not implemented yet! */
 
     return srtp_err_status_ok;

libs/srtp/crypto/test/sha1_driver.c

@@ -68,12 +68,12 @@ typedef struct hash_test_case_t {
 
 hash_test_case_t *sha1_test_case_list;
 
-srtp_err_status_t
+srtp_err_status_t hash_test_case_add(hash_test_case_t **list_ptr,
-hash_test_case_add(hash_test_case_t **list_ptr, 
                                      char *hex_data,
                                      unsigned data_len,
                                      char *hex_hash,
-		   unsigned hash_len) {
+                                     unsigned hash_len)
+{
     hash_test_case_t *list_head = *list_ptr;
     hash_test_case_t *test_case;
     unsigned tmp_len;
@@ -82,13 +82,15 @@ hash_test_case_add(hash_test_case_t **list_ptr,
     if (test_case == NULL)
         return srtp_err_status_alloc_fail;
 
-  tmp_len = hex_string_to_octet_string((char *)test_case->data, hex_data, data_len*2);
+    tmp_len = hex_string_to_octet_string((char *)test_case->data, hex_data,
+                                         data_len * 2);
     if (tmp_len != data_len * 2) {
         free(test_case);
         return srtp_err_status_parse_err;
     }
 
-  tmp_len = hex_string_to_octet_string((char *)test_case->hash, hex_hash, hash_len*2);
+    tmp_len = hex_string_to_octet_string((char *)test_case->hash, hex_hash,
+                                         hash_len * 2);
     if (tmp_len != hash_len * 2) {
         free(test_case);
         return srtp_err_status_parse_err;
@@ -104,8 +106,8 @@ hash_test_case_add(hash_test_case_t **list_ptr,
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t sha1_test_case_validate(const hash_test_case_t *test_case)
-sha1_test_case_validate(const hash_test_case_t *test_case) {
+{
     srtp_sha1_ctx_t ctx;
     uint32_t hash_value[5];
 
@@ -136,7 +138,6 @@ sha1_test_case_validate(const hash_test_case_t *test_case) {
            octet_string_hex_string((const uint8_t *)hash_value, 20));
 
     return srtp_err_status_algo_fail;
-  
 }
 
 struct hex_sha1_test_case_t {
@@ -145,8 +146,8 @@ struct hex_sha1_test_case_t {
     char hex_hash[40];
 };
 
-srtp_err_status_t
+srtp_err_status_t sha1_add_test_cases(void)
-sha1_add_test_cases(void) {
+{
     int i;
     srtp_err_status_t err;
 
@@ -156,336 +157,167 @@ sha1_add_test_cases(void) {
      */
 
     struct hex_sha1_test_case_t tc[] = {
-    { 
+        { 0, "", "da39a3ee5e6b4b0d3255bfef95601890afd80709" },
-      0,
+        { 8, "a8", "99f2aa95e36f95c2acb0eaf23998f030638f3f15" },
-      "",
+        { 16, "3000", "f944dcd635f9801f7ac90a407fbc479964dec024" },
-      "da39a3ee5e6b4b0d3255bfef95601890afd80709"
+        { 24, "42749e", "a444319e9b6cc1e8464c511ec0969c37d6bb2619" },
-    },
+        { 32, "9fc3fe08", "16a0ff84fcc156fd5d3ca3a744f20a232d172253" },
-    {
+        { 40, "b5c1c6f1af", "fec9deebfcdedaf66dda525e1be43597a73a1f93" },
-      8,
+        { 48, "e47571e5022e", "8ce051181f0ed5e9d0c498f6bc4caf448d20deb5" },
-      "a8",
+        { 56, "3e1b28839fb758", "67da53837d89e03bf652ef09c369a3415937cfd3" },
-      "99f2aa95e36f95c2acb0eaf23998f030638f3f15"
+        { 64, "a81350cbb224cb90", "305e4ff9888ad855a78573cddf4c5640cce7e946" },
-    }, 
+        { 72, "c243d167923dec3ce1",
-    {
+          "5902b77b3265f023f9bbc396ba1a93fa3509bde7" },
-      16, 
+        { 80, "50ac18c59d6a37a29bf4",
-      "3000",
+          "fcade5f5d156bf6f9af97bdfa9c19bccfb4ff6ab" },
-      "f944dcd635f9801f7ac90a407fbc479964dec024"
+        { 88, "98e2b611ad3b1cccf634f6",
-    }, 
+          "1d20fbe00533c10e3cbd6b27088a5de0c632c4b5" },
-    {
+        { 96, "73fe9afb68e1e8712e5d4eec",
-      24, 
+          "7e1b7e0f7a8f3455a9c03e9580fd63ae205a2d93" },
-      "42749e", 
+        { 104, "9e701ed7d412a9226a2a130e66",
-      "a444319e9b6cc1e8464c511ec0969c37d6bb2619"
+          "706f0677146307b20bb0e8d6311e329966884d13" },
-    }, 
+        { 112, "6d3ee90413b0a7cbf69e5e6144ca",
-    {
+          "a7241a703aaf0d53fe142f86bf2e849251fa8dff" },
-      32, 
+        { 120, "fae24d56514efcb530fd4802f5e71f",
-      "9fc3fe08", 
+          "400f53546916d33ad01a5e6df66822dfbdc4e9e6" },
-      "16a0ff84fcc156fd5d3ca3a744f20a232d172253"
+        { 128, "c5a22dd6eda3fe2bdc4ddb3ce6b35fd1",
-    }, 
+          "fac8ab93c1ae6c16f0311872b984f729dc928ccd" },
-    {
+        { 136, "d98cded2adabf08fda356445c781802d95",
-      40, 
+          "fba6d750c18da58f6e2aab10112b9a5ef3301b3b" },
-      "b5c1c6f1af",
+        { 144, "bcc6d7087a84f00103ccb32e5f5487a751a2",
-      "fec9deebfcdedaf66dda525e1be43597a73a1f93"
+          "29d27c2d44c205c8107f0351b05753ac708226b6" },
-    },
+        { 152, "36ecacb1055434190dbbc556c48bafcb0feb0d",
-    {
+          "b971bfc1ebd6f359e8d74cb7ecfe7f898d0ba845" },
-      48, 
+        { 160, "5ff9edb69e8f6bbd498eb4537580b7fba7ad31d0",
-      "e47571e5022e",
+          "96d08c430094b9fcc164ad2fb6f72d0a24268f68" },
-      "8ce051181f0ed5e9d0c498f6bc4caf448d20deb5"
+        { 168, "c95b441d8270822a46a798fae5defcf7b26abace36",
-    }, 
+          "a287ea752a593d5209e287881a09c49fa3f0beb1" },
-    {
+        { 176, "83104c1d8a55b28f906f1b72cb53f68cbb097b44f860",
-      56, 
+          "a06c713779cbd88519ed4a585ac0cb8a5e9d612b" },
-      "3e1b28839fb758",
+        { 184, "755175528d55c39c56493d697b790f099a5ce741f7754b",
-      "67da53837d89e03bf652ef09c369a3415937cfd3"
+          "bff7d52c13a3688132a1d407b1ab40f5b5ace298" },
-    },
+        { 192, "088fc38128bbdb9fd7d65228b3184b3faac6c8715f07272f",
-    {
+          "c7566b91d7b6f56bdfcaa9781a7b6841aacb17e9" },
-      64, 
+        { 200, "a4a586eb9245a6c87e3adf1009ac8a49f46c07e14185016895",
-      "a81350cbb224cb90",
+          "ffa30c0b5c550ea4b1e34f8a60ec9295a1e06ac1" },
-      "305e4ff9888ad855a78573cddf4c5640cce7e946"
+        { 208, "8e7c555270c006092c2a3189e2a526b873e2e269f0fb28245256",
-    }, 
+          "29e66ed23e914351e872aa761df6e4f1a07f4b81" },
-    {
+        { 216, "a5f3bfa6bb0ba3b59f6b9cbdef8a558ec565e8aa3121f405e7f2f0",
-      72, "c243d167923dec3ce1",
+          "b28cf5e5b806a01491d41f69bd9248765c5dc292" },
-      "5902b77b3265f023f9bbc396ba1a93fa3509bde7"
+        { 224, "589054f0d2bd3c2c85b466bfd8ce18e6ec3e0b87d944cd093ba36469",
-    },
+          "60224fb72c46069652cd78bcd08029ef64da62f3" },
-    {
+        { 232, "a0abb12083b5bbc78128601bf1cbdbc0fdf4b862b24d899953d8da0ff3",
-      80, 
+          "b72c4a86f72608f24c05f3b9088ef92fba431df7" },
-      "50ac18c59d6a37a29bf4",
+        { 240, "82143f4cea6fadbf998e128a8811dc75301cf1db4f079501ea568da68eeb",
-      "fcade5f5d156bf6f9af97bdfa9c19bccfb4ff6ab"
+          "73779ad5d6b71b9b8328ef7220ff12eb167076ac" },
-    }, 
+        { 248, "9f1231dd6df1ff7bc0b0d4f989d048672683ce35d956d2f57913046267e6f3",
-    {
+          "a09671d4452d7cf50015c914a1e31973d20cc1a0" },
-      88, 
+        { 256,
-      "98e2b611ad3b1cccf634f6",
-      "1d20fbe00533c10e3cbd6b27088a5de0c632c4b5"
-    },
-    {
-      96, 
-      "73fe9afb68e1e8712e5d4eec",
-      "7e1b7e0f7a8f3455a9c03e9580fd63ae205a2d93"
-    }, 
-    {
-      104, 
-      "9e701ed7d412a9226a2a130e66",
-      "706f0677146307b20bb0e8d6311e329966884d13"
-    }, 
-    {
-      112, 
-      "6d3ee90413b0a7cbf69e5e6144ca",
-      "a7241a703aaf0d53fe142f86bf2e849251fa8dff"
-    }, 
-    {
-      120, 
-      "fae24d56514efcb530fd4802f5e71f",
-      "400f53546916d33ad01a5e6df66822dfbdc4e9e6"
-    }, 
-    {
-      128, 
-      "c5a22dd6eda3fe2bdc4ddb3ce6b35fd1",
-      "fac8ab93c1ae6c16f0311872b984f729dc928ccd"
-    }, 
-    {
-      136, 
-      "d98cded2adabf08fda356445c781802d95",
-      "fba6d750c18da58f6e2aab10112b9a5ef3301b3b"
-    }, 
-    {
-      144, 
-      "bcc6d7087a84f00103ccb32e5f5487a751a2",
-      "29d27c2d44c205c8107f0351b05753ac708226b6"
-    }, 
-    {
-      152, 
-      "36ecacb1055434190dbbc556c48bafcb0feb0d",
-      "b971bfc1ebd6f359e8d74cb7ecfe7f898d0ba845"
-    }, 
-    {
-      160, 
-      "5ff9edb69e8f6bbd498eb4537580b7fba7ad31d0",
-      "96d08c430094b9fcc164ad2fb6f72d0a24268f68"
-    },
-    {
-      168, "c95b441d8270822a46a798fae5defcf7b26abace36",
-      "a287ea752a593d5209e287881a09c49fa3f0beb1"
-    }, 
-    {
-      176, 
-      "83104c1d8a55b28f906f1b72cb53f68cbb097b44f860",
-      "a06c713779cbd88519ed4a585ac0cb8a5e9d612b"
-    }, 
-    {
-      184,
-      "755175528d55c39c56493d697b790f099a5ce741f7754b",
-      "bff7d52c13a3688132a1d407b1ab40f5b5ace298"
-    }, 
-    {
-      192,
-      "088fc38128bbdb9fd7d65228b3184b3faac6c8715f07272f",
-      "c7566b91d7b6f56bdfcaa9781a7b6841aacb17e9"
-    }, 
-    {
-      200,
-      "a4a586eb9245a6c87e3adf1009ac8a49f46c07e14185016895",
-      "ffa30c0b5c550ea4b1e34f8a60ec9295a1e06ac1"
-    }, 
-    {
-      208, 
-      "8e7c555270c006092c2a3189e2a526b873e2e269f0fb28245256",
-      "29e66ed23e914351e872aa761df6e4f1a07f4b81"
-    }, 
-    {
-      216, 
-      "a5f3bfa6bb0ba3b59f6b9cbdef8a558ec565e8aa3121f405e7f2f0",
-      "b28cf5e5b806a01491d41f69bd9248765c5dc292"
-    }, 
-    {
-      224,
-      "589054f0d2bd3c2c85b466bfd8ce18e6ec3e0b87d944cd093ba36469",
-      "60224fb72c46069652cd78bcd08029ef64da62f3"
-    }, 
-    {
-      232,
-      "a0abb12083b5bbc78128601bf1cbdbc0fdf4b862b24d899953d8da0ff3",
-      "b72c4a86f72608f24c05f3b9088ef92fba431df7"
-    }, 
-    {
-      240,
-      "82143f4cea6fadbf998e128a8811dc75301cf1db4f079501ea568da68eeb",
-      "73779ad5d6b71b9b8328ef7220ff12eb167076ac"
-    },
-    {
-      248,
-      "9f1231dd6df1ff7bc0b0d4f989d048672683ce35d956d2f57913046267e6f3",
-      "a09671d4452d7cf50015c914a1e31973d20cc1a0"
-    }, 
-    {
-      256, 
           "041c512b5eed791f80d3282f3a28df263bb1df95e1239a7650e5670fc2187919",
-      "e88cdcd233d99184a6fd260b8fca1b7f7687aee0"
+          "e88cdcd233d99184a6fd260b8fca1b7f7687aee0" },
-    }, 
+        { 264,
-    {
-      264,
           "17e81f6ae8c2e5579d69dafa6e070e7111461552d314b691e7a3e7a4feb3fae418",
-      "010def22850deb1168d525e8c84c28116cb8a269"
+          "010def22850deb1168d525e8c84c28116cb8a269" },
-    },
+        { 272, "d15976b23a1d712ad28fad04d805f572026b54dd64961fda94d5355a0cc9862"
-    {
+               "0cf77",
-      272, 
+          "aeaa40ba1717ed5439b1e6ea901b294ba500f9ad" },
-      "d15976b23a1d712ad28fad04d805f572026b54dd64961fda94d5355a0cc98620cf77",
+        { 280, "09fce4d434f6bd32a44e04b848ff50ec9f642a8a85b37a264dc73f130f22838"
-      "aeaa40ba1717ed5439b1e6ea901b294ba500f9ad"
+               "443328f",
-    }, 
+          "c6433791238795e34f080a5f1f1723f065463ca0" },
-    {
+        { 288, "f17af27d776ec82a257d8d46d2b46b639462c56984cc1be9c1222eadb8b2659"
-      280, 
+               "4a25c709d",
-      "09fce4d434f6bd32a44e04b848ff50ec9f642a8a85b37a264dc73f130f22838443328f",
+          "e21e22b89c1bb944a32932e6b2a2f20d491982c3" },
-      "c6433791238795e34f080a5f1f1723f065463ca0"
+        { 296, "b13ce635d6f8758143ffb114f2f601cb20b6276951416a2f94fbf4ad081779d"
-    }, 
+               "79f4f195b22",
-    {
+          "575323a9661f5d28387964d2ba6ab92c17d05a8a" },
-      288, "f17af27d776ec82a257d8d46d2b46b639462c56984cc1be9c1222eadb8b26594a25c709d",
+        { 304, "5498793f60916ff1c918dde572cdea76da8629ba4ead6d065de3dfb48de94d2"
-      "e21e22b89c1bb944a32932e6b2a2f20d491982c3"
+               "34cc1c5002910",
-    }, 
+          "feb44494af72f245bfe68e86c4d7986d57c11db7" },
-    {
+        { 312, "498a1e0b39fa49582ae688cd715c86fbaf8a81b8b11b4d1594c49c902d197c8"
-      296, 
+               "ba8a621fd6e3be5",
-      "b13ce635d6f8758143ffb114f2f601cb20b6276951416a2f94fbf4ad081779d79f4f195b22",
+          "cff2290b3648ba2831b98dde436a72f9ebf51eee" },
-      "575323a9661f5d28387964d2ba6ab92c17d05a8a"
+        { 320, "3a36ae71521f9af628b3e34dcb0d4513f84c78ee49f10416a98857150b8b15c"
-    },
+               "b5c83afb4b570376e",
-    {
+          "9b4efe9d27b965905b0c3dab67b8d7c9ebacd56c" },
-      304,
+        { 328, "dcc76b40ae0ea3ba253e92ac50fcde791662c5b6c948538cffc2d95e9de99ca"
-      "5498793f60916ff1c918dde572cdea76da8629ba4ead6d065de3dfb48de94d234cc1c5002910",
+               "c34dfca38910db2678f",
-      "feb44494af72f245bfe68e86c4d7986d57c11db7"
+          "afedb0ff156205bcd831cbdbda43db8b0588c113" },
-    },
+        { 336, "5b5ec6ec4fd3ad9c4906f65c747fd4233c11a1736b6b228b92e90cddabb0c7c"
-    {
+               "2fcf9716d3fad261dff33",
-      312,
+          "8deb1e858f88293a5e5e4d521a34b2a4efa70fc4" },
-      "498a1e0b39fa49582ae688cd715c86fbaf8a81b8b11b4d1594c49c902d197c8ba8a621fd6e3be5",
+        { 344, "df48a37b29b1d6de4e94717d60cdb4293fcf170bba388bddf7a9035a15d433f"
-      "cff2290b3648ba2831b98dde436a72f9ebf51eee"
+               "20fd697c3e4c8b8c5f590ab",
-    }, 
+          "95cbdac0f74afa69cebd0e5c7defbc6faf0cbeaf" },
-    {
+        { 352, "1f179b3b82250a65e1b0aee949e218e2f45c7a8dbfd6ba08de05c55acfc226b"
-      320,
+               "48c68d7f7057e5675cd96fcfc",
-      "3a36ae71521f9af628b3e34dcb0d4513f84c78ee49f10416a98857150b8b15cb5c83afb4b570376e",
+          "f0307bcb92842e5ae0cd4f4f14f3df7f877fbef2" },
-      "9b4efe9d27b965905b0c3dab67b8d7c9ebacd56c"
+        { 360, "ee3d72da3a44d971578972a8e6780ce64941267e0f7d0179b214fa97855e179"
-    }, 
+               "0e888e09fbe3a70412176cb3b54",
-    {
+          "7b13bb0dbf14964bd63b133ac85e22100542ef55" },
-      328,
+        { 368, "d4d4c7843d312b30f610b3682254c8be96d5f6684503f8fbfbcd15774fc1b08"
-      "dcc76b40ae0ea3ba253e92ac50fcde791662c5b6c948538cffc2d95e9de99cac34dfca38910db2678f",
+               "4d3741afb8d24aaa8ab9c104f7258",
-      "afedb0ff156205bcd831cbdbda43db8b0588c113"
+          "c314d2b6cf439be678d2a74e890d96cfac1c02ed" },
-    }, 
+        { 376, "32c094944f5936a190a0877fb9178a7bf60ceae36fd530671c5b38c5dbd5e6a"
-    {
+               "6c0d615c2ac8ad04b213cc589541cf6",
-      336,
+          "4d0be361e410b47a9d67d8ce0bb6a8e01c53c078" },
-      "5b5ec6ec4fd3ad9c4906f65c747fd4233c11a1736b6b228b92e90cddabb0c7c2fcf9716d3fad261dff33",
+        { 384, "e5d3180c14bf27a5409fa12b104a8fd7e9639609bfde6ee82bbf9648be2546d"
-      "8deb1e858f88293a5e5e4d521a34b2a4efa70fc4"
+               "29688a65e2e3f3da47a45ac14343c9c02",
-    }, 
+          "e5353431ffae097f675cbf498869f6fbb6e1c9f2" },
-    {
+        { 392, "e7b6e4b69f724327e41e1188a37f4fe38b1dba19cbf5a7311d6e32f1038e97a"
-      344,
+               "b506ee05aebebc1eed09fc0e357109818b9",
-      "df48a37b29b1d6de4e94717d60cdb4293fcf170bba388bddf7a9035a15d433f20fd697c3e4c8b8c5f590ab",
+          "b8720a7068a085c018ab18961de2765aa6cd9ac4" },
-      "95cbdac0f74afa69cebd0e5c7defbc6faf0cbeaf"
+        { 400, "bc880cb83b8ac68ef2fedc2da95e7677ce2aa18b0e2d8b322701f67af7d5e7a"
-    }, 
+               "0d96e9e33326ccb7747cfff0852b961bfd475",
-    {
+          "b0732181568543ba85f2b6da602b4b065d9931aa" },
-      352, 
+        { 408, "235ea9c2ba7af25400f2e98a47a291b0bccdaad63faa2475721fda5510cc7da"
-      "1f179b3b82250a65e1b0aee949e218e2f45c7a8dbfd6ba08de05c55acfc226b48c68d7f7057e5675cd96fcfc",
+               "d814bce8dabb611790a6abe56030b798b75c944",
-      "f0307bcb92842e5ae0cd4f4f14f3df7f877fbef2"
+          "9c22674cf3222c3ba921672694aafee4ce67b96b" },
-    }, 
+        { 416, "07e3e29fed63104b8410f323b975fd9fba53f636af8c4e68a53fb202ca35dd9"
-    {
+               "ee07cb169ec5186292e44c27e5696a967f5e67709",
-      360,
+          "d128335f4cecca9066cdae08958ce656ff0b4cfc" },
-      "ee3d72da3a44d971578972a8e6780ce64941267e0f7d0179b214fa97855e1790e888e09fbe3a70412176cb3b54",
+        { 424, "65d2a1dd60a517eb27bfbf530cf6a5458f9d5f4730058bd9814379547f34241"
-      "7b13bb0dbf14964bd63b133ac85e22100542ef55"
+               "822bf67e6335a6d8b5ed06abf8841884c636a25733f",
-    }, 
+          "0b67c57ac578de88a2ae055caeaec8bb9b0085a0" },
-    {
+        { 432, "dcc86b3bd461615bab739d8daafac231c0f462e819ad29f9f14058f3ab5b759"
-      368,
+               "41d4241ea2f17ebb8a458831b37a9b16dead4a76a9b0e",
-      "d4d4c7843d312b30f610b3682254c8be96d5f6684503f8fbfbcd15774fc1b084d3741afb8d24aaa8ab9c104f7258",
+          "c766f912a89d4ccda88e0cce6a713ef5f178b596" },
-      "c314d2b6cf439be678d2a74e890d96cfac1c02ed"
+        { 440, "4627d54f0568dc126b62a8c35fb46a9ac5024400f2995e51635636e1afc4373"
-    }, 
+               "dbb848eb32df23914230560b82477e9c3572647a7f2bb92",
-    {
+          "9aa3925a9dcb177b15ccff9b78e70cf344858779" },
-      376, 
+        { 448, "ba531affd4381168ef24d8b275a84d9254c7f5cc55fded53aa8024b2c5c5c8a"
-      "32c094944f5936a190a0877fb9178a7bf60ceae36fd530671c5b38c5dbd5e6a6c0d615c2ac8ad04b213cc589541cf6",
+               "a7146fe1d1b83d62b70467e9a2e2cb67b3361830adbab28d7",
-      "4d0be361e410b47a9d67d8ce0bb6a8e01c53c078"
+          "4811fa30042fc076acf37c8e2274d025307e5943" },
-    }, 
+        { 456, "8764dcbcf89dcf4282eb644e3d568bdccb4b13508bfa7bfe0ffc05efd1390be"
-    {
+               "22109969262992d377691eb4f77f3d59ea8466a74abf57b2ef4",
-      384,
+          "6743018450c9730761ee2b130df9b91c1e118150" },
-      "e5d3180c14bf27a5409fa12b104a8fd7e9639609bfde6ee82bbf9648be2546d29688a65e2e3f3da47a45ac14343c9c02",
+        { 464, "497d9df9ddb554f3d17870b1a31986c1be277bc44feff713544217a9f579623"
-      "e5353431ffae097f675cbf498869f6fbb6e1c9f2"
+               "d18b5ffae306c25a45521d2759a72c0459b58957255ab592f3be4",
-    },
+          "71ad4a19d37d92a5e6ef3694ddbeb5aa61ada645" },
-    {
+        { 472, "72c3c2e065aefa8d9f7a65229e818176eef05da83f835107ba90ec2e95472e7"
-      392, 
+               "3e538f783b416c04654ba8909f26a12db6e5c4e376b7615e4a25819",
-      "e7b6e4b69f724327e41e1188a37f4fe38b1dba19cbf5a7311d6e32f1038e97ab506ee05aebebc1eed09fc0e357109818b9",
+          "a7d9dc68dacefb7d6116186048cb355cc548e11d" },
-      "b8720a7068a085c018ab18961de2765aa6cd9ac4"
+        { 480, "7cc9894454d0055ab5069a33984e2f712bef7e3124960d33559f5f3b81906bb"
-    }, 
+               "66fe64da13c153ca7f5cabc89667314c32c01036d12ecaf5f9a78de98",
-    {
+          "142e429f0522ba5abf5131fa81df82d355b96909" },
-      400,
+        { 488, "74e8404d5a453c5f4d306f2cfa338ca65501c840ddab3fb82117933483afd69"
-      "bc880cb83b8ac68ef2fedc2da95e7677ce2aa18b0e2d8b322701f67af7d5e7a0d96e9e33326ccb7747cfff0852b961bfd475",
+               "13c56aaf8a0a0a6b2a342fc3d9dc7599f4a850dfa15d06c61966d74ea59",
-      "b0732181568543ba85f2b6da602b4b065d9931aa"
+          "ef72db70dcbcab991e9637976c6faf00d22caae9" },
-    }, 
+        { 496, "46fe5ed326c8fe376fcc92dc9e2714e2240d3253b105adfbb256ff7a19bc409"
-    {
+               "75c604ad7c0071c4fd78a7cb64786e1bece548fa4833c04065fe593f6fb10",
-      408,
+          "f220a7457f4588d639dc21407c942e9843f8e26b" },
-      "235ea9c2ba7af25400f2e98a47a291b0bccdaad63faa2475721fda5510cc7dad814bce8dabb611790a6abe56030b798b75c944",
+        { 504, "836dfa2524d621cf07c3d2908835de859e549d35030433c796b81272fd8bc03"
-      "9c22674cf3222c3ba921672694aafee4ce67b96b"
+               "48e8ddbc7705a5ad1fdf2155b6bc48884ac0cd376925f069a37849c089c864"
-    }, 
+               "5",
-    {
+          "ddd2117b6e309c233ede85f962a0c2fc215e5c69" },
-      416, 
+        { 512, "7e3a4c325cb9c52b88387f93d01ae86d42098f5efa7f9457388b5e74b6d28b2"
-      "07e3e29fed63104b8410f323b975fd9fba53f636af8c4e68a53fb202ca35dd9ee07cb169ec5186292e44c27e5696a967f5e67709",
+               "438d42d8b64703324d4aa25ab6aad153ae30cd2b2af4d5e5c00a8a2d0220c61"
-      "d128335f4cecca9066cdae08958ce656ff0b4cfc"
+               "16",
-    }, 
+          "a3054427cdb13f164a610b348702724c808a0dcc" }
-    {
-      424, 
-      "65d2a1dd60a517eb27bfbf530cf6a5458f9d5f4730058bd9814379547f34241822bf67e6335a6d8b5ed06abf8841884c636a25733f",
-      "0b67c57ac578de88a2ae055caeaec8bb9b0085a0"
-    },
-    {
-      432,
-      "dcc86b3bd461615bab739d8daafac231c0f462e819ad29f9f14058f3ab5b75941d4241ea2f17ebb8a458831b37a9b16dead4a76a9b0e",
-      "c766f912a89d4ccda88e0cce6a713ef5f178b596"
-    }, 
-    {
-      440,
-      "4627d54f0568dc126b62a8c35fb46a9ac5024400f2995e51635636e1afc4373dbb848eb32df23914230560b82477e9c3572647a7f2bb92",
-      "9aa3925a9dcb177b15ccff9b78e70cf344858779"
-    }, 
-    {
-      448,
-      "ba531affd4381168ef24d8b275a84d9254c7f5cc55fded53aa8024b2c5c5c8aa7146fe1d1b83d62b70467e9a2e2cb67b3361830adbab28d7",
-      "4811fa30042fc076acf37c8e2274d025307e5943"
-    }, 
-    {
-      456,
-      "8764dcbcf89dcf4282eb644e3d568bdccb4b13508bfa7bfe0ffc05efd1390be22109969262992d377691eb4f77f3d59ea8466a74abf57b2ef4",
-      "6743018450c9730761ee2b130df9b91c1e118150"
-    }, 
-    {
-      464,
-      "497d9df9ddb554f3d17870b1a31986c1be277bc44feff713544217a9f579623d18b5ffae306c25a45521d2759a72c0459b58957255ab592f3be4",
-      "71ad4a19d37d92a5e6ef3694ddbeb5aa61ada645"
-    }, 
-    {
-      472, 
-      "72c3c2e065aefa8d9f7a65229e818176eef05da83f835107ba90ec2e95472e73e538f783b416c04654ba8909f26a12db6e5c4e376b7615e4a25819",
-      "a7d9dc68dacefb7d6116186048cb355cc548e11d"
-    }, 
-    {
-      480,
-      "7cc9894454d0055ab5069a33984e2f712bef7e3124960d33559f5f3b81906bb66fe64da13c153ca7f5cabc89667314c32c01036d12ecaf5f9a78de98",
-      "142e429f0522ba5abf5131fa81df82d355b96909"
-    }, 
-    {
-      488,
-      "74e8404d5a453c5f4d306f2cfa338ca65501c840ddab3fb82117933483afd6913c56aaf8a0a0a6b2a342fc3d9dc7599f4a850dfa15d06c61966d74ea59",
-      "ef72db70dcbcab991e9637976c6faf00d22caae9"
-    }, 
-    {
-      496,
-      "46fe5ed326c8fe376fcc92dc9e2714e2240d3253b105adfbb256ff7a19bc40975c604ad7c0071c4fd78a7cb64786e1bece548fa4833c04065fe593f6fb10",
-      "f220a7457f4588d639dc21407c942e9843f8e26b"
-    }, 
-    {
-      504, 
-      "836dfa2524d621cf07c3d2908835de859e549d35030433c796b81272fd8bc0348e8ddbc7705a5ad1fdf2155b6bc48884ac0cd376925f069a37849c089c8645", 
-      "ddd2117b6e309c233ede85f962a0c2fc215e5c69"
-    }, 
-    {
-      512, 
-      "7e3a4c325cb9c52b88387f93d01ae86d42098f5efa7f9457388b5e74b6d28b2438d42d8b64703324d4aa25ab6aad153ae30cd2b2af4d5e5c00a8a2d0220c6116", 
-      "a3054427cdb13f164a610b348702724c808a0dcc"
-    }
     };
 
-
     for (i = 0; i < 65; i++) {
-    err = hash_test_case_add(&sha1_test_case_list, 
+        err = hash_test_case_add(&sha1_test_case_list, tc[i].hex_data,
-			     tc[i].hex_data, 
+                                 tc[i].bit_len / 8, tc[i].hex_hash, 20);
-			     tc[i].bit_len/8, 
-			     tc[i].hex_hash, 20);
         if (err) {
             printf("error adding hash test case (code %d)\n", err);
             return err;
@@ -495,8 +327,8 @@ sha1_add_test_cases(void) {
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t sha1_dealloc_test_cases(void)
-sha1_dealloc_test_cases(void) {
+{
     hash_test_case_t *t, *next;
 
     for (t = sha1_test_case_list; t != NULL; t = next) {
@@ -509,10 +341,8 @@ sha1_dealloc_test_cases(void) {
     return srtp_err_status_ok;
 }
 
-
+srtp_err_status_t sha1_validate(void)
-
+{
-srtp_err_status_t
-sha1_validate(void) {
     hash_test_case_t *test_case;
     srtp_err_status_t err;
 
@@ -540,10 +370,8 @@ sha1_validate(void) {
     return srtp_err_status_ok;
 }
 
-
+int main(void)
-
+{
-int
-main (void) {
     srtp_err_status_t err;
 
     printf("sha1 test driver\n");
@@ -556,5 +384,4 @@ main (void) {
     printf("SHA1 passed validation tests\n");
 
     return 0;
-
 }

libs/srtp/crypto/test/stat_driver.c

@@ -59,19 +59,18 @@ typedef struct {
     void *state;
 } random_source_t;
 
-srtp_err_status_t
+srtp_err_status_t random_source_alloc(void);
-random_source_alloc(void);
 
-void
+void err_check(srtp_err_status_t s)
-err_check(srtp_err_status_t s) {
+{
     if (s) {
         printf("error (code %d)\n", s);
         exit(1);
     }
 }
 
-int
+int main(int argc, char *argv[])
-main (int argc, char *argv[]) {
+{
     uint8_t buffer[2532];
     unsigned int buf_len = 2500;
     int i, j;
@@ -82,6 +81,7 @@ main (int argc, char *argv[]) {
     extern srtp_cipher_type_t srtp_aes_gcm_256_openssl;
 #endif
     srtp_cipher_t *c;
+    /* clang-format off */
     uint8_t key[46] = {
         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
@@ -90,6 +90,7 @@ main (int argc, char *argv[]) {
         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
         0x00, 0x01, 0x02, 0x03, 0x04, 0x05
     };
+    /* clang-format on */
     v128_t nonce;
     int num_trials = 500;
     int num_fail;
@@ -117,7 +118,8 @@ main (int argc, char *argv[]) {
     /* set buffer to cipher output */
     for (i = 0; i < 2500; i++)
         buffer[i] = 0;
-  err_check(srtp_cipher_type_alloc(&srtp_aes_icm_128, &c, SRTP_AES_ICM_128_KEY_LEN_WSALT, 0));
+    err_check(srtp_cipher_type_alloc(&srtp_aes_icm_128, &c,
+                                     SRTP_AES_ICM_128_KEY_LEN_WSALT, 0));
     err_check(srtp_cipher_init(c, key));
     err_check(srtp_cipher_set_iv(c, (uint8_t *)&nonce, srtp_direction_encrypt));
     err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
@@ -134,7 +136,8 @@ main (int argc, char *argv[]) {
         for (i = 0; i < 2500; i++)
             buffer[i] = 0;
         nonce.v32[3] = i;
-    err_check(srtp_cipher_set_iv(c, (uint8_t*)&nonce, srtp_direction_encrypt));
+        err_check(
+            srtp_cipher_set_iv(c, (uint8_t *)&nonce, srtp_direction_encrypt));
         err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
         if (stat_test_runs(buffer)) {
             num_fail++;
@@ -151,7 +154,8 @@ main (int argc, char *argv[]) {
     /* set buffer to cipher output */
     for (i = 0; i < 2500; i++)
         buffer[i] = 0;
-  err_check(srtp_cipher_type_alloc(&srtp_aes_icm_256, &c, SRTP_AES_ICM_256_KEY_LEN_WSALT, 0));
+    err_check(srtp_cipher_type_alloc(&srtp_aes_icm_256, &c,
+                                     SRTP_AES_ICM_256_KEY_LEN_WSALT, 0));
     err_check(srtp_cipher_init(c, key));
     err_check(srtp_cipher_set_iv(c, (uint8_t *)&nonce, srtp_direction_encrypt));
     err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
@@ -168,7 +172,8 @@ main (int argc, char *argv[]) {
         for (i = 0; i < 2500; i++)
             buffer[i] = 0;
         nonce.v32[3] = i;
-    err_check(srtp_cipher_set_iv(c, (uint8_t*)&nonce, srtp_direction_encrypt));
+        err_check(
+            srtp_cipher_set_iv(c, (uint8_t *)&nonce, srtp_direction_encrypt));
         err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
         if (stat_test_runs(buffer)) {
             num_fail++;
@@ -182,9 +187,11 @@ main (int argc, char *argv[]) {
         for (i = 0; i < 2500; i++) {
             buffer[i] = 0;
         }
-    err_check(srtp_cipher_type_alloc(&srtp_aes_gcm_128_openssl, &c, SRTP_AES_GCM_128_KEY_LEN_WSALT, 8));
+        err_check(srtp_cipher_type_alloc(&srtp_aes_gcm_128_openssl, &c,
+                                         SRTP_AES_GCM_128_KEY_LEN_WSALT, 8));
         err_check(srtp_cipher_init(c, key));
-    err_check(srtp_cipher_set_iv(c, (uint8_t*)&nonce, srtp_direction_encrypt));
+        err_check(
+            srtp_cipher_set_iv(c, (uint8_t *)&nonce, srtp_direction_encrypt));
         err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
         /* run tests on cipher outout */
         printf("monobit %d\n", stat_test_monobit(buffer));
@@ -198,7 +205,8 @@ main (int argc, char *argv[]) {
                 buffer[i] = 0;
             }
             nonce.v32[3] = i;
-	err_check(srtp_cipher_set_iv(c, (uint8_t*)&nonce, srtp_direction_encrypt));
+            err_check(srtp_cipher_set_iv(c, (uint8_t *)&nonce,
+                                         srtp_direction_encrypt));
             err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
             buf_len = 2500;
             if (stat_test_runs(buffer)) {
@@ -211,9 +219,11 @@ main (int argc, char *argv[]) {
         for (i = 0; i < 2500; i++) {
             buffer[i] = 0;
         }
-    err_check(srtp_cipher_type_alloc(&srtp_aes_gcm_256_openssl, &c, SRTP_AES_GCM_256_KEY_LEN_WSALT, 16));
+        err_check(srtp_cipher_type_alloc(&srtp_aes_gcm_256_openssl, &c,
+                                         SRTP_AES_GCM_256_KEY_LEN_WSALT, 16));
         err_check(srtp_cipher_init(c, key));
-    err_check(srtp_cipher_set_iv(c, (uint8_t*)&nonce, srtp_direction_encrypt));
+        err_check(
+            srtp_cipher_set_iv(c, (uint8_t *)&nonce, srtp_direction_encrypt));
         err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
         /* run tests on cipher outout */
         printf("monobit %d\n", stat_test_monobit(buffer));
@@ -227,7 +237,8 @@ main (int argc, char *argv[]) {
                 buffer[i] = 0;
             }
             nonce.v32[3] = i;
-	err_check(srtp_cipher_set_iv(c, (uint8_t*)&nonce, srtp_direction_encrypt));
+            err_check(srtp_cipher_set_iv(c, (uint8_t *)&nonce,
+                                         srtp_direction_encrypt));
             err_check(srtp_cipher_encrypt(c, buffer, &buf_len));
             buf_len = 2500;
             if (stat_test_runs(buffer)) {

libs/srtp/format.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+#
+# format.sh
+#
+# run clang-format on each .c & .h file
+#
+# assumes git tree is clean when reporting status
+
+if [ -z "${CLANG_FORMAT}" ]; then
+    CLANG_FORMAT=clang-format
+fi
+
+a=`git ls-files '*.h' '*.c'`
+for x in $a; do
+    if [ $x != "config_in.h" ]; then
+        $CLANG_FORMAT -i -style=file $x
+    fi
+done
+
+m=`git ls-files -m`
+if [ -n "$m" ]; then
+    v=`$CLANG_FORMAT -version`
+    echo "Fromatting required when checking with $v"
+    echo
+    echo "The following files required formatting:"
+    for f in $m; do
+        echo $f
+    done
+    if [ "$1" = "-d" ]; then
+        echo
+        git diff
+    fi
+    exit 1
+fi
+exit 0

libs/srtp/include/ekt.h

@@ -42,8 +42,6 @@
  *
  */
 
-
-
 /*
  * EKT implementation strategy
  *
@@ -76,7 +74,6 @@ extern "C" {
 
 typedef uint16_t srtp_ekt_spi_t;
 
-
 unsigned srtp_ekt_octets_after_base_tag(srtp_ekt_stream_t ekt);
 
 /*
@@ -94,7 +91,6 @@ typedef struct srtp_ekt_policy_ctx_t {
     struct srtp_ekt_policy_ctx_t *next_ekt_policy;
 } srtp_ekt_policy_ctx_t;
 
-
 /*
  * an srtp_ekt_data_t structure holds the data corresponding to an ekt key,
  * spi, and so on
@@ -121,20 +117,26 @@ typedef struct srtp_ekt_stream_ctx_t {
     uint8_t encrypted_master_key[SRTP_MAX_KEY_LEN];
 } srtp_ekt_stream_ctx_t;
 
+srtp_err_status_t srtp_ekt_alloc(srtp_ekt_stream_t *stream_data,
+                                 srtp_ekt_policy_t policy);
 
+srtp_err_status_t srtp_ekt_stream_init(srtp_ekt_stream_t e,
+                                       srtp_ekt_spi_t spi,
+                                       void *ekt_key,
+                                       unsigned ekt_cipher_type);
 
-srtp_err_status_t srtp_ekt_alloc(srtp_ekt_stream_t *stream_data, srtp_ekt_policy_t policy);
+srtp_err_status_t srtp_ekt_stream_init_from_policy(srtp_ekt_stream_t e,
+                                                   srtp_ekt_policy_t p);
 
-srtp_err_status_t srtp_ekt_stream_init(srtp_ekt_stream_t e, srtp_ekt_spi_t spi, void *ekt_key, unsigned ekt_cipher_type);
+srtp_err_status_t srtp_stream_init_from_ekt(srtp_stream_t stream,
+                                            const void *srtcp_hdr,
+                                            unsigned pkt_octet_len);
 
-srtp_err_status_t srtp_ekt_stream_init_from_policy(srtp_ekt_stream_t e, srtp_ekt_policy_t p);
+void srtp_ekt_write_data(srtp_ekt_stream_t ekt,
-  
+                         uint8_t *base_tag,
-
+                         unsigned base_tag_len,
-
+                         int *packet_len,
-srtp_err_status_t srtp_stream_init_from_ekt(srtp_stream_t stream, const void *srtcp_hdr, unsigned pkt_octet_len);
+                         srtp_xtd_seq_num_t pkt_index);
-		
-
-void srtp_ekt_write_data(srtp_ekt_stream_t ekt, uint8_t *base_tag, unsigned base_tag_len, int *packet_len, srtp_xtd_seq_num_t pkt_index);		
 
 /*
  * We handle EKT by performing some additional steps before
@@ -144,10 +146,13 @@ void srtp_ekt_write_data(srtp_ekt_stream_t ekt, uint8_t *base_tag, unsigned base
  * With EKT, the tag_len parameter is actually the base tag
  * length
  */
-srtp_err_status_t srtp_ekt_tag_verification_preproces(uint8_t *pkt_tag, uint8_t *pkt_tag_copy, unsigned tag_len);
+srtp_err_status_t srtp_ekt_tag_verification_preproces(uint8_t *pkt_tag,
-
+                                                      uint8_t *pkt_tag_copy,
-srtp_err_status_t srtp_ekt_tag_verification_postproces(uint8_t *pkt_tag, uint8_t *pkt_tag_copy, unsigned tag_len);
+                                                      unsigned tag_len);
 
+srtp_err_status_t srtp_ekt_tag_verification_postproces(uint8_t *pkt_tag,
+                                                       uint8_t *pkt_tag_copy,
+                                                       unsigned tag_len);
 
 /*
  * @brief EKT pre-processing for srtcp tag generation
@@ -161,12 +166,14 @@ srtp_err_status_t srtp_ekt_tag_verification_postproces(uint8_t *pkt_tag, uint8_t
  * When EKT is not used, this function is a no-op.
  *
  */
-srtp_err_status_t srtp_stream_srtcp_auth_tag_generation_preprocess(const srtp_stream_t *s, uint8_t *pkt_tag, unsigned pkt_octet_len);
+srtp_err_status_t srtp_stream_srtcp_auth_tag_generation_preprocess(
+    const srtp_stream_t *s,
+    uint8_t *pkt_tag,
+    unsigned pkt_octet_len);
 
 /* it's not clear that a tag_generation_postprocess function is needed */
 srtp_err_status_t srtcp_auth_tag_generation_postprocess(void);
 
-
 #ifdef __cplusplus
 }
 #endif

libs/srtp/include/getopt_s.h

@@ -54,8 +54,7 @@ extern "C" {
  * versions of the POSIX standard getopt() interface.
  */
 
-int
+int getopt_s(int argc, char *const argv[], const char *optstring);
-getopt_s(int argc, char * const argv[], const char *optstring);
 
 extern char *optarg_s; /* defined in getopt.c */
 

libs/srtp/include/rtp.h

@@ -1,139 +0,0 @@
-/*
- * rtp.h
- * 
- * rtp interface for srtp reference implementation
- *
- * David A. McGrew
- * Cisco Systems, Inc.
- *
- * data types:
- *
- * rtp_msg_t       an rtp message (the data that goes on the wire)
- * rtp_sender_t    sender side socket and rtp info
- * rtp_receiver_t  receiver side socket and rtp info
- *
- */
-
-/*
- *	
- * Copyright (c) 2001-2006, Cisco Systems, Inc.
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- *   Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * 
- *   Redistributions in binary form must reproduce the above
- *   copyright notice, this list of conditions and the following
- *   disclaimer in the documentation and/or other materials provided
- *   with the distribution.
- * 
- *   Neither the name of the Cisco Systems, Inc. nor the names of its
- *   contributors may be used to endorse or promote products derived
- *   from this software without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-
-#ifndef RTP_H
-#define RTP_H
-
-#ifdef HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#elif defined HAVE_WINSOCK2_H
-# include <winsock2.h>
-#endif
-
-#include "srtp.h"
-
-typedef struct rtp_sender_ctx_t *rtp_sender_t;
-
-typedef struct rtp_receiver_ctx_t *rtp_receiver_t;
-
-int
-rtp_sendto(rtp_sender_t sender, const void* msg, int len);
-
-int
-rtp_recvfrom(rtp_receiver_t receiver, void *msg, int *len);
-
-int
-rtp_receiver_init(rtp_receiver_t rcvr, int sock, 
-		  struct sockaddr_in addr, unsigned int ssrc);
-
-int
-rtp_sender_init(rtp_sender_t sender, int sock, 
-		struct sockaddr_in addr, unsigned int ssrc);
-
-/*
- * srtp_sender_init(...) initializes an rtp_sender_t
- */
-
-int
-srtp_sender_init(rtp_sender_t rtp_ctx,          /* structure to be init'ed */
-		 struct sockaddr_in name,       /* socket name             */
-		 sec_serv_t security_services,  /* sec. servs. to be used  */
-		 unsigned char *input_key       /* master key/salt in hex  */
-		 );
-
-int
-srtp_receiver_init(rtp_receiver_t rtp_ctx,       /* structure to be init'ed */
-		   struct sockaddr_in name, 	 /* socket name             */
-		   sec_serv_t security_services, /* sec. servs. to be used  */
-		   unsigned char *input_key	 /* master key/salt in hex  */
-		   );
-
-
-int
-rtp_sender_init_srtp(rtp_sender_t sender, const srtp_policy_t *policy);
-
-int
-rtp_sender_deinit_srtp(rtp_sender_t sender);
-
-int
-rtp_receiver_init_srtp(rtp_receiver_t sender, const srtp_policy_t *policy);
-
-int
-rtp_receiver_deinit_srtp(rtp_receiver_t sender);
-
-
-rtp_sender_t 
-rtp_sender_alloc(void);
-
-void
-rtp_sender_dealloc(rtp_sender_t rtp_ctx);
-
-rtp_receiver_t 
-rtp_receiver_alloc(void);
-
-void
-rtp_receiver_dealloc(rtp_receiver_t rtp_ctx);
-
-
-/*
- * RTP_HEADER_LEN indicates the size of an RTP header
- */
-#define RTP_HEADER_LEN   12
-
-/* 
- * RTP_MAX_BUF_LEN defines the largest RTP packet in the rtp.c implementation
- */
-#define RTP_MAX_BUF_LEN  16384
-
-
-#endif /* RTP_H */

libs/srtp/include/srtp.h

@@ -42,7 +42,6 @@
  *
  */
 
-
 #ifndef SRTP_SRTP_H
 #define SRTP_SRTP_H
 
@@ -84,7 +83,6 @@ extern "C" {
  */
 #define SRTP_MAX_MKI_LEN 128
 
-
 /**
  * SRTP_MAX_TRAILER_LEN is the maximum length of the SRTP trailer
  * (authentication tag and MKI) supported by libSRTP.  This value is
@@ -103,6 +101,7 @@ extern "C" {
 #define SRTP_MAX_NUM_MASTER_KEYS 16
 
 #define SRTP_SALT_LEN 14
+
 /*
  * SRTP_AEAD_SALT_LEN is the length of the SALT values used with
  * GCM mode.  GCM mode requires an IV.  The SALT value is used
@@ -118,9 +117,12 @@ extern "C" {
 #define SRTP_AES_ICM_192_KEY_LEN_WSALT (SRTP_SALT_LEN + SRTP_AES_192_KEY_LEN)
 #define SRTP_AES_ICM_256_KEY_LEN_WSALT (SRTP_SALT_LEN + SRTP_AES_256_KEY_LEN)
 
-#define SRTP_AES_GCM_128_KEY_LEN_WSALT   (SRTP_AEAD_SALT_LEN + SRTP_AES_128_KEY_LEN)
+#define SRTP_AES_GCM_128_KEY_LEN_WSALT                                         \
-#define SRTP_AES_GCM_192_KEY_LEN_WSALT   (SRTP_AEAD_SALT_LEN + SRTP_AES_192_KEY_LEN)
+    (SRTP_AEAD_SALT_LEN + SRTP_AES_128_KEY_LEN)
-#define SRTP_AES_GCM_256_KEY_LEN_WSALT   (SRTP_AEAD_SALT_LEN + SRTP_AES_256_KEY_LEN)
+#define SRTP_AES_GCM_192_KEY_LEN_WSALT                                         \
+    (SRTP_AEAD_SALT_LEN + SRTP_AES_192_KEY_LEN)
+#define SRTP_AES_GCM_256_KEY_LEN_WSALT                                         \
+    (SRTP_AEAD_SALT_LEN + SRTP_AES_256_KEY_LEN)
 
 /**
  *  @brief A srtp_cipher_type_id_t is an identifier for a particular cipher
@@ -137,7 +139,8 @@ extern "C" {
 typedef uint32_t srtp_cipher_type_id_t;
 
 /**
- *  @brief An srtp_auth_type_id_t is an identifier for a particular authentication
+ *  @brief An srtp_auth_type_id_t is an identifier for a particular
+ * authentication
  *   function.
  *
  *  An srtp_auth_type_id_t is an integer that represents a particular
@@ -165,15 +168,18 @@ typedef enum {
     srtp_err_status_alloc_fail = 3,     /**< couldn't allocate memory        */
     srtp_err_status_dealloc_fail = 4,   /**< couldn't deallocate properly    */
     srtp_err_status_init_fail = 5,      /**< couldn't initialize             */
-  srtp_err_status_terminus     = 6,  /**< can't process as much data as requested */
+    srtp_err_status_terminus = 6,       /**< can't process as much data as   */
+                                        /**< requested                       */
     srtp_err_status_auth_fail = 7,      /**< authentication failure          */
     srtp_err_status_cipher_fail = 8,    /**< cipher failure                  */
     srtp_err_status_replay_fail = 9,    /**< replay check failed (bad index) */
-  srtp_err_status_replay_old   = 10, /**< replay check failed (index too old)     */
+    srtp_err_status_replay_old = 10,    /**< replay check failed (index too  */
+                                        /**< old)                            */
     srtp_err_status_algo_fail = 11,     /**< algorithm failed test routine   */
     srtp_err_status_no_such_op = 12,    /**< unsupported operation           */
     srtp_err_status_no_ctx = 13,        /**< no appropriate context found    */
-  srtp_err_status_cant_check   = 14, /**< unable to perform desired validation    */
+    srtp_err_status_cant_check = 14,    /**< unable to perform desired       */
+                                        /**< validation                      */
     srtp_err_status_key_expired = 15,   /**< can't use key any more          */
     srtp_err_status_socket_err = 16,    /**< error in use of socket          */
     srtp_err_status_signal_err = 17,    /**< error in use POSIX signals      */
@@ -184,12 +190,14 @@ typedef enum {
     srtp_err_status_encode_err = 22,    /**< error encoding data             */
     srtp_err_status_semaphore_err = 23, /**< error while using semaphores    */
     srtp_err_status_pfkey_err = 24,     /**< error while using pfkey         */
-  srtp_err_status_bad_mki      = 25, /**< error MKI present in packet is invalid  */
+    srtp_err_status_bad_mki = 25,       /**< error MKI present in packet is  */
-  srtp_err_status_pkt_idx_old  = 26, /**< packet index is too old to consider     */
+                                        /**< invalid                         */
-  srtp_err_status_pkt_idx_adv  = 27 /**< packet index advanced, reset needed      */
+    srtp_err_status_pkt_idx_old = 26,   /**< packet index is too old to      */
+                                        /**< consider                        */
+    srtp_err_status_pkt_idx_adv = 27    /**< packet index advanced, reset    */
+                                        /**< needed                          */
 } srtp_err_status_t;
 
-
 typedef struct srtp_ctx_t_ srtp_ctx_t;
 
 /**
@@ -199,7 +207,6 @@ typedef struct srtp_ctx_t_ srtp_ctx_t;
  * security services that will be applied by a particular crypto
  * policy (or other mechanism).
  */
-
 typedef enum {
     sec_serv_none = 0,         /**< no services                        */
     sec_serv_conf = 1,         /**< confidentiality                    */
@@ -216,63 +223,58 @@ typedef enum {
  * consists of a list of these policies, one for each SRTP stream
  * in the session.
  */
-
 typedef struct srtp_crypto_policy_t {
-  srtp_cipher_type_id_t cipher_type;    /**< An integer representing
+    srtp_cipher_type_id_t cipher_type; /**< An integer representing          */
-				         *   the type of cipher.  */
+                                       /**< the type of cipher.              */
-  int              cipher_key_len; /**< The length of the cipher key
+    int cipher_key_len;                /**< The length of the cipher key     */
-				    *   in octets.                       */
+                                       /**< in octets.                       */
-  srtp_auth_type_id_t   auth_type;      /**< An integer representing the
+    srtp_auth_type_id_t auth_type;     /**< An integer representing the      */
-				         *   authentication function.         */
+                                       /**< authentication function.         */
-  int              auth_key_len;   /**< The length of the authentication 
+    int auth_key_len;                  /**< The length of the authentication */
-				    *   function key in octets.          */
+                                       /**< function key in octets.          */
-  int              auth_tag_len;   /**< The length of the authentication 
+    int auth_tag_len;                  /**< The length of the authentication */
-				    *   tag in octets.                   */
+                                       /**< tag in octets.                   */
-  srtp_sec_serv_t  sec_serv;       /**< The flag indicating the security
+    srtp_sec_serv_t sec_serv;          /**< The flag indicating the security */
-				    *   services to be applied.          */
+                                       /**< services to be applied.          */
 } srtp_crypto_policy_t;
 
-
 /**
  * @brief srtp_ssrc_type_t describes the type of an SSRC.
  *
  * An srtp_ssrc_type_t enumeration is used to indicate a type of SSRC.  See
  * @ref srtp_policy_t for more informataion.
  */
-
 typedef enum {
     ssrc_undefined = 0,   /**< Indicates an undefined SSRC type.    */
     ssrc_specific = 1,    /**< Indicates a specific SSRC value      */
-  ssrc_any_inbound  = 2, /**< Indicates any inbound SSRC value 
+    ssrc_any_inbound = 2, /**< Indicates any inbound SSRC value     */
-			    (i.e. a value that is used in the
+                          /**< (i.e. a value that is used in the    */
-			    function srtp_unprotect())              */
+                          /**< function srtp_unprotect())           */
-  ssrc_any_outbound = 3  /**< Indicates any outbound SSRC value 
+    ssrc_any_outbound = 3 /**< Indicates any outbound SSRC value    */
-			    (i.e. a value that is used in the 
+                          /**< (i.e. a value that is used in the    */
-			    function srtp_protect())		  */
+                          /**< function srtp_protect())             */
 } srtp_ssrc_type_t;
 
 /**
- * @brief An srtp_ssrc_t represents a particular SSRC value, or a `wildcard' SSRC.
+ * @brief An srtp_ssrc_t represents a particular SSRC value, or a `wildcard'
+ * SSRC.
  *
  * An srtp_ssrc_t represents a particular SSRC value (if its type is
  * ssrc_specific), or a wildcard SSRC value that will match all
  * outbound SSRCs (if its type is ssrc_any_outbound) or all inbound
  * SSRCs (if its type is ssrc_any_inbound).
- *
  */
-
 typedef struct {
     srtp_ssrc_type_t type; /**< The type of this particular SSRC */
-  unsigned int     value; /**< The value of this SSRC, if it is not a wildcard */
+    unsigned int value;    /**< The value of this SSRC, if it is not a */
+                           /**< wildcard */
 } srtp_ssrc_t;
 
-
 /**
  * @brief points to an EKT policy
  */
 typedef struct srtp_ekt_policy_ctx_t *srtp_ekt_policy_t;
 
-
 /**
  * @brief points to EKT stream data
  */
@@ -312,41 +314,38 @@ typedef struct srtp_master_key_t {
  * lapses result from accidental re-use of SSRC values during key
  * sharing.
  *
- * 
  * @warning The final element of the list @b must have its `next' pointer
  *          set to NULL.
  */
 
 typedef struct srtp_policy_t {
-  srtp_ssrc_t   ssrc;        /**< The SSRC value of stream, or the 
+    srtp_ssrc_t ssrc;              /**< The SSRC value of stream, or the    */
-			      *   flags SSRC_ANY_INBOUND or 
+                                   /**< flags SSRC_ANY_INBOUND or           */
-			      *   SSRC_ANY_OUTBOUND if key sharing
+                                   /**< SSRC_ANY_OUTBOUND if key sharing    */
-			      *   is used for this policy element.
+                                   /**< is used for this policy element.    */
-			      */
     srtp_crypto_policy_t rtp;      /**< SRTP crypto policy.                 */
     srtp_crypto_policy_t rtcp;     /**< SRTCP crypto policy.                */
-  unsigned char *key;          /**< Pointer to the SRTP master key for
+    unsigned char *key;            /**< Pointer to the SRTP master key for  */
-                                *    this stream.                        */
+                                   /**< this stream.                        */
     srtp_master_key_t **keys;      /** Array of Master Key structures       */
     unsigned long num_master_keys; /** Number of master keys                */
-  srtp_ekt_policy_t ekt;       /**< Pointer to the EKT policy structure
+    srtp_ekt_policy_t ekt;         /**< Pointer to the EKT policy structure */
-                                *   for this stream (if any)             */ 
+                                   /**< for this stream (if any)            */
-  unsigned long window_size;   /**< The window size to use for replay
+    unsigned long window_size;     /**< The window size to use for replay   */
-				*   protection. */
+                                   /**< protection.                         */
-  int        allow_repeat_tx;  /**< Whether retransmissions of
+    int allow_repeat_tx;           /**< Whether retransmissions of          */
-				*   packets with the same sequence number
+                                   /**< packets with the same sequence      */
-				*   are allowed.  (Note that such repeated
+                                   /**< number are allowed.                 */
-				*   transmissions must have the same RTP
+                                   /**< (Note that such repeated            */
-				*   payload, or a severe security weakness
+                                   /**< transmissions must have the same    */
-				*   is introduced!)                      */
+                                   /**< RTP payload, or a severe security   */
+                                   /**< weakness is introduced!)            */
     int *enc_xtn_hdr;              /**< List of header ids to encrypt.      */
-  int enc_xtn_hdr_count;       /**< Number of entries in list of header ids. */
+    int enc_xtn_hdr_count;         /**< Number of entries in list of header */
+                                   /**<  ids.                               */
     struct srtp_policy_t *next;    /**< Pointer to next stream policy.      */
 } srtp_policy_t;
 
-
-
-
 /**
  * @brief An srtp_t points to an SRTP session structure.
  *
@@ -359,17 +358,14 @@ typedef struct srtp_policy_t {
  * Audio/Video Profile).  A session can be viewed as a set of SRTP
  * streams, each of which originates with a different participant.
  */
-
 typedef srtp_ctx_t *srtp_t;
 
-
 /**
  * @brief srtp_init() initializes the srtp library.
  *
  * @warning This function @b must be called before any other srtp
  * functions.
  */
-
 srtp_err_status_t srtp_init(void);
 
 /**
@@ -377,7 +373,6 @@ srtp_err_status_t srtp_init(void);
  *
  * @warning No srtp functions may be called after calling this function.
  */
-
 srtp_err_status_t srtp_shutdown(void);
 
 /**
@@ -420,7 +415,6 @@ srtp_err_status_t srtp_shutdown(void);
  *    - srtp_err_status_replay_fail   rtp sequence number was non-increasing
  *    - @e other                 failure in cryptographic mechanisms
  */
-
 srtp_err_status_t srtp_protect(srtp_t ctx, void *rtp_hdr, int *len_ptr);
 
 /**
@@ -459,7 +453,8 @@ srtp_err_status_t srtp_protect(srtp_t ctx, void *rtp_hdr, int *len_ptr);
  * Otherwise, the value of the data to which it points is undefined.
  *
  * @param use_mki is a boolean to tell the system if mki is being used.  If
- * set to false then will use the first set of session keys.  If set to true will
+ * set to false then will use the first set of session keys.  If set to true
+ * will
  * use the session keys identified by the mki_index
  *
  * @param mki_index integer value specifying which set of session keys should be
@@ -470,9 +465,10 @@ srtp_err_status_t srtp_protect(srtp_t ctx, void *rtp_hdr, int *len_ptr);
  *    - srtp_err_status_replay_fail   rtp sequence number was non-increasing
  *    - @e other                 failure in cryptographic mechanisms
  */
-
+srtp_err_status_t srtp_protect_mki(srtp_ctx_t *ctx,
-srtp_err_status_t srtp_protect_mki(srtp_ctx_t *ctx, void *rtp_hdr,
+                                   void *rtp_hdr,
-                                   int *pkt_octet_len, unsigned int use_mki,
+                                   int *pkt_octet_len,
+                                   unsigned int use_mki,
                                    unsigned int mki_index);
 
 /**
@@ -510,12 +506,11 @@ srtp_err_status_t srtp_protect_mki(srtp_ctx_t *ctx, void *rtp_hdr,
  *    - srtp_err_status_ok          if the RTP packet is valid.
  *    - srtp_err_status_auth_fail   if the SRTP packet failed the message
  *                                  authentication check.
- *    - srtp_err_status_replay_fail if the SRTP packet is a replay (e.g. packet has
+ *    - srtp_err_status_replay_fail if the SRTP packet is a replay (e.g. packet
- *                             already been processed and accepted).
+ *                                  has already been processed and accepted).
  *    - [other]  if there has been an error in the cryptographic mechanisms.
  *
  */
-
 srtp_err_status_t srtp_unprotect(srtp_t ctx, void *srtp_hdr, int *len_ptr);
 
 /**
@@ -550,21 +545,23 @@ srtp_err_status_t srtp_unprotect(srtp_t ctx, void *srtp_hdr, int *len_ptr);
  * Otherwise, the value of the data to which it points is undefined.
  *
  * @param use_mki is a boolean to tell the system if mki is being used.  If
- * set to false then will use the first set of session keys.  If set to true will
+ * set to false then will use the first set of session keys.  If set to true
+ * will
  * use the session keys identified by the mki_index
  *
  * @return
  *    - srtp_err_status_ok          if the RTP packet is valid.
  *    - srtp_err_status_auth_fail   if the SRTP packet failed the message
  *                                  authentication check.
- *    - srtp_err_status_replay_fail if the SRTP packet is a replay (e.g. packet has
+ *    - srtp_err_status_replay_fail if the SRTP packet is a replay (e.g. packet
- *                             already been processed and accepted).
+ *                                  has already been processed and accepted).
  *    - srtp_err_status_bad_mki if the MKI in the packet is not a known MKI id
  *    - [other]  if there has been an error in the cryptographic mechanisms.
  *
  */
-
+srtp_err_status_t srtp_unprotect_mki(srtp_t ctx,
-srtp_err_status_t srtp_unprotect_mki(srtp_t ctx, void *srtp_hdr, int *len_ptr,
+                                     void *srtp_hdr,
+                                     int *len_ptr,
                                      unsigned int use_mki);
 
 /**
@@ -588,10 +585,8 @@ srtp_err_status_t srtp_unprotect_mki(srtp_t ctx, void *srtp_hdr, int *len_ptr,
  *    - srtp_err_status_alloc_fail   if allocation failed.
  *    - srtp_err_status_init_fail    if initialization failed.
  */
-
 srtp_err_status_t srtp_create(srtp_t *session, const srtp_policy_t *policy);
 
-
 /**
  * @brief srtp_add_stream() allocates and initializes an SRTP stream
  * within a given SRTP session.
@@ -606,10 +601,8 @@ srtp_err_status_t srtp_create(srtp_t *session, const srtp_policy_t *policy);
  *    - srtp_err_status_alloc_fail   if stream allocation failed
  *    - srtp_err_status_init_fail    if stream initialization failed.
  */
-
 srtp_err_status_t srtp_add_stream(srtp_t session, const srtp_policy_t *policy);
 
-
 /**
  * @brief srtp_remove_stream() deallocates an SRTP stream.
  *
@@ -631,7 +624,6 @@ srtp_err_status_t srtp_add_stream(srtp_t session, const srtp_policy_t *policy);
  *    - [other]           otherwise.
  *
  */
-
 srtp_err_status_t srtp_remove_stream(srtp_t session, unsigned int ssrc);
 
 /**
@@ -658,7 +650,6 @@ srtp_err_status_t srtp_remove_stream(srtp_t session, unsigned int ssrc);
  *    - [other]                 otherwise.
  *
  */
-
 srtp_err_status_t srtp_update(srtp_t session, const srtp_policy_t *policy);
 
 /**
@@ -682,8 +673,8 @@ srtp_err_status_t srtp_update(srtp_t session, const srtp_policy_t *policy);
  *    - [other]                      otherwise.
  *
  */
-
+srtp_err_status_t srtp_update_stream(srtp_t session,
-srtp_err_status_t srtp_update_stream(srtp_t session, const srtp_policy_t *policy);
+                                     const srtp_policy_t *policy);
 
 /**
  * @brief srtp_crypto_policy_set_rtp_default() sets a crypto policy
@@ -703,7 +694,6 @@ srtp_err_status_t srtp_update_stream(srtp_t session, const srtp_policy_t *policy
  * @return void.
  *
  */
-
 void srtp_crypto_policy_set_rtp_default(srtp_crypto_policy_t *p);
 
 /**
@@ -724,7 +714,6 @@ void srtp_crypto_policy_set_rtp_default(srtp_crypto_policy_t *p);
  * @return void.
  *
  */
-
 void srtp_crypto_policy_set_rtcp_default(srtp_crypto_policy_t *p);
 
 /**
@@ -741,9 +730,8 @@ void srtp_crypto_policy_set_rtcp_default(srtp_crypto_policy_t *p);
  * @return void.
  *
  */
-
+#define srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(p)                      \
-#define srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(p) srtp_crypto_policy_set_rtp_default(p)
+    srtp_crypto_policy_set_rtp_default(p)
-
 
 /**
  * @brief srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32() sets a crypto
@@ -775,11 +763,8 @@ void srtp_crypto_policy_set_rtcp_default(srtp_crypto_policy_t *p);
  * @return void.
  *
  */
-
 void srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(srtp_crypto_policy_t *p);
 
-
-
 /**
  * @brief srtp_crypto_policy_set_aes_cm_128_null_auth() sets a crypto
  * policy structure to an encryption-only policy
@@ -805,10 +790,8 @@ void srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(srtp_crypto_policy_t *p);
  * @return void.
  *
  */
-
 void srtp_crypto_policy_set_aes_cm_128_null_auth(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_crypto_policy_set_null_cipher_hmac_sha1_80() sets a crypto
  * policy structure to an authentication-only policy
@@ -860,7 +843,6 @@ void srtp_crypto_policy_set_null_cipher_hmac_sha1_80(srtp_crypto_policy_t *p);
  */
 void srtp_crypto_policy_set_null_cipher_hmac_null(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80() sets a crypto
  * policy structure to a encryption and authentication policy using AES-256
@@ -883,10 +865,8 @@ void srtp_crypto_policy_set_null_cipher_hmac_null(srtp_crypto_policy_t *p);
  * @return void.
  *
  */
-
 void srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32() sets a crypto
  * policy structure to a short-authentication tag policy using AES-256
@@ -917,7 +897,6 @@ void srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(srtp_crypto_policy_t *p);
  * @return void.
  *
  */
-
 void srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32(srtp_crypto_policy_t *p);
 
 /**
@@ -947,7 +926,6 @@ void srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32(srtp_crypto_policy_t *p);
  */
 void srtp_crypto_policy_set_aes_cm_256_null_auth(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80() sets a crypto
  * policy structure to a encryption and authentication policy using AES-192
@@ -972,7 +950,6 @@ void srtp_crypto_policy_set_aes_cm_256_null_auth(srtp_crypto_policy_t *p);
  */
 void srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32() sets a crypto
  * policy structure to a short-authentication tag policy using AES-192
@@ -1005,7 +982,6 @@ void srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80(srtp_crypto_policy_t *p);
  */
 void srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_crypto_policy_set_aes_cm_192_null_auth() sets a crypto
  * policy structure to an encryption-only policy
@@ -1033,7 +1009,6 @@ void srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32(srtp_crypto_policy_t *p);
  */
 void srtp_crypto_policy_set_aes_cm_192_null_auth(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_crypto_policy_set_aes_gcm_128_8_auth() sets a crypto
  * policy structure to an AEAD encryption policy.
@@ -1172,7 +1147,6 @@ void srtp_crypto_policy_set_aes_gcm_128_16_auth(srtp_crypto_policy_t *p);
  */
 void srtp_crypto_policy_set_aes_gcm_256_16_auth(srtp_crypto_policy_t *p);
 
-
 /**
  * @brief srtp_dealloc() deallocates storage for an SRTP session
  * context.
@@ -1188,10 +1162,8 @@ void srtp_crypto_policy_set_aes_gcm_256_16_auth(srtp_crypto_policy_t *p);
  *    - srtp_err_status_ok             if there no problems.
  *    - srtp_err_status_dealloc_fail   a memory deallocation failure occured.
  */
-
 srtp_err_status_t srtp_dealloc(srtp_t s);
 
-
 /*
  * @brief identifies a particular SRTP profile
  *
@@ -1200,7 +1172,6 @@ srtp_err_status_t srtp_dealloc(srtp_t s);
  * are defined for DTLS-SRTP:
  * https://www.iana.org/assignments/srtp-protection/srtp-protection.xhtml
  */
-
 typedef enum {
     srtp_profile_reserved = 0,
     srtp_profile_aes128_cm_sha1_80 = 1,
@@ -1211,7 +1182,6 @@ typedef enum {
     srtp_profile_aead_aes_256_gcm = 8,
 } srtp_profile_t;
 
-
 /**
  * @brief srtp_crypto_policy_set_from_profile_for_rtp() sets a crypto policy
  * structure to the appropriate value for RTP based on an srtp_profile_t
@@ -1235,10 +1205,9 @@ typedef enum {
  *     - srtp_err_status_bad_param  the profile is not supported
  *
  */
-srtp_err_status_t srtp_crypto_policy_set_from_profile_for_rtp(srtp_crypto_policy_t *policy, srtp_profile_t profile);
+srtp_err_status_t srtp_crypto_policy_set_from_profile_for_rtp(
-
+    srtp_crypto_policy_t *policy,
-
+    srtp_profile_t profile);
-
 
 /**
  * @brief srtp_crypto_policy_set_from_profile_for_rtcp() sets a crypto policy
@@ -1263,20 +1232,19 @@ srtp_err_status_t srtp_crypto_policy_set_from_profile_for_rtp(srtp_crypto_policy
  *     - srtp_err_status_bad_param  the profile is not supported
  *
  */
-srtp_err_status_t srtp_crypto_policy_set_from_profile_for_rtcp(srtp_crypto_policy_t *policy, srtp_profile_t profile);
+srtp_err_status_t srtp_crypto_policy_set_from_profile_for_rtcp(
+    srtp_crypto_policy_t *policy,
+    srtp_profile_t profile);
 
 /**
  * @brief returns the master key length for a given SRTP profile
  */
-unsigned int
+unsigned int srtp_profile_get_master_key_length(srtp_profile_t profile);
-srtp_profile_get_master_key_length(srtp_profile_t profile);
-
 
 /**
  * @brief returns the master salt length for a given SRTP profile
  */
-unsigned int
+unsigned int srtp_profile_get_master_salt_length(srtp_profile_t profile);
-srtp_profile_get_master_salt_length(srtp_profile_t profile);
 
 /**
  * @brief appends the salt to the key
@@ -1289,19 +1257,15 @@ srtp_profile_get_master_salt_length(srtp_profile_t profile);
  *          available at the location pointed to by key.
  *
  */
-
+void srtp_append_salt_to_key(unsigned char *key,
-void
+                             unsigned int bytes_in_key,
-srtp_append_salt_to_key(unsigned char *key, unsigned int bytes_in_key,
+                             unsigned char *salt,
-	  	        unsigned char *salt, unsigned int bytes_in_salt);
+                             unsigned int bytes_in_salt);
-
-
 
 /**
  * @}
  */
 
-
-
 /**
  * @defgroup SRTCP Secure RTCP
  * @ingroup  SRTP
@@ -1358,10 +1322,9 @@ srtp_append_salt_to_key(unsigned char *key, unsigned int bytes_in_key,
  *    - [other]                  if there was a failure in
  *                               the cryptographic mechanisms.
  */
-	     
+srtp_err_status_t srtp_protect_rtcp(srtp_t ctx,
-
+                                    void *rtcp_hdr,
-srtp_err_status_t srtp_protect_rtcp(srtp_t ctx, void *rtcp_hdr, int *pkt_octet_len);
+                                    int *pkt_octet_len);
-
 
 /**
  * @brief srtp_protect_rtcp_mki() is the Secure RTCP sender-side packet
@@ -1396,7 +1359,8 @@ srtp_err_status_t srtp_protect_rtcp(srtp_t ctx, void *rtcp_hdr, int *pkt_octet_l
  * is undefined.
  *
  * @param use_mki is a boolean to tell the system if mki is being used.  If
- * set to false then will use the first set of session keys.  If set to true will
+ * set to false then will use the first set of session keys.  If set to true
+ * will
  * use the session keys identified by the mki_index
  *
  * @param mki_index integer value specifying which set of session kesy should be
@@ -1407,9 +1371,11 @@ srtp_err_status_t srtp_protect_rtcp(srtp_t ctx, void *rtcp_hdr, int *pkt_octet_l
  *    - [other]                  if there was a failure in
  *                               the cryptographic mechanisms.
  */
-
+srtp_err_status_t srtp_protect_rtcp_mki(srtp_t ctx,
-srtp_err_status_t srtp_protect_rtcp_mki(srtp_t ctx, void *rtcp_hdr, int *pkt_octet_len,
+                                        void *rtcp_hdr,
-                                        unsigned int use_mki, unsigned int mki_index);
+                                        int *pkt_octet_len,
+                                        unsigned int use_mki,
+                                        unsigned int mki_index);
 
 /**
  * @brief srtp_unprotect_rtcp() is the Secure RTCP receiver-side packet
@@ -1449,8 +1415,9 @@ srtp_err_status_t srtp_protect_rtcp_mki(srtp_t ctx, void *rtcp_hdr, int *pkt_oct
  *    - [other]  if there has been an error in the cryptographic mechanisms.
  *
  */
-
+srtp_err_status_t srtp_unprotect_rtcp(srtp_t ctx,
-srtp_err_status_t srtp_unprotect_rtcp(srtp_t ctx, void *srtcp_hdr, int *pkt_octet_len);
+                                      void *srtcp_hdr,
+                                      int *pkt_octet_len);
 
 /**
  * @brief srtp_unprotect_rtcp() is the Secure RTCP receiver-side packet
@@ -1482,8 +1449,8 @@ srtp_err_status_t srtp_unprotect_rtcp(srtp_t ctx, void *srtcp_hdr, int *pkt_octe
  * undefined.
  *
  * @param use_mki is a boolean to tell the system if mki is being used.  If
- * set to false then will use the first set of session keys.  If set to true will
+ * set to false then will use the first set of session keys.  If set to true
- * use the session keys identified by the mki_index
+ * will use the session keys identified by the mki_index
  *
  * @return
  *    - srtp_err_status_ok          if the RTCP packet is valid.
@@ -1491,12 +1458,14 @@ srtp_err_status_t srtp_unprotect_rtcp(srtp_t ctx, void *srtcp_hdr, int *pkt_octe
  *                                  authentication check.
  *    - srtp_err_status_replay_fail if the SRTCP packet is a replay (e.g. has
  *                                  already been processed and accepted).
- *    - srtp_err_status_bad_mki if the MKI in the packet is not a known MKI id
+ *    - srtp_err_status_bad_mki     if the MKI in the packet is not a known MKI
- *    - [other]  if there has been an error in the cryptographic mechanisms.
+ *                                  id
+ *    - [other]                     if there has been an error in the
+ *                                  cryptographic mechanisms.
  *
  */
-
+srtp_err_status_t srtp_unprotect_rtcp_mki(srtp_t ctx,
-srtp_err_status_t srtp_unprotect_rtcp_mki(srtp_t ctx, void *srtcp_hdr,
+                                          void *srtcp_hdr,
                                           int *pkt_octet_len,
                                           unsigned int use_mki);
 
@@ -1504,7 +1473,6 @@ srtp_err_status_t srtp_unprotect_rtcp_mki(srtp_t ctx, void *srtcp_hdr,
  * @}
  */
 
-
 /**
  * @defgroup User data associated to a SRTP session.
  * @ingroup  SRTP
@@ -1527,9 +1495,7 @@ srtp_err_status_t srtp_unprotect_rtcp_mki(srtp_t ctx, void *srtcp_hdr,
  * @return void.
  *
  */
-
+void srtp_set_user_data(srtp_t ctx, void *data);
-void
-srtp_set_user_data(srtp_t ctx, void *data);
 
 /**
  * @brief srtp_get_user_data() retrieves the pointer to the custom data
@@ -1546,15 +1512,12 @@ srtp_set_user_data(srtp_t ctx, void *data);
  * @return void* pointer to the user data.
  *
  */
-
+void *srtp_get_user_data(srtp_t ctx);
-void*
-srtp_get_user_data(srtp_t ctx);
 
 /**
  * @}
  */
 
-
 /**
  * @defgroup SRTPevents SRTP events and callbacks
  * @ingroup  SRTP
@@ -1596,20 +1559,14 @@ srtp_get_user_data(srtp_t ctx);
  * are unaffected, unless key sharing is used by that stream.  In the
  * latter case, all of the streams in the session will expire.
  */
-
 typedef enum {
-  event_ssrc_collision,    /**<
+    event_ssrc_collision,    /**< An SSRC collision occured.            */
-			    * An SSRC collision occured.             
+    event_key_soft_limit,    /**< An SRTP stream reached the soft key   */
-			    */
+                             /**< usage limit and will expire soon.     */
-  event_key_soft_limit,    /**< An SRTP stream reached the soft key
+    event_key_hard_limit,    /**< An SRTP stream reached the hard       */
-			    *   usage limit and will expire soon.	   
+                             /**< key usage limit and has expired.      */
-			    */
+    event_packet_index_limit /**< An SRTP stream reached the hard       */
-  event_key_hard_limit,    /**< An SRTP stream reached the hard 
+                             /**< packet limit (2^48 packets).          */
-			    *   key usage limit and has expired.
-			    */
-  event_packet_index_limit /**< An SRTP stream reached the hard 
-			    * packet limit (2^48 packets).             
-			    */
 } srtp_event_t;
 
 /**
@@ -1619,10 +1576,10 @@ typedef enum {
  * The struct srtp_event_data_t holds the data passed to the event
  * handler function.
  */
-
 typedef struct srtp_event_data_t {
     srtp_t session;     /**< The session in which the event happend.        */
-  uint32_t      ssrc;     /**< The ssrc in host order of the stream in which the event happend */
+    uint32_t ssrc;      /**< The ssrc in host order of the stream in which  */
+                        /**< the event happend                              */
     srtp_event_t event; /**< An enum indicating the type of event.          */
 } srtp_event_data_t;
 
@@ -1636,7 +1593,6 @@ typedef struct srtp_event_data_t {
  * There can only be a single, global handler for all events in
  * libSRTP.
  */
-
 typedef void(srtp_event_handler_func_t)(srtp_event_data_t *data);
 
 /**
@@ -1651,7 +1607,6 @@ typedef void (srtp_event_handler_func_t)(srtp_event_data_t *data);
  *             pointer as an argument and returns void.  This function
  *             will be used by libSRTP to handle events.
  */
-
 srtp_err_status_t srtp_install_event_handler(srtp_event_handler_func_t func);
 
 /**
@@ -1706,7 +1661,9 @@ typedef enum {
  * There can only be a single, global handler for all log messages in
  * libSRTP.
  */
-typedef void (srtp_log_handler_func_t)(srtp_log_level_t level, const char * msg, void *data);
+typedef void(srtp_log_handler_func_t)(srtp_log_level_t level,
+                                      const char *msg,
+                                      void *data);
 
 /**
  * @brief sets the log handler to the function supplied by the caller.
@@ -1719,34 +1676,44 @@ typedef void (srtp_log_handler_func_t)(srtp_log_level_t level, const char * msg,
  *
  * @param func is a pointer to a fuction of type srtp_log_handler_func_t.
  *             This function will be used by libSRTP to output log messages.
- * @param data is a user pointer that will be returned as the data argument in func.
+ * @param data is a user pointer that will be returned as the data argument in
+ * func.
  */
-srtp_err_status_t srtp_install_log_handler(srtp_log_handler_func_t func, void *data);
+srtp_err_status_t srtp_install_log_handler(srtp_log_handler_func_t func,
+                                           void *data);
 
 /**
  * @brief srtp_get_protect_trailer_length(session, use_mki, mki_index, length)
  *
  * Determines the length of the amount of data Lib SRTP will add to the
- * packet during the protect process. The length is returned in the length parameter
+ * packet during the protect process. The length is returned in the length
+ * parameter
  *
- * returns err_status_ok on success, err_status_bad_mki if the MKI index is invalid
+ * returns err_status_ok on success, err_status_bad_mki if the MKI index is
+ * invalid
  *
  */
-srtp_err_status_t srtp_get_protect_trailer_length(srtp_t session, uint32_t use_mki,
+srtp_err_status_t srtp_get_protect_trailer_length(srtp_t session,
-                                                  uint32_t mki_index, uint32_t *length);
+                                                  uint32_t use_mki,
+                                                  uint32_t mki_index,
+                                                  uint32_t *length);
 
 /**
- * @brief srtp_get_protect_rtcp_trailer_length(session, use_mki, mki_index, length)
+ * @brief srtp_get_protect_rtcp_trailer_length(session, use_mki, mki_index,
+ * length)
  *
  * Determines the length of the amount of data Lib SRTP will add to the
- * packet during the protect process. The length is returned in the length parameter
+ * packet during the protect process. The length is returned in the length
+ * parameter
  *
- * returns err_status_ok on success, err_status_bad_mki if the MKI index is invalid
+ * returns err_status_ok on success, err_status_bad_mki if the MKI index is
+ * invalid
  *
  */
-srtp_err_status_t srtp_get_protect_rtcp_trailer_length(srtp_t session, uint32_t use_mki,
+srtp_err_status_t srtp_get_protect_rtcp_trailer_length(srtp_t session,
-                                                       uint32_t mki_index, uint32_t *length);
+                                                       uint32_t use_mki,
-
+                                                       uint32_t mki_index,
+                                                       uint32_t *length);
 
 /**
  * @brief srtp_set_stream_roc(session, ssrc, roc)
@@ -1757,7 +1724,9 @@ srtp_err_status_t srtp_get_protect_rtcp_trailer_length(srtp_t session, uint32_t
  * stream found
  *
  */
-srtp_err_status_t srtp_set_stream_roc(srtp_t session, uint32_t ssrc, uint32_t roc);
+srtp_err_status_t srtp_set_stream_roc(srtp_t session,
+                                      uint32_t ssrc,
+                                      uint32_t roc);
 
 /**
  * @brief srtp_get_stream_roc(session, ssrc, roc)
@@ -1768,14 +1737,17 @@ srtp_err_status_t srtp_set_stream_roc(srtp_t session, uint32_t ssrc, uint32_t ro
  * stream found
  *
  */
-srtp_err_status_t srtp_get_stream_roc(srtp_t session, uint32_t ssrc, uint32_t *roc);
+srtp_err_status_t srtp_get_stream_roc(srtp_t session,
-
+                                      uint32_t ssrc,
+                                      uint32_t *roc);
 
 /**
  * @}
  */
+
 /* in host order, so outside the #if */
 #define SRTCP_E_BIT 0x80000000
+
 /* for byte-access */
 #define SRTCP_E_BYTE_BIT 0x80
 #define SRTCP_INDEX_MASK 0x7fffffff

libs/srtp/include/srtp_priv.h

@@ -78,7 +78,6 @@ typedef srtp_stream_ctx_t *srtp_stream_t;
  */
 srtp_stream_t srtp_get_stream(srtp_t srtp, uint32_t ssrc);
 
-
 /*
  * srtp_stream_init_keys(s, k) (re)initializes the srtp_stream_t s by
  * deriving all of the needed keys using the KDF and the key k.
@@ -88,10 +87,12 @@ srtp_err_status_t srtp_stream_init_keys(srtp_stream_ctx_t *srtp,
                                         const unsigned int current_mki_index);
 
 /*
- * srtp_stream_init_all_master_keys(s, k, m) (re)initializes the srtp_stream_t s by
+ * srtp_stream_init_all_master_keys(s, k, m) (re)initializes the srtp_stream_t s
- * deriving all of the needed keys for all the master keys using the KDF and the keys from k.
+ * by deriving all of the needed keys for all the master keys using the KDF and
+ * the keys from k.
  */
-srtp_err_status_t srtp_steam_init_all_master_keys(srtp_stream_ctx_t *srtp,
+srtp_err_status_t srtp_steam_init_all_master_keys(
+    srtp_stream_ctx_t *srtp,
     unsigned char *key,
     srtp_master_key_t **keys,
     const unsigned int max_master_keys);
@@ -102,11 +103,9 @@ srtp_err_status_t srtp_steam_init_all_master_keys(srtp_stream_ctx_t *srtp,
  */
 srtp_err_status_t srtp_stream_init(srtp_stream_t srtp, const srtp_policy_t *p);
 
-
 /*
  * libsrtp internal datatypes
  */
-
 typedef enum direction_t {
     dir_unknown = 0,
     dir_srtp_sender = 1,
@@ -131,7 +130,6 @@ typedef struct srtp_session_keys_t {
     srtp_key_limit_ctx_t *limit;
 } srtp_session_keys_t;
 
-
 /*
  * an srtp_stream_t has its own SSRC, encryption key, authentication
  * key, sequence number, and replay database
@@ -139,7 +137,6 @@ typedef struct srtp_session_keys_t {
  * note that the keys might not actually be unique, in which case the
  * srtp_cipher_t and srtp_auth_t pointers will point to the same structures
  */
-
 typedef struct srtp_stream_ctx_t_ {
     uint32_t ssrc;
     srtp_session_keys_t *session_keys;
@@ -157,18 +154,16 @@ typedef struct srtp_stream_ctx_t_ {
     struct srtp_stream_ctx_t_ *next; /* linked list of streams */
 } strp_stream_ctx_t_;
 
-
 /*
  * an srtp_ctx_t holds a stream list and a service description
  */
-
 typedef struct srtp_ctx_t_ {
     struct srtp_stream_ctx_t_ *stream_list;     /* linked list of streams     */
-  struct srtp_stream_ctx_t_ *stream_template; /* act as template for other streams */
+    struct srtp_stream_ctx_t_ *stream_template; /* act as template for other  */
+                                                /* streams                    */
     void *user_data;                            /* user custom data           */
 } srtp_ctx_t_;
 
-
 /*
  * srtp_hdr_t represents an RTP or SRTP header.  The bit-fields in
  * this structure should be declared "unsigned int" instead of
@@ -181,10 +176,6 @@ typedef struct srtp_ctx_t_ {
  * is not identical)
  */
 
-#ifdef _MSC_VER
-#pragma pack(push, r1, 1)
-#endif
-
 #ifndef WORDS_BIGENDIAN
 
 typedef struct {
@@ -194,8 +185,8 @@ typedef struct {
     unsigned version : 2; /* protocol version       */
     unsigned pt : 7;      /* payload type           */
     unsigned m : 1;       /* marker bit             */
-    unsigned seq : 16;    /* sequence number        */
+    uint16_t seq;              /* sequence number        */
-    unsigned ts : 32;     /* timestamp              */
+    uint32_t ts;               /* timestamp              */
     uint32_t ssrc;             /* synchronization source */
 } srtp_hdr_t;
 
@@ -208,8 +199,8 @@ typedef struct {
     unsigned cc : 4;      /* CSRC count             */
     unsigned m : 1;       /* marker bit             */
     unsigned pt : 7;      /* payload type           */
-    unsigned seq: 16;     /* sequence number        */
+    uint16_t seq;              /* sequence number        */
-    unsigned ts : 32;     /* timestamp              */
+    uint32_t ts;               /* timestamp              */
     uint32_t ssrc;             /* synchronization source */
 } srtp_hdr_t;
 
@@ -220,7 +211,6 @@ typedef struct {
     uint16_t length;           /* number of 32-bit words in extension */
 } srtp_hdr_xtnd_t;
 
-
 /*
  * srtcp_hdr_t represents a secure rtcp header
  *
@@ -235,7 +225,7 @@ typedef struct {
     unsigned p : 1;       /* padding flag           */
     unsigned version : 2; /* protocol version       */
     unsigned pt : 8;      /* payload type           */
-    unsigned len : 16;         /* length                 */
+    uint16_t len;              /* length                 */
     uint32_t ssrc;             /* synchronization source */
 } srtcp_hdr_t;
 
@@ -253,7 +243,7 @@ typedef struct {
     unsigned p : 1;       /* padding flag           */
     unsigned rc : 5;      /* reception report count */
     unsigned pt : 8;      /* payload type           */
-    unsigned len : 16;         /* length                 */
+    uint16_t len;              /* length                 */
     uint32_t ssrc;             /* synchronization source */
 } srtcp_hdr_t;
 
@@ -266,10 +256,6 @@ typedef struct {
 
 #endif
 
-#ifdef _MSC_VER
-#pragma pack(pop, r1)
-#endif
-
 /*
  * srtp_handle_event(srtp, srtm, evnt) calls the event handling
  * function, if there is one.

libs/srtp/include/ut_sim.h

@@ -44,8 +44,6 @@
  *
  */
 
-
-
 #ifndef UT_SIM_H
 #define UT_SIM_H
 
@@ -69,16 +67,14 @@ typedef struct {
  * ut_connection
  */
 
-void
+void ut_init(ut_connection *utc);
-ut_init(ut_connection *utc);
 
 /*
  * ut_next_index(&u) returns the next index from the simulated
  * unreliable connection
  */
 
-uint32_t
+uint32_t ut_next_index(ut_connection *utc);
-ut_next_index(ut_connection *utc);
 
 #ifdef __cplusplus
 }

libs/srtp/libsrtp.2017.vcxproj

@@ -392,6 +392,7 @@
     <ClInclude Include="crypto\include\alloc.h" />
     <ClInclude Include="crypto\include\auth.h" />
     <ClInclude Include="crypto\include\cipher.h" />
+    <ClInclude Include="crypto\include\cipher_types.h" />
     <ClInclude Include="crypto\include\config.h" />
     <ClInclude Include="crypto\include\crypto_kernel.h" />
     <ClInclude Include="crypto\include\crypto_types.h" />

libs/srtp/srtp-1.42.pc.in

@@ -1,10 +0,0 @@
-prefix = @prefix@
-exec_prefix = @exec_prefix@
-libdir = @libdir@
-includedir = @includedir@
-
-Name: srtp
-Description: Secure RTP (SRTP) and UST Reference Implementations
-Version: @VERSION@
-Libs: -L${libdir} -lsrtp.so
-Cflags: -I${includedir}/srtp

libs/srtp/srtp/ekt.c

@@ -42,7 +42,6 @@
  *
  */
 
-
 #include "srtp_priv.h"
 #include "err.h"
 #include "ekt.h"
@@ -71,7 +70,8 @@ extern srtp_debug_module_t mod_srtp;
 #define EKT_OCTETS_AFTER_ROC 4
 #define EKT_SPI_LEN 2
 
-unsigned srtp_ekt_octets_after_base_tag(srtp_ekt_stream_t ekt) {
+unsigned srtp_ekt_octets_after_base_tag(srtp_ekt_stream_t ekt)
+{
     /*
      * if the pointer ekt is NULL, then EKT is not in effect, so we
      * indicate this by returning zero
@@ -89,7 +89,10 @@ unsigned srtp_ekt_octets_after_base_tag(srtp_ekt_stream_t ekt) {
     return 0;
 }
 
-static inline srtp_ekt_spi_t srtcp_packet_get_ekt_spi(const uint8_t *packet_start, unsigned pkt_octet_len) {
+static inline srtp_ekt_spi_t srtcp_packet_get_ekt_spi(
+    const uint8_t *packet_start,
+    unsigned pkt_octet_len)
+{
     const uint8_t *spi_location;
 
     spi_location = packet_start + (pkt_octet_len - EKT_SPI_LEN);
@@ -97,7 +100,9 @@ static inline srtp_ekt_spi_t srtcp_packet_get_ekt_spi(const uint8_t *packet_star
     return *((const srtp_ekt_spi_t *)spi_location);
 }
 
-static inline uint32_t srtcp_packet_get_ekt_roc(const uint8_t *packet_start, unsigned pkt_octet_len) {
+static inline uint32_t srtcp_packet_get_ekt_roc(const uint8_t *packet_start,
+                                                unsigned pkt_octet_len)
+{
     const uint8_t *roc_location;
 
     roc_location = packet_start + (pkt_octet_len - EKT_OCTETS_AFTER_ROC);
@@ -105,7 +110,10 @@ static inline uint32_t srtcp_packet_get_ekt_roc(const uint8_t *packet_start, uns
     return *((const uint32_t *)roc_location);
 }
 
-static inline const uint8_t * srtcp_packet_get_emk_location(const uint8_t *packet_start, unsigned pkt_octet_len) {
+static inline const uint8_t *srtcp_packet_get_emk_location(
+    const uint8_t *packet_start,
+    unsigned pkt_octet_len)
+{
     const uint8_t *location;
 
     location = packet_start + (pkt_octet_len - EKT_OCTETS_AFTER_BASE_TAG);
@@ -113,9 +121,9 @@ static inline const uint8_t * srtcp_packet_get_emk_location(const uint8_t *packe
     return location;
 }
 
-
+srtp_err_status_t srtp_ekt_alloc(srtp_ekt_stream_t *stream_data,
-srtp_err_status_t srtp_ekt_alloc(srtp_ekt_stream_t *stream_data, srtp_ekt_policy_t policy) {
+                                 srtp_ekt_policy_t policy)
-
+{
     /*
      * if the policy pointer is NULL, then EKT is not in use
      * so we just set the EKT stream data pointer to NULL
@@ -131,15 +139,18 @@ srtp_err_status_t srtp_ekt_alloc(srtp_ekt_stream_t *stream_data, srtp_ekt_policy
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t srtp_ekt_stream_init_from_policy(srtp_ekt_stream_t stream_data, srtp_ekt_policy_t policy) {
+srtp_err_status_t srtp_ekt_stream_init_from_policy(
+    srtp_ekt_stream_t stream_data,
+    srtp_ekt_policy_t policy)
+{
     if (!stream_data)
         return srtp_err_status_ok;
 
     return srtp_err_status_ok;
 }
 
-
+void aes_decrypt_with_raw_key(void *ciphertext, const void *key, int key_len)
-void aes_decrypt_with_raw_key(void *ciphertext, const void *key, int key_len) {
+{
 #ifndef OPENSSL
     // FIXME: need to get this working through the crypto module interface
     srtp_aes_expanded_key_t expanded_key;
@@ -154,7 +165,10 @@ void aes_decrypt_with_raw_key(void *ciphertext, const void *key, int key_len) {
  * the EKT data from an SRTCP trailer.
  */
 
-srtp_err_status_t srtp_stream_init_from_ekt(srtp_stream_t stream, const void *srtcp_hdr, unsigned pkt_octet_len) {
+srtp_err_status_t srtp_stream_init_from_ekt(srtp_stream_t stream,
+                                            const void *srtcp_hdr,
+                                            unsigned pkt_octet_len)
+{
     srtp_err_status_t err;
     const uint8_t *master_key;
     srtp_policy_t srtp_policy;
@@ -175,20 +189,28 @@ srtp_err_status_t srtp_stream_init_from_ekt(srtp_stream_t stream, const void *sr
     /* FIX!? This decrypts the master key in-place, and never uses it */
     /* FIX!? It's also passing to ekt_dec_key (which is an aes_expanded_key_t)
      * to a function which expects a raw (unexpanded) key */
-  aes_decrypt_with_raw_key((void*)master_key, &stream->ekt->data->ekt_dec_key, 16);
+    aes_decrypt_with_raw_key((void *)master_key,
+                             &stream->ekt->data->ekt_dec_key, 16);
 
     /* set the SRTP ROC */
     roc = srtcp_packet_get_ekt_roc(srtcp_hdr, pkt_octet_len);
     err = srtp_rdbx_set_roc(&stream->rtp_rdbx, roc);
-  if (err) return err;
+    if (err)
+        return err;
 
     err = srtp_stream_init(stream, &srtp_policy);
-  if (err) return err;
+    if (err)
+        return err;
 
     return srtp_err_status_ok;
 }
 
-void srtp_ekt_write_data(srtp_ekt_stream_t ekt, uint8_t *base_tag, unsigned base_tag_len, int *packet_len, srtp_xtd_seq_num_t pkt_index) {
+void srtp_ekt_write_data(srtp_ekt_stream_t ekt,
+                         uint8_t *base_tag,
+                         unsigned base_tag_len,
+                         int *packet_len,
+                         srtp_xtd_seq_num_t pkt_index)
+{
     uint32_t roc;
     uint16_t isn;
     unsigned emk_len;
@@ -234,7 +256,6 @@ void srtp_ekt_write_data(srtp_ekt_stream_t ekt, uint8_t *base_tag, unsigned base
     *packet_len += EKT_OCTETS_AFTER_EMK + emk_len;
 }
 
-
 /*
  * The function call srtcp_ekt_trailer(ekt, auth_len, auth_tag   )
  *
@@ -245,7 +266,11 @@ void srtp_ekt_write_data(srtp_ekt_stream_t ekt, uint8_t *base_tag, unsigned base
  * auth_tag pointer is set to the location
  */
 
-void srtcp_ekt_trailer(srtp_ekt_stream_t ekt, unsigned *auth_len, void **auth_tag, void *tag_copy) { 
+void srtcp_ekt_trailer(srtp_ekt_stream_t ekt,
+                       unsigned *auth_len,
+                       void **auth_tag,
+                       void *tag_copy)
+{
     /*
      * if there is no EKT policy, then the other inputs are unaffected
      */
@@ -253,6 +278,4 @@ void srtcp_ekt_trailer(srtp_ekt_stream_t ekt, unsigned *auth_len, void **auth_ta
         return;
 
     /* copy auth_tag into temporary location */
-  
 }
-

libs/srtp/srtp2.vcxproj

@@ -370,6 +370,7 @@
     <ClInclude Include="crypto\include\alloc.h" />
     <ClInclude Include="crypto\include\auth.h" />
     <ClInclude Include="crypto\include\cipher.h" />
+    <ClInclude Include="crypto\include\cipher_types.h" />
     <ClInclude Include="crypto\include\config.h" />
     <ClInclude Include="crypto\include\crypto.h" />
     <ClInclude Include="crypto\include\cryptoalg.h" />

libs/srtp/srtp2.vcxproj.filters

@@ -107,6 +107,9 @@
     <ClInclude Include="crypto\include\cipher.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="crypto\include\cipher_types.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="crypto\include\config.h">
       <Filter>Header Files</Filter>
     </ClInclude>

libs/srtp/test/cutest.h

@@ -26,7 +26,6 @@
 #ifndef CUTEST_H__
 #define CUTEST_H__
 
-
 /************************
  *** Public interface ***
  ************************/
@@ -58,7 +57,6 @@
  */
 #define TEST_LIST const struct test__ test_list__[]
 
-
 /* Macros for testing whether an unit test succeeds or fails. These macros
  * can be used arbitrarily in functions implementing the unit tests.
  *
@@ -78,10 +76,10 @@
  *       TEST_CHECK(ptr->member2 > 200);
  *   }
  */
-#define TEST_CHECK_(cond,...)  test_check__((cond), __FILE__, __LINE__, __VA_ARGS__)
+#define TEST_CHECK_(cond, ...)                                                 \
+    test_check__((cond), __FILE__, __LINE__, __VA_ARGS__)
 #define TEST_CHECK(cond) test_check__((cond), __FILE__, __LINE__, "%s", #cond)
 
-
 /**********************
  *** Implementation ***
  **********************/
@@ -112,16 +110,13 @@
 #include <exception>
 #endif
 
-
 /* Note our global private identifiers end with '__' to mitigate risk of clash
  * with the unit tests implementation. */
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 struct test__ {
     const char *name;
     void (*func)(void);
@@ -131,7 +126,6 @@ extern const struct test__ test_list__[];
 
 int test_check__(int cond, const char *file, int line, const char *fmt, ...);
 
-
 #ifndef TEST_NO_MAIN
 
 static char *test_argv0__ = NULL;
@@ -156,8 +150,7 @@ static int test_colorize__ = 0;
 #define CUTEST_COLOR_GREEN_INTENSIVE__ 4
 #define CUTEST_COLOR_RED_INTENSIVE__ 5
 
-static size_t
+static size_t test_print_in_color__(int color, const char *fmt, ...)
-test_print_in_color__(int color, const char* fmt, ...)
 {
     va_list args;
     char buffer[256];
@@ -176,12 +169,24 @@ test_print_in_color__(int color, const char* fmt, ...)
     {
         const char *col_str;
         switch (color) {
-            case CUTEST_COLOR_GREEN__:             col_str = "\033[0;32m"; break;
+        case CUTEST_COLOR_GREEN__:
-            case CUTEST_COLOR_RED__:               col_str = "\033[0;31m"; break;
+            col_str = "\033[0;32m";
-            case CUTEST_COLOR_GREEN_INTENSIVE__:   col_str = "\033[1;32m"; break;
+            break;
-            case CUTEST_COLOR_RED_INTENSIVE__:     col_str = "\033[1;30m"; break;
+        case CUTEST_COLOR_RED__:
-            case CUTEST_COLOR_DEFAULT_INTENSIVE__: col_str = "\033[1m"; break;
+            col_str = "\033[0;31m";
-            default:                               col_str = "\033[0m"; break;
+            break;
+        case CUTEST_COLOR_GREEN_INTENSIVE__:
+            col_str = "\033[1;32m";
+            break;
+        case CUTEST_COLOR_RED_INTENSIVE__:
+            col_str = "\033[1;30m";
+            break;
+        case CUTEST_COLOR_DEFAULT_INTENSIVE__:
+            col_str = "\033[1m";
+            break;
+        default:
+            col_str = "\033[0m";
+            break;
         }
         printf("%s", col_str);
         n = printf("%s", buffer);
@@ -198,12 +203,25 @@ test_print_in_color__(int color, const char* fmt, ...)
         GetConsoleScreenBufferInfo(h, &info);
 
         switch (color) {
-            case CUTEST_COLOR_GREEN__:             attr = FOREGROUND_GREEN; break;
+        case CUTEST_COLOR_GREEN__:
-            case CUTEST_COLOR_RED__:               attr = FOREGROUND_RED; break;
+            attr = FOREGROUND_GREEN;
-            case CUTEST_COLOR_GREEN_INTENSIVE__:   attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break;
+            break;
-            case CUTEST_COLOR_RED_INTENSIVE__:     attr = FOREGROUND_RED | FOREGROUND_INTENSITY; break;
+        case CUTEST_COLOR_RED__:
-            case CUTEST_COLOR_DEFAULT_INTENSIVE__: attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY; break;
+            attr = FOREGROUND_RED;
-            default:                               attr = 0; break;
+            break;
+        case CUTEST_COLOR_GREEN_INTENSIVE__:
+            attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY;
+            break;
+        case CUTEST_COLOR_RED_INTENSIVE__:
+            attr = FOREGROUND_RED | FOREGROUND_INTENSITY;
+            break;
+        case CUTEST_COLOR_DEFAULT_INTENSIVE__:
+            attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED |
+                   FOREGROUND_INTENSITY;
+            break;
+        default:
+            attr = 0;
+            break;
         }
         if (attr != 0)
             SetConsoleTextAttribute(h, attr);
@@ -217,8 +235,7 @@ test_print_in_color__(int color, const char* fmt, ...)
 #endif
 }
 
-int
+int test_check__(int cond, const char *file, int line, const char *fmt, ...)
-test_check__(int cond, const char* file, int line, const char* fmt, ...)
 {
     const char *result_str;
     int result_color;
@@ -263,8 +280,7 @@ test_check__(int cond, const char* file, int line, const char* fmt, ...)
     return (cond != 0);
 }
 
-static void
+static void test_list_names__(void)
-test_list_names__(void)
 {
     const struct test__ *test;
 
@@ -273,8 +289,7 @@ test_list_names__(void)
         printf("  %s\n", test->name);
 }
 
-static const struct test__*
+static const struct test__ *test_by_name__(const char *name)
-test_by_name__(const char* name)
 {
     const struct test__ *test;
 
@@ -287,21 +302,22 @@ test_by_name__(const char* name)
 }
 
 /* Call directly the given test unit function. */
-static int
+static int test_do_run__(const struct test__ *test)
-test_do_run__(const struct test__* test)
 {
     test_current_unit__ = test;
     test_current_failures__ = 0;
     test_current_already_logged__ = 0;
 
     if (test_verbose_level__ >= 3) {
-        test_print_in_color__(CUTEST_COLOR_DEFAULT_INTENSIVE__, "Test %s:\n", test->name);
+        test_print_in_color__(CUTEST_COLOR_DEFAULT_INTENSIVE__, "Test %s:\n",
+                              test->name);
         test_current_already_logged__++;
     } else if (test_verbose_level__ >= 1) {
         size_t n;
         char spaces[32];
 
-        n = test_print_in_color__(CUTEST_COLOR_DEFAULT_INTENSIVE__, "Test %s... ", test->name);
+        n = test_print_in_color__(CUTEST_COLOR_DEFAULT_INTENSIVE__,
+                                  "Test %s... ", test->name);
         memset(spaces, ' ', sizeof(spaces));
         if (n < sizeof(spaces))
             printf("%.*s", (int)(sizeof(spaces) - n), spaces);
@@ -333,9 +349,19 @@ test_do_run__(const struct test__* test)
 
     if (test_verbose_level__ >= 3) {
         switch (test_current_failures__) {
-            case 0:  test_print_in_color__(CUTEST_COLOR_GREEN_INTENSIVE__, "  All conditions have passed.\n\n"); break;
+        case 0:
-            case 1:  test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, "  One condition has FAILED.\n\n"); break;
+            test_print_in_color__(CUTEST_COLOR_GREEN_INTENSIVE__,
-            default: test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, "  %d conditions have FAILED.\n\n", test_current_failures__); break;
+                                  "  All conditions have passed.\n\n");
+            break;
+        case 1:
+            test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__,
+                                  "  One condition has FAILED.\n\n");
+            break;
+        default:
+            test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__,
+                                  "  %d conditions have FAILED.\n\n",
+                                  test_current_failures__);
+            break;
         }
     } else if (test_verbose_level__ >= 1 && test_current_failures__ == 0) {
         printf("[   ");
@@ -351,15 +377,15 @@ test_do_run__(const struct test__* test)
 /* Called if anything goes bad in cutest, or if the unit test ends in other
  * way then by normal returning from its function (e.g. exception or some
  * abnormal child process termination). */
-static void
+static void test_error__(const char *fmt, ...)
-test_error__(const char* fmt, ...)
 {
     va_list args;
 
     if (test_verbose_level__ == 0)
         return;
 
-    if(test_verbose_level__ <= 2  &&  !test_current_already_logged__  &&  test_current_unit__ != NULL) {
+    if (test_verbose_level__ <= 2 && !test_current_already_logged__ &&
+        test_current_unit__ != NULL) {
         printf("[ ");
         test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, "FAILED");
         printf(" ]\n");
@@ -378,8 +404,7 @@ test_error__(const char* fmt, ...)
 /* Trigger the unit test. If possible (and not suppressed) it starts a child
  * process who calls test_do_run__(), otherwise it calls test_do_run__()
  * directly. */
-static void
+static void test_run__(const struct test__ *test)
-test_run__(const struct test__* test)
 {
     int failed = 1;
 
@@ -387,7 +412,6 @@ test_run__(const struct test__* test)
     test_current_already_logged__ = 0;
 
     if (!test_no_exec__) {
-
 #if defined(CUTEST_UNIX__)
 
         pid_t pid;
@@ -406,23 +430,47 @@ test_run__(const struct test__* test)
             waitpid(pid, &exit_code, 0);
             if (WIFEXITED(exit_code)) {
                 switch (WEXITSTATUS(exit_code)) {
-                    case 0:   failed = 0; break;   /* test has passed. */
+                case 0:
-                    case 1:   /* noop */ break;    /* "normal" failure. */
+                    failed = 0;
-                    default:  test_error__("Unexpected exit code [%d]", WEXITSTATUS(exit_code));
+                    break; /* test has passed. */
+                case 1:    /* noop */
+                    break; /* "normal" failure. */
+                default:
+                    test_error__("Unexpected exit code [%d]",
+                                 WEXITSTATUS(exit_code));
                 }
             } else if (WIFSIGNALED(exit_code)) {
                 char tmp[32];
                 const char *signame;
                 switch (WTERMSIG(exit_code)) {
-                    case SIGINT:  signame = "SIGINT"; break;
+                case SIGINT:
-                    case SIGHUP:  signame = "SIGHUP"; break;
+                    signame = "SIGINT";
-                    case SIGQUIT: signame = "SIGQUIT"; break;
+                    break;
-                    case SIGABRT: signame = "SIGABRT"; break;
+                case SIGHUP:
-                    case SIGKILL: signame = "SIGKILL"; break;
+                    signame = "SIGHUP";
-                    case SIGSEGV: signame = "SIGSEGV"; break;
+                    break;
-                    case SIGILL:  signame = "SIGILL"; break;
+                case SIGQUIT:
-                    case SIGTERM: signame = "SIGTERM"; break;
+                    signame = "SIGQUIT";
-                    default:      sprintf(tmp, "signal %d", WTERMSIG(exit_code)); signame = tmp; break;
+                    break;
+                case SIGABRT:
+                    signame = "SIGABRT";
+                    break;
+                case SIGKILL:
+                    signame = "SIGKILL";
+                    break;
+                case SIGSEGV:
+                    signame = "SIGSEGV";
+                    break;
+                case SIGILL:
+                    signame = "SIGILL";
+                    break;
+                case SIGTERM:
+                    signame = "SIGTERM";
+                    break;
+                default:
+                    sprintf(tmp, "signal %d", WTERMSIG(exit_code));
+                    signame = tmp;
+                    break;
                 }
                 test_error__("Test interrupted by %s", signame);
             } else {
@@ -444,14 +492,16 @@ test_run__(const struct test__* test)
                   test_argv0__, test_verbose_level__,
                   test_colorize__ ? "always" : "never", test->name);
         startupInfo.cb = sizeof(STARTUPINFO);
-        if(CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo)) {
+        if (CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL,
+                           &startupInfo, &processInfo)) {
             WaitForSingleObject(processInfo.hProcess, INFINITE);
             GetExitCodeProcess(processInfo.hProcess, &exitCode);
             CloseHandle(processInfo.hThread);
             CloseHandle(processInfo.hProcess);
             failed = (exitCode != 0);
         } else {
-            test_error__("Cannot create unit test subprocess [%ld].", GetLastError());
+            test_error__("Cannot create unit test subprocess [%ld].",
+                         GetLastError());
             failed = 1;
         }
 
@@ -476,8 +526,7 @@ test_run__(const struct test__* test)
 
 #if defined(CUTEST_WIN__)
 /* Callback for SEH events. */
-static LONG CALLBACK
+static LONG CALLBACK test_exception_filter__(EXCEPTION_POINTERS *ptrs)
-test_exception_filter__(EXCEPTION_POINTERS *ptrs)
 {
     test_error__("Unhandled SEH exception %08lx at %p.",
                  ptrs->ExceptionRecord->ExceptionCode,
@@ -488,33 +537,40 @@ test_exception_filter__(EXCEPTION_POINTERS *ptrs)
 }
 #endif
 
-static void
+static void test_help__(void)
-test_help__(void)
 {
     printf("Usage: %s [options] [test...]\n", test_argv0__);
-    printf("Run the specified unit tests; or if the option '--skip' is used, run all\n");
+    printf("Run the specified unit tests; or if the option '--skip' is used, "
-    printf("tests in the suite but those listed.  By default, if no tests are specified\n");
+           "run all\n");
+    printf("tests in the suite but those listed.  By default, if no tests are "
+           "specified\n");
     printf("on the command line, all unit tests in the suite are run.\n");
     printf("\n");
     printf("Options:\n");
-    printf("  -s, --skip            Execute all unit tests but the listed ones\n");
+    printf(
-    printf("      --no-exec         Do not execute unit tests as child processes\n");
+        "  -s, --skip            Execute all unit tests but the listed ones\n");
-    printf("      --no-summary      Suppress printing of test results summary\n");
+    printf("      --no-exec         Do not execute unit tests as child "
+           "processes\n");
+    printf(
+        "      --no-summary      Suppress printing of test results summary\n");
     printf("  -l, --list            List unit tests in the suite and exit\n");
     printf("  -v, --verbose         Enable more verbose output\n");
     printf("      --verbose=LEVEL   Set verbose level to LEVEL:\n");
     printf("                          0 ... Be silent\n");
-    printf("                          1 ... Output one line per test (and summary)\n");
+    printf("                          1 ... Output one line per test (and "
-    printf("                          2 ... As 1 and failed conditions (this is default)\n");
+           "summary)\n");
-    printf("                          3 ... As 1 and all conditions (and extended summary)\n");
+    printf("                          2 ... As 1 and failed conditions (this "
-    printf("      --color=WHEN      Enable colorized output (WHEN is one of 'auto', 'always', 'never')\n");
+           "is default)\n");
+    printf("                          3 ... As 1 and all conditions (and "
+           "extended summary)\n");
+    printf("      --color=WHEN      Enable colorized output (WHEN is one of "
+           "'auto', 'always', 'never')\n");
     printf("  -h, --help            Display this help and exit\n");
     printf("\n");
     test_list_names__();
 }
 
-int
+int main(int argc, char **argv)
-main(int argc, char** argv)
 {
     const struct test__ **tests = NULL;
     int i, j, n = 0;
@@ -533,40 +589,48 @@ main(int argc, char** argv)
     /* Parse options */
     for (i = 1; i < argc; i++) {
         if (seen_double_dash || argv[i][0] != '-') {
-            tests = (const struct test__**) realloc((void*)tests, (n+1) * sizeof(const struct test__*));
+            tests = (const struct test__ **)realloc(
+                (void *)tests, (n + 1) * sizeof(const struct test__ *));
             if (tests == NULL) {
                 fprintf(stderr, "Out of memory.\n");
                 exit(2);
             }
             tests[n] = test_by_name__(argv[i]);
             if (tests[n] == NULL) {
-                fprintf(stderr, "%s: Unrecognized unit test '%s'\n", argv[0], argv[i]);
+                fprintf(stderr, "%s: Unrecognized unit test '%s'\n", argv[0],
-                fprintf(stderr, "Try '%s --list' for list of unit tests.\n", argv[0]);
+                        argv[i]);
+                fprintf(stderr, "Try '%s --list' for list of unit tests.\n",
+                        argv[0]);
                 exit(2);
             }
             n++;
         } else if (strcmp(argv[i], "--") == 0) {
             seen_double_dash = 1;
-        } else if(strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
+        } else if (strcmp(argv[i], "--help") == 0 ||
+                   strcmp(argv[i], "-h") == 0) {
             test_help__();
             exit(0);
-        } else if(strcmp(argv[i], "--verbose") == 0 || strcmp(argv[i], "-v") == 0) {
+        } else if (strcmp(argv[i], "--verbose") == 0 ||
+                   strcmp(argv[i], "-v") == 0) {
             test_verbose_level__++;
         } else if (strncmp(argv[i], "--verbose=", 10) == 0) {
             test_verbose_level__ = atoi(argv[i] + 10);
         } else if (strcmp(argv[i], "--color=auto") == 0) {
             /* noop (set from above) */
-        } else if(strcmp(argv[i], "--color=always") == 0 || strcmp(argv[i], "--color") == 0) {
+        } else if (strcmp(argv[i], "--color=always") == 0 ||
+                   strcmp(argv[i], "--color") == 0) {
             test_colorize__ = 1;
         } else if (strcmp(argv[i], "--color=never") == 0) {
             test_colorize__ = 0;
-        } else if(strcmp(argv[i], "--skip") == 0 || strcmp(argv[i], "-s") == 0) {
+        } else if (strcmp(argv[i], "--skip") == 0 ||
+                   strcmp(argv[i], "-s") == 0) {
             test_skip_mode__ = 1;
         } else if (strcmp(argv[i], "--no-exec") == 0) {
             test_no_exec__ = 1;
         } else if (strcmp(argv[i], "--no-summary") == 0) {
             test_no_summary__ = 1;
-        } else if(strcmp(argv[i], "--list") == 0 || strcmp(argv[i], "-l") == 0) {
+        } else if (strcmp(argv[i], "--list") == 0 ||
+                   strcmp(argv[i], "-l") == 0) {
             test_list_names__();
             exit(0);
         } else {
@@ -615,16 +679,20 @@ main(int argc, char** argv)
 
         if (test_verbose_level__ >= 3) {
             printf("  Count of all unit tests:     %4d\n", test_count__);
-            printf("  Count of run unit tests:     %4d\n", test_stat_run_units__);
+            printf("  Count of run unit tests:     %4d\n",
-            printf("  Count of failed unit tests:  %4d\n", test_stat_failed_units__);
+                   test_stat_run_units__);
-            printf("  Count of skipped unit tests: %4d\n", test_count__ - test_stat_run_units__);
+            printf("  Count of failed unit tests:  %4d\n",
+                   test_stat_failed_units__);
+            printf("  Count of skipped unit tests: %4d\n",
+                   test_count__ - test_stat_run_units__);
         }
 
         if (test_stat_failed_units__ == 0) {
             test_print_in_color__(CUTEST_COLOR_GREEN_INTENSIVE__,
                                   "  SUCCESS: All unit tests have passed.\n");
         } else {
-            test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__,
+            test_print_in_color__(
+                CUTEST_COLOR_RED_INTENSIVE__,
                 "  FAILED: %d of %d unit tests have failed.\n",
                 test_stat_failed_units__, test_stat_run_units__);
         }
@@ -636,12 +704,10 @@ main(int argc, char** argv)
     return (test_stat_failed_units__ == 0) ? 0 : 1;
 }
 
-
 #endif /* #ifndef TEST_NO_MAIN */
 
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 
-
 #endif /* #ifndef CUTEST_H__ */

libs/srtp/test/dtls_srtp_driver.c

@@ -46,22 +46,21 @@
 #include "getopt_s.h" /* for local getopt()    */
 #include "srtp_priv.h"
 
-srtp_err_status_t 
+srtp_err_status_t test_dtls_srtp(void);
-test_dtls_srtp(void);
 
-srtp_hdr_t *
+srtp_hdr_t *srtp_create_test_packet(int pkt_octet_len, uint32_t ssrc);
-srtp_create_test_packet(int pkt_octet_len, uint32_t ssrc);
 
-void
+void usage(char *prog_name)
-usage(char *prog_name) {
+{
     printf("usage: %s [ -t ][ -c ][ -v ][-d <debug_module> ]* [ -l ]\n"
            "  -d <mod>   turn on debugging module <mod>\n"
-         "  -l         list debugging modules\n", prog_name);
+           "  -l         list debugging modules\n",
+           prog_name);
     exit(1);
 }
 
-int
+int main(int argc, char *argv[])
-main(int argc, char *argv[]) {
+{
     unsigned do_list_mods = 0;
     int q;
     srtp_err_status_t err;
@@ -122,9 +121,8 @@ main(int argc, char *argv[]) {
     return 0;
 }
 
-
+srtp_err_status_t test_dtls_srtp(void)
-srtp_err_status_t
+{
-test_dtls_srtp(void) {
     srtp_hdr_t *test_packet;
     int test_packet_len = 80;
     srtp_t s;
@@ -149,24 +147,26 @@ test_dtls_srtp(void) {
     test_packet = srtp_create_test_packet(80, 0xa5a5a5a5);
     if (test_packet == NULL)
         return srtp_err_status_alloc_fail;
+
     err = srtp_protect(s, test_packet, &test_packet_len);
     if (err != srtp_err_status_no_ctx) {
-    printf("wrong return value from srtp_protect() (got code %d)\n", 
+        printf("wrong return value from srtp_protect() (got code %d)\n", err);
-	   err);
         return srtp_err_status_fail;
     }
+
     err = srtp_unprotect(s, test_packet, &test_packet_len);
     if (err != srtp_err_status_no_ctx) {
-    printf("wrong return value from srtp_unprotect() (got code %d)\n", 
+        printf("wrong return value from srtp_unprotect() (got code %d)\n", err);
-	   err);
         return srtp_err_status_fail;
     }
+
     err = srtp_protect_rtcp(s, test_packet, &test_packet_len);
     if (err != srtp_err_status_no_ctx) {
         printf("wrong return value from srtp_protect_rtcp() (got code %d)\n",
                err);
         return srtp_err_status_fail;
     }
+
     err = srtp_unprotect_rtcp(s, test_packet, &test_packet_len);
     if (err != srtp_err_status_no_ctx) {
         printf("wrong return value from srtp_unprotect_rtcp() (got code %d)\n",
@@ -174,7 +174,6 @@ test_dtls_srtp(void) {
         return srtp_err_status_fail;
     }
 
-
     /*
      * set keys to known values for testing
      */
@@ -188,9 +187,11 @@ test_dtls_srtp(void) {
 
     /* initialize SRTP policy from profile  */
     err = srtp_crypto_policy_set_from_profile_for_rtp(&policy.rtp, profile);
-  if (err) return err;
+    if (err)
+        return err;
     err = srtp_crypto_policy_set_from_profile_for_rtcp(&policy.rtcp, profile);
-  if (err) return err;
+    if (err)
+        return err;
     policy.ssrc.type = ssrc_any_inbound;
     policy.ekt = NULL;
     policy.window_size = 128;
@@ -210,8 +211,6 @@ test_dtls_srtp(void) {
     return srtp_err_status_ok;
 }
 
-
-
 /*
  * srtp_create_test_packet(len, ssrc) returns a pointer to a
  * (malloced) example RTP packet whose data field has the length given
@@ -225,16 +224,15 @@ test_dtls_srtp(void) {
  * deallocated with the free() call once it is no longer needed.
  */
 
-srtp_hdr_t *
+srtp_hdr_t *srtp_create_test_packet(int pkt_octet_len, uint32_t ssrc)
-srtp_create_test_packet(int pkt_octet_len, uint32_t ssrc) {
+{
     int i;
     uint8_t *buffer;
     srtp_hdr_t *hdr;
     int bytes_in_hdr = 12;
 
     /* allocate memory for test packet */
-  hdr = malloc(pkt_octet_len + bytes_in_hdr
+    hdr = malloc(pkt_octet_len + bytes_in_hdr + SRTP_MAX_TRAILER_LEN + 4);
-	       + SRTP_MAX_TRAILER_LEN + 4);
     if (!hdr)
         return NULL;
 

libs/srtp/test/getopt_s.c

@@ -52,8 +52,8 @@ char *optarg_s;
 #define GETOPT_FOUND_WITH_ARGUMENT 1
 #define GETOPT_NOT_FOUND 0
 
-static int 
+static int getopt_check_character(char c, const char *string)
-getopt_check_character(char c, const char *string) {
+{
     unsigned int max_string_len = 128;
 
     while (*string != 0) {
@@ -71,12 +71,8 @@ getopt_check_character(char c, const char *string) {
     return GETOPT_NOT_FOUND;
 }
 
-int
+int getopt_s(int argc, char *const argv[], const char *optstring)
-getopt_s(int argc, 
+{
-       char * const argv[], 
-       const char *optstring) {
-
-
     while (optind_s + 1 < argc) {
         char *string;
 

libs/srtp/test/rdbx_driver.c

@@ -6,7 +6,6 @@
  * David A. McGrew
  * Cisco Systems, Inc.
  */
-
 /*
  *
  * Copyright (c) 2001-2017, Cisco Systems, Inc.
@@ -58,20 +57,18 @@
 
 #include "ut_sim.h"
 
-srtp_err_status_t 
+srtp_err_status_t test_replay_dbx(int num_trials, unsigned long ws);
-test_replay_dbx(int num_trials, unsigned long ws);
 
-double
+double rdbx_check_adds_per_second(int num_trials, unsigned long ws);
-rdbx_check_adds_per_second(int num_trials, unsigned long ws);
 
-void
+void usage(char *prog_name)
-usage(char *prog_name) {
+{
     printf("usage: %s [ -t | -v ]\n", prog_name);
     exit(255);
 }
 
-int
+int main(int argc, char *argv[])
-main (int argc, char *argv[]) {
+{
     double rate;
     srtp_err_status_t status;
     int q;
@@ -132,16 +129,13 @@ main (int argc, char *argv[]) {
     return 0;
 }
 
-void
+void print_rdbx(srtp_rdbx_t *rdbx)
-print_rdbx(srtp_rdbx_t *rdbx) {
+{
     char buf[2048];
-  printf("rdbx: {%llu, %s}\n",
+    printf("rdbx: {%llu, %s}\n", (unsigned long long)(rdbx->index),
-	 (unsigned long long)(rdbx->index),
+           bitvector_bit_string(&rdbx->bitmask, buf, sizeof(buf)));
-	 bitvector_bit_string(&rdbx->bitmask, buf, sizeof(buf))
-);
 }
 
-
 /*
  * rdbx_check_add(rdbx, idx) checks a known-to-be-good idx against
  * rdbx, then adds it.  if a failure is detected (i.e., the check
@@ -150,8 +144,8 @@ print_rdbx(srtp_rdbx_t *rdbx) {
  *
  */
 
-srtp_err_status_t
+srtp_err_status_t rdbx_check_add(srtp_rdbx_t *rdbx, uint32_t idx)
-rdbx_check_add(srtp_rdbx_t *rdbx, uint32_t idx) {
+{
     int delta;
     srtp_xtd_seq_num_t est;
 
@@ -182,8 +176,8 @@ rdbx_check_add(srtp_rdbx_t *rdbx, uint32_t idx) {
  * and thus will be rejected
  */
 
-srtp_err_status_t
+srtp_err_status_t rdbx_check_expect_failure(srtp_rdbx_t *rdbx, uint32_t idx)
-rdbx_check_expect_failure(srtp_rdbx_t *rdbx, uint32_t idx) {
+{
     int delta;
     srtp_xtd_seq_num_t est;
     srtp_err_status_t status;
@@ -200,8 +194,8 @@ rdbx_check_expect_failure(srtp_rdbx_t *rdbx, uint32_t idx) {
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t rdbx_check_add_unordered(srtp_rdbx_t *rdbx, uint32_t idx)
-rdbx_check_add_unordered(srtp_rdbx_t *rdbx, uint32_t idx) {
+{
     int delta;
     srtp_xtd_seq_num_t est;
     srtp_err_status_t rstat;
@@ -209,7 +203,8 @@ rdbx_check_add_unordered(srtp_rdbx_t *rdbx, uint32_t idx) {
     delta = srtp_index_guess(&rdbx->index, &est, idx);
 
     rstat = srtp_rdbx_check(rdbx, delta);
-  if ((rstat != srtp_err_status_ok) && (rstat != srtp_err_status_replay_old)) {
+    if ((rstat != srtp_err_status_ok) &&
+        (rstat != srtp_err_status_replay_old)) {
         printf("replay_check_add_unordered failed at index %u\n", idx);
         return srtp_err_status_algo_fail;
     }
@@ -224,8 +219,8 @@ rdbx_check_add_unordered(srtp_rdbx_t *rdbx, uint32_t idx) {
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t test_replay_dbx(int num_trials, unsigned long ws)
-test_replay_dbx(int num_trials, unsigned long ws) {
+{
     srtp_rdbx_t rdbx;
     uint32_t idx, ircvd;
     ut_connection utc;
@@ -309,7 +304,8 @@ test_replay_dbx(int num_trials, unsigned long ws) {
      * check for false positives for each insertion.
      */
     printf("\ttesting insertion with large gaps...");
-  for (idx=0, ircvd=0; (int) idx < num_trials; idx++, ircvd += (1 << (rand() % 12))) {
+    for (idx = 0, ircvd = 0; (int)idx < num_trials;
+         idx++, ircvd += (1 << (rand() % 12))) {
         status = rdbx_check_add(&rdbx, ircvd);
         if (status)
             return status;
@@ -324,13 +320,11 @@ test_replay_dbx(int num_trials, unsigned long ws) {
     return srtp_err_status_ok;
 }
 
-
-
 #include <time.h>   /* for clock()  */
 #include <stdlib.h> /* for random() */
 
-double
+double rdbx_check_adds_per_second(int num_trials, unsigned long ws)
-rdbx_check_adds_per_second(int num_trials, unsigned long ws) {
+{
     uint32_t i;
     int delta;
     srtp_rdbx_t rdbx;
@@ -346,13 +340,11 @@ rdbx_check_adds_per_second(int num_trials, unsigned long ws) {
     failures = 0;
     timer = clock();
     for (i = 0; (int)i < num_trials; i++) {
-    
         delta = srtp_index_guess(&rdbx.index, &est, i);
 
         if (srtp_rdbx_check(&rdbx, delta) != srtp_err_status_ok)
             ++failures;
-    else
+        else if (srtp_rdbx_add_index(&rdbx, delta) != srtp_err_status_ok)
-      if (srtp_rdbx_add_index(&rdbx, delta) != srtp_err_status_ok)
             ++failures;
     }
     timer = clock() - timer;
@@ -363,4 +355,3 @@ rdbx_check_adds_per_second(int num_trials, unsigned long ws) {
 
     return (double)CLOCKS_PER_SEC * num_trials / timer;
 }
-

libs/srtp/test/replay_driver.c

@@ -59,14 +59,12 @@
 
 unsigned num_trials = 1 << 16;
 
-srtp_err_status_t
+srtp_err_status_t test_rdb_db(void);
-test_rdb_db(void);
 
-double
+double rdb_check_adds_per_second(void);
-rdb_check_adds_per_second(void);
 
-int
+int main(void)
-main (void) {
+{
     srtp_err_status_t err;
 
     printf("testing anti-replay database (srtp_rdb_t)...\n");
@@ -77,21 +75,19 @@ main (void) {
     }
     printf("done\n");
 
-  printf("rdb_check/rdb_adds per second: %e\n",
+    printf("rdb_check/rdb_adds per second: %e\n", rdb_check_adds_per_second());
-	 rdb_check_adds_per_second());
 
     return 0;
 }
 
-
+void print_rdb(srtp_rdb_t *rdb)
-void
+{
-print_rdb(srtp_rdb_t *rdb) {
+    printf("rdb: {%u, %s}\n", rdb->window_start,
-  printf("rdb: {%u, %s}\n", rdb->window_start, v128_bit_string(&rdb->bitmask));
+           v128_bit_string(&rdb->bitmask));
 }
 
-srtp_err_status_t
+srtp_err_status_t rdb_check_add(srtp_rdb_t *rdb, uint32_t idx)
-rdb_check_add(srtp_rdb_t *rdb, uint32_t idx) {
+{
-
     if (srtp_rdb_check(rdb, idx) != srtp_err_status_ok) {
         printf("rdb_check failed at index %u\n", idx);
         return srtp_err_status_fail;
@@ -104,12 +100,13 @@ rdb_check_add(srtp_rdb_t *rdb, uint32_t idx) {
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t rdb_check_expect_failure(srtp_rdb_t *rdb, uint32_t idx)
-rdb_check_expect_failure(srtp_rdb_t *rdb, uint32_t idx) {
+{
     srtp_err_status_t err;
 
     err = srtp_rdb_check(rdb, idx);
-  if ((err != srtp_err_status_replay_old) && (err != srtp_err_status_replay_fail)) {
+    if ((err != srtp_err_status_replay_old) &&
+        (err != srtp_err_status_replay_fail)) {
         printf("rdb_check failed at index %u (false positive)\n", idx);
         return srtp_err_status_fail;
     }
@@ -117,13 +114,14 @@ rdb_check_expect_failure(srtp_rdb_t *rdb, uint32_t idx) {
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t rdb_check_add_unordered(srtp_rdb_t *rdb, uint32_t idx)
-rdb_check_add_unordered(srtp_rdb_t *rdb, uint32_t idx) {
+{
     srtp_err_status_t rstat;
 
     /* printf("index: %u\n", idx); */
     rstat = srtp_rdb_check(rdb, idx);
-  if ((rstat != srtp_err_status_ok) && (rstat != srtp_err_status_replay_old)) {
+    if ((rstat != srtp_err_status_ok) &&
+        (rstat != srtp_err_status_replay_old)) {
         printf("rdb_check_add_unordered failed at index %u\n", idx);
         return rstat;
     }
@@ -138,8 +136,8 @@ rdb_check_add_unordered(srtp_rdb_t *rdb, uint32_t idx) {
     return srtp_err_status_ok;
 }
 
-srtp_err_status_t
+srtp_err_status_t test_rdb_db()
-test_rdb_db() {
+{
     srtp_rdb_t rdb;
     uint32_t idx, ircvd;
     ut_connection utc;
@@ -190,7 +188,8 @@ test_rdb_db() {
     }
 
     /* test insertion with large gaps */
-  for (idx=0, ircvd=0; idx < num_trials; idx++, ircvd += (1 << (rand() % 10))) {
+    for (idx = 0, ircvd = 0; idx < num_trials;
+         idx++, ircvd += (1 << (rand() % 10))) {
         err = rdb_check_add(&rdb, ircvd);
         if (err)
             return err;
@@ -234,7 +233,8 @@ test_rdb_db() {
         return srtp_err_status_fail;
     }
     if (srtp_rdb_increment(&rdb) != srtp_err_status_key_expired) {
-    printf("srtp_rdb_increment of 0x7fffffff did not return srtp_err_status_key_expired\n");
+        printf("srtp_rdb_increment of 0x7fffffff did not return "
+               "srtp_err_status_key_expired\n");
         return srtp_err_status_fail;
     }
     if (srtp_rdb_get_value(&rdb) != 0x7fffffff) {
@@ -242,7 +242,6 @@ test_rdb_db() {
         return srtp_err_status_fail;
     }
 
-
     return srtp_err_status_ok;
 }
 
@@ -251,8 +250,8 @@ test_rdb_db() {
 
 #define REPLAY_NUM_TRIALS 10000000
 
-double
+double rdb_check_adds_per_second(void)
-rdb_check_adds_per_second(void) {
+{
     uint32_t i;
     srtp_rdb_t rdb;
     clock_t timer;

libs/srtp/test/roc_driver.c

@@ -43,7 +43,6 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -61,11 +60,10 @@
 #include "rdbx.h"
 #include "ut_sim.h"
 
-srtp_err_status_t
+srtp_err_status_t roc_test(int num_trials);
-roc_test(int num_trials);
 
-int
+int main(void)
-main (void) {
+{
     srtp_err_status_t status;
 
     printf("rollover counter test driver\n"
@@ -82,11 +80,10 @@ main (void) {
     return 0;
 }
 
-
 #define ROC_VERBOSE 0
 
-srtp_err_status_t
+srtp_err_status_t roc_test(int num_trials)
-roc_test(int num_trials) {
+{
     srtp_xtd_seq_num_t local, est, ref;
     ut_connection utc;
     int i, num_bad_est = 0;
@@ -120,7 +117,6 @@ roc_test(int num_trials) {
     }
     printf("done\n");
 
-
     printf("\ttesting non-sequential insertion...");
     srtp_index_init(&local);
     srtp_index_init(&ref);
@@ -128,7 +124,6 @@ roc_test(int num_trials) {
     ut_init(&utc);
 
     for (i = 0; i < num_trials; i++) {
-    
         /* get next seq num from unreliable transport simulator */
         ircvd = ut_next_index(&utc);
 
@@ -138,8 +133,8 @@ roc_test(int num_trials) {
         /* estimate index based on low bits of ircvd */
         delta = srtp_index_guess(&local, &est, (uint16_t)ref);
 #if ROC_VERBOSE
-    printf("ref: %lld, local: %lld, est: %lld, ircvd: %d, delta: %d\n", 
+        printf("ref: %lld, local: %lld, est: %lld, ircvd: %d, delta: %d\n", ref,
-	   ref, local, est, ircvd, delta);
+               local, est, ircvd, delta);
 #endif
 
         if (local + delta != est) {

libs/srtp/test/rtp.c

@@ -56,8 +56,8 @@
 #define PRINT_DEBUG 0   /* set to 1 to print out debugging data */
 #define VERBOSE_DEBUG 0 /* set to 1 to print out more data      */
 
-int
+int rtp_sendto(rtp_sender_t sender, const void *msg, int len)
-rtp_sendto(rtp_sender_t sender, const void* msg, int len) {
+{
     int octets_sent;
     srtp_err_status_t stat;
     int pkt_len = len + RTP_HEADER_LEN;
@@ -82,9 +82,9 @@ rtp_sendto(rtp_sender_t sender, const void* msg, int len) {
 #if VERBOSE_DEBUG
     srtp_print_packet(&sender->message.header, pkt_len);
 #endif
-  octets_sent = sendto(sender->socket, (void*)&sender->message,
+    octets_sent =
-		       pkt_len, 0, (struct sockaddr *)&sender->addr,
+        sendto(sender->socket, (void *)&sender->message, pkt_len, 0,
-		       sizeof (struct sockaddr_in));
+               (struct sockaddr *)&sender->addr, sizeof(struct sockaddr_in));
 
     if (octets_sent != pkt_len) {
 #if PRINT_DEBUG
@@ -96,13 +96,13 @@ rtp_sendto(rtp_sender_t sender, const void* msg, int len) {
     return octets_sent;
 }
 
-int
+int rtp_recvfrom(rtp_receiver_t receiver, void *msg, int *len)
-rtp_recvfrom(rtp_receiver_t receiver, void *msg, int *len) {
+{
     int octets_recvd;
     srtp_err_status_t stat;
 
-  octets_recvd = recvfrom(receiver->socket, (void *)&receiver->message,
+    octets_recvd = recvfrom(receiver->socket, (void *)&receiver->message, *len,
-			 *len, 0, (struct sockaddr *) NULL, 0);
+                            0, (struct sockaddr *)NULL, 0);
 
     if (octets_recvd == -1) {
         *len = 0;
@@ -116,21 +116,23 @@ rtp_recvfrom(rtp_receiver_t receiver, void *msg, int *len) {
     }
 
 #if PRINT_DEBUG
-  fprintf(stderr, "%d octets received from SSRC %u\n",
+    fprintf(stderr, "%d octets received from SSRC %u\n", octets_recvd,
-	  octets_recvd, receiver->message.header.ssrc);
+            receiver->message.header.ssrc);
 #endif
 #if VERBOSE_DEBUG
     srtp_print_packet(&receiver->message.header, octets_recvd);
 #endif
 
     /* apply srtp */
-  stat = srtp_unprotect(receiver->srtp_ctx,
+    stat = srtp_unprotect(receiver->srtp_ctx, &receiver->message.header,
-			&receiver->message.header, &octets_recvd);
+                          &octets_recvd);
     if (stat) {
-    fprintf(stderr,
+        fprintf(stderr, "error: srtp unprotection failed with code %d%s\n",
-	    "error: srtp unprotection failed with code %d%s\n", stat,
+                stat,
-	    stat == srtp_err_status_replay_fail ? " (replay check failed)" :
+                stat == srtp_err_status_replay_fail
-	    stat == srtp_err_status_auth_fail ? " (auth check failed)" : "");
+                    ? " (replay check failed)"
+                    : stat == srtp_err_status_auth_fail ? " (auth check failed)"
+                                                        : "");
         return -1;
     }
     strncpy(msg, receiver->message.body, octets_recvd);
@@ -138,12 +140,11 @@ rtp_recvfrom(rtp_receiver_t receiver, void *msg, int *len) {
     return octets_recvd;
 }
 
-int
+int rtp_sender_init(rtp_sender_t sender,
-rtp_sender_init(rtp_sender_t sender, 
                     int sock,
                     struct sockaddr_in addr,
-		unsigned int ssrc) {
+                    unsigned int ssrc)
-
+{
     /* set header values */
     sender->message.header.ssrc = htonl(ssrc);
     sender->message.header.ts = 0;
@@ -162,12 +163,11 @@ rtp_sender_init(rtp_sender_t sender,
     return 0;
 }
 
-int
+int rtp_receiver_init(rtp_receiver_t rcvr,
-rtp_receiver_init(rtp_receiver_t rcvr, 
                       int sock,
                       struct sockaddr_in addr,
-		  unsigned int ssrc) {
+                      unsigned int ssrc)
-  
+{
     /* set header values */
     rcvr->message.header.ssrc = htonl(ssrc);
     rcvr->message.header.ts = 0;
@@ -186,42 +186,42 @@ rtp_receiver_init(rtp_receiver_t rcvr,
     return 0;
 }
 
-int
+int rtp_sender_init_srtp(rtp_sender_t sender, const srtp_policy_t *policy)
-rtp_sender_init_srtp(rtp_sender_t sender, const srtp_policy_t *policy) {
+{
     return srtp_create(&sender->srtp_ctx, policy);
 }
 
-int
+int rtp_sender_deinit_srtp(rtp_sender_t sender)
-rtp_sender_deinit_srtp(rtp_sender_t sender) {
+{
     return srtp_dealloc(sender->srtp_ctx);
 }
 
-int
+int rtp_receiver_init_srtp(rtp_receiver_t sender, const srtp_policy_t *policy)
-rtp_receiver_init_srtp(rtp_receiver_t sender, const srtp_policy_t *policy) {
+{
     return srtp_create(&sender->srtp_ctx, policy);
 }
 
-int
+int rtp_receiver_deinit_srtp(rtp_receiver_t sender)
-rtp_receiver_deinit_srtp(rtp_receiver_t sender) {
+{
     return srtp_dealloc(sender->srtp_ctx);
 }
 
-rtp_sender_t 
+rtp_sender_t rtp_sender_alloc(void)
-rtp_sender_alloc(void) {
+{
     return (rtp_sender_t)malloc(sizeof(rtp_sender_ctx_t));
 }
 
-void
+void rtp_sender_dealloc(rtp_sender_t rtp_ctx)
-rtp_sender_dealloc(rtp_sender_t rtp_ctx) {
+{
     free(rtp_ctx);
 }
 
-rtp_receiver_t 
+rtp_receiver_t rtp_receiver_alloc(void)
-rtp_receiver_alloc(void) {
+{
     return (rtp_receiver_t)malloc(sizeof(rtp_receiver_ctx_t));
 }
 
-void
+void rtp_receiver_dealloc(rtp_receiver_t rtp_ctx)
-rtp_receiver_dealloc(rtp_receiver_t rtp_ctx) {
+{
     free(rtp_ctx);
 }

libs/srtp/test/rtp.h

@@ -50,7 +50,6 @@
  *
  */
 
-
 #ifndef SRTP_RTP_H
 #define SRTP_RTP_H
 
@@ -76,7 +75,6 @@ extern "C" {
  */
 #define RTP_MAX_BUF_LEN 16384
 
-
 typedef srtp_hdr_t rtp_hdr_t;
 
 typedef struct {
@@ -98,69 +96,57 @@ typedef struct rtp_receiver_ctx_t {
     struct sockaddr_in addr; /* receiver's address */
 } rtp_receiver_ctx_t;
 
-
 typedef struct rtp_sender_ctx_t *rtp_sender_t;
 
 typedef struct rtp_receiver_ctx_t *rtp_receiver_t;
 
-int
+int rtp_sendto(rtp_sender_t sender, const void *msg, int len);
-rtp_sendto(rtp_sender_t sender, const void* msg, int len);
 
-int
+int rtp_recvfrom(rtp_receiver_t receiver, void *msg, int *len);
-rtp_recvfrom(rtp_receiver_t receiver, void *msg, int *len);
 
-int
+int rtp_receiver_init(rtp_receiver_t rcvr,
-rtp_receiver_init(rtp_receiver_t rcvr, int sock, 
+                      int sock,
-		  struct sockaddr_in addr, unsigned int ssrc);
+                      struct sockaddr_in addr,
+                      unsigned int ssrc);
 
-int
+int rtp_sender_init(rtp_sender_t sender,
-rtp_sender_init(rtp_sender_t sender, int sock, 
+                    int sock,
-		struct sockaddr_in addr, unsigned int ssrc);
+                    struct sockaddr_in addr,
+                    unsigned int ssrc);
 
 /*
  * srtp_sender_init(...) initializes an rtp_sender_t
  */
 
-int
+int srtp_sender_init(
-srtp_sender_init(rtp_sender_t rtp_ctx,          /* structure to be init'ed */
+    rtp_sender_t rtp_ctx,              /* structure to be init'ed */
     struct sockaddr_in name,           /* socket name             */
     srtp_sec_serv_t security_services, /* sec. servs. to be used  */
     unsigned char *input_key           /* master key/salt in hex  */
     );
 
-int
+int srtp_receiver_init(
-srtp_receiver_init(rtp_receiver_t rtp_ctx,       /* structure to be init'ed */
+    rtp_receiver_t rtp_ctx,            /* structure to be init'ed */
     struct sockaddr_in name,           /* socket name             */
     srtp_sec_serv_t security_services, /* sec. servs. to be used  */
     unsigned char *input_key           /* master key/salt in hex  */
     );
 
+int rtp_sender_init_srtp(rtp_sender_t sender, const srtp_policy_t *policy);
 
-int
+int rtp_sender_deinit_srtp(rtp_sender_t sender);
-rtp_sender_init_srtp(rtp_sender_t sender, const srtp_policy_t *policy);
 
-int
+int rtp_receiver_init_srtp(rtp_receiver_t sender, const srtp_policy_t *policy);
-rtp_sender_deinit_srtp(rtp_sender_t sender);
 
-int
+int rtp_receiver_deinit_srtp(rtp_receiver_t sender);
-rtp_receiver_init_srtp(rtp_receiver_t sender, const srtp_policy_t *policy);
 
-int
+rtp_sender_t rtp_sender_alloc(void);
-rtp_receiver_deinit_srtp(rtp_receiver_t sender);
 
+void rtp_sender_dealloc(rtp_sender_t rtp_ctx);
 
-rtp_sender_t 
+rtp_receiver_t rtp_receiver_alloc(void);
-rtp_sender_alloc(void);
-
-void
-rtp_sender_dealloc(rtp_sender_t rtp_ctx);
-
-rtp_receiver_t 
-rtp_receiver_alloc(void);
-
-void
-rtp_receiver_dealloc(rtp_receiver_t rtp_ctx);
 
+void rtp_receiver_dealloc(rtp_receiver_t rtp_ctx);
 
 #ifdef __cplusplus
 }

libs/srtp/test/rtp_decoder.c

@@ -4,14 +4,19 @@
  * decoder structures and functions for SRTP pcap decoder
  *
  * Example:
- * $ wget --no-check-certificate https://raw.githubusercontent.com/gteissier/srtp-decrypt/master/marseillaise-srtp.pcap
+ * $ wget --no-check-certificate \
- * $ ./test/rtp_decoder -a -t 10 -e 128 -b aSBrbm93IGFsbCB5b3VyIGxpdHRsZSBzZWNyZXRz \
+ *     https://raw.githubusercontent.com/gteissier/srtp-decrypt/master/marseillaise-srtp.pcap
- *    < ~/marseillaise-srtp.pcap | text2pcap -t "%M:%S." -u 10000,10000 - - > ./marseillaise-rtp.pcap
+ * $ ./test/rtp_decoder -a -t 10 -e 128 -b \
+ *     aSBrbm93IGFsbCB5b3VyIGxpdHRsZSBzZWNyZXRz \
+ *         < ~/marseillaise-srtp.pcap \
+ *         | text2pcap -t "%M:%S." -u 10000,10000 - - \
+ *         > ./marseillaise-rtp.pcap
  *
  * There is also a different way of setting up key size and tag size
  * based upon RFC 4568 crypto suite specification, i.e.:
  *
- * $ ./test/rtp_decoder -s AES_CM_128_HMAC_SHA1_80 -b aSBrbm93IGFsbCB5b3VyIGxpdHRsZSBzZWNyZXRz ...
+ * $ ./test/rtp_decoder -s AES_CM_128_HMAC_SHA1_80 -b \
+ *     aSBrbm93IGFsbCB5b3VyIGxpdHRsZSBzZWNyZXRz ...
  *
  * Audio can be extracted using extractaudio utility from the RTPproxy
  * package:
@@ -64,6 +69,18 @@
 #include "rtp_decoder.h"
 #include "util.h"
 
+#ifndef timersub
+#define timersub(a, b, result)                                                 \
+    do {                                                                       \
+        (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                          \
+        (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                       \
+        if ((result)->tv_usec < 0) {                                           \
+            --(result)->tv_sec;                                                \
+            (result)->tv_usec += 1000000;                                      \
+        }                                                                      \
+    } while (0)
+#endif
+
 #define MAX_KEY_LEN 96
 #define MAX_FILTER 256
 
@@ -83,8 +100,8 @@ static struct srtp_crypto_suite srtp_crypto_suites[] = {
     {.can_name = NULL }
 };
 
-int
+int main(int argc, char *argv[])
-main (int argc, char *argv[]) {
+{
     char errbuf[PCAP_ERRBUF_SIZE];
     bpf_u_int32 pcap_net = 0;
     pcap_t *pcap_handle;
@@ -109,12 +126,15 @@ main (int argc, char *argv[]) {
     int expected_len;
     int do_list_mods = 0;
 
-  fprintf(stderr, "Using %s [0x%x]\n", srtp_get_version_string(), srtp_get_version());
+    fprintf(stderr, "Using %s [0x%x]\n", srtp_get_version_string(),
+            srtp_get_version());
 
     /* initialize srtp library */
     status = srtp_init();
     if (status) {
-    fprintf(stderr, "error: srtp initialization failed with error code %d\n", status);
+        fprintf(stderr,
+                "error: srtp initialization failed with error code %d\n",
+                status);
         exit(1);
     }
 
@@ -134,7 +154,9 @@ main (int argc, char *argv[]) {
         case 'e':
             scs.key_size = atoi(optarg_s);
             if (scs.key_size != 128 && scs.key_size != 256) {
-        fprintf(stderr, "error: encryption key size must be 128 or 256 (%d)\n", scs.key_size);
+                fprintf(stderr,
+                        "error: encryption key size must be 128 or 256 (%d)\n",
+                        scs.key_size);
                 exit(1);
             }
             input_key = malloc(scs.key_size);
@@ -153,13 +175,15 @@ main (int argc, char *argv[]) {
         case 'd':
             status = srtp_crypto_kernel_set_debug_module(optarg_s, 1);
             if (status) {
-        fprintf(stderr, "error: set debug module (%s) failed\n", optarg_s);
+                fprintf(stderr, "error: set debug module (%s) failed\n",
+                        optarg_s);
                 exit(1);
             }
             break;
         case 'f':
             if (strlen(optarg_s) > MAX_FILTER) {
-        fprintf(stderr, "error: filter bigger than %d characters\n", MAX_FILTER);
+                fprintf(stderr, "error: filter bigger than %d characters\n",
+                        MAX_FILTER);
                 exit(1);
             }
             fprintf(stderr, "Setting filter as %s\n", optarg_s);
@@ -169,13 +193,15 @@ main (int argc, char *argv[]) {
             do_list_mods = 1;
             break;
         case 's':
-      for (i_scsp = &srtp_crypto_suites[0]; i_scsp->can_name != NULL; i_scsp++) {
+            for (i_scsp = &srtp_crypto_suites[0]; i_scsp->can_name != NULL;
+                 i_scsp++) {
                 if (strcasecmp(i_scsp->can_name, optarg_s) == 0) {
                     break;
                 }
             }
             if (i_scsp->can_name == NULL) {
-        fprintf(stderr, "Unknown/unsupported crypto suite name %s\n", optarg_s);
+                fprintf(stderr, "Unknown/unsupported crypto suite name %s\n",
+                        optarg_s);
                 exit(1);
             }
             scs = *i_scsp;
@@ -188,7 +214,8 @@ main (int argc, char *argv[]) {
     }
 
     if (gcm_on && scs.tag_size != 8 && scs.tag_size != 16) {
-    fprintf(stderr, "error: GCM tag size must be 8 or 16 (%d)\n", scs.tag_size);
+        fprintf(stderr, "error: GCM tag size must be 8 or 16 (%d)\n",
+                scs.tag_size);
         // exit(1);
     }
 
@@ -216,8 +243,6 @@ main (int argc, char *argv[]) {
         usage(argv[0]);
     }
 
-
-
     /* report security services selected on the command line */
     fprintf(stderr, "security services: ");
     if (sec_servs & sec_serv_conf)
@@ -250,7 +275,8 @@ main (int argc, char *argv[]) {
                     break;
                 }
 #else
-	fprintf(stderr, "error: GCM mode only supported when using the OpenSSL crypto engine.\n");
+                fprintf(stderr, "error: GCM mode only supported when using the "
+                                "OpenSSL crypto engine.\n");
                 return 0;
 #endif
             } else {
@@ -268,7 +294,9 @@ main (int argc, char *argv[]) {
             break;
         case sec_serv_conf:
             if (gcm_on) {
-	  fprintf(stderr, "error: GCM mode must always be used with auth enabled\n");
+                fprintf(
+                    stderr,
+                    "error: GCM mode must always be used with auth enabled\n");
                 return -1;
             } else {
                 switch (scs.key_size) {
@@ -289,15 +317,18 @@ main (int argc, char *argv[]) {
                 switch (scs.key_size) {
                 case 128:
                     srtp_crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtp);
-	  srtp_crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtcp);
+                    srtp_crypto_policy_set_aes_gcm_128_8_only_auth(
+                        &policy.rtcp);
                     break;
                 case 256:
                     srtp_crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtp);
-	  srtp_crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtcp);
+                    srtp_crypto_policy_set_aes_gcm_256_8_only_auth(
+                        &policy.rtcp);
                     break;
                 }
 #else
-	printf("error: GCM mode only supported when using the OpenSSL crypto engine.\n");
+                printf("error: GCM mode only supported when using the OpenSSL "
+                       "crypto engine.\n");
                 return 0;
 #endif
             } else {
@@ -316,7 +347,8 @@ main (int argc, char *argv[]) {
         policy.window_size = 128;
         policy.allow_repeat_tx = 0;
         policy.rtp.sec_serv = sec_servs;
-    policy.rtcp.sec_serv = sec_servs; //sec_serv_none;  /* we don't do RTCP anyway */
+        policy.rtcp.sec_serv =
+            sec_servs; // sec_serv_none;  /* we don't do RTCP anyway */
         fprintf(stderr, "setting tag len %d\n", scs.tag_size);
         policy.rtp.auth_tag_len = scs.tag_size;
 
@@ -326,12 +358,14 @@ main (int argc, char *argv[]) {
         }
 
         /*
-     * read key from hexadecimal or base64 on command line into an octet string
+         * read key from hexadecimal or base64 on command line into an octet
+         * string
          */
         if (b64_input) {
             int pad;
             expected_len = policy.rtp.cipher_key_len * 4 / 3;
-      len = base64_string_to_octet_string(key, &pad, input_key, expected_len);
+            len = base64_string_to_octet_string(key, &pad, input_key,
+                                                expected_len);
             if (pad != 0) {
                 fprintf(stderr, "error: padding in base64 unexpected\n");
                 exit(1);
@@ -342,25 +376,25 @@ main (int argc, char *argv[]) {
         }
         /* check that hex string is the right length */
         if (len < expected_len) {
-      fprintf(stderr,
+            fprintf(stderr, "error: too few digits in key/salt "
-	      "error: too few digits in key/salt "
                             "(should be %d digits, found %d)\n",
                     expected_len, len);
             exit(1);
         }
         if (strlen(input_key) > policy.rtp.cipher_key_len * 2) {
-      fprintf(stderr,
+            fprintf(stderr, "error: too many digits in key/salt "
-	      "error: too many digits in key/salt "
                             "(should be %d hexadecimal digits, found %u)\n",
                     policy.rtp.cipher_key_len * 2, (unsigned)strlen(input_key));
             exit(1);
         }
 
-    fprintf(stderr, "set master key/salt to %s/", octet_string_hex_string(key, 16));
+        fprintf(stderr, "set master key/salt to %s/",
+                octet_string_hex_string(key, 16));
         fprintf(stderr, "%s\n", octet_string_hex_string(key + 16, 14));
 
     } else {
-      fprintf(stderr, "error: neither encryption or authentication were selected");
+        fprintf(stderr,
+                "error: neither encryption or authentication were selected");
         exit(1);
     }
 
@@ -396,18 +430,19 @@ main (int argc, char *argv[]) {
 
     status = srtp_shutdown();
     if (status) {
-    fprintf(stderr, "error: srtp shutdown failed with error code %d\n", status);
+        fprintf(stderr, "error: srtp shutdown failed with error code %d\n",
+                status);
         exit(1);
     }
 
     return 0;
 }
 
-
+void usage(char *string)
-void
+{
-usage(char *string) {
+    fprintf(
-
+        stderr,
-  fprintf(stderr, "usage: %s [-d <debug>]* [[-k][-b] <key> [-a][-e]]\n"
+        "usage: %s [-d <debug>]* [[-k][-b] <key> [-a][-e]]\n"
         "or     %s -l\n"
         "where  -a use message authentication\n"
         "       -e <key size> use encryption (use 128 or 256 for key size)\n"
@@ -422,32 +457,32 @@ usage(char *string) {
         "          on RFC4568-style crypto suite specification\n",
         string, string);
     exit(1);
-
 }
 
-rtp_decoder_t
+rtp_decoder_t rtp_decoder_alloc(void)
-rtp_decoder_alloc(void) {
+{
     return (rtp_decoder_t)malloc(sizeof(rtp_decoder_ctx_t));
 }
 
-void
+void rtp_decoder_dealloc(rtp_decoder_t rtp_ctx)
-rtp_decoder_dealloc(rtp_decoder_t rtp_ctx) {
+{
     free(rtp_ctx);
 }
 
-srtp_err_status_t
+srtp_err_status_t rtp_decoder_init_srtp(rtp_decoder_t decoder,
-rtp_decoder_init_srtp(rtp_decoder_t decoder, unsigned int ssrc) {
+                                        unsigned int ssrc)
+{
     decoder->policy.ssrc.value = htonl(ssrc);
     return srtp_create(&decoder->srtp_ctx, &decoder->policy);
 }
 
-int
+int rtp_decoder_deinit_srtp(rtp_decoder_t decoder)
-rtp_decoder_deinit_srtp(rtp_decoder_t decoder) {
+{
     return srtp_dealloc(decoder->srtp_ctx);
 }
 
-int
+int rtp_decoder_init(rtp_decoder_t dcdr, srtp_policy_t policy)
-rtp_decoder_init(rtp_decoder_t dcdr, srtp_policy_t policy) {
+{
     dcdr->rtp_offset = DEFAULT_RTP_OFFSET;
     dcdr->srtp_ctx = NULL;
     dcdr->start_tv.tv_usec = 0;
@@ -462,7 +497,8 @@ rtp_decoder_init(rtp_decoder_t dcdr, srtp_policy_t policy) {
  * decodes key as base64
  */
 
-void hexdump(const void *ptr, size_t size) {
+void hexdump(const void *ptr, size_t size)
+{
     int i, j;
     const unsigned char *cptr = ptr;
 
@@ -475,9 +511,10 @@ void hexdump(const void *ptr, size_t size) {
     }
 }
 
-void
+void rtp_decoder_handle_pkt(u_char *arg,
-rtp_decoder_handle_pkt(u_char *arg, const struct pcap_pkthdr *hdr,
+                            const struct pcap_pkthdr *hdr,
-	const u_char *bytes) {
+                            const u_char *bytes)
+{
     rtp_decoder_t dcdr = (rtp_decoder_t)arg;
     int pktsize;
     struct timeval delta;
@@ -517,11 +554,14 @@ rtp_decoder_handle_pkt(u_char *arg, const struct pcap_pkthdr *hdr,
         return;
     }
     timersub(&hdr->ts, &dcdr->start_tv, &delta);
-  fprintf(stdout, "%02ld:%02ld.%06ld\n", delta.tv_sec/60, delta.tv_sec%60, (long)delta.tv_usec);
+    fprintf(stdout, "%02ld:%02ld.%06ld\n", delta.tv_sec / 60, delta.tv_sec % 60,
+            (long)delta.tv_usec);
     hexdump(&dcdr->message, octets_recvd);
 }
 
-void rtp_print_error(srtp_err_status_t status, char *message) {
+void rtp_print_error(srtp_err_status_t status, char *message)
+{
+    // clang-format off
     fprintf(stderr,
             "error: %s %d%s\n", message, status,
             status == srtp_err_status_replay_fail ? " (replay check failed)" :
@@ -530,4 +570,5 @@ void rtp_print_error(srtp_err_status_t status, char *message) {
             status == srtp_err_status_cipher_fail ? " (cipher failed)" :
             status == srtp_err_status_key_expired ? " (key expired)" :
             status == srtp_err_status_auth_fail ? " (auth check failed)" : "");
+    // clang-format on
 }

libs/srtp/test/rtp_decoder.h

@@ -44,7 +44,6 @@
  *
  */
 
-
 #ifndef RTP_DECODER_H
 #define RTP_DECODER_H
 
@@ -88,7 +87,9 @@ char *decode_sdes(char *in, char *out);
 /*
  * pcap handling
  */
-void rtp_decoder_handle_pkt(u_char *arg, const struct pcap_pkthdr *hdr, const u_char *bytes);
+void rtp_decoder_handle_pkt(u_char *arg,
+                            const struct pcap_pkthdr *hdr,
+                            const u_char *bytes);
 
 rtp_decoder_t rtp_decoder_alloc(void);
 
@@ -96,9 +97,9 @@ void rtp_decoder_dealloc(rtp_decoder_t rtp_ctx);
 
 int rtp_decoder_init(rtp_decoder_t dcdr, srtp_policy_t policy);
 
-srtp_err_status_t rtp_decoder_init_srtp(rtp_decoder_t decoder, unsigned int ssrc);
+srtp_err_status_t rtp_decoder_init_srtp(rtp_decoder_t decoder,
+                                        unsigned int ssrc);
 
-int
+int rtp_decoder_deinit_srtp(rtp_decoder_t decoder);
-rtp_decoder_deinit_srtp(rtp_decoder_t decoder);
 
 #endif /* RTP_DECODER_H */

libs/srtp/test/rtpw.c

@@ -8,7 +8,7 @@
  *
  * This app is a simple RTP application intended only for testing
  * libsrtp.  It reads one word at a time from words.txt (or
- * whatever file is specified as DICT_FILE), and sends one word out
+ * whatever file is specified as DICT_FILE or with -w), and sends one word out
  * each USEC_RATE microseconds.  Secure RTP protections can be
  * applied.  See the usage() function for more details.
  *
@@ -50,7 +50,6 @@
  *
  */
 
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -95,7 +94,6 @@
 #define ADDR_IS_MULTICAST(a) IN_MULTICAST(htonl(a))
 #define MAX_KEY_LEN 96
 
-
 #ifndef HAVE_USLEEP
 #ifdef HAVE_WINDOWS_H
 #define usleep(us) Sleep((us) / 1000)
@@ -104,22 +102,18 @@
 #endif
 #endif
 
-
 /*
  * the function usage() prints an error message describing how this
  * program should be called, then calls exit()
  */
 
-void
+void usage(char *prog_name);
-usage(char *prog_name);
 
 /*
  * leave_group(...) de-registers from a multicast group
  */
 
-void
+void leave_group(int sock, struct ip_mreq mreq, char *name);
-leave_group(int sock, struct ip_mreq mreq, char *name);
-
 
 /*
  * setup_signal_handler() sets up a signal handler to trigger
@@ -139,8 +133,8 @@ volatile int interrupted = 0;
 
 typedef enum { sender, receiver, unknown } program_type;
 
-int
+int main(int argc, char *argv[])
-main (int argc, char *argv[]) {
+{
     char *dictfile = DICT_FILE;
     FILE *dict;
     char word[MAX_WORD_LEN];
@@ -192,13 +186,14 @@ main (int argc, char *argv[]) {
     /* initialize srtp library */
     status = srtp_init();
     if (status) {
-    printf("error: srtp initialization failed with error code %d\n", status);
+        printf("error: srtp initialization failed with error code %d\n",
+               status);
         exit(1);
     }
 
     /* check args */
     while (1) {
-    c = getopt_s(argc, argv, "b:k:rsgt:ae:ld:");
+        c = getopt_s(argc, argv, "b:k:rsgt:ae:ld:w:");
         if (c == -1) {
             break;
         }
@@ -212,7 +207,8 @@ main (int argc, char *argv[]) {
         case 'e':
             key_size = atoi(optarg_s);
             if (key_size != 128 && key_size != 256) {
-        printf("error: encryption key size must be 128 or 256 (%d)\n", key_size);
+                printf("error: encryption key size must be 128 or 256 (%d)\n",
+                       key_size);
                 exit(1);
             }
             sec_servs |= sec_serv_conf;
@@ -247,6 +243,9 @@ main (int argc, char *argv[]) {
         case 'l':
             do_list_mods = 1;
             break;
+        case 'w':
+            dictfile = optarg_s;
+            break;
         default:
             usage(argv[0]);
         }
@@ -288,7 +287,8 @@ main (int argc, char *argv[]) {
 /* set address */
 #ifdef HAVE_INET_ATON
     if (0 == inet_aton(address, &rcvr_addr)) {
-    fprintf(stderr, "%s: cannot parse IP v4 address %s\n", argv[0], address);
+        fprintf(stderr, "%s: cannot parse IP v4 address %s\n", argv[0],
+                address);
         exit(1);
     }
     if (rcvr_addr.s_addr == INADDR_NONE) {
@@ -298,7 +298,8 @@ main (int argc, char *argv[]) {
 #else
     rcvr_addr.s_addr = inet_addr(address);
     if (0xffffffff == rcvr_addr.s_addr) {
-    fprintf(stderr, "%s: cannot parse IP v4 address %s\n", argv[0], address);
+        fprintf(stderr, "%s: cannot parse IP v4 address %s\n", argv[0],
+                address);
         exit(1);
     }
 #endif
@@ -325,7 +326,8 @@ main (int argc, char *argv[]) {
             ret = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
                              sizeof(ttl));
             if (ret < 0) {
-	fprintf(stderr, "%s: Failed to set TTL for multicast group", argv[0]);
+                fprintf(stderr, "%s: Failed to set TTL for multicast group",
+                        argv[0]);
                 perror("");
                 exit(1);
             }
@@ -374,7 +376,8 @@ main (int argc, char *argv[]) {
                     break;
                 }
 #else
-	printf("error: GCM mode only supported when using the OpenSSL crypto engine.\n");
+                printf("error: GCM mode only supported when using the OpenSSL "
+                       "crypto engine.\n");
                 return 0;
 #endif
             } else {
@@ -392,7 +395,8 @@ main (int argc, char *argv[]) {
             break;
         case sec_serv_conf:
             if (gcm_on) {
-	  printf("error: GCM mode must always be used with auth enabled\n");
+                printf(
+                    "error: GCM mode must always be used with auth enabled\n");
                 return -1;
             } else {
                 switch (key_size) {
@@ -413,15 +417,18 @@ main (int argc, char *argv[]) {
                 switch (key_size) {
                 case 128:
                     srtp_crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtp);
-	  srtp_crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtcp);
+                    srtp_crypto_policy_set_aes_gcm_128_8_only_auth(
+                        &policy.rtcp);
                     break;
                 case 256:
                     srtp_crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtp);
-	  srtp_crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtcp);
+                    srtp_crypto_policy_set_aes_gcm_256_8_only_auth(
+                        &policy.rtcp);
                     break;
                 }
 #else
-	printf("error: GCM mode only supported when using the OpenSSL crypto engine.\n");
+                printf("error: GCM mode only supported when using the OpenSSL "
+                       "crypto engine.\n");
                 return 0;
 #endif
             } else {
@@ -448,12 +455,14 @@ main (int argc, char *argv[]) {
         }
 
         /*
-     * read key from hexadecimal or base64 on command line into an octet string
+         * read key from hexadecimal or base64 on command line into an octet
+         * string
          */
         if (b64_input) {
             int pad;
             expected_len = (policy.rtp.cipher_key_len * 4) / 3;
-        len = base64_string_to_octet_string(key, &pad, input_key, expected_len);
+            len = base64_string_to_octet_string(key, &pad, input_key,
+                                                expected_len);
             if (pad != 0) {
                 fprintf(stderr, "error: padding in base64 unexpected\n");
                 exit(1);
@@ -464,15 +473,13 @@ main (int argc, char *argv[]) {
         }
         /* check that hex string is the right length */
         if (len < expected_len) {
-      fprintf(stderr, 
+            fprintf(stderr, "error: too few digits in key/salt "
-	      "error: too few digits in key/salt "
                             "(should be %d digits, found %d)\n",
                     expected_len, len);
             exit(1);
         }
         if ((int)strlen(input_key) > policy.rtp.cipher_key_len * 2) {
-      fprintf(stderr, 
+            fprintf(stderr, "error: too many digits in key/salt "
-	      "error: too many digits in key/salt "
                             "(should be %d hexadecimal digits, found %u)\n",
                     policy.rtp.cipher_key_len * 2, (unsigned)strlen(input_key));
             exit(1);
@@ -503,7 +510,6 @@ main (int argc, char *argv[]) {
     }
 
     if (prog_type == sender) {
-
 #if BEW
         /* bind to local socket (to match crypto policy, if need be) */
         memset(&local, 0, sizeof(struct sockaddr_in));
@@ -526,8 +532,7 @@ main (int argc, char *argv[]) {
         rtp_sender_init(snd, sock, name, ssrc);
         status = rtp_sender_init_srtp(snd, &policy);
         if (status) {
-      fprintf(stderr, 
+            fprintf(stderr, "error: srtp_create() failed with code %d\n",
-	      "error: srtp_create() failed with code %d\n", 
                     status);
             exit(1);
         }
@@ -580,8 +585,7 @@ main (int argc, char *argv[]) {
         rtp_receiver_init(rcvr, sock, name, ssrc);
         status = rtp_receiver_init_srtp(rcvr, &policy);
         if (status) {
-      fprintf(stderr, 
+            fprintf(stderr, "error: srtp_create() failed with code %d\n",
-	      "error: srtp_create() failed with code %d\n", 
                     status);
             exit(1);
         }
@@ -624,10 +628,8 @@ main (int argc, char *argv[]) {
     return 0;
 }
 
-
+void usage(char *string)
-void
+{
-usage(char *string) {
-
     printf("usage: %s [-d <debug>]* [-k <key> [-a][-e]] "
            "[-s | -r] dest_ip dest_port\n"
            "or     %s -l\n"
@@ -640,15 +642,14 @@ usage(char *string) {
            "       -s act as rtp sender\n"
            "       -r act as rtp receiver\n"
            "       -l list debug modules\n"
-	 "       -d <debug> turn on debugging for module <debug>\n",
+           "       -d <debug> turn on debugging for module <debug>\n"
-	 string, string);
+           "       -w <wordsfile> use <wordsfile> for input, rather than %s\n",
+           string, string, DICT_FILE);
     exit(1);
-  
 }
 
-
+void leave_group(int sock, struct ip_mreq mreq, char *name)
-void
+{
-leave_group(int sock, struct ip_mreq mreq, char *name) {
     int ret;
 
     ret = setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (void *)&mreq,

libs/srtp/test/test_srtp.c

@@ -146,9 +146,9 @@ void srtp_calc_aead_iv_srtcp_seq_num_over_0x7FFFFFFF_bad_param()
  */
 void srtp_calc_aead_iv_srtcp_distinct_iv_per_sequence_number()
 {
+#define SAMPLE_COUNT (3)
     // Preconditions
     // Test each significant bit high in each full byte.
-    #define SAMPLE_COUNT (3)
     srtp_session_keys_t session_keys;
     srtcp_hdr_t header;
     v128_t output_iv[SAMPLE_COUNT];
@@ -173,8 +173,8 @@ void srtp_calc_aead_iv_srtcp_distinct_iv_per_sequence_number()
     size_t i = 0;
     for (i = 0; i < SAMPLE_COUNT; i++) {
         TEST_CHECK(srtp_calc_aead_iv_srtcp(&session_keys, &output_iv[i],
-                                           sequence_num[i], &header)
+                                           sequence_num[i],
-                   == srtp_err_status_ok);
+                                           &header) == srtp_err_status_ok);
     }
 
     // Then all IVs are as expected

libs/srtp/test/util.c

@@ -52,29 +52,52 @@ char bit_string[MAX_PRINT_STRING_LEN];
 static inline int hex_char_to_nibble(uint8_t c)
 {
     switch (c) {
-    case ('0'): return 0x0;
+    case ('0'):
-    case ('1'): return 0x1;
+        return 0x0;
-    case ('2'): return 0x2;
+    case ('1'):
-    case ('3'): return 0x3;
+        return 0x1;
-    case ('4'): return 0x4;
+    case ('2'):
-    case ('5'): return 0x5;
+        return 0x2;
-    case ('6'): return 0x6;
+    case ('3'):
-    case ('7'): return 0x7;
+        return 0x3;
-    case ('8'): return 0x8;
+    case ('4'):
-    case ('9'): return 0x9;
+        return 0x4;
-    case ('a'): return 0xa;
+    case ('5'):
-    case ('A'): return 0xa;
+        return 0x5;
-    case ('b'): return 0xb;
+    case ('6'):
-    case ('B'): return 0xb;
+        return 0x6;
-    case ('c'): return 0xc;
+    case ('7'):
-    case ('C'): return 0xc;
+        return 0x7;
-    case ('d'): return 0xd;
+    case ('8'):
-    case ('D'): return 0xd;
+        return 0x8;
-    case ('e'): return 0xe;
+    case ('9'):
-    case ('E'): return 0xe;
+        return 0x9;
-    case ('f'): return 0xf;
+    case ('a'):
-    case ('F'): return 0xf;
+        return 0xa;
-    default: return -1; /* this flags an error */
+    case ('A'):
+        return 0xa;
+    case ('b'):
+        return 0xb;
+    case ('B'):
+        return 0xb;
+    case ('c'):
+        return 0xc;
+    case ('C'):
+        return 0xc;
+    case ('d'):
+        return 0xd;
+    case ('D'):
+        return 0xd;
+    case ('e'):
+        return 0xe;
+    case ('E'):
+        return 0xe;
+    case ('f'):
+        return 0xf;
+    case ('F'):
+        return 0xf;
+    default:
+        return -1; /* this flags an error */
     }
     /* NOTREACHED */
     return -1; /* this keeps compilers from complaining */
@@ -152,7 +175,9 @@ static int base64_block_to_octet_triple (char *out, char *in)
         char *p = strchr(b64chars, in[i]);
         if (p != NULL) {
             sextets[i] = p - b64chars;
-        } else{  j++; }
+        } else {
+            j++;
+        }
     }
 
     out[0] = (sextets[0] << 2) | (sextets[1] >> 4);

w32/Library/FreeSwitchCore.2017.vcxproj

@@ -112,6 +112,7 @@
   <ItemDefinitionGroup>
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\libs\apr\include\arch\win32;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>HAVE_WINSOCK2_H;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <PostBuildEvent>
       <Command>if not exist "$(OutDir)conf" xcopy "$(SolutionDir)conf\vanilla\*.*" "$(OutDir)conf\" /C /D /Y /S

w32/openssl.props

@@ -68,7 +68,7 @@
       <AdditionalIncludeDirectories>$(OpenSSLLibDir)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <AdditionalIncludeDirectories Condition="'$(Platform)'=='Win32'">$(OpenSSLLibDir)\include_x86;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <AdditionalIncludeDirectories Condition="'$(Platform)'=='x64'">$(OpenSSLLibDir)\include_x64;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>HAVE_OPENSSL;HAVE_OPENSSL_DTLS_SRTP;HAVE_OPENSSL_DTLS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>OPENSSL;HAVE_OPENSSL;HAVE_OPENSSL_DTLS_SRTP;HAVE_OPENSSL_DTLS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
       <AdditionalLibraryDirectories>$(OpenSSLLibDir)\binaries\$(Platform)\$(LibraryConfiguration)\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>