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
|
/***************************************************************************/
/* Copyright (c) 2024 Microsoft Corporation */
/* Copyright (c) 2026 Eclipse ThreadX contributors */
/* */
/* This program and the accompanying materials are made available under */
/* the terms of the MIT License which is available at */
/* https://opensource.org/licenses/MIT. */
/* */
/* SPDX-License-Identifier: MIT */
/***************************************************************************/
#include "nx_crypto_hash_clone_test.h"
NX_CRYPTO_KEEP UINT _nx_crypto_method_hash_clone_test_init(struct NX_CRYPTO_METHOD_STRUCT *method,
UCHAR *key, NX_CRYPTO_KEY_SIZE key_size_in_bits,
VOID **handle,
VOID *crypto_metadata,
ULONG crypto_metadata_size)
{
UINT status;
if ((method == NX_CRYPTO_NULL) || (crypto_metadata == NX_CRYPTO_NULL))
{
return(NX_CRYPTO_PTR_ERROR);
}
/* Verify the metadata addrsss is 4-byte aligned. */
if((((ULONG)crypto_metadata) & 0x3) != 0)
{
return(NX_CRYPTO_PTR_ERROR);
}
if(crypto_metadata_size < sizeof(NX_CRYPTO_HASH_CLONE_TEST))
{
return(NX_CRYPTO_PTR_ERROR);
}
NX_CRYPTO_MEMSET(crypto_metadata, 0, sizeof(NX_CRYPTO_HASH_CLONE_TEST));
status = _nx_crypto_method_clone_cleanup_test_init(method, key, key_size_in_bits,
handle, crypto_metadata, crypto_metadata_size);
return(status);
}
NX_CRYPTO_KEEP UINT _nx_crypto_method_hash_clone_test_cleanup(VOID *crypto_metadata)
{
UINT status;
if (!crypto_metadata)
return (NX_CRYPTO_SUCCESS);
status = _nx_crypto_method_clone_cleanup_test_cleanup(crypto_metadata);
return(status);
}
NX_CRYPTO_KEEP UINT _nx_crypto_method_hash_clone_test_operation(UINT op, /* Encrypt, Decrypt, Authenticate */
VOID *handle, /* Crypto handler */
struct NX_CRYPTO_METHOD_STRUCT *method,
UCHAR *key,
NX_CRYPTO_KEY_SIZE key_size_in_bits,
UCHAR *input,
ULONG input_length_in_byte,
UCHAR *iv_ptr,
UCHAR *output,
ULONG output_length_in_byte,
VOID *crypto_metadata,
ULONG crypto_metadata_size,
VOID *packet_ptr,
VOID (*nx_crypto_hw_process_callback)(VOID *packet_ptr, UINT status))
{
UINT status;
if (method == NX_CRYPTO_NULL)
{
return(NX_CRYPTO_PTR_ERROR);
}
/* Verify the metadata addrsss is 4-byte aligned. */
if((crypto_metadata == NX_CRYPTO_NULL) || ((((ULONG)crypto_metadata) & 0x3) != 0))
{
return(NX_CRYPTO_PTR_ERROR);
}
if(crypto_metadata_size < sizeof(NX_CRYPTO_HASH_CLONE_TEST))
{
return(NX_CRYPTO_PTR_ERROR);
}
status = _nx_crypto_method_clone_cleanup_test_operation(op, handle, method, key, key_size_in_bits,
input, input_length_in_byte, iv_ptr,
output, output_length_in_byte,
crypto_metadata, crypto_metadata_size,
packet_ptr, nx_crypto_hw_process_callback);
return(status);
}
UINT nx_crypto_hash_clone_test_clone(VOID *dest_metadata, VOID *source_metadata, ULONG length)
{
if (length != sizeof(NX_CRYPTO_HASH_CLONE_TEST))
{
NX_CRYPTO_MEMCPY(dest_metadata, source_metadata, length);
return(NX_CRYPTO_SUCCESS);
}
return(nx_crypto_clone_cleanup_test_clone(dest_metadata, source_metadata, length));
}
|
