Compiler Explorer

Source code

#![no_std]
#![cfg(all(target_arch = "riscv64", target_feature="zkne"))]

use core::arch::asm;

#[inline]
pub unsafe fn aes64esm(rs1: u64, rs2: u64) -> u64 {
    let value: u64;
    unsafe {
        asm!(
            "aes64esm {rd},{rs1},{rs2}",
            rd = lateout(reg) value,
            rs1 = in(reg) rs1,
            rs2 = in(reg) rs2,
            options(pure, nomem, nostack),
        )
    }
    value
}

#[target_feature(enable = "zkne")]
#[inline]
pub unsafe fn aes64es(rs1: u64, rs2: u64) -> u64 {
    let value: u64;
    unsafe {
        asm!(
            "aes64es {rd},{rs1},{rs2}",
            rd = lateout(reg) value,
            rs1 = in(reg) rs1,
            rs2 = in(reg) rs2,
            options(pure, nomem, nostack),
        )
    }
    value
}

#[derive(Copy, Clone)]
#[repr(C, align(16))]
pub struct AesBlock(u64, u64);

impl core::ops::BitXor for AesBlock {
    type Output = Self;

#[inline]
    fn bitxor(self, rhs: Self) -> Self::Output {
        Self(self.0 ^ rhs.0, self.1 ^ rhs.1)
    }
}

impl AesBlock {
    #[inline]
    pub fn enc(self, round_key:Self) -> Self {
        unsafe {
            Self(
                aes64esm(self.0, self.1) ^ round_key.0,
                aes64esm(self.1, self.0) ^ round_key.1,
            )
        }
    }

#[inline]
    pub fn enc_last(self, round_key:Self) -> Self {
        unsafe {
            Self(
                aes64es(self.0, self.1) ^ round_key.0,
                aes64es(self.1, self.0) ^ round_key.1,
            )
        }
    }
}

pub fn encrypt(plaintext: AesBlock, round_keys: &[AesBlock;11]) -> AesBlock {
    let mut acc = plaintext ^ round_keys[0];
    for i in 1..10 {
        acc = acc.enc(round_keys[i])
    }
    acc.enc_last(round_keys[10])
}

Source code

#![no_std]
#![cfg(all(target_arch = "riscv64", target_feature="zkne"))]
#![feature(riscv_ext_intrinsics)]

use core::arch::riscv64::*;

#[derive(Copy, Clone)]
#[repr(C, align(16))]
pub struct AesBlock(u64, u64);

impl core::ops::BitXor for AesBlock {
    type Output = Self;

#[inline]
    fn bitxor(self, rhs: Self) -> Self::Output {
        Self(self.0 ^ rhs.0, self.1 ^ rhs.1)
    }
}