feat(csharp): add C# ChaCha20Poly1305 detection rules

csharp/src/main/java/com/ibm/plugin/rules/detection/CSharpDetectionRules.java

@@ -21,17 +21,7 @@
 
 import com.ibm.engine.language.csharp.tree.CSharpTree;
 import com.ibm.engine.rule.IDetectionRule;
-import com.ibm.plugin.rules.detection.dotnet.DotNetAES;
-import com.ibm.plugin.rules.detection.dotnet.DotNetDES;
-import com.ibm.plugin.rules.detection.dotnet.DotNetDSA;
-import com.ibm.plugin.rules.detection.dotnet.DotNetECDiffieHellman;
-import com.ibm.plugin.rules.detection.dotnet.DotNetECDsa;
-import com.ibm.plugin.rules.detection.dotnet.DotNetHMAC;
-import com.ibm.plugin.rules.detection.dotnet.DotNetRC2;
-import com.ibm.plugin.rules.detection.dotnet.DotNetRSA;
-import com.ibm.plugin.rules.detection.dotnet.DotNetRfc2898DeriveBytes;
-import com.ibm.plugin.rules.detection.dotnet.DotNetSHA;
-import com.ibm.plugin.rules.detection.dotnet.DotNetTripleDES;
+import com.ibm.plugin.rules.detection.dotnet.*;
 import java.util.List;
 import java.util.stream.Stream;
 import javax.annotation.Nonnull;
