FFmpeg: libavutil/aes_ctr.c Source File

FFmpeg

[フレーム]

libavutil

aes_ctr.c

Go to the documentation of this file.

1 /*

2 * AES-CTR cipher

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include <string.h>

24 #include "aes_ctr.h"

25 #include "aes.h"

26 #include "aes_internal.h"

27 #include "macros.h"

28 #include "mem.h"

29 #include "random_seed.h"

31 #define AES_BLOCK_SIZE (16)

33 typedef struct AVAESCTR {

34 uint8_t counter[AES_BLOCK_SIZE];

35 uint8_t encrypted_counter[AES_BLOCK_SIZE];

36 int block_offset;

37 AVAES aes;

38 } AVAESCTR;

40 struct AVAESCTR *av_aes_ctr_alloc(void)

41 {

42 return av_mallocz(sizeof(struct AVAESCTR));

43 }

45 void av_aes_ctr_set_iv(struct AVAESCTR *a, const uint8_t* iv)

46 {

47 memcpy(a->counter, iv, AES_CTR_IV_SIZE);

48 memset(a->counter + AES_CTR_IV_SIZE, 0, sizeof(a->counter) - AES_CTR_IV_SIZE);

49 a->block_offset = 0;

50 }

52 void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t* iv)

53 {

54 memcpy(a->counter, iv, sizeof(a->counter));

55 a->block_offset = 0;

56 }

58 const uint8_t* av_aes_ctr_get_iv(struct AVAESCTR *a)

59 {

60 return a->counter;

61 }

63 void av_aes_ctr_set_random_iv(struct AVAESCTR *a)

64 {

65 uint32_t iv[2];

67 iv[0] = av_get_random_seed();

68 iv[1] = av_get_random_seed();

70 av_aes_ctr_set_iv(a, (uint8_t*)iv);

71 }

73 int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key)

74 {

75 av_aes_init(&a->aes, key, 128, 0);

77 memset(a->counter, 0, sizeof(a->counter));

78 a->block_offset = 0;

80 return 0;

81 }

83 void av_aes_ctr_free(struct AVAESCTR *a)

84 {

85 av_free(a);

86 }

88 static void av_aes_ctr_increment_be64(uint8_t* counter)

89 {

90 uint8_t* cur_pos;

92 for (cur_pos = counter + 7; cur_pos >= counter; cur_pos--) {

93 (*cur_pos)++;

94 if (*cur_pos != 0) {

95 break;

96 }

97 }

98 }

100 void av_aes_ctr_increment_iv(struct AVAESCTR *a)

101 {

102 av_aes_ctr_increment_be64(a->counter);

103 memset(a->counter + AES_CTR_IV_SIZE, 0, sizeof(a->counter) - AES_CTR_IV_SIZE);

104 a->block_offset = 0;

105 }

106

107 void av_aes_ctr_crypt(struct AVAESCTR *a, uint8_t *dst, const uint8_t *src, int count)

108 {

109 const uint8_t* src_end = src + count;

110 const uint8_t* cur_end_pos;

111 uint8_t* encrypted_counter_pos;

112

113 while (src < src_end) {

114 if (a->block_offset == 0) {

115 av_aes_crypt(&a->aes, a->encrypted_counter, a->counter, 1, NULL, 0);

116

117 av_aes_ctr_increment_be64(a->counter + 8);

118 }

119

120 encrypted_counter_pos = a->encrypted_counter + a->block_offset;

121 cur_end_pos = src + AES_BLOCK_SIZE - a->block_offset;

122 cur_end_pos = FFMIN(cur_end_pos, src_end);

123

124 a->block_offset += cur_end_pos - src;

125 a->block_offset &= (AES_BLOCK_SIZE - 1);

126

127 while (src < cur_end_pos) {

128 *dst++ = *src++ ^ *encrypted_counter_pos++;

129 }

130 }

131 }

av_aes_init

int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)

Initialize an AVAES context.

Definition: aes.c:201

AVAESCTR::block_offset

int block_offset

Definition: aes_ctr.c:36

av_aes_ctr_set_random_iv

void av_aes_ctr_set_random_iv(struct AVAESCTR *a)

Generate a random iv.

Definition: aes_ctr.c:63

av_get_random_seed

uint32_t av_get_random_seed(void)

Get a seed to use in conjunction with random functions.

Definition: random_seed.c:121

macros.h

av_aes_ctr_get_iv

const uint8_t * av_aes_ctr_get_iv(struct AVAESCTR *a)

Get the current iv.

Definition: aes_ctr.c:58

AES_BLOCK_SIZE

#define AES_BLOCK_SIZE

Definition: aes_ctr.c:31

key

const char * key

Definition: hwcontext_opencl.c:174

AVAESCTR::aes

AVAES aes

Definition: aes_ctr.c:37

aes.h

NULL

#define NULL

Definition: coverity.c:32

av_aes_ctr_alloc

struct AVAESCTR * av_aes_ctr_alloc(void)

Allocate an AVAESCTR context.

Definition: aes_ctr.c:40

av_aes_crypt

void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)

Encrypt or decrypt a buffer using a previously initialized context.

Definition: aes.c:169

av_aes_ctr_init

int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key)

Initialize an AVAESCTR context.

Definition: aes_ctr.c:73

av_aes_ctr_set_iv

void av_aes_ctr_set_iv(struct AVAESCTR *a, const uint8_t *iv)

Forcefully change the 8-byte iv.

Definition: aes_ctr.c:45

av_aes_ctr_set_full_iv

void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t *iv)

Forcefully change the "full" 16-byte iv, including the counter.

Definition: aes_ctr.c:52

aes_ctr.h

AVAESCTR::encrypted_counter

uint8_t encrypted_counter[AES_BLOCK_SIZE]

Definition: aes_ctr.c:35

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

aes_internal.h

av_aes_ctr_free

void av_aes_ctr_free(struct AVAESCTR *a)

Release an AVAESCTR context.

Definition: aes_ctr.c:83

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...