C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System.Linq;
using System;
using System.Security.Cryptography;
using System.IO;
					
public class Program
{
	public static void Main()
	{
				string apduSM = chipherAPDU("00a4040c07a0000002471001", "3d7155f3791c313c2924f51ae60f1ac9" , "b5feb9488f17be03e54c7d80907e8a1f");
				Console.WriteLine("ADPU SM : " + apduSM);


	}
	
	 public static string chipherAPDU(string apdu, string keyEnc, string keyMac)
 {
     string chipherApdu = "";

     byte[] apduBytes = StringToByteArray(apdu);
     byte[] KeyENC = StringToByteArray(keyEnc);
     byte[] KeyMAC = StringToByteArray(keyMac);
     byte[] secureMessagingSSC = StringToByteArray("00000000000000000000000000000001");
     SecureMessaging sm = new SecureMessaging(KeyMAC, KeyENC);
     chipherApdu = byteToHexStr ( sm.encrypt(apduBytes, secureMessagingSSC) );
     return chipherApdu;
 }
  public static string byteToHexStr(byte[] bytes)
  {
      string returnStr = "";
      if (bytes != null)
      {
          for (int i = 0; i < bytes.Length; i++)
          {
              returnStr += bytes[i].ToString("X2");
          }
      }
      return returnStr;
  }

   public static byte[] StringToByteArray(string hex)
 {
     return Enumerable.Range(0, hex.Length)
                      .Where(x => x % 2 == 0)
                      .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                      .ToArray();
 }
	
  internal class SecureMessaging
  {

          private readonly byte[] NULL = new byte[] { 0x00 };
          private const byte PAD = 0x80;
          private readonly byte[] secureMessagingSSC;
          private readonly byte[] keyMAC;
          private readonly byte[] keyENC;           

          public SecureMessaging(byte[] keyMAC, byte[] keyENC)
          {
              this.keyENC = keyENC;
              this.keyMAC = keyMAC;

              secureMessagingSSC = new byte[16];
          }

          public byte[] encrypt(byte[] apdu)
          {
              incrementSSC(secureMessagingSSC);
              byte[] commandAPDU = encrypt(apdu, secureMessagingSSC);
              incrementSSC(secureMessagingSSC);

              return commandAPDU;
          }

          public byte[] encrypt(byte[] apdu, byte[] secureMessagingSSC)
          {
              MemoryStream outputStream = new MemoryStream();
              CardCommandAPDU cAPDU = new CardCommandAPDU(apdu);

              if (cAPDU.isSecureMessaging())
              {
                  throw new ArgumentException("Malformed APDU.");
              }

              byte[] data = cAPDU.data;
              byte[] header = cAPDU.header;
              int lc = cAPDU.lc;
              int le = cAPDU.le;

              if (data.Length > 0)
              {
                  data = pad(data, 16);
                  using (Aes aes = Aes.Create())
                  {
                      aes.Key = keyENC;
                      aes.IV = getCipherIV(secureMessagingSSC);
                      aes.Mode = CipherMode.CBC;
                      aes.Padding = PaddingMode.None;

                      ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
                      byte[] encryptedData = encryptor.TransformFinalBlock(data, 0, data.Length);

                      outputStream.Write(new byte[] { 0x01 }, 0, 1);
                      outputStream.Write(encryptedData, 0, encryptedData.Length);
                  }
              }

              return outputStream.ToArray();
          }

          public byte[] decrypt(byte[] response)
          {
              if (response.Length < 12)
              {
                  throw new ArgumentException("Malformed Secure Messaging APDU.");
              }
              return decrypt(response, secureMessagingSSC);
          }

          private byte[] decrypt(byte[] response, byte[] secureMessagingSSC)
          {
              MemoryStream outputStream = new MemoryStream();
              byte[] statusBytes = new byte[2];
              byte[] dataObject = null;
              byte[] macObject = new byte[8];                

              return outputStream.ToArray();
          }

          public static void incrementSSC(byte[] ssc)
          {
              for (int i = ssc.Length - 1; i >= 0; i--)
              {
                  ssc[i]++;
                  if (ssc[i] != 0)
                  {
                      break;
                  }
              }
          }

