/src/liboqs/src/common/aes/aes_impl.c

Source
// SPDX-License-Identifier: MIT

#include <assert.h>
#include <stdio.h>
#include <string.h>

#include <oqs/common.h>

#include "aes.h"
#include "aes_local.h"

#if defined(OQS_DIST_X86_64_BUILD)
#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
   do { \
      if (OQS_CPU_has_extension(OQS_CPU_EXT_AES)) { \
          stmt_ni; \
      } else { \
          stmt_c; \
      } \
   } while(0)
#elif defined(OQS_DIST_ARM64_V8_BUILD)
#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
    do { \
        if (OQS_CPU_has_extension(OQS_CPU_EXT_ARM_AES)) {  \
            stmt_arm; \
        } else { \
            stmt_c; \
        } \
    } while(0)
#elif defined(OQS_USE_AES_INSTRUCTIONS)
#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
    stmt_ni
#elif defined(OQS_USE_ARM_AES_INSTRUCTIONS)
#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
    stmt_arm
#else
#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
    stmt_c
#endif

static void AES128_ECB_load_schedule(const uint8_t *key, void **_schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes128_load_schedule_c(key, _schedule),
      oqs_aes128_load_schedule_ni(key, _schedule),
      oqs_aes128_load_schedule_no_bitslice(key, _schedule)
  );
}

static void AES128_CTR_inc_init(const uint8_t *key, void **_schedule) {
  AES128_ECB_load_schedule(key, _schedule);
}

static void AES128_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *_schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes128_load_iv_c(iv, iv_len, _schedule),
      oqs_aes128_load_iv_ni(iv, iv_len, _schedule),
      oqs_aes128_load_iv_armv8(iv, iv_len, _schedule)
  );
}

static void AES128_CTR_inc_ivu64(uint64_t iv, void *_schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes128_load_iv_u64_c(iv, _schedule),
      oqs_aes128_load_iv_u64_ni(iv, _schedule),
      (void) iv; (void) _schedule
  );
}

static void AES128_free_schedule(void *schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes128_free_schedule_c(schedule),
      oqs_aes128_free_schedule_ni(schedule),
      oqs_aes128_free_schedule_no_bitslice(schedule)
  );
}

static void AES256_ECB_load_schedule(const uint8_t *key, void **_schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes256_load_schedule_c(key, _schedule),
      oqs_aes256_load_schedule_ni(key, _schedule),
      oqs_aes256_load_schedule_no_bitslice(key, _schedule)
  );
}

static void AES256_CTR_inc_init(const uint8_t *key, void **_schedule) {
  AES256_ECB_load_schedule(key, _schedule);
}

static void AES256_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *_schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes256_load_iv_c(iv, iv_len, _schedule),
      oqs_aes256_load_iv_ni(iv, iv_len, _schedule),
      oqs_aes256_load_iv_armv8(iv, iv_len, _schedule)
  );
}

static void AES256_CTR_inc_ivu64(uint64_t iv, void *_schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes256_load_iv_u64_c(iv, _schedule),
      oqs_aes256_load_iv_u64_ni(iv, _schedule),
      (void) iv; (void) _schedule
  );
}

static void AES256_free_schedule(void *schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes256_free_schedule_c(schedule),
      oqs_aes256_free_schedule_ni(schedule),
      oqs_aes256_free_schedule_no_bitslice(schedule)
  );
}

static void AES128_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext);

static void AES128_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext) {
  void *schedule = NULL;
  AES128_ECB_load_schedule(key, &schedule);
  AES128_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
  AES128_free_schedule(schedule);
}

static void AES128_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext) {
  C_OR_NI_OR_ARM(
      oqs_aes128_ecb_enc_sch_c(plaintext, plaintext_len, schedule, ciphertext),
      oqs_aes128_ecb_enc_sch_ni(plaintext, plaintext_len, schedule, ciphertext),
      oqs_aes128_ecb_enc_sch_armv8(plaintext, plaintext_len, schedule, ciphertext)
  );
}

static void AES128_CTR_inc_stream_iv(const uint8_t *iv, const size_t iv_len, const void *schedule, uint8_t *out, size_t out_len) {
  C_OR_NI_OR_ARM(
      oqs_aes128_ctr_enc_sch_c(iv, iv_len, schedule, out, out_len),
      oqs_aes128_ctr_enc_sch_ni(iv, iv_len, schedule, out, out_len),
      oqs_aes128_ctr_enc_sch_armv8(iv, iv_len, schedule, out, out_len)
  );
}

