add component

Signed-off-by: sirivarma <siri.varma@outlook.com>

Author: siri-varma

.github/workflows/validate.yml

@@ -113,6 +113,10 @@ jobs:
         run: sleep 30 && docker logs dapr_scheduler && nc -vz localhost 50006
       - name: Install jars
         run: ./mvnw clean install -DskipTests -q
+      - name: Validate crypto example
+        working-directory: ./examples
+        run: |
+          mm.py ./src/main/java/io/dapr/examples/crypto/README.md
       - name: Validate workflows example
         working-directory: ./examples
         run: |
@@ -185,9 +189,6 @@ jobs:
         working-directory: ./examples
         run: |
           mm.py ./src/main/java/io/dapr/examples/pubsub/stream/README.md
-      - name: Validate crypto example
-        working-directory: ./examples
-        run: |
-          mm.py ./src/main/java/io/dapr/examples/crypto/README.md
+
 
 

examples/components/crypto/localstorage.yaml

@@ -7,7 +7,6 @@ spec:
   version: v1
   metadata:
     # Path to the directory containing keys (PEM files)
-    # On Linux/Mac: ~/.dapr/keys
-    # On Windows: %USERPROFILE%\.dapr\keys
+    # This path is relative to where the dapr run command is executed
     - name: path
-      value: "${HOME}/.dapr/keys"
+      value: "./components/crypto/keys"

examples/src/main/java/io/dapr/examples/crypto/CryptoExample.java

@@ -21,53 +21,58 @@
 import io.dapr.config.Property;
 import reactor.core.publisher.Flux;
 