          // Other methods omitted for brevity
          private byte[] pad(byte[] data, int blockSize)
          {
              byte[] result = new byte[data.Length + (blockSize - data.Length % blockSize)];
              Array.Copy(data, 0, result, 0, data.Length);
              result[data.Length] = PAD;

              return result;
          }

          private byte[] getCipherIV(byte[] smssc)
          {
              using (Aes aes = Aes.Create())
              {
                  aes.Key = keyENC;
                  aes.Mode = CipherMode.ECB;
                  aes.Padding = PaddingMode.None;

                  ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, null);
                  return encryptor.TransformFinalBlock(smssc, 0, smssc.Length);
              }
          }
  }

  public class CardCommandAPDU
  {
      public byte[] header = new byte[4];
      public int le = -1;
      public int lc = -1;
      public byte[] data;
      public CardCommandAPDU(byte[] commandAPDU)
      {
          Array.Copy(commandAPDU, 0, header, 0, 4);
          setBody(copy(commandAPDU, 4, commandAPDU.Length - 4));
      }



      /**
       * Définit le corps (LE, DATA, LC) de l'APDU.
       *
       * @param body Corps de l'APDU
       */
      public void setBody(byte[] body)
      {
          /*
           * Cas 1. : |CLA|INS|P1|P2|
           * Cas 2. : |CLA|INS|P1|P2|LE|
           * Cas 2.1: |CLA|INS|P1|P2|EXTLE|
           * Cas 3. : |CLA|INS|P1|P2|LC|DATA|
           * Cas 3.1: |CLA|INS|P1|P2|EXTLC|DATA|
           * Cas 4. : |CLA|INS|P1|P2|LC|DATA|LE|
           * Cas 4.1: |CLA|INS|P1|P2|EXTLC|DATA|LE|
           * Cas 4.2: |CLA|INS|P1|P2|LC|DATA|EXTLE|
           * Cas 4.3: |CLA|INS|P1|P2|EXTLC|DATA|EXTLE|
           */
          try
          {
              using (MemoryStream stream = new MemoryStream(body))
              {
                  int length = (int)stream.Length;

                  // Nettoyage
                  lc = -1;
                  le = -1;
                  data = new byte[0];

                  if (length == 0)
                  {
                      // Cas 1. : |CLA|INS|P1|P2|
                  }
                  else if (length == 1)
                  {
                      // Cas 2 |CLA|INS|P1|P2|LE|
                      le = stream.ReadByte() & 0xFF;
                  }
                  else if (length < 65536)
                  {
                      int tmp = stream.ReadByte();

                      if (tmp == 0)
                      {
                          // Cas 2.1, 3.1, 4.1, 4.3
                          if (stream.Length < 3)
                          {
                              // Cas 2.1 |CLA|INS|P1|P2|EXTLE|
                              le = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;
                          }
                          else
                          {
                              // Cas 3.1, 4.1, 4.3
                              lc = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;

                              data = new byte[lc];
                              stream.Read(data, 0, lc);

                              if (stream.Length == 1)
                              {
                                  // Cas 4.1 |CLA|INS|P1|P2|EXTLC|DATA|LE|
                                  le = stream.ReadByte() & 0xFF;
                              }
                              else if (stream.Length == 2)
                              {
                                  // Cas 4.3 |CLA|INS|P1|P2|EXTLC|DATA|EXTLE|
                                  le = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;
                              }
                              else if (stream.Length == 3)
                              {
                                  if (stream.ReadByte() == 0)
                                  {
                                      // Cas 4.3 |CLA|INS|P1|P2|EXTLC|DATA|EXTLE|
                                      le = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;
                                  }
                                  else
                                  {
                                      throw new ArgumentException("APDU malformée.");
                                  }
                              }
                              else if (stream.Length > 3)
                              {
                                  throw new ArgumentException("APDU malformée.");
                              }
                          }
                      }
                      else if (tmp > 0)
                      {
                          // Cas 3, 4, 4.2
                          lc = tmp & 0xFF;
                          data = new byte[lc];
                          stream.Read(data, 0, lc);

                          if (stream.Length == 1)
                          {
                              // Cas 4 |CLA|INS|P1|P2|LC|DATA|LE|
                              setLE((byte)stream.ReadByte());
                          }
                          else if (stream.Length == 3)
                          {
                              // Cas 4.2 |CLA|INS|P1|P2|LC|DATA|EXTLE|
                              stream.ReadByte(); // Ignorer le premier octet
                              setLE((short)((stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF));
                          }
                          else if (stream.Length == 2 || stream.Length > 3)
                          {
                              throw new ArgumentException("APDU malformée.");
                          }
                      }
                      else
                      {
                          throw new ArgumentException("APDU malformée.");
                      }
                  }
                  else
                  {
                      throw new ArgumentException("APDU malformée.");
                  }
              }
          }
          catch (Exception e)
          {
              Console.WriteLine("Exception", e);
          }
      }

      /**
       * Définit le champ de longueur attendue (LE) de l'APDU.
       *
       * @param le Champ de longueur attendue (LE)
       */
      public void setLE(short le)
      {
          if (le == (short)0x0000)
          {
              setLE(65536);
          }
          else
          {
              setLE((int)le & 0xFFFF);
          }
      }

      /**
       * Définit le champ de longueur attendue (LE) de l'APDU.
       *
       * @param le Champ de longueur attendue (LE)
       */
      public void setLE(int le)
      {
          if (le < 0 || le > 65536)
          {
              throw new ArgumentException("La longueur doit être comprise entre '1' et '65535'.");
          }
          else
          {
              this.le = le;
          }
      }

              /**
       * Copie une plage de bytes.
       *
       * @param input l'entrée
       * @param offset l'offset
       * @param length la longueur
       * @return le tableau de bytes
       */
      public static byte[] copy(byte[] input, int offset, int length)
      {
          if (input == null)
          {
              return null;
          }
          byte[] tmp = new byte[length];
          Array.Copy(input, offset, tmp, 0, length);
          return tmp;
      }


      public  bool isSecureMessaging()
      {
          return (header[0] & 0x0F) == 0x0C;
      }

  }

     
}

