Skip to content

Commit 20bc382

Browse files
NilanjanDawNilanjanDaw
committed
code refactor for clippy and lint warnings.
1 parent bb8bd17 commit 20bc382

File tree

2 files changed

+179
-136
lines changed
  • keymanager
    • key_protection_service/key_custody_core/src
    • workload_service/key_custody_core/src

2 files changed

+179
-136
lines changed

‎keymanager/key_protection_service/key_custody_core/src/lib.rs‎

Lines changed: 111 additions & 86 deletions
Original file line numberDiff line numberDiff line change
@@ -108,10 +108,20 @@ pub unsafe extern "C" fn key_manager_generate_kem_keypair(
108108
/// * `aad_len` - The length of the AAD.
109109
/// * `out_encapsulated_key` - A pointer to a buffer where the new encapsulated key will be written.
110110
/// * `out_encapsulated_key_len` - A pointer to a `usize` containing the size of `out_encapsulated_key`.
111-
/// On success, updated with the actual size.
111+
/// On success, updated with the actual size.
112112
/// * `out_ciphertext` - A pointer to a buffer where the sealed ciphertext will be written.
113113
/// * `out_ciphertext_len` - A pointer to a `usize` containing the size of `out_ciphertext`.
114-
/// On success, updated with the actual size.
114+
/// On success, updated with the actual size.
115+
///
116+
/// ## Safety
117+
/// This function is unsafe because it dereferences raw pointers. The caller must ensure that:
118+
/// * `uuid_bytes` points to a valid 16-byte buffer.
119+
/// * `encapsulated_key` points to a valid buffer of at least `encapsulated_key_len` bytes.
120+
/// * `aad` is either null or points to a valid buffer of at least `aad_len` bytes.
121+
/// * `out_encapsulated_key` points to a valid buffer of at least `*out_encapsulated_key_len` bytes.
122+
/// * `out_encapsulated_key_len` points to a valid `usize`.
123+
/// * `out_ciphertext` points to a valid buffer of at least `*out_ciphertext_len` bytes.
124+
/// * `out_ciphertext_len` points to a valid `usize`.
115125
///
116126
/// ## Returns
117127
/// * `0` on success.
@@ -120,7 +130,7 @@ pub unsafe extern "C" fn key_manager_generate_kem_keypair(
120130
/// * `-3` if decapsulation fails.
121131
/// * `-4` if sealing (HPKE encryption) fails.
122132
#[unsafe(no_mangle)]
123-
pub extern "C" fn key_manager_decap_and_seal(
133+
pub unsafe extern "C" fn key_manager_decap_and_seal(
124134
uuid_bytes: *const u8,
125135
encapsulated_key: *const u8,
126136
encapsulated_key_len: usize,
@@ -437,16 +447,17 @@ mod tests {
437447
kdf: KdfAlgorithm::HkdfSha256 as i32,
438448
aead: AeadAlgorithm::Aes256Gcm as i32,
439449
};
440-
441-
key_manager_generate_kem_keypair(
442-
algo,
443-
binding_pk.as_ptr(),
444-
binding_pk.len(),
445-
3600,
446-
uuid_bytes.as_mut_ptr(),
447-
kem_pubkey_bytes.as_mut_ptr(),
448-
&mut kem_pubkey_len,
449-
);
450+
unsafe {
451+
key_manager_generate_kem_keypair(
452+
algo,
453+
binding_pk.as_ptr(),
454+
binding_pk.len(),
455+
3600,
456+
uuid_bytes.as_mut_ptr(),
457+
kem_pubkey_bytes.as_mut_ptr(),
458+
&mut kem_pubkey_len,
459+
);
460+
}
450461

451462
// 3. Generate a "client" ciphertext/encapsulation targeting KEM key.
452463
let pt = b"ignored_plaintext";
@@ -461,17 +472,19 @@ mod tests {
461472
let mut out_ct = [0u8; 48]; // 32 bytes secret + 16 tag
462473
let mut out_ct_len = 48;
463474

464-
let result = key_manager_decap_and_seal(
465-
uuid_bytes.as_ptr(),
466-
client_enc.as_ptr(),
467-
client_enc.len(),
468-
aad.as_ptr(),
469-
aad.len(),
470-
out_enc_key.as_mut_ptr(),
471-
&mut out_enc_key_len,
472-
out_ct.as_mut_ptr(),
473-
&mut out_ct_len,
474-
);
475+
let result = unsafe {
476+
key_manager_decap_and_seal(
477+
uuid_bytes.as_ptr(),
478+
client_enc.as_ptr(),
479+
client_enc.len(),
480+
aad.as_ptr(),
481+
aad.len(),
482+
out_enc_key.as_mut_ptr(),
483+
&mut out_enc_key_len,
484+
out_ct.as_mut_ptr(),
485+
&mut out_ct_len,
486+
)
487+
};
475488

476489
assert_eq!(result, 0);
477490

@@ -515,17 +528,19 @@ mod tests {
515528
let mut out_ct = [0u8; 48];
516529
let mut out_ct_len = 48;
517530

518-
let result = key_manager_decap_and_seal(
519-
[0u8; 16].as_ptr(),
520-
[0u8; 32].as_ptr(),
521-
32,
522-
std::ptr::null(),
523-
0,
524-
out_enc_key.as_mut_ptr(),
525-
&mut out_enc_key_len,
526-
out_ct.as_mut_ptr(),
527-
&mut out_ct_len,
528-
);
531+
let result = unsafe {
532+
key_manager_decap_and_seal(
533+
[0u8; 16].as_ptr(),
534+
[0u8; 32].as_ptr(),
535+
32,
536+
std::ptr::null(),
537+
0,
538+
out_enc_key.as_mut_ptr(),
539+
&mut out_enc_key_len,
540+
out_ct.as_mut_ptr(),
541+
&mut out_ct_len,
542+
)
543+
};
529544

530545
assert_eq!(result, -1);
531546
}
@@ -535,17 +550,19 @@ mod tests {
535550
let mut out_enc_key = [0u8; 32];
536551
let mut out_enc_key_len = 32;
537552

538-
let result = key_manager_decap_and_seal(
539-
std::ptr::null(),
540-
std::ptr::null(),
541-
0,
542-
std::ptr::null(),
543-
0,
544-
out_enc_key.as_mut_ptr(),
545-
&mut out_enc_key_len,
546-
std::ptr::null_mut(),
547-
std::ptr::null_mut(),
548-
);
553+
let result = unsafe {
554+
key_manager_decap_and_seal(
555+
std::ptr::null(),
556+
std::ptr::null(),
557+
0,
558+
std::ptr::null(),
559+
0,
560+
out_enc_key.as_mut_ptr(),
561+
&mut out_enc_key_len,
562+
std::ptr::null_mut(),
563+
std::ptr::null_mut(),
564+
)
565+
};
549566

550567
assert_eq!(result, -1);
551568
}
@@ -563,33 +580,37 @@ mod tests {
563580
kdf: KdfAlgorithm::HkdfSha256 as i32,
564581
aead: AeadAlgorithm::Aes256Gcm as i32,
565582
};
566-
key_manager_generate_kem_keypair(
567-
algo,
568-
binding_pk.as_ptr(),
569-
binding_pk.len(),
570-
3600,
571-
uuid_bytes.as_mut_ptr(),
572-
std::ptr::null_mut(),
573-
std::ptr::null_mut(),
574-
);
583+
unsafe {
584+
key_manager_generate_kem_keypair(
585+
algo,
586+
binding_pk.as_ptr(),
587+
binding_pk.len(),
588+
3600,
589+
uuid_bytes.as_mut_ptr(),
590+
std::ptr::null_mut(),
591+
std::ptr::null_mut(),
592+
);
593+
}
575594

576595
// 3. Call with invalid encapsulated key (wrong length for X25519)
577596
let mut out_enc_key = [0u8; 32];
578597
let mut out_enc_key_len = 32;
579598
let mut out_ct = [0u8; 48];
580599
let mut out_ct_len = 48;
581600

582-
let result = key_manager_decap_and_seal(
583-
uuid_bytes.as_ptr(),
584-
[0u8; 31].as_ptr(),
585-
31,
586-
std::ptr::null(),
587-
0,
588-
out_enc_key.as_mut_ptr(),
589-
&mut out_enc_key_len,
590-
out_ct.as_mut_ptr(),
591-
&mut out_ct_len,
592-
);
601+
let result = unsafe {
602+
key_manager_decap_and_seal(
603+
uuid_bytes.as_ptr(),
604+
[0u8; 31].as_ptr(),
605+
31,
606+
std::ptr::null(),
607+
0,
608+
out_enc_key.as_mut_ptr(),
609+
&mut out_enc_key_len,
610+
out_ct.as_mut_ptr(),
611+
&mut out_ct_len,
612+
)
613+
};
593614

594615
assert_eq!(result, -3);
595616
}
@@ -609,15 +630,17 @@ mod tests {
609630
kdf: KdfAlgorithm::HkdfSha256 as i32,
610631
aead: AeadAlgorithm::Aes256Gcm as i32,
611632
};
612-
key_manager_generate_kem_keypair(
613-
algo.clone(),
614-
binding_pk.as_ptr(),
615-
binding_pk.len(),
616-
3600,
617-
uuid_bytes.as_mut_ptr(),
618-
kem_pubkey_bytes.as_mut_ptr(),
619-
&mut kem_pubkey_len,
620-
);
633+
unsafe {
634+
key_manager_generate_kem_keypair(
635+
algo,
636+
binding_pk.as_ptr(),
637+
binding_pk.len(),
638+
3600,
639+
uuid_bytes.as_mut_ptr(),
640+
kem_pubkey_bytes.as_mut_ptr(),
641+
&mut kem_pubkey_len,
642+
);
643+
}
621644

622645
// 3. Generate valid client encapsulation
623646
let (client_enc, _) =
@@ -629,17 +652,19 @@ mod tests {
629652
let mut out_ct = [0u8; 47]; // Small
630653
let mut out_ct_len = 47;
631654

632-
let result = key_manager_decap_and_seal(
633-
uuid_bytes.as_ptr(),
634-
client_enc.as_ptr(),
635-
client_enc.len(),
636-
std::ptr::null(),
637-
0,
638-
out_enc_key.as_mut_ptr(),
639-
&mut out_enc_key_len,
640-
out_ct.as_mut_ptr(),
641-
&mut out_ct_len,
642-
);
655+
let result = unsafe {
656+
key_manager_decap_and_seal(
657+
uuid_bytes.as_ptr(),
658+
client_enc.as_ptr(),
659+
client_enc.len(),
660+
std::ptr::null(),
661+
0,
662+
out_enc_key.as_mut_ptr(),
663+
&mut out_enc_key_len,
664+
out_ct.as_mut_ptr(),
665+
&mut out_ct_len,
666+
)
667+
};
643668

644669
assert_eq!(result, -2);
645670
}

0 commit comments

Comments
 (0)