static void AES256_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext);

static void AES256_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext) {
  void *schedule = NULL;
  AES256_ECB_load_schedule(key, &schedule);
  AES256_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
  AES256_free_schedule(schedule);
}

static void AES256_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext) {
  C_OR_NI_OR_ARM(
      oqs_aes256_ecb_enc_sch_c(plaintext, plaintext_len, schedule, ciphertext),
      oqs_aes256_ecb_enc_sch_ni(plaintext, plaintext_len, schedule, ciphertext),
      oqs_aes256_ecb_enc_sch_armv8(plaintext, plaintext_len, schedule, ciphertext)
  );
}

static void AES256_CTR_inc_stream_iv(const uint8_t *iv, const size_t iv_len, const void *schedule, uint8_t *out, size_t out_len) {
  C_OR_NI_OR_ARM(
      oqs_aes256_ctr_enc_sch_c(iv, iv_len, schedule, out, out_len),
      oqs_aes256_ctr_enc_sch_ni(iv, iv_len, schedule, out, out_len),
      oqs_aes256_ctr_enc_sch_armv8(iv, iv_len, schedule, out, out_len)
  );
}

static void AES256_CTR_inc_stream_blks(void *schedule, uint8_t *out, size_t out_blks) {
  C_OR_NI_OR_ARM(
      oqs_aes256_ctr_enc_sch_upd_blks_c(schedule, out, out_blks),
      oqs_aes256_ctr_enc_sch_upd_blks_ni(schedule, out, out_blks),
      oqs_aes256_ctr_enc_sch_upd_blks_armv8(schedule, out, out_blks)
  );
}

static void AES192_ECB_load_schedule(const uint8_t *key, void **_schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes192_load_schedule_c(key, _schedule),
      oqs_aes192_load_schedule_ni(key, _schedule),
      oqs_aes192_load_schedule_no_bitslice(key, _schedule)
  );
}

static void AES192_free_schedule(void *schedule) {
  C_OR_NI_OR_ARM(
      oqs_aes192_free_schedule_c(schedule),
      oqs_aes192_free_schedule_ni(schedule),
      oqs_aes192_free_schedule_no_bitslice(schedule)
  );
}

static void AES192_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext);

static void AES192_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext) {
  void *schedule = NULL;
  AES192_ECB_load_schedule(key, &schedule);
  AES192_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
  AES192_free_schedule(schedule);
}

static void AES192_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext) {
  C_OR_NI_OR_ARM(
      oqs_aes192_ecb_enc_sch_c(plaintext, plaintext_len, schedule, ciphertext),
      oqs_aes192_ecb_enc_sch_ni(plaintext, plaintext_len, schedule, ciphertext),
      oqs_aes192_ecb_enc_sch_armv8(plaintext, plaintext_len, schedule, ciphertext)
  );
}

struct OQS_AES_callbacks aes_default_callbacks = {
  .AES128_ECB_load_schedule = AES128_ECB_load_schedule,
  .AES128_CTR_inc_init = AES128_CTR_inc_init,
  .AES128_CTR_inc_iv = AES128_CTR_inc_iv,
  .AES128_CTR_inc_ivu64 = AES128_CTR_inc_ivu64,
  .AES128_free_schedule = AES128_free_schedule,
  .AES128_ECB_enc = AES128_ECB_enc,
  .AES128_ECB_enc_sch = AES128_ECB_enc_sch,
  .AES128_CTR_inc_stream_iv = AES128_CTR_inc_stream_iv,
  .AES256_ECB_load_schedule = AES256_ECB_load_schedule,
  .AES256_CTR_inc_init = AES256_CTR_inc_init,
  .AES256_CTR_inc_iv = AES256_CTR_inc_iv,
  .AES256_CTR_inc_ivu64 = AES256_CTR_inc_ivu64,
  .AES256_free_schedule = AES256_free_schedule,
  .AES256_ECB_enc = AES256_ECB_enc,
  .AES256_ECB_enc_sch = AES256_ECB_enc_sch,
  .AES256_CTR_inc_stream_iv = AES256_CTR_inc_stream_iv,
  .AES256_CTR_inc_stream_blks = AES256_CTR_inc_stream_blks,
  .AES192_ECB_load_schedule = AES192_ECB_load_schedule,
  .AES192_free_schedule = AES192_free_schedule,
  .AES192_ECB_enc = AES192_ECB_enc,
  .AES192_ECB_enc_sch = AES192_ECB_enc_sch,
};