​x
 
using System.Linq;
using System;
using System.Security.Cryptography;
using System.IO;
                    
public class Program
{
    public static void Main()
    {
                string apduSM = chipherAPDU("00a4040c07a0000002471001", "3d7155f3791c313c2924f51ae60f1ac9" , "b5feb9488f17be03e54c7d80907e8a1f");
                Console.WriteLine("ADPU SM : " + apduSM);
​
​
    }
    
     public static string chipherAPDU(string apdu, string keyEnc, string keyMac)
 {
     string chipherApdu = "";
​
     byte[] apduBytes = StringToByteArray(apdu);
     byte[] KeyENC = StringToByteArray(keyEnc);
     byte[] KeyMAC = StringToByteArray(keyMac);
     byte[] secureMessagingSSC = StringToByteArray("00000000000000000000000000000001");
     SecureMessaging sm = new SecureMessaging(KeyMAC, KeyENC);
     chipherApdu = byteToHexStr ( sm.encrypt(apduBytes, secureMessagingSSC) );
     return chipherApdu;
 }
  public static string byteToHexStr(byte[] bytes)
  {
      string returnStr = "";
      if (bytes != null)
      {
          for (int i = 0; i < bytes.Length; i++)
          {
              returnStr += bytes[i].ToString("X2");
          }
      }
      return returnStr;
  }
​
   public static byte[] StringToByteArray(string hex)
 {
     return Enumerable.Range(0, hex.Length)
                      .Where(x => x % 2 == 0)
                      .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                      .ToArray();
 }
    
