docs: add hello ockam e2ee to riscv guide
@@ -117,6 +117,55 @@ Hello, Ockam!
In most cases, `cross` is sufficient for cross compiling to RISC-V Linux. However, it does require Docker or Podman.
+### Hello Ockam
+
+Let's create an encrypted secure channel between Alice and Bob. When a message is sent through this channel it will be encrypted when it enters the channel and decrypted just before it exits the channel.
+
+For the purpose of our example, we'll create a local channel within one program. In our [other examples](https://github.com/ockam-network/ockam/tree/develop/documentation/guides/rust#readme), you'll see that it's just as easy to create end-to-end protected channels over multi-hop, multi-protocol transport routes:
+
+Replace the contents of `src/main.rs` with the following code:
+
+```rust
+
+use ockam::{route, Context, Entity, Result, TrustEveryonePolicy, Vault};
+
+#[ockam::node]
+async fn main(mut ctx: Context) -> Result<()> {
+ // Create a Vault to safely store secret keys for Alice and Bob.
+ let vault = Vault::create(&ctx).await?;
+
+ // Create an Entity to represent Bob.
+ let mut bob = Entity::create(&ctx, &vault).await?;
+
+ // Create a secure channel listener for Bob that will wait for requests to
+ // initiate an Authenticated Key Exchange.
+ bob.create_secure_channel_listener("bob", TrustEveryonePolicy).await?;
+
+ // Create an entity to represent Alice.
+ let mut alice = Entity::create(&ctx, &vault).await?;
+
+ // As Alice, connect to Bob's secure channel listener and perform an
+ // Authenticated Key Exchange to establish an encrypted secure channel with Bob.
+ let channel = alice.create_secure_channel("bob", TrustEveryonePolicy).await?;
+
+ // Send a message, ** THROUGH ** the secure channel,
+ // to the "app" worker on the other side.
+ //
+ // This message will automatically get encrypted when it enters the channel
+ // and decrypted just before it exits the channel.
+ ctx.send(route![channel, "app"], "Hello Ockam!".to_string()).await?;
+
+ // Wait to receive a message for the "app" worker and print it.
+ let message = ctx.receive::<String>().await?;
+ println!("App Received: {}", message); // should print "Hello Ockam!"
+
+ // Stop all workers, stop the node, cleanup and return.
+ ctx.stop().await
+}
+```
+
+A lot happened when you ran this small example. It created a secure vault, spawned workers to represent entities, established a mutually authenticated channel and then routed a message through that channel. This involved running cryptographic protocols for generating keys, authenticating as an entity, performing an authenticated key exchange and exchanging messages with authenticated encryption.
+
### Rust on RISC-V with OS toolchains
The process for installing cross-compiling tools differs between OSes and distributions. The primary requirement for
