Trac #2877: security risk -- restrict the input of eval in CC constructor

There are valid uses for eval() and sage_eval(), it makes it much easier
to parse output from  interfaces for example.

It is difficult (if not impossible) to completely sanitize arbitrary
input, but one should be able to (say) write a backend that takes
specific data, calls on Sage to process it, and then returns the result.
For example, I might want a webpage that uses Sage to compute Julia
sets, and takes as input a complex number. That the following work is
scary

{{{
sage: CC("os.getpid()")
10324.0000000000
sage: CC("os.mkdir('a')")
NaN - NaN*I
sage: CC("os.rmdir('a')")
NaN - NaN*I
sage: CC("os.exec(...)")
}}}

In this ticket, one introduces restrictions on the text input to CC that
prevent most of these terrible examples.

URL: https://trac.sagemath.org/2877
Reported by: robertwb
Ticket author(s): Frédéric Chapoton
Reviewer(s): Travis Scrimshaw, Kwankyu Lee

Author: Release Manager

src/sage/interfaces/singular.py

@@ -1576,10 +1576,10 @@ def sage_global_ring(self):
             ''
             sage: R = singular('r5').sage_global_ring(); R
             Multivariate Polynomial Ring in a, b, c over Complex Field with 54 bits of precision
-            sage: R.base_ring()('j')
+            sage: R.base_ring()('k')
             Traceback (most recent call last):
             ...
-            NameError: name 'j' is not defined
+            ValueError: given string 'k' is not a complex number
             sage: R.base_ring()('I')
             1.00000000000000*I
 

src/sage/rings/complex_mpfr.pyx

@@ -500,15 +500,31 @@ class ComplexField_class(sage.rings.abc.ComplexField):
             sage: CC(i)
             1.00000000000000*I
 
+        TESTS::
+
+            sage: CC('1.2+3.4*j')
+            1.20000000000000 + 3.40000000000000*I
+            sage: CC('hello')
+            Traceback (most recent call last):
+            ...
+            ValueError: given string 'hello' is not a complex number
         """
         if not isinstance(x, (RealNumber, tuple)):
             if isinstance(x, ComplexDoubleElement):
                 return ComplexNumber(self, x.real(), x.imag())
             elif isinstance(x, str):
+                x = x.replace(' ', '')
+                x = x.replace('i', 'I')
+                x = x.replace('j', 'I')
+                x = x.replace('E', 'e')
+                allowed = '+-.*0123456789Ie'
+                if not all(letter in allowed for letter in x):
+                    raise ValueError(f'given string {x!r} is not a complex number')
+                # This should rather use a proper parser to validate input.
                 # TODO: this is probably not the best and most
                 # efficient way to do this.  -- Martin Albrecht
                 return ComplexNumber(self,
-                            sage_eval(x.replace(' ',''), locals={"I":self.gen(),"i":self.gen()}))
+                                     sage_eval(x, locals={"I": self.gen()}))
 
             late_import()
             if isinstance(x, NumberFieldElement_quadratic):

src/sage/schemes/elliptic_curves/period_lattice.py

@@ -204,12 +204,12 @@ def __init__(self, E, embedding=None):
         K = E.base_field()
         if embedding is None:
             embs = K.embeddings(AA)
-            real = len(embs)>0
+            real = len(embs) > 0
             if not real:
                 embs = K.embeddings(QQbar)
             embedding = embs[0]
         else:
-            embedding = refine_embedding(embedding,Infinity)
+            embedding = refine_embedding(embedding, Infinity)
             real = embedding(K.gen()).imag().is_zero()
 
         self.embedding = embedding
@@ -1802,7 +1802,7 @@ def elliptic_exponential(self, z, to_curve=True):
                     z = C(z)
                     z_is_real = z.is_real()
                 except TypeError:
-                    raise TypeError("%s is not a complex number"%z)
+                    raise TypeError("%s is not a complex number" % z)
         prec = C.precision()
 
         # test for the point at infinity:
@@ -1813,7 +1813,7 @@ def elliptic_exponential(self, z, to_curve=True):
             if to_curve:
                 return self.curve().change_ring(K)(0)
             else:
-                return (K('+infinity'), K('+infinity'))
+                return K(Infinity), K(Infinity)
 
         # general number field code (including QQ):
 
@@ -1830,7 +1830,7 @@ def elliptic_exponential(self, z, to_curve=True):
         # the same precision as the input.
 
         x, y = pari(self.basis(prec=prec)).ellwp(z, flag=1)
-        x, y = [C(t) for t in (x,y)]
+        x, y = [C(t) for t in (x, y)]
 
         if self.real_flag and z_is_real:
             x = x.real()
@@ -1839,14 +1839,15 @@ def elliptic_exponential(self, z, to_curve=True):
         if to_curve:
             K = x.parent()
             v = refine_embedding(self.embedding, Infinity)
-            a1,a2,a3,a4,a6 = [K(v(a)) for a in self.E.ainvs()]
+            a1, a2, a3, a4, a6 = [K(v(a)) for a in self.E.ainvs()]
             b2 = K(v(self.E.b2()))
             x = x - b2 / 12
             y = (y - (a1 * x + a3)) / 2
-            EK = EllipticCurve(K,[a1,a2,a3,a4,a6])
-            return EK.point((x,y,K(1)), check=False)
+            EK = EllipticCurve(K, [a1, a2, a3, a4, a6])
+            return EK.point((x, y, K.one()), check=False)
         else:
-            return (x,y)
+            return (x, y)
+
 
 def reduce_tau(tau):
     r"""