← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/third_party/srtp/crypto/include/cipher.h

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.1.0/third_party/srtp/crypto/include/cipher.h
 
1
/*
 
2
 * cipher.h
 
3
 *
 
4
 * common interface to ciphers
 
5
 *
 
6
 * David A. McGrew
 
7
 * Cisco Systems, Inc.
 
8
 */
 
9
/*
 
10
 *      
 
11
 * Copyright (c) 2001-2006, Cisco Systems, Inc.
 
12
 * All rights reserved.
 
13
 * 
 
14
 * Redistribution and use in source and binary forms, with or without
 
15
 * modification, are permitted provided that the following conditions
 
16
 * are met:
 
17
 * 
 
18
 *   Redistributions of source code must retain the above copyright
 
19
 *   notice, this list of conditions and the following disclaimer.
 
20
 * 
 
21
 *   Redistributions in binary form must reproduce the above
 
22
 *   copyright notice, this list of conditions and the following
 
23
 *   disclaimer in the documentation and/or other materials provided
 
24
 *   with the distribution.
 
25
 * 
 
26
 *   Neither the name of the Cisco Systems, Inc. nor the names of its
 
27
 *   contributors may be used to endorse or promote products derived
 
28
 *   from this software without specific prior written permission.
 
29
 * 
 
30
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
31
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
32
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 
33
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 
34
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 
35
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
36
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
37
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
38
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
39
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
40
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 
41
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 
42
 *
 
43
 */
 
44
 
 
45
 
 
46
#ifndef CIPHER_H
 
47
#define CIPHER_H
 
48
 
 
49
#include "datatypes.h"          
 
50
#include "rdbx.h"               /* for xtd_seq_num_t */
 
51
#include "err.h"                /* for error codes  */
 
52
 
 
53
 
 
54
/**
 
55
 * @brief cipher_direction_t defines a particular cipher operation. 
 
56
 *
 
57
 * A cipher_direction_t is an enum that describes a particular cipher
 
58
 * operation, i.e. encryption or decryption.  For some ciphers, this
 
59
 * distinction does not matter, but for others, it is essential.
 
60
 */
 
61
 
 
62
typedef enum { 
 
63
  direction_encrypt, /**< encryption (convert plaintext to ciphertext) */
 
64
  direction_decrypt, /**< decryption (convert ciphertext to plaintext) */
 
65
  direction_any      /**< encryption or decryption                     */
 
66
} cipher_direction_t;
 
67
 
 
68
/*
 
69
 * the cipher_pointer and cipher_type_pointer definitions are needed
 
70
 * as cipher_t and cipher_type_t are not yet defined
 
71
 */
 
72
 
 
73
typedef struct cipher_type_t *cipher_type_pointer_t;
 
74
typedef struct cipher_t      *cipher_pointer_t;
 
75
 
 
76
/*
 
77
 *  a cipher_alloc_func_t allocates (but does not initialize) a cipher_t 
 
78
 */
 
79
 
 
80
typedef err_status_t (*cipher_alloc_func_t)
 
81
     (cipher_pointer_t *cp, int key_len);
 
82
 
 
83
/* 
 
84
 * a cipher_init_func_t [re-]initializes a cipher_t with a given key
 
85
 * and direction (i.e., encrypt or decrypt)
 
86
 */
 
87
 
 
88
typedef err_status_t (*cipher_init_func_t)
 
89
  (void *state, const uint8_t *key, cipher_direction_t dir);
 
90
 
 
91
/* a cipher_dealloc_func_t de-allocates a cipher_t */
 
92
 
 
93
typedef err_status_t (*cipher_dealloc_func_t)(cipher_pointer_t cp);
 
94
 
 
95
/* a cipher_set_segment_func_t sets the segment index of a cipher_t */
 
96
 
 
97
typedef err_status_t (*cipher_set_segment_func_t)
 
98
     (void *state, xtd_seq_num_t idx);
 
99
 
 
100
/* a cipher_encrypt_func_t encrypts data in-place */
 
101
 
 
102
typedef err_status_t (*cipher_encrypt_func_t)
 
103
     (void *state, uint8_t *buffer, unsigned int *octets_to_encrypt);
 
104
 
 
105
/* a cipher_decrypt_func_t decrypts data in-place */
 
106
 
 
107
typedef err_status_t (*cipher_decrypt_func_t)
 
108
     (void *state, uint8_t *buffer, unsigned int *octets_to_decrypt);
 
109
 
 
110
/* 
 
111
 * a cipher_set_nonce_seq_func_t function sets both the nonce
 
112
 * and the extended sequence number
 
113
 */
 
114
 
 
115
typedef err_status_t (*cipher_set_iv_func_t)
 