@@ -47,6 +37,7 @@ private CSharpDetectionRules() {
     public static List<IDetectionRule<CSharpTree>> rules() {
         return Stream.of(
                         DotNetAES.rules().stream(),
+                        DotNetChaCha20Poly1305.rules().stream(),
                         DotNetDES.rules().stream(),
                         DotNetTripleDES.rules().stream(),
                         DotNetRC2.rules().stream(),

csharp/src/main/java/com/ibm/plugin/rules/detection/dotnet/DotNetChaCha20Poly1305.java

@@ -0,0 +1,79 @@
+/*
+ * Sonar Cryptography Plugin
+ * Copyright (C) 2026 PQCA
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.ibm.plugin.rules.detection.dotnet;
+
+import com.ibm.engine.detection.MethodMatcher;
+import com.ibm.engine.language.csharp.tree.CSharpTree;
+import com.ibm.engine.model.context.CipherContext;
+import com.ibm.engine.model.factory.ValueActionFactory;
+import com.ibm.engine.rule.IDetectionRule;
+import com.ibm.engine.rule.builder.DetectionRuleBuilder;
+import java.util.List;
+import javax.annotation.Nonnull;
+
+public final class DotNetChaCha20Poly1305 {
+    private DotNetChaCha20Poly1305() {
+        // nothing
+    }
+
+    // chaCha20Poly1305.Encrypt(nonce, plaintext, ciphertext, tag [, associatedData])
+    private static final IDetectionRule<CSharpTree> CHACHA20POLY1305_ENCRYPT_OP =
+            new DetectionRuleBuilder<CSharpTree>()
+                    .createDetectionRule()
+                    .forObjectTypes(MethodMatcher.ANY)
+                    .forMethods("Encrypt")
+                    .shouldBeDetectedAs(new ValueActionFactory<>("ENCRYPT"))
+                    .withAnyParameters() // Byte[] or ReadOnlySpan<Byte> overloads
+                    .buildForContext(new CipherContext())
+                    .inBundle(() -> "DotNet")
+                    .withoutDependingDetectionRules();
+
+    // chaCha20Poly1305.Decrypt(nonce, ciphertext, tag, plaintext [, associatedData])
+    private static final IDetectionRule<CSharpTree> CHACHA20POLY1305_DECRYPT_OP =
+            new DetectionRuleBuilder<CSharpTree>()
+                    .createDetectionRule()
+                    .forObjectTypes(MethodMatcher.ANY)
+                    .forMethods("Decrypt")
+                    .shouldBeDetectedAs(new ValueActionFactory<>("DECRYPT"))
+                    .withAnyParameters() // Byte[] or ReadOnlySpan<Byte> overloads
+                    .buildForContext(new CipherContext())
+                    .inBundle(() -> "DotNet")
+                    .withoutDependingDetectionRules();
+
+    private static final List<IDetectionRule<CSharpTree>> CHACHA20POLY1305_OP_RULES =
+            List.of(CHACHA20POLY1305_ENCRYPT_OP, CHACHA20POLY1305_DECRYPT_OP);
+
+    // new ChaCha20Poly1305(key)
+    private static final IDetectionRule<CSharpTree> CHACHA20POLY1305 =
+            new DetectionRuleBuilder<CSharpTree>()
+                    .createDetectionRule()
+                    .forObjectTypes("ChaCha20Poly1305")
+                    .forMethods("<init>")
+                    .shouldBeDetectedAs(new ValueActionFactory<>("CHACHA20POLY1305"))
+                    .withAnyParameters() // Byte[] or ReadOnlySpan<Byte>, 1 parameter
+                    .buildForContext(new CipherContext())
+                    .inBundle(() -> "DotNet")
+                    .withDependingDetectionRules(CHACHA20POLY1305_OP_RULES);
+
+    @Nonnull
+    public static List<IDetectionRule<CSharpTree>> rules() {
+        return List.of(CHACHA20POLY1305);
+    }
+}

csharp/src/main/java/com/ibm/plugin/translation/translator/contexts/CSharpCipherContextTranslator.java

@@ -34,11 +34,9 @@
 import com.ibm.mapper.mapper.jca.JcaPaddingMapper;
 import com.ibm.mapper.model.INode;
 import com.ibm.mapper.model.KeyLength;
-import com.ibm.mapper.model.algorithms.AES;
-import com.ibm.mapper.model.algorithms.DES;
-import com.ibm.mapper.model.algorithms.DESede;
-import com.ibm.mapper.model.algorithms.RC2;
-import com.ibm.mapper.model.algorithms.RSA;
+import com.ibm.mapper.model.algorithms.*;
+import com.ibm.mapper.model.functionality.Decrypt;
+import com.ibm.mapper.model.functionality.Encrypt;
 import com.ibm.mapper.utils.DetectionLocation;
 import java.util.Optional;
 import javax.annotation.Nonnull;
@@ -63,11 +61,15 @@ public final class CSharpCipherContextTranslator
             Optional<INode> result =
                     switch (valueStr) {
                         case "AES" -> Optional.of(new AES(detectionLocation));
+                        case "CHACHA20POLY1305" ->
+                                Optional.of(new ChaCha20Poly1305(detectionLocation));
                         case "DES" -> Optional.of(new DES(detectionLocation));
                         case "3DES", "DESEDE", "TRIPLEDES" ->
                                 Optional.of(new DESede(detectionLocation));
                         case "RSA" -> Optional.of(new RSA(detectionLocation));
                         case "RC2" -> Optional.of(new RC2(detectionLocation));
+                        case "ENCRYPT" -> Optional.of(new Encrypt(detectionLocation));
+                        case "DECRYPT" -> Optional.of(new Decrypt(detectionLocation));
                         default -> Optional.empty();
                     };
             if (result.isPresent()) {

csharp/src/test/files/rules/detection/dotnet/DotNetChaCha20Poly1305TestFile.cs

@@ -0,0 +1,158 @@
+/*
+ * Test file for System.Security.Cryptography.ChaCha20Poly1305 detection rules.
+ *
+ * Covers the full API surface of the ChaCha20Poly1305 class:
+ *   - constructor overloads (byte[] key, ReadOnlySpan<byte> key)
+ *   - Encrypt overloads (byte[] and ReadOnlySpan<byte>), with and without associatedData
+ *   - Decrypt overloads (byte[] and ReadOnlySpan<byte>), with and without associatedData
+ *
+ * Architecture note: Encrypt/Decrypt are depending rules attached to the constructor
+ * (see DotNetChaCha20Poly1305.java), so each method below that constructs-then-uses
+ * the object produces a single finding with nested Encrypt/Decrypt children, not separate
+ * disconnected findings.
+ */
+
+using System.Security.Cryptography;
+
+public class DotNetChaCha20Poly1305ComprehensiveTest
+{
+    // -------------------------------------------------------------------------
+    // Section 1: Constructor overloads
+    // -------------------------------------------------------------------------
+
+    public void TestConstructByteArrayKey()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+    }
+
+    public void TestConstructSpanKey()
+    {
+        var key = new ReadOnlySpan<byte>[32];
+        var chaCha = new ChaCha20Poly1305(key);
+    }
+
+    // -------------------------------------------------------------------------
+    // Section 2: Encrypt — byte[] overload
+    // -------------------------------------------------------------------------
+
+    public void TestEncryptByteArrayWithAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new byte[12];
+        var plainText = new byte[32];
+        var cipherText = new byte[32];
+        var tag = new byte[16];
+        var associatedData = new byte[32];
+
+        chaCha.Encrypt(nonce, plainText, cipherText, tag, associatedData);
+    }
+
+    public void TestEncryptByteArrayNoAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new byte[12];
+        var plainText = new byte[32];
+        var cipherText = new byte[32];
+        var tag = new byte[16];
+
+        chaCha.Encrypt(nonce, plainText, cipherText, tag);
+    }
+
+    // -------------------------------------------------------------------------
+    // Section 3: Encrypt — ReadOnlySpan<byte> overload
+    // -------------------------------------------------------------------------
+
+    public void TestEncryptSpanWithAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new ReadOnlySpan<byte>[12];
+        var plainText = new ReadOnlySpan<byte>[32];
+        var cipherText = new ReadOnlySpan<byte>[32];
+        var tag = new ReadOnlySpan<byte>[16];
+        var associatedData = new ReadOnlySpan<byte>[32];
+
+        chaCha.Encrypt(nonce, plainText, cipherText, tag, associatedData);
+    }
+
+    public void TestEncryptSpanNoAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new ReadOnlySpan<byte>[12];
+        var plainText = new ReadOnlySpan<byte>[32];
+        var cipherText = new ReadOnlySpan<byte>[32];
+        var tag = new ReadOnlySpan<byte>[16];
+
+        chaCha.Encrypt(nonce, plainText, cipherText, tag);
+    }
+
+    // -------------------------------------------------------------------------
+    // Section 4: Decrypt — byte[] overload
+    // -------------------------------------------------------------------------
+
+    public void TestDecryptByteArrayWithAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new byte[12];
+        var cipherText = new byte[32];
+        var tag = new byte[16];
+        var plainText = new byte[32];
+        var associatedData = new byte[32];
+
+        chaCha.Decrypt(nonce, cipherText, tag, plainText, associatedData);
+    }
+
+    public void TestDecryptByteArrayNoAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new byte[12];
+        var cipherText = new byte[32];
+        var tag = new byte[16];
+        var plainText = new byte[32];
+
+        chaCha.Decrypt(nonce, cipherText, tag, plainText);
+    }
+
+    // -------------------------------------------------------------------------
+    // Section 5: Decrypt — ReadOnlySpan<byte> overload
+    // -------------------------------------------------------------------------
+
+    public void TestDecryptSpanWithAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new ReadOnlySpan<byte>[12];
+        var cipherText = new ReadOnlySpan<byte>[32];
+        var tag = new ReadOnlySpan<byte>[16];
+        var plainText = new ReadOnlySpan<byte>[32];
+        var associatedData = new ReadOnlySpan<byte>[32];
+
+        chaCha.Decrypt(nonce, cipherText, tag, plainText, associatedData);
+    }
+
+    public void TestDecryptSpanNoAad()
+    {
+        var key = new byte[32];
+        var chaCha = new ChaCha20Poly1305(key);
+
+        var nonce = new ReadOnlySpan<byte>[12];
+        var cipherText = new ReadOnlySpan<byte>[32];
+        var tag = new ReadOnlySpan<byte>[16];
+        var plainText = new ReadOnlySpan<byte>[32];
+
+        chaCha.Decrypt(nonce, cipherText, tag, plainText);
+    }
+}