Algorithm for symmetric encryption (diffusion without confusion)? I'm looking for a symmetric encryption algorithm with specific characteristic. Having a key $k$ a message $m$ returns a ciphertext $c$, where $E_{k}[m] \rightarrow c$


It should be hard to perform a KPA. I believe the diffusion concept makes it hard to perform such an attack?
Yet I require that $k + x \rightarrow e$, $E_{e}[m] \rightarrow (c + x)$ where $+$ can be the sum operator in a finite field. I believe this will require to avoid the confusion concept?


Edit: From $E_{e}[m]$ I should be able to recover $c = E_{e}[m] - x$, or some other possible operation that can revert x.

Is there any algorithm with those characteristics? I do believe that a hash function can work for my use-case.
It should be hard to perform a KPA. I believe the diffusion concept makes it hard to perform such an attack?


Assuming the context of traditional symmetric encryption: confusion (combined with diffusion) is what makes this hard.

For simplicity, suppose we have a 4-bit message. Suppose the equations for each bit of ciphertext are: \begin{align}
c_0 &amp;= m_0 \oplus m_1 \oplus k_0\\
c_1 &amp;= m_1 \oplus m_2 \oplus k_1\\
c_2 &amp;= m_2 \oplus m_3 \oplus k_2\\
c_3 &amp;= m_3 \oplus m_0 \oplus m_1 \oplus k_3
\end{align}

Recovering the bits $k_i$ is trivial when you know $m$:

\begin{align}
k_0 &amp;= c_0 \oplus m_0 \oplus m_1\\
k_1 &amp;= c_1 \oplus m_1 \oplus m_2\\
k_2 &amp;= c_2 \oplus m_2 \oplus m_3\\
k_3 &amp;= c_3 \oplus m_3 \oplus m_0 \oplus m_1
\end{align}

Diffusion by itself is not generically sufficient to protect against known-plaintext attacks.


  Yet I require that $k+x→e, E_e[m]→(c+x)$ where $+$ can be the sum operator in a finite field. I believe this will require to avoid the confusion concept?


This would no longer the realm of traditional symmetric encryption. 

You'll be looking for some kind of homomorphic encryption. There might be some kind of lattice-based construction that offers this feature. If I recall correctly, Ajtai's hash function offers some kind of "key homomorphism", but I'm not sure that it works the way that you require. 

I can't provide a more precise suggestion of a scheme. Maybe someone else can.