116
     (cipher_pointer_t cp, void *iv);
 
117
 
 
118
/*
 
119
 * cipher_test_case_t is a (list of) key, salt, xtd_seq_num_t,
 
120
 * plaintext, and ciphertext values that are known to be correct for a
 
121
 * particular cipher.  this data can be used to test an implementation
 
122
 * in an on-the-fly self test of the correcness of the implementation.
 
123
 * (see the cipher_type_self_test() function below)
 
124
 */
 
125
 
 
126
typedef struct cipher_test_case_t {
 
127
  int key_length_octets;                      /* octets in key            */
 
128
  uint8_t *key;                               /* key                      */
 
129
  uint8_t *idx;                               /* packet index             */
 
130
  unsigned int plaintext_length_octets;       /* octets in plaintext      */ 
 
131
  uint8_t *plaintext;                         /* plaintext                */
 
132
  unsigned int ciphertext_length_octets;      /* octets in plaintext      */ 
 
133
  uint8_t *ciphertext;                        /* ciphertext               */
 
134
  struct cipher_test_case_t *next_test_case;  /* pointer to next testcase */
 
135
} cipher_test_case_t;
 
136
 
 
137
/* cipher_type_t defines the 'metadata' for a particular cipher type */
 
138
 
 
139
typedef struct cipher_type_t {
 
140
  cipher_alloc_func_t         alloc;
 
141
  cipher_dealloc_func_t       dealloc;
 
142
  cipher_init_func_t          init;
 
143
  cipher_encrypt_func_t       encrypt;
 
144
  cipher_encrypt_func_t       decrypt;
 
145
  cipher_set_iv_func_t        set_iv;
 
146
  char                       *description;
 
147
  int                         ref_count;
 
148
  cipher_test_case_t         *test_data;
 
149
  debug_module_t             *debug;
 
150
} cipher_type_t;
 
151
 
 
152
/*
 
153
 * cipher_t defines an instantiation of a particular cipher, with fixed
 
154
 * key length, key and salt values
 
155
 */
 
156
 
 
157
typedef struct cipher_t {
 
158
  cipher_type_t *type;
 
159
  void          *state;
 
160
  int            key_len;
 
161
#ifdef FORCE_64BIT_ALIGN
 
162
  int            pad;
 
163
#endif
 
164
} cipher_t;
 
165
 
 
166
/* some syntactic sugar on these function types */
 
167
 
 
168
#define cipher_type_alloc(ct, c, klen) ((ct)->alloc((c), (klen)))
 
169
 
 
170
#define cipher_dealloc(c) (((c)->type)->dealloc(c))
 
171
 
 
172
#define cipher_init(c, k, dir) (((c)->type)->init(((c)->state), (k), (dir)))
 
173
 
 
174
#define cipher_encrypt(c, buf, len) \
 
175
        (((c)->type)->encrypt(((c)->state), (buf), (len)))
 
176
 
 
177
#define cipher_decrypt(c, buf, len) \
 
178
        (((c)->type)->decrypt(((c)->state), (buf), (len)))
 
179
 
 
180
#define cipher_set_iv(c, n)                           \
 
181
  ((c) ? (((c)->type)->set_iv(((cipher_pointer_t)(c)->state), (n))) :   \
 
182
                                err_status_no_such_op)  
 
183
 
 
184
err_status_t
 
185
cipher_output(cipher_t *c, uint8_t *buffer, int num_octets_to_output);
 
186
 
 
187
 
 
188
/* some bookkeeping functions */
 
189
 
 
190
int
 
191
cipher_get_key_length(const cipher_t *c);
 
192
 
 
193
 
 
194
/* 
 
195
 * cipher_type_self_test() tests a cipher against test cases provided in 
 
196
 * an array of values of key/xtd_seq_num_t/plaintext/ciphertext 
 
197
 * that is known to be good
 
198
 */
 
199
 
 
200
err_status_t
 
201
cipher_type_self_test(const cipher_type_t *ct);
 
202
 
 
203
 
 
204
/*
 
205
 * cipher_bits_per_second(c, l, t) computes (and estimate of) the
 
206
 * number of bits that a cipher implementation can encrypt in a second
 
207
 * 
 
208
 * c is a cipher (which MUST be allocated and initialized already), l
 
209
 * is the length in octets of the test data to be encrypted, and t is
 
210
 * the number of trials
 
211
 *
 
212
 * if an error is encountered, then the value 0 is returned
 
213
 */
 
214
 
 
215
uint64_t
 
216
cipher_bits_per_second(cipher_t *c, int octets_in_buffer, int num_trials);
 
217
 
 
218
#endif /* CIPHER_H */