  internal class SecureMessaging
  {
​
          private readonly byte[] NULL = new byte[] { 0x00 };
          private const byte PAD = 0x80;
          private readonly byte[] secureMessagingSSC;
          private readonly byte[] keyMAC;
          private readonly byte[] keyENC;           
​
          public SecureMessaging(byte[] keyMAC, byte[] keyENC)
          {
              this.keyENC = keyENC;
              this.keyMAC = keyMAC;
​
              secureMessagingSSC = new byte[16];
          }
​
          public byte[] encrypt(byte[] apdu)
          {
              incrementSSC(secureMessagingSSC);
              byte[] commandAPDU = encrypt(apdu, secureMessagingSSC);
              incrementSSC(secureMessagingSSC);
​
              return commandAPDU;
          }
​
          public byte[] encrypt(byte[] apdu, byte[] secureMessagingSSC)
          {
              MemoryStream outputStream = new MemoryStream();
              CardCommandAPDU cAPDU = new CardCommandAPDU(apdu);
​
              if (cAPDU.isSecureMessaging())
              {
                  throw new ArgumentException("Malformed APDU.");
              }
​
              byte[] data = cAPDU.data;
              byte[] header = cAPDU.header;
              int lc = cAPDU.lc;
              int le = cAPDU.le;
​
              if (data.Length > 0)
              {
                  data = pad(data, 16);
                  using (Aes aes = Aes.Create())
                  {
                      aes.Key = keyENC;
                      aes.IV = getCipherIV(secureMessagingSSC);
                      aes.Mode = CipherMode.CBC;
                      aes.Padding = PaddingMode.None;
​
                      ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
                      byte[] encryptedData = encryptor.TransformFinalBlock(data, 0, data.Length);
​
                      outputStream.Write(new byte[] { 0x01 }, 0, 1);
                      outputStream.Write(encryptedData, 0, encryptedData.Length);
                  }
              }
​
              return outputStream.ToArray();
          }
​
          public byte[] decrypt(byte[] response)
          {
              if (response.Length < 12)
              {
                  throw new ArgumentException("Malformed Secure Messaging APDU.");
              }
              return decrypt(response, secureMessagingSSC);
          }
​
          private byte[] decrypt(byte[] response, byte[] secureMessagingSSC)
          {
              MemoryStream outputStream = new MemoryStream();
              byte[] statusBytes = new byte[2];
              byte[] dataObject = null;
              byte[] macObject = new byte[8];                
​
              return outputStream.ToArray();
          }
​
          public static void incrementSSC(byte[] ssc)
          {
              for (int i = ssc.Length - 1; i >= 0; i--)
              {
                  ssc[i]++;
                  if (ssc[i] != 0)
                  {
                      break;
                  }
              }
          }
​
          // Other methods omitted for brevity
          private byte[] pad(byte[] data, int blockSize)
          {
              byte[] result = new byte[data.Length + (blockSize - data.Length % blockSize)];
              Array.Copy(data, 0, result, 0, data.Length);
              result[data.Length] = PAD;
​
              return result;
          }
​
          private byte[] getCipherIV(byte[] smssc)
          {
              using (Aes aes = Aes.Create())
              {
                  aes.Key = keyENC;
                  aes.Mode = CipherMode.ECB;
                  aes.Padding = PaddingMode.None;
​
                  ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, null);
                  return encryptor.TransformFinalBlock(smssc, 0, smssc.Length);
              }
          }
  }
