Skip to content

Commit fece44b

Browse files
Donnie-IceDonnie-Ice
committed
[#436] More spelling warnings
1 parent 6c14c1d commit fece44b

7 files changed

+70
-70
lines changed

‎include/crypto_error.h

+15-15
Original file line numberDiff line numberDiff line change
@@ -39,24 +39,24 @@
3939

4040
#define CRYPTOGRAPHY_INVALID_CRYPTO_INTERFACE_TYPE 400
4141
#define CRYPTOGRAPHY_UNSUPPORTED_OPERATION_FOR_KEY_RING 401
42-
#define CRYPTOGRAPHY_LIBRARY_INITIALIZIATION_ERROR 402
42+
#define CRYPTOGRAPHY_LIBRARY_INITIALIZATION_ERROR 402
4343

4444
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_CONFIGURATION_NOT_COMPLETE 500
4545
#define CRYPTOGRAPHY_KMC_CURL_INITIALIZATION_FAILURE 501
46-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_CONNECTION_ERROR 502
47-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_AEAD_ENCRYPT_ERROR 503
48-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_AEAD_DECRYPT_ERROR 504
49-
#define CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR 505
50-
#define CRYPTOGRAHPY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE 506
51-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE 507
52-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_AUTHENTICATION_ERROR 508
53-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_MAC_VALIDATION_ERROR 509
54-
#define CRYPTOGRAHPY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE 510
55-
#define CRYPTOGRAHPY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA 511
56-
#define CRYPTOGRAHPY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA 512
57-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE 513
58-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_DECRYPT_ERROR 514
59-
#define CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_ENCRYPT_ERROR 515
46+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_CONNECTION_ERROR 502
47+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_AEAD_ENCRYPT_ERROR 503
48+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_AEAD_DECRYPT_ERROR 504
49+
#define CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR 505
50+
#define CRYPTOGRAPHY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE 506
51+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE 507
52+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_AUTHENTICATION_ERROR 508
53+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_MAC_VALIDATION_ERROR 509
54+
#define CRYPTOGRAPHY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE 510
55+
#define CRYPTOGRAPHY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA 511
56+
#define CRYPTOGRAPHY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA 512
57+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE 513
58+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_DECRYPT_ERROR 514
59+
#define CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_ENCRYPT_ERROR 515
6060

6161
#define CAM_CONFIG_NOT_SUPPORTED_ERROR 600
6262
#define CAM_INVALID_COOKIE_FILE_CONFIGURATION_NULL 601

‎src/core/crypto_error.c

+15-15
Original file line numberDiff line numberDiff line change
@@ -121,25 +121,25 @@ char *crypto_enum_errlist_sa_mariadb[] = {
121121
char *crypto_enum_errlist_crypto_if[] = {
122122
(char *)"CRYPTOGRAPHY_INVALID_CRYPTO_INTERFACE_TYPE",
123123
(char *)"CRYPTOGRAPHY_UNSUPPORTED_OPERATION_FOR_KEY_RING",
124-
(char *)"CRYPTOGRAPHY_LIBRARY_INITIALIZIATION_ERROR",
124+
(char *)"CRYPTOGRAPHY_LIBRARY_INITIALIZATION_ERROR",
125125
};
126126
char *crypto_enum_errlist_crypto_kmc[] = {
127127
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_CONFIGURATION_NOT_COMPLETE",
128128
(char *)"CRYPTOGRAPHY_KMC_CURL_INITIALIZATION_FAILURE",
129-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_CONNECTION_ERROR",
130-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_AEAD_ENCRYPT_ERROR",
131-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_AEAD_DECRYPT_ERROR",
132-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR",
133-
(char *)"CRYPTOGRAHPY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE",
134-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE",
135-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_AUTHENTICATION_ERROR",
136-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_MAC_VALIDATION_ERROR",
137-
(char *)"CRYPTOGRAHPY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE",
138-
(char *)"CRYPTOGRAHPY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA",
139-
(char *)"CRYPTOGRAHPY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA",
140-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE",
141-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_DECRYPT_ERROR",
142-
(char *)"CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_ENCRYPT_ERROR",
129+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_CONNECTION_ERROR",
130+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_AEAD_ENCRYPT_ERROR",
131+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_AEAD_DECRYPT_ERROR",
132+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR",
133+
(char *)"CRYPTOGRAPHY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE",
134+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE",
135+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_AUTHENTICATION_ERROR",
136+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_MAC_VALIDATION_ERROR",
137+
(char *)"CRYPTOGRAPHY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE",
138+
(char *)"CRYPTOGRAPHY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA",
139+
(char *)"CRYPTOGRAPHY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA",
140+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE",
141+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_DECRYPT_ERROR",
142+
(char *)"CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_ENCRYPT_ERROR",
143143
};
144144

145145
char *crypto_enum_errlist_crypto_cam[] = {

‎src/crypto/kmc/cryptography_interface_kmc_crypto_service.template.c

+31-31
Original file line numberDiff line numberDiff line change
@@ -265,7 +265,7 @@ static int32_t cryptography_encrypt(uint8_t *data_out, size_t len_data_out, uint
265265

266266
if (sa_ptr->ek_ref[0] == '\0')
267267
{
268-
status = CRYPTOGRAHPY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
268+
status = CRYPTOGRAPHY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
269269
return status;
270270
}
271271

@@ -342,7 +342,7 @@ static int32_t cryptography_encrypt(uint8_t *data_out, size_t len_data_out, uint
342342
// Find the 'base64ciphertext' token
343343
if (parse_result < 0)
344344
{
345-
status = CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR;
345+
status = CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR;
346346
printf("Failed to parse JSON: %d\n", parse_result);
347347
return status;
348348
}
@@ -444,7 +444,7 @@ static int32_t cryptography_encrypt(uint8_t *data_out, size_t len_data_out, uint
444444
#endif
445445
if (http_code != 200)
446446
{
447-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
447+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
448448
fprintf(stderr, "KMC Crypto Failure Response:\n%s\n", chunk_write->response);
449449
return status;
450450
}
@@ -455,7 +455,7 @@ static int32_t cryptography_encrypt(uint8_t *data_out, size_t len_data_out, uint
455455
}
456456
if (ciphertext_found == CRYPTO_FALSE)
457457
{
458-
status = CRYPTOGRAHPY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
458+
status = CRYPTOGRAPHY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
459459
return status;
460460
}
461461

@@ -514,7 +514,7 @@ static int32_t cryptography_decrypt(uint8_t *data_out, size_t len_data_out, uint
514514

515515
if (sa_ptr->ek_ref[0] == '\0')
516516
{
517-
status = CRYPTOGRAHPY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
517+
status = CRYPTOGRAPHY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
518518
return status;
519519
}
520520

@@ -585,7 +585,7 @@ static int32_t cryptography_decrypt(uint8_t *data_out, size_t len_data_out, uint
585585
// Find the 'base64ciphertext' token
586586
if (parse_result < 0)
587587
{
588-
status = CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR;
588+
status = CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR;
589589
printf("Failed to parse JSON: %d\n", parse_result);
590590
return status;
591591
}
@@ -631,7 +631,7 @@ static int32_t cryptography_decrypt(uint8_t *data_out, size_t len_data_out, uint
631631
#endif
632632
if (http_code != 200)
633633
{
634-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
634+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
635635
fprintf(stderr, "KMC Crypto Failure Response:\n%s\n", chunk_write->response);
636636
return status;
637637
}
@@ -642,7 +642,7 @@ static int32_t cryptography_decrypt(uint8_t *data_out, size_t len_data_out, uint
642642
}
643643
if (ciphertext_found == CRYPTO_FALSE)
644644
{
645-
status = CRYPTOGRAHPY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
645+
status = CRYPTOGRAPHY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
646646
return status;
647647
}
648648

@@ -715,7 +715,7 @@ static int32_t cryptography_authenticate(uint8_t *data_out, size_t len_data_out,
715715

716716
if (sa_ptr->ak_ref[0] == '\0')
717717
{
718-
status = CRYPTOGRAHPY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA;
718+
status = CRYPTOGRAPHY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA;
719719
return status;
720720
}
721721

@@ -782,7 +782,7 @@ static int32_t cryptography_authenticate(uint8_t *data_out, size_t len_data_out,
782782
// Find the 'integrityCheckValue' token
783783
if (parse_result < 0)
784784
{
785-
status = CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR;
785+
status = CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR;
786786
printf("Failed to parse JSON: %d\n", parse_result);
787787
return status;
788788
}
@@ -829,7 +829,7 @@ static int32_t cryptography_authenticate(uint8_t *data_out, size_t len_data_out,
829829
metadata += comma_idx + 1;
830830
if (metadata >= metadata_end)
831831
{
832-
status = CRYPTOGRAHPY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE;
832+
status = CRYPTOGRAPHY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE;
833833
return status;
834834
}
835835
}
@@ -865,7 +865,7 @@ static int32_t cryptography_authenticate(uint8_t *data_out, size_t len_data_out,
865865
#endif
866866
if (http_code != 200)
867867
{
868-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
868+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
869869
fprintf(stderr, "KMC Crypto Failure Response:\n%s\n", chunk_write->response);
870870
return status;
871871
}
@@ -876,7 +876,7 @@ static int32_t cryptography_authenticate(uint8_t *data_out, size_t len_data_out,
876876
}
877877
if (icvtext_found == CRYPTO_FALSE)
878878
{
879-
status = CRYPTOGRAHPY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE;
879+
status = CRYPTOGRAPHY_KMC_ICV_NOT_FOUND_IN_JSON_RESPONSE;
880880
return status;
881881
}
882882

@@ -954,7 +954,7 @@ static int32_t cryptography_validate_authentication(uint8_t *data_out, size_t le
954954

955955
if (sa_ptr->ak_ref[0] == '\0')
956956
{
957-
status = CRYPTOGRAHPY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA;
957+
status = CRYPTOGRAPHY_KMC_NULL_AUTHENTICATION_KEY_REFERENCE_IN_SA;
958958
return status;
959959
}
960960

@@ -1029,7 +1029,7 @@ static int32_t cryptography_validate_authentication(uint8_t *data_out, size_t le
10291029

10301030
if (parse_result < 0)
10311031
{
1032-
status = CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR;
1032+
status = CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR;
10331033
printf("Failed to parse JSON: %d\n", parse_result);
10341034
return status;
10351035
}
@@ -1056,7 +1056,7 @@ static int32_t cryptography_validate_authentication(uint8_t *data_out, size_t le
10561056
#endif
10571057
if (http_code != 200)
10581058
{
1059-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
1059+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
10601060
fprintf(stderr, "KMC Crypto Generic Failure Response:\n%s\n", chunk_write->response);
10611061
return status;
10621062
}
@@ -1081,7 +1081,7 @@ static int32_t cryptography_validate_authentication(uint8_t *data_out, size_t le
10811081
#endif
10821082
if (strcmp(result_str, "true") != 0) // KMC crypto service returns true string if ICV check succeeds.
10831083
{
1084-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_MAC_VALIDATION_ERROR;
1084+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_MAC_VALIDATION_ERROR;
10851085
fprintf(stderr, "KMC Crypto MAC Validation Failure Response:\n%s\n", chunk_write->response);
10861086
return status;
10871087
}
@@ -1090,7 +1090,7 @@ static int32_t cryptography_validate_authentication(uint8_t *data_out, size_t le
10901090
}
10911091
if (http_status_found == CRYPTO_FALSE)
10921092
{
1093-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
1093+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
10941094
fprintf(stderr, "KMC Crypto Generic Failure Response:\n%s\n", chunk_write->response);
10951095
return status;
10961096
}
@@ -1138,7 +1138,7 @@ static int32_t cryptography_aead_encrypt(uint8_t *data_out, size_t len_data_out,
11381138

11391139
if (sa_ptr->ek_ref[0] == '\0')
11401140
{
1141-
status = CRYPTOGRAHPY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
1141+
status = CRYPTOGRAPHY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
11421142
free(iv_base64);
11431143
return status;
11441144
}
@@ -1297,7 +1297,7 @@ static int32_t cryptography_aead_encrypt(uint8_t *data_out, size_t len_data_out,
12971297
// Find the 'base64ciphertext' token
12981298
if (parse_result < 0)
12991299
{
1300-
status = CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR;
1300+
status = CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR;
13011301
printf("Failed to parse JSON: %d\n", parse_result);
13021302
if (iv_base64 != NULL)
13031303
free(iv_base64);
@@ -1409,7 +1409,7 @@ static int32_t cryptography_aead_encrypt(uint8_t *data_out, size_t len_data_out,
14091409
#endif
14101410
if (http_code != 200)
14111411
{
1412-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
1412+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
14131413
fprintf(stderr, "KMC Crypto Failure Response:\n%s\n", chunk_write->response);
14141414
if (iv_base64 != NULL)
14151415
free(iv_base64);
@@ -1435,7 +1435,7 @@ static int32_t cryptography_aead_encrypt(uint8_t *data_out, size_t len_data_out,
14351435
}
14361436
if (ciphertext_found == CRYPTO_FALSE)
14371437
{
1438-
status = CRYPTOGRAHPY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
1438+
status = CRYPTOGRAPHY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
14391439
if (encrypt_uri != NULL)
14401440
free(encrypt_uri);
14411441
if (iv_base64 != NULL)
@@ -1548,7 +1548,7 @@ static int32_t cryptography_aead_decrypt(uint8_t *data_out, size_t len_data_out,
15481548

15491549
if (sa_ptr->ek_ref[0] == '\0')
15501550
{
1551-
status = CRYPTOGRAHPY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
1551+
status = CRYPTOGRAPHY_KMC_NULL_ENCRYPTION_KEY_REFERENCE_IN_SA;
15521552
return status;
15531553
}
15541554

@@ -1683,7 +1683,7 @@ static int32_t cryptography_aead_decrypt(uint8_t *data_out, size_t len_data_out,
16831683
// Find the 'base64ciphertext' token
16841684
if (parse_result < 0)
16851685
{
1686-
status = CRYPTOGRAHPY_KMC_CRYPTO_JSON_PARSE_ERROR;
1686+
status = CRYPTOGRAPHY_KMC_CRYPTO_JSON_PARSE_ERROR;
16871687
printf("Failed to parse JSON: %d\n", parse_result);
16881688
free(decrypt_payload);
16891689
free(decrypt_uri);
@@ -1732,7 +1732,7 @@ static int32_t cryptography_aead_decrypt(uint8_t *data_out, size_t len_data_out,
17321732
#endif
17331733
if (http_code != 200)
17341734
{
1735-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
1735+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
17361736
fprintf(stderr, "KMC Crypto Failure Response:\n%s\n", chunk_write->response);
17371737
free(chunk_read);
17381738
free(chunk_write);
@@ -1749,7 +1749,7 @@ static int32_t cryptography_aead_decrypt(uint8_t *data_out, size_t len_data_out,
17491749
}
17501750
if (ciphertext_found == CRYPTO_FALSE)
17511751
{
1752-
status = CRYPTOGRAHPY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
1752+
status = CRYPTOGRAPHY_KMC_CIPHER_TEXT_NOT_FOUND_IN_JSON_RESPONSE;
17531753
free(chunk_read);
17541754
free(chunk_write);
17551755
free(cleartext_base64);
@@ -2133,15 +2133,15 @@ int32_t curl_response_error_check(CURL *curl_handle, char *response)
21332133
}
21342134
else // CAM not enabled, but cam is configured and 302 received -- likely misconfiguration!
21352135
{
2136-
response_status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
2136+
response_status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
21372137
return response_status;
21382138
}
21392139
}
21402140
}
21412141

21422142
if (response_code != 200) // unhandled error case
21432143
{
2144-
response_status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
2144+
response_status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
21452145
return response_status;
21462146
}
21472147

@@ -2151,7 +2151,7 @@ int32_t curl_response_error_check(CURL *curl_handle, char *response)
21512151

21522152
if (response == NULL) // No response, possibly because service is CAM secured.
21532153
{
2154-
response_status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE;
2154+
response_status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE;
21552155
fprintf(stderr, "curl_easy_perform() unexpected empty response: \n%s\n",
21562156
"Empty Crypto Service response can be caused by CAM security, is CAM configured?");
21572157
return response_status;
@@ -2174,7 +2174,7 @@ int32_t curl_perform_with_cam_retries(CURL *curl_handle, memory_write *chunk_wri
21742174

21752175
if (res != CURLE_OK) // This is not a response w/return code, this is something breaking!
21762176
{
2177-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
2177+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_GENERIC_FAILURE;
21782178
fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
21792179
break; // Go to Post retry loop cleanup and return status.
21802180
}
@@ -2227,7 +2227,7 @@ int32_t curl_perform_with_cam_retries(CURL *curl_handle, memory_write *chunk_wri
22272227
if (status == CRYPTO_LIB_SUCCESS &&
22282228
chunk_write->response == NULL) // no error case detected, but invalid NULL response!
22292229
{
2230-
status = CRYPTOGRAHPY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE;
2230+
status = CRYPTOGRAPHY_KMC_CRYPTO_SERVICE_EMPTY_RESPONSE;
22312231
}
22322232
return status;
22332233
}

‎src/crypto/libgcrypt/cryptography_interface_libgcrypt.template.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ static int32_t cryptography_init(void)
9090
}
9191
if (gcry_control(GCRYCTL_SELFTEST) != GPG_ERR_NO_ERROR)
9292
{
93-
status = CRYPTOGRAPHY_LIBRARY_INITIALIZIATION_ERROR;
93+
status = CRYPTOGRAPHY_LIBRARY_INITIALIZATION_ERROR;
9494
printf(KRED "ERROR: gcrypt self test failed\n" RESET);
9595
}
9696
gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);

‎src/crypto/wolfssl/cryptography_interface_wolfssl.template.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -98,7 +98,7 @@ static int32_t cryptography_init(void)
9898
// Initialize WolfSSL
9999
if (LIBWOLFSSL_VERSION_HEX != wolfSSL_lib_version_hex())
100100
{
101-
status = CRYPTOGRAPHY_LIBRARY_INITIALIZIATION_ERROR;
101+
status = CRYPTOGRAPHY_LIBRARY_INITIALIZATION_ERROR;
102102
printf(KRED "ERROR: wolfssl version mismatch!\n" RESET);
103103
}
104104

0 commit comments

Comments
 (0)