+import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.util.Base64;
 import java.util.Map;
 
 /**
  * CryptoExample demonstrates using the Dapr Cryptography building block
  * to encrypt and decrypt data using a cryptography component.
- * 
+ *
  * <p>This example shows:
  * <ul>
  *   <li>Encrypting plaintext data with a specified key and algorithm</li>
  *   <li>Decrypting ciphertext data back to plaintext</li>
- *   <li>Working with streaming data for large payloads</li>
+ *   <li>Automatic key generation if keys don't exist</li>
  * </ul>
- * 
+ *
  * <p>Prerequisites:
  * <ul>
  *   <li>Dapr installed and initialized</li>
  *   <li>A cryptography component configured (e.g., local storage crypto)</li>
- *   <li>A key pair available for the crypto component</li>
  * </ul>
  */
 public class CryptoExample {
 
-  // The crypto component name as defined in the component YAML file
   private static final String CRYPTO_COMPONENT_NAME = "localstoragecrypto";
-  
-  // The key name to use for encryption/decryption
-  private static final String KEY_NAME = "mykey";
-  
-  // The key wrap algorithm - RSA-OAEP-256 for RSA keys
-  private static final String KEY_WRAP_ALGORITHM = "RSA-OAEP-256";
+  private static final String KEY_NAME = "rsa-private-key";
+  private static final String KEY_WRAP_ALGORITHM = "RSA";
+  private static final String KEYS_DIR = "components/crypto/keys";
 
   /**
    * The main method demonstrating encryption and decryption with Dapr.
    *
    * @param args Command line arguments (unused).
    */
-  public static void main(String[] args) {
+  public static void main(String[] args) throws Exception {
+    // Generate keys if they don't exist
+    generateKeysIfNeeded();
+
     Map<Property<?>, String> overrides = Map.of(
         Properties.HTTP_PORT, "3500",
         Properties.GRPC_PORT, "50001"
     );
 
     try (DaprPreviewClient client = new DaprClientBuilder().withPropertyOverrides(overrides).buildPreviewClient()) {
 
-      // Original message to encrypt
-      String originalMessage = "Hello, Dapr Cryptography! This is a secret message.";
+      String originalMessage = "This is a secret message";
       byte[] plainText = originalMessage.getBytes(StandardCharsets.UTF_8);
 
       System.out.println("=== Dapr Cryptography Example ===");
@@ -83,19 +88,9 @@ public static void main(String[] args) {
           KEY_WRAP_ALGORITHM
       );
 
-      // Collect encrypted data from the stream
       byte[] encryptedData = client.encrypt(encryptRequest)
           .collectList()
-          .map(chunks -> {
-            int totalSize = chunks.stream().mapToInt(chunk -> chunk.length).sum();
-            byte[] result = new byte[totalSize];
-            int pos = 0;
-            for (byte[] chunk : chunks) {
-              System.arraycopy(chunk, 0, result, pos, chunk.length);
-              pos += chunk.length;
-            }
-            return result;
-          })
+          .map(CryptoExample::combineChunks)
           .block();
 
       System.out.println("Encryption successful!");
@@ -109,36 +104,70 @@ public static void main(String[] args) {
           Flux.just(encryptedData)
       );
 
-      // Collect decrypted data from the stream
       byte[] decryptedData = client.decrypt(decryptRequest)
           .collectList()
-          .map(chunks -> {
-            int totalSize = chunks.stream().mapToInt(chunk -> chunk.length).sum();
-            byte[] result = new byte[totalSize];
-            int pos = 0;
-            for (byte[] chunk : chunks) {
-              System.arraycopy(chunk, 0, result, pos, chunk.length);
-              pos += chunk.length;
-            }
-            return result;
-          })
+          .map(CryptoExample::combineChunks)
           .block();
 
       String decryptedMessage = new String(decryptedData, StandardCharsets.UTF_8);
       System.out.println("Decryption successful!");
       System.out.println("Decrypted message: " + decryptedMessage);
       System.out.println();
 
-      // Verify the message matches
       if (originalMessage.equals(decryptedMessage)) {
-        System.out.println("✓ Success! The decrypted message matches the original.");
+        System.out.println("SUCCESS: The decrypted message matches the original.");
       } else {
-        System.out.println("✗ Error! The decrypted message does not match the original.");
+        System.out.println("ERROR: The decrypted message does not match the original.");
       }
 
     } catch (Exception e) {
       System.err.println("Error during crypto operations: " + e.getMessage());
       throw new RuntimeException(e);
     }
   }
+
+  /**
+   * Generates RSA key pair if the key file doesn't exist.
+   */
+  private static void generateKeysIfNeeded() throws NoSuchAlgorithmException, IOException {
+    Path keysDir = Paths.get(KEYS_DIR);
+    Path keyFile = keysDir.resolve(KEY_NAME + ".pem");
+
+    if (Files.exists(keyFile)) {
+      System.out.println("Using existing key: " + keyFile.toAbsolutePath());
+      return;
+    }
+
+    System.out.println("Generating RSA key pair...");
+    Files.createDirectories(keysDir);
+
+    KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
+    keyGen.initialize(4096);
+    KeyPair keyPair = keyGen.generateKeyPair();
+
+    String privateKeyPem = "-----BEGIN PRIVATE KEY-----\n"
+        + Base64.getMimeEncoder(64, "\n".getBytes()).encodeToString(keyPair.getPrivate().getEncoded())
+        + "\n-----END PRIVATE KEY-----\n";
+
+    String publicKeyPem = "-----BEGIN PUBLIC KEY-----\n"
+        + Base64.getMimeEncoder(64, "\n".getBytes()).encodeToString(keyPair.getPublic().getEncoded())
+        + "\n-----END PUBLIC KEY-----\n";
+
+    Files.writeString(keyFile, privateKeyPem + publicKeyPem);
+    System.out.println("Key generated: " + keyFile.toAbsolutePath());
+  }
+
+  /**
+   * Combines byte array chunks into a single byte array.
+   */
+  private static byte[] combineChunks(java.util.List<byte[]> chunks) {
+    int totalSize = chunks.stream().mapToInt(chunk -> chunk.length).sum();
+    byte[] result = new byte[totalSize];
+    int pos = 0;
+    for (byte[] chunk : chunks) {
+      System.arraycopy(chunk, 0, result, pos, chunk.length);
+      pos += chunk.length;
+    }
+    return result;
+  }
 }

examples/src/main/java/io/dapr/examples/crypto/README.md

@@ -43,31 +43,9 @@ cd examples
 
 Run `dapr init` to initialize Dapr in Self-Hosted Mode if it's not already initialized.
 
-### Setting Up the Cryptography Component
-
-Before running the examples, you need to set up a cryptography component. This example uses the local storage crypto component.
-
-1. Create a directory for your keys:
-
-```bash
-mkdir -p ~/.dapr/keys
-```
-
-2. Generate an RSA key pair (you can use OpenSSL):
-
-```bash
-# Generate a 4096-bit RSA private key
-openssl genrsa -out ~/.dapr/keys/mykey 4096
-
-# Extract the public key
-openssl rsa -in ~/.dapr/keys/mykey -pubout -out ~/.dapr/keys/mykey.pub
-```
-
-The component configuration file is already provided in `./components/crypto/localstorage.yaml`.
-
 ### Running the Example
 
-This example uses the Java SDK Dapr client to **Encrypt and Decrypt** data.
+This example uses the Java SDK Dapr client to **Encrypt and Decrypt** data. The example automatically generates RSA keys if they don't exist.
 
 #### Example 1: Basic Crypto Example
 
@@ -76,13 +54,13 @@ This example uses the Java SDK Dapr client to **Encrypt and Decrypt** data.
 ```java
 public class CryptoExample {
   private static final String CRYPTO_COMPONENT_NAME = "localstoragecrypto";
-  private static final String KEY_NAME = "mykey";
-  private static final String KEY_WRAP_ALGORITHM = "RSA-OAEP-256";
+  private static final String KEY_NAME = "rsa-private-key";
+  private static final String KEY_WRAP_ALGORITHM = "RSA";
 
   public static void main(String[] args) {
     try (DaprPreviewClient client = new DaprClientBuilder().buildPreviewClient()) {
-      
-      String originalMessage = "Hello, Dapr Cryptography!";
+
+      String originalMessage = "This is a secret message";
       byte[] plainText = originalMessage.getBytes(StandardCharsets.UTF_8);
 
       // Encrypt the message
@@ -92,7 +70,7 @@ public class CryptoExample {
           KEY_NAME,
           KEY_WRAP_ALGORITHM
       );
-      
+
       byte[] encryptedData = client.encrypt(encryptRequest)
           .collectList()
           .map(chunks -> /* combine chunks */)
@@ -103,7 +81,7 @@ public class CryptoExample {
           CRYPTO_COMPONENT_NAME,
           Flux.just(encryptedData)
       );
-      
+
       byte[] decryptedData = client.decrypt(decryptRequest)
           .collectList()
           .map(chunks -> /* combine chunks */)
@@ -118,7 +96,7 @@ Use the following command to run this example:
 <!-- STEP
 name: Run Crypto Example
 expected_stdout_lines:
-  - "== APP == ✓ Success! The decrypted message matches the original."
+  - "== APP == SUCCESS: The decrypted message matches the original."
 background: true
 output_match_mode: substring
 sleep: 10
@@ -145,17 +123,17 @@ dapr run --resources-path ./components/crypto --app-id crypto-app --dapr-http-po
 
 ```
 === Dapr Cryptography Example ===
-Original message: Hello, Dapr Cryptography! This is a secret message.
+Original message: This is a secret message
 
 Encrypting message...
 Encryption successful!
 Encrypted data length: 512 bytes
 
 Decrypting message...
 Decryption successful!
-Decrypted message: Hello, Dapr Cryptography! This is a secret message.
+Decrypted message: This is a secret message
 
-✓ Success! The decrypted message matches the original.
+SUCCESS: The decrypted message matches the original.
 ```
 
 ### Supported Key Wrap Algorithms