secapi-sys 0.2.0

FFI bindings to SecAPI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

/*
 * Copyright 2020-2023 Comcast Cable Communications Management, LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#ifndef SA_CRYPTO_CIPHER_COMMON_H
#define SA_CRYPTO_CIPHER_COMMON_H

#include "sa_types.h"
#include "gtest/gtest.h"
#include <memory>
#include <openssl/ec.h>
#include <vector>

typedef struct { // NOLINT
    sa_cipher_algorithm cipher_algorithm;
    std::shared_ptr<sa_key> key;
    std::vector<uint8_t> clear_key;
    std::vector<uint8_t> iv;
    std::vector<uint8_t> aad;
    std::vector<uint8_t> tag;
    std::shared_ptr<void> parameters;
    std::shared_ptr<void> end_parameters;
    sa_elliptic_curve curve;
    sa_digest_algorithm oaep_digest_algorithm;
    sa_digest_algorithm oaep_mgf1_digest_algorithm;
    size_t oaep_label_length;
    bool svp_required;
} cipher_parameters;

class SaCipherCryptoBase {
protected:
    static bool import_key(
            cipher_parameters& parameters,
            sa_key_type key_type,
            size_t key_size);

    static void get_cipher_parameters(cipher_parameters& parameters);

    static std::shared_ptr<sa_crypto_cipher_context> initialize_cipher(
            sa_cipher_mode cipher_mode,
            sa_key_type key_type,
            size_t key_size,
            cipher_parameters& parameters);

    static bool verify_encrypt(
            sa_buffer* encrypted,
            std::vector<uint8_t>& clear,
            cipher_parameters& parameters,
            bool padded);

    static bool verify_decrypt(
            sa_buffer* decrypted,
            std::vector<uint8_t>& clear);

    static std::vector<uint8_t> encrypt_openssl(
            std::vector<uint8_t>& clear,
            cipher_parameters& parameters);

    static std::vector<uint8_t> decrypt_openssl(
            std::vector<uint8_t>& encrypted_data,
            cipher_parameters& parameters);

    static size_t get_required_length(
            sa_cipher_algorithm cipher_algorithm,
            size_t key_length,
            size_t bytes_to_process,
            bool apply_pad);

    static bool ec_is_valid_x_coordinate(
            std::shared_ptr<EC_GROUP>& ec_group,
            const std::vector<uint8_t>& coordinate);
};

// clang-format off
using SaCryptoCipherDecryptTestType = std::tuple<sa_cipher_algorithm, sa_key_type, size_t, sa_buffer_type,
    sa_digest_algorithm, sa_digest_algorithm, size_t>;

class SaCryptoCipherDecryptTest : public ::testing::TestWithParam<SaCryptoCipherDecryptTestType>,
                                  public SaCipherCryptoBase {
protected:
    void SetUp() override;
};

typedef std::tuple<sa_cipher_algorithm, sa_key_type, size_t, sa_buffer_type> SaCryptoCipherTestType;

class SaCryptoCipherEncryptTest : public ::testing::TestWithParam<SaCryptoCipherTestType>, public SaCipherCryptoBase {
protected:
    void SetUp() override;
};

class SaCryptoCipherProcessLastTest : public ::testing::TestWithParam<SaCryptoCipherTestType>,
                                      public SaCipherCryptoBase {
protected:
    void SetUp() override;
};

typedef std::tuple<sa_buffer_type, sa_cipher_mode> SaCryptoCipherWithSvpTestType;

class SaCryptoCipherWithSvpTest : public ::testing::TestWithParam<SaCryptoCipherWithSvpTestType>,
                                  public SaCipherCryptoBase {
protected:
    void SetUp() override;
};

typedef std::tuple<sa_cipher_mode> SaCryptoCipherWithoutSvpTestType;

class SaCryptoCipherWithoutSvpTest : public ::testing::TestWithParam<SaCryptoCipherWithoutSvpTestType>,
                                     public SaCipherCryptoBase {};

class SaCryptoCipherSvpOnlyTest : public ::testing::Test, public SaCipherCryptoBase {
protected:
    void SetUp() override;
};

typedef std::tuple<sa_elliptic_curve> SaCryptoCipherElGamalTestType;

class SaCryptoCipherElGamalTest : public ::testing::TestWithParam<SaCryptoCipherElGamalTestType>,
                                  public SaCipherCryptoBase {};

class SaCryptoCipherElGamalFailTest : public ::testing::TestWithParam<SaCryptoCipherElGamalTestType>,
                                      public SaCipherCryptoBase {};

class SaCryptoCipherMultipleThread : public ::testing::Test, public SaCipherCryptoBase {
public:
    static sa_status process_multiple_threads(size_t id);
};

// clang-format on
#endif // SA_CRYPTO_CIPHER_COMMON_H