key_client: supply GetRandomBytes API. (#1271)

Author: LykxSassinator

sdk/core/src/bytes_stream.rs

@@ -43,7 +43,7 @@ impl Stream for BytesStream {
         self: Pin<&mut Self>,
         _cx: &mut std::task::Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        let mut self_mut = self.get_mut();
+        let self_mut = self.get_mut();
 
         // we return all the available bytes in one call.
         if self_mut.bytes_read < self_mut.bytes.len() {
@@ -75,7 +75,7 @@ impl AsyncRead for BytesStream {
         _cx: &mut std::task::Context<'_>,
         buf: &mut [u8],
     ) -> Poll<std::io::Result<usize>> {
-        let mut self_mut = self.get_mut();
+        let self_mut = self.get_mut();
 
         if self_mut.bytes_read < self_mut.bytes.len() {
             let bytes_read = self_mut.bytes_read;

sdk/security_keyvault/src/clients/key_client.rs

@@ -85,4 +85,19 @@ impl KeyClient {
     {
         EncryptBuilder::new(self.clone(), name.into(), encrypt_parameters)
     }
+
+    /// Get the requested number of bytes containing random values from a managed HSM.
+    ///
+    /// The `count` parameter is limited to a range between 1 and 128 inclusive.
+    ///
+    /// This operation requires the `rng` permission to be granted to the HSM. Furthermore,
+    /// it is only valid for clients that have been built using HSM URLs.
+    ///
+    /// POST {managedHsmBaseUrl}/rng?api-version=7.4
+    pub fn get_random_bytes<N>(&self, hsm_name: N, count: u8) -> GetRandomBytesBuilder
+    where
+        N: Into<String>,
+    {
+        GetRandomBytesBuilder::new(self.clone(), hsm_name.into(), count)
+    }
 }

sdk/security_keyvault/src/keys/models.rs

@@ -403,3 +403,10 @@ pub struct EncryptResult {
     )]
     pub result: Vec<u8>,
 }
+
+#[derive(Debug, Deserialize)]
+pub struct GetRandomBytesResult {
+    /// `value` is encoded as a base64url string.
+    #[serde(rename = "value", deserialize_with = "deser_base64")]
+    pub result: Vec<u8>,
+}

sdk/security_keyvault/src/keys/operations/get_random_bytes.rs

@@ -0,0 +1,48 @@
+use crate::prelude::*;
+use azure_core::{headers::Headers, CollectedResponse, Method};
+use serde_json::{Map, Value};
+
+operation! {
+    GetRandomBytes,
+    client: KeyClient,
+    hsm_name: String,
+    count: u8,
+}
+
+impl GetRandomBytesBuilder {
+    pub fn into_future(mut self) -> GetRandomBytes {
+        Box::pin(async move {
+            // POST {HSMBaseUrl}//rng?api-version=7.4
+            let vault_url = format!("https://{}.managedhsm.azure.net/", self.hsm_name);
+            let mut uri = url::Url::parse(&vault_url)?;
+            let path = "rng".to_string();
+
+            uri.set_path(&path);
+
+            let mut request_body = Map::new();
+            request_body.insert("count".to_owned(), Value::from(self.count));
+
+            let headers = Headers::new();
+            let mut request = self.client.keyvault_client.finalize_request(
+                uri,
+                Method::Post,
+                headers,
+                Some(Value::Object(request_body).to_string().into()),
+            )?;
+
+            let response = self
+                .client
+                .keyvault_client
+                .send(&mut self.context, &mut request)
+                .await?;
+
+            let response = CollectedResponse::from_response(response).await?;
+            let body = response.body();
+
+            let result = serde_json::from_slice::<GetRandomBytesResult>(body)?;
+            Ok(result)
+        })
+    }
+}
+
+type GetRandomBytesResponse = GetRandomBytesResult;

sdk/security_keyvault/src/keys/operations/mod.rs

@@ -1,8 +1,10 @@
 mod decrypt;
 mod encrypt;
 mod get_key;
+mod get_random_bytes;
 mod sign;
 pub use decrypt::*;
 pub use encrypt::*;
 pub use get_key::*;
+pub use get_random_bytes::*;
 pub use sign::*;