void OQS_AES_init(void) {
}

Coverage Report

Created: 2026-11-12 06:30

Line	Count	Source
1		// SPDX-License-Identifier: MIT
2
3		#include <assert.h>
4		#include <stdio.h>
5		#include <string.h>
6
7		#include <oqs/common.h>
8
9		#include "aes.h"
10		#include "aes_local.h"
11
12		#if defined(OQS_DIST_X86_64_BUILD)
13		#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
14	85.7M	do { \
15	85.7M	if (OQS_CPU_has_extension(OQS_CPU_EXT_AES)) { \
16	85.7M	stmt_ni; \
17	85.7M	} else { \
18	0	stmt_c; \
19	0	} \
20	85.7M	} while(0)
21		#elif defined(OQS_DIST_ARM64_V8_BUILD)
22		#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
23		do { \
24		if (OQS_CPU_has_extension(OQS_CPU_EXT_ARM_AES)) { \
25		stmt_arm; \
26		} else { \
27		stmt_c; \
28		} \
29		} while(0)
30		#elif defined(OQS_USE_AES_INSTRUCTIONS)
31		#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
32		stmt_ni
33		#elif defined(OQS_USE_ARM_AES_INSTRUCTIONS)
34		#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
35		stmt_arm
36		#else
37		#define C_OR_NI_OR_ARM(stmt_c, stmt_ni, stmt_arm) \
38		stmt_c
39		#endif
40
41	19.1M	static void AES128_ECB_load_schedule(const uint8_t key, void *_schedule) {
42	19.1M	C_OR_NI_OR_ARM(
43	19.1M	oqs_aes128_load_schedule_c(key, _schedule),
44	19.1M	oqs_aes128_load_schedule_ni(key, _schedule),
45	19.1M	oqs_aes128_load_schedule_no_bitslice(key, _schedule)
46	19.1M	);
47	19.1M	}
48
49	5.59k	static void AES128_CTR_inc_init(const uint8_t key, void *_schedule) {
50	5.59k	AES128_ECB_load_schedule(key, _schedule);
51	5.59k	}
52
53	0	static void AES128_CTR_inc_iv(const uint8_t iv, size_t iv_len, void _schedule) {
54	0	C_OR_NI_OR_ARM(
55	0	oqs_aes128_load_iv_c(iv, iv_len, _schedule),
56	0	oqs_aes128_load_iv_ni(iv, iv_len, _schedule),
57	0	oqs_aes128_load_iv_armv8(iv, iv_len, _schedule)
58	0	);
59	0	}
60
61	0	static void AES128_CTR_inc_ivu64(uint64_t iv, void *_schedule) {
62	0	C_OR_NI_OR_ARM(
63	0	oqs_aes128_load_iv_u64_c(iv, _schedule),
64	0	oqs_aes128_load_iv_u64_ni(iv, _schedule),
65	0	(void) iv; (void) _schedule
66	0	);
67	0	}
68
69	19.1M	static void AES128_free_schedule(void *schedule) {
70	19.1M	C_OR_NI_OR_ARM(
71	19.1M	oqs_aes128_free_schedule_c(schedule),
72	19.1M	oqs_aes128_free_schedule_ni(schedule),
73	19.1M	oqs_aes128_free_schedule_no_bitslice(schedule)
74	19.1M	);
75	19.1M	}
76
77	0	static void AES256_ECB_load_schedule(const uint8_t key, void *_schedule) {
78	0	C_OR_NI_OR_ARM(
79	0	oqs_aes256_load_schedule_c(key, _schedule),
80	0	oqs_aes256_load_schedule_ni(key, _schedule),
81	0	oqs_aes256_load_schedule_no_bitslice(key, _schedule)
82	0	);
83	0	}
84
85	0	static void AES256_CTR_inc_init(const uint8_t key, void *_schedule) {
86	0	AES256_ECB_load_schedule(key, _schedule);
87	0	}
88
89	0	static void AES256_CTR_inc_iv(const uint8_t iv, size_t iv_len, void _schedule) {
90	0	C_OR_NI_OR_ARM(
91	0	oqs_aes256_load_iv_c(iv, iv_len, _schedule),
92	0	oqs_aes256_load_iv_ni(iv, iv_len, _schedule),
93	0	oqs_aes256_load_iv_armv8(iv, iv_len, _schedule)
94	0	);
95	0	}
96
97	0	static void AES256_CTR_inc_ivu64(uint64_t iv, void *_schedule) {
98	0	C_OR_NI_OR_ARM(
99	0	oqs_aes256_load_iv_u64_c(iv, _schedule),
100	0	oqs_aes256_load_iv_u64_ni(iv, _schedule),
101	0	(void) iv; (void) _schedule
102	0	);
103	0	}
104
105	0	static void AES256_free_schedule(void *schedule) {
106	0	C_OR_NI_OR_ARM(
107	0	oqs_aes256_free_schedule_c(schedule),
108	0	oqs_aes256_free_schedule_ni(schedule),
109	0	oqs_aes256_free_schedule_no_bitslice(schedule)
110	0	);
111	0	}
112
113		static void AES128_ECB_enc_sch(const uint8_t plaintext, const size_t plaintext_len, const void schedule, uint8_t *ciphertext);
114
115	94	static void AES128_ECB_enc(const uint8_t plaintext, const size_t plaintext_len, const uint8_t key, uint8_t *ciphertext) {
116	94	void *schedule = NULL;
117	94	AES128_ECB_load_schedule(key, &schedule);
118	94	AES128_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
119	94	AES128_free_schedule(schedule);
120	94	}
121
122	46.3M	static void AES128_ECB_enc_sch(const uint8_t plaintext, const size_t plaintext_len, const void schedule, uint8_t *ciphertext) {
123	46.3M	C_OR_NI_OR_ARM(
124	46.3M	oqs_aes128_ecb_enc_sch_c(plaintext, plaintext_len, schedule, ciphertext),
125	46.3M	oqs_aes128_ecb_enc_sch_ni(plaintext, plaintext_len, schedule, ciphertext),
126	46.3M	oqs_aes128_ecb_enc_sch_armv8(plaintext, plaintext_len, schedule, ciphertext)
127	46.3M	);
128	46.3M	}
129
130	1.05M	static void AES128_CTR_inc_stream_iv(const uint8_t iv, const size_t iv_len, const void schedule, uint8_t *out, size_t out_len) {
131	1.05M	C_OR_NI_OR_ARM(
132	1.05M	oqs_aes128_ctr_enc_sch_c(iv, iv_len, schedule, out, out_len),
133	1.05M	oqs_aes128_ctr_enc_sch_ni(iv, iv_len, schedule, out, out_len),
134	1.05M	oqs_aes128_ctr_enc_sch_armv8(iv, iv_len, schedule, out, out_len)
135	1.05M	);
136	1.05M	}
137
138		static void AES256_ECB_enc_sch(const uint8_t plaintext, const size_t plaintext_len, const void schedule, uint8_t *ciphertext);
139
140	0	static void AES256_ECB_enc(const uint8_t plaintext, const size_t plaintext_len, const uint8_t key, uint8_t *ciphertext) {
141	0	void *schedule = NULL;
142	0	AES256_ECB_load_schedule(key, &schedule);
143	0	AES256_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
144	0	AES256_free_schedule(schedule);
145	0	}
146
147	0	static void AES256_ECB_enc_sch(const uint8_t plaintext, const size_t plaintext_len, const void schedule, uint8_t *ciphertext) {
148	0	C_OR_NI_OR_ARM(
149	0	oqs_aes256_ecb_enc_sch_c(plaintext, plaintext_len, schedule, ciphertext),
150	0	oqs_aes256_ecb_enc_sch_ni(plaintext, plaintext_len, schedule, ciphertext),
151	0	oqs_aes256_ecb_enc_sch_armv8(plaintext, plaintext_len, schedule, ciphertext)
152	0	);
153	0	}
154
155	0	static void AES256_CTR_inc_stream_iv(const uint8_t iv, const size_t iv_len, const void schedule, uint8_t *out, size_t out_len) {
156	0	C_OR_NI_OR_ARM(
157	0	oqs_aes256_ctr_enc_sch_c(iv, iv_len, schedule, out, out_len),
158	0	oqs_aes256_ctr_enc_sch_ni(iv, iv_len, schedule, out, out_len),
159	0	oqs_aes256_ctr_enc_sch_armv8(iv, iv_len, schedule, out, out_len)
160	0	);
161	0	}
162
163	0	static void AES256_CTR_inc_stream_blks(void schedule, uint8_t out, size_t out_blks) {
164	0	C_OR_NI_OR_ARM(
165	0	oqs_aes256_ctr_enc_sch_upd_blks_c(schedule, out, out_blks),
166	0	oqs_aes256_ctr_enc_sch_upd_blks_ni(schedule, out, out_blks),
167	0	oqs_aes256_ctr_enc_sch_upd_blks_armv8(schedule, out, out_blks)
168	0	);
169	0	}
170
171	0	static void AES192_ECB_load_schedule(const uint8_t key, void *_schedule) {
172	0	C_OR_NI_OR_ARM(
173	0	oqs_aes192_load_schedule_c(key, _schedule),
174	0	oqs_aes192_load_schedule_ni(key, _schedule),
175	0	oqs_aes192_load_schedule_no_bitslice(key, _schedule)
176	0	);
177	0	}
178
179	0	static void AES192_free_schedule(void *schedule) {
180	0	C_OR_NI_OR_ARM(
181	0	oqs_aes192_free_schedule_c(schedule),
182	0	oqs_aes192_free_schedule_ni(schedule),
183	0	oqs_aes192_free_schedule_no_bitslice(schedule)
184	0	);
185	0	}
186
187		static void AES192_ECB_enc_sch(const uint8_t plaintext, const size_t plaintext_len, const void schedule, uint8_t *ciphertext);
188
189	0	static void AES192_ECB_enc(const uint8_t plaintext, const size_t plaintext_len, const uint8_t key, uint8_t *ciphertext) {
190	0	void *schedule = NULL;
191	0	AES192_ECB_load_schedule(key, &schedule);
192	0	AES192_ECB_enc_sch(plaintext, plaintext_len, schedule, ciphertext);
193	0	AES192_free_schedule(schedule);
194	0	}
195
196	0	static void AES192_ECB_enc_sch(const uint8_t plaintext, const size_t plaintext_len, const void schedule, uint8_t *ciphertext) {
197	0	C_OR_NI_OR_ARM(
198	0	oqs_aes192_ecb_enc_sch_c(plaintext, plaintext_len, schedule, ciphertext),
199	0	oqs_aes192_ecb_enc_sch_ni(plaintext, plaintext_len, schedule, ciphertext),
200	0	oqs_aes192_ecb_enc_sch_armv8(plaintext, plaintext_len, schedule, ciphertext)
201	0	);
202	0	}
203
204		struct OQS_AES_callbacks aes_default_callbacks = {
205		.AES128_ECB_load_schedule = AES128_ECB_load_schedule,
206		.AES128_CTR_inc_init = AES128_CTR_inc_init,
207		.AES128_CTR_inc_iv = AES128_CTR_inc_iv,
208		.AES128_CTR_inc_ivu64 = AES128_CTR_inc_ivu64,
209		.AES128_free_schedule = AES128_free_schedule,
210		.AES128_ECB_enc = AES128_ECB_enc,
211		.AES128_ECB_enc_sch = AES128_ECB_enc_sch,
212		.AES128_CTR_inc_stream_iv = AES128_CTR_inc_stream_iv,
213		.AES256_ECB_load_schedule = AES256_ECB_load_schedule,
214		.AES256_CTR_inc_init = AES256_CTR_inc_init,
215		.AES256_CTR_inc_iv = AES256_CTR_inc_iv,
216		.AES256_CTR_inc_ivu64 = AES256_CTR_inc_ivu64,
217		.AES256_free_schedule = AES256_free_schedule,
218		.AES256_ECB_enc = AES256_ECB_enc,
219		.AES256_ECB_enc_sch = AES256_ECB_enc_sch,
220		.AES256_CTR_inc_stream_iv = AES256_CTR_inc_stream_iv,
221		.AES256_CTR_inc_stream_blks = AES256_CTR_inc_stream_blks,
222		.AES192_ECB_load_schedule = AES192_ECB_load_schedule,
223		.AES192_free_schedule = AES192_free_schedule,
224		.AES192_ECB_enc = AES192_ECB_enc,
225		.AES192_ECB_enc_sch = AES192_ECB_enc_sch,
226		};
227
228	0	void OQS_AES_init(void) {
229	0	}