​
  public class CardCommandAPDU
  {
      public byte[] header = new byte[4];
      public int le = -1;
      public int lc = -1;
      public byte[] data;
      public CardCommandAPDU(byte[] commandAPDU)
      {
          Array.Copy(commandAPDU, 0, header, 0, 4);
          setBody(copy(commandAPDU, 4, commandAPDU.Length - 4));
      }
​
​
​
      /**
       * Définit le corps (LE, DATA, LC) de l'APDU.
       *
       * @param body Corps de l'APDU
       */
      public void setBody(byte[] body)
      {
          /*
           * Cas 1. : |CLA|INS|P1|P2|
           * Cas 2. : |CLA|INS|P1|P2|LE|
           * Cas 2.1: |CLA|INS|P1|P2|EXTLE|
           * Cas 3. : |CLA|INS|P1|P2|LC|DATA|
           * Cas 3.1: |CLA|INS|P1|P2|EXTLC|DATA|
           * Cas 4. : |CLA|INS|P1|P2|LC|DATA|LE|
           * Cas 4.1: |CLA|INS|P1|P2|EXTLC|DATA|LE|
           * Cas 4.2: |CLA|INS|P1|P2|LC|DATA|EXTLE|
           * Cas 4.3: |CLA|INS|P1|P2|EXTLC|DATA|EXTLE|
           */
          try
          {
              using (MemoryStream stream = new MemoryStream(body))
              {
                  int length = (int)stream.Length;
​
                  // Nettoyage
                  lc = -1;
                  le = -1;
                  data = new byte[0];
​
                  if (length == 0)
                  {
                      // Cas 1. : |CLA|INS|P1|P2|
                  }
                  else if (length == 1)
                  {
                      // Cas 2 |CLA|INS|P1|P2|LE|
                      le = stream.ReadByte() & 0xFF;
                  }
                  else if (length < 65536)
                  {
                      int tmp = stream.ReadByte();
​
                      if (tmp == 0)
                      {
                          // Cas 2.1, 3.1, 4.1, 4.3
                          if (stream.Length < 3)
                          {
                              // Cas 2.1 |CLA|INS|P1|P2|EXTLE|
                              le = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;
                          }
                          else
                          {
                              // Cas 3.1, 4.1, 4.3
                              lc = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;
​
                              data = new byte[lc];
                              stream.Read(data, 0, lc);
​
                              if (stream.Length == 1)
                              {
                                  // Cas 4.1 |CLA|INS|P1|P2|EXTLC|DATA|LE|
                                  le = stream.ReadByte() & 0xFF;
                              }
                              else if (stream.Length == 2)
                              {
                                  // Cas 4.3 |CLA|INS|P1|P2|EXTLC|DATA|EXTLE|
                                  le = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;
                              }
                              else if (stream.Length == 3)
                              {
                                  if (stream.ReadByte() == 0)
                                  {
                                      // Cas 4.3 |CLA|INS|P1|P2|EXTLC|DATA|EXTLE|
                                      le = (stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF;
                                  }
                                  else
                                  {
                                      throw new ArgumentException("APDU malformée.");
                                  }
                              }
                              else if (stream.Length > 3)
                              {
                                  throw new ArgumentException("APDU malformée.");
                              }
                          }
                      }
                      else if (tmp > 0)
                      {
                          // Cas 3, 4, 4.2
                          lc = tmp & 0xFF;
                          data = new byte[lc];
                          stream.Read(data, 0, lc);
​
                          if (stream.Length == 1)
                          {
                              // Cas 4 |CLA|INS|P1|P2|LC|DATA|LE|
                              setLE((byte)stream.ReadByte());
                          }
                          else if (stream.Length == 3)
                          {
                              // Cas 4.2 |CLA|INS|P1|P2|LC|DATA|EXTLE|
                              stream.ReadByte(); // Ignorer le premier octet
                              setLE((short)((stream.ReadByte() & 0xFF) << 8 | stream.ReadByte() & 0xFF));
                          }
                          else if (stream.Length == 2 || stream.Length > 3)
                          {
                              throw new ArgumentException("APDU malformée.");
                          }
                      }
                      else
                      {
                          throw new ArgumentException("APDU malformée.");
                      }
                  }
                  else
                  {
                      throw new ArgumentException("APDU malformée.");
                  }
              }
          }
          catch (Exception e)
          {
              Console.WriteLine("Exception", e);
          }
      }
​
      /**
       * Définit le champ de longueur attendue (LE) de l'APDU.
       *
       * @param le Champ de longueur attendue (LE)
       */
      public void setLE(short le)
      {
          if (le == (short)0x0000)
          {
              setLE(65536);
          }
          else
          {
              setLE((int)le & 0xFFFF);
          }
      }
​
      /**
       * Définit le champ de longueur attendue (LE) de l'APDU.
       *
       * @param le Champ de longueur attendue (LE)
       */
      public void setLE(int le)
      {
          if (le < 0 || le > 65536)
          {
              throw new ArgumentException("La longueur doit être comprise entre '1' et '65535'.");
          }
          else
          {
              this.le = le;
          }
      }
​
              /**
       * Copie une plage de bytes.
       *
       * @param input l'entrée
       * @param offset l'offset
       * @param length la longueur
       * @return le tableau de bytes
       */
      public static byte[] copy(byte[] input, int offset, int length)
      {
          if (input == null)
          {
              return null;
          }
          byte[] tmp = new byte[length];
          Array.Copy(input, offset, tmp, 0, length);
          return tmp;
      }
​
​
      public  bool isSecureMessaging()
      {
          return (header[0] & 0x0F) == 0x0C;
      }
​
  }
​
     
}